windows-server-2003/multimedia/directx/dxg/d3d8/tnl/loops.mcp

/*==========================================================================;
 *
 *  Copyright (C) 1998 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:   loops.mcp
 *  Content:    Generates code for multiple loop geometry pipeline
 *
 ***************************************************************************/
#include "pch.cpp"
#pragma hdrstop

include(`pvvid.mh') dnl
#include "stdio.h"

dnl//------------------------------------------------------------------
dnl//           d_ComputeSpecular
dnl//
dnl//   Generates code to compute specular component based on a dot product
dnl//
dnl// Arguments:
dnl//   $1  - margin count
dnl//   $2  - if present, equal to the attenuation factor 
dnl//   dot                 - dot product
dnl//   pv                  - process vertices structure
dnl//   d_Op - operation "=" or "+="
dnl//   d_LightingFlags     - DWORD
dnl//   d_SPECULARCOMPUTED  - bit
dnl//   d_pInpSpecular      - vertex specular color (DWORD*)
dnl//   d_OutSpecular       - output specular color, (D3DFE_COLOR)
dnl//
define(`d_ComputeSpecular',`dnl
d_empty_($1)if (FLOAT_CMP_POS(dot, >=, pv->lighting.specThreshold))
d_margin($1){                                               
d_margin($1)    d_LightingFlags |= __LIGHT_SPECULARCOMPUTED;
d_margin($1)    // Compute power = dot**SpecularExponent;
d_margin($1)    D3DVALUE power;
d_margin($1)    if (FLOAT_CMP_PONE(dot, <))
d_margin($1)    {
d_margin($1)        int     indx;                
d_margin($1)        float   v;
d_margin($1)        float   dot_floor;
d_margin($1)        dot *= 255.0f;
d_margin($1)        dot_floor = (float)floor(dot);
d_margin($1)        indx = FTOI(dot_floor);
d_margin($1)        dot -= dot_floor;                                            
d_margin($1)        v = pv->lighting.currentSpecTable[indx];
d_margin($1)        power = v + (pv->lighting.currentSpecTable[indx+1] - v)*dot;
d_margin($1)    }
d_margin($1)    else
d_margin($1)        power = pv->lighting.currentSpecTable[255];
dnl
ifelse($#,2,`d_margin($1+1)power*= $2;')dnl// If parameter 2 (attenuation) is present, use it

d_margin($1)    // Update specular component
d_margin($1)    if (!(dwFlags & D3DPV_COLORVERTEX_S))
d_margin($1)    {
d_margin($1)        d_OutSpecular.r d_Op light->specularMat.r * power;
d_margin($1)        d_OutSpecular.g d_Op light->specularMat.g * power;
d_margin($1)        d_OutSpecular.b d_Op light->specularMat.b * power;
d_margin($1)    }
d_margin($1)    else
d_margin($1)    {
d_margin($1)        const D3DVALUE r = (D3DVALUE)RGBA_GETRED(*d_pInpSpecular);
d_margin($1)        const D3DVALUE g = (D3DVALUE)RGBA_GETGREEN(*d_pInpSpecular);
d_margin($1)        const D3DVALUE b = (D3DVALUE)RGBA_GETBLUE(*d_pInpSpecular);
d_margin($1)        d_OutSpecular.r d_Op light->specular.r * r * power;
d_margin($1)        d_OutSpecular.g d_Op light->specular.g * g * power;
d_margin($1)        d_OutSpecular.b d_Op light->specular.b * b * power;
d_margin($1)    }
d_margin($1)}')dnl
dnl//------------------------------------------------------------------
dnl//           d_UpdateDiffuseColor
dnl//
dnl// Generates code to compute diffuse component, based on a dot product
dnl//
dnl// Arguments:
dnl//   $1  - margin count
dnl//   $2  - operation "=" or "+=" 
dnl//   dot                 - dot product
dnl//   d_LightingFlags     - DWORD
dnl//   d_pInpDiffuse       - vertex specular color (DWORD*)
dnl//   d_OutDiffuse        - output specular color, (D3DFE_COLOR)
dnl//
define(`d_UpdateDiffuseColor',`dnl
d_empty_($1)if (!(dwFlags & D3DPV_COLORVERTEX_D))
d_margin($1){
d_margin($1)    d_OutDiffuse.r $2 light->diffuseMat.r * dot;
d_margin($1)    d_OutDiffuse.g $2 light->diffuseMat.g * dot;
d_margin($1)    d_OutDiffuse.b $2 light->diffuseMat.b * dot;
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1)    const D3DVALUE r = (D3DVALUE)RGBA_GETRED(*d_pInpDiffuse);
d_margin($1)    const D3DVALUE g = (D3DVALUE)RGBA_GETGREEN(*d_pInpDiffuse);
d_margin($1)    const D3DVALUE b = (D3DVALUE)RGBA_GETBLUE(*d_pInpDiffuse);
d_margin($1)    d_OutDiffuse.r $2 light->diffuse.r * r * dot;
d_margin($1)    d_OutDiffuse.g $2 light->diffuse.g * g * dot;
d_margin($1)    d_OutDiffuse.b $2 light->diffuse.b * b * dot;
d_margin($1)}
d_margin($1)d_LightingFlags |= __LIGHT_DIFFUSECOMPUTED;')dnl
dnl//------------------------------------------------------------------
dnl//           d_UpdateAmbientColor
dnl//
dnl// Generates code to compute ambient component
dnl//
dnl// Arguments:
dnl//   $1  - margin count
dnl//   $2  - "* att" or empty
dnl//   dot                 - dot product
dnl//   d_Op - operation "=" or "+="
dnl//   d_LightingFlags     - DWORD
dnl//   d_OutDiffuse        - output specular color, (D3DFE_COLOR)
dnl//
define(`d_UpdateAmbientColor',`dnl
d_empty_($1)if (!(light->flags & D3DLIGHTI_AMBIENT_IS_ZERO))
d_margin($1){
d_margin($1)    if (!(dwFlags & D3DPV_COLORVERTEX_A))
d_margin($1)    {
d_margin($1)        d_OutDiffuse.r d_Op light->ambientMat.r $2;
d_margin($1)        d_OutDiffuse.g d_Op light->ambientMat.g $2;
d_margin($1)        d_OutDiffuse.b d_Op light->ambientMat.b $2;
d_margin($1)    }
d_margin($1)    else
d_margin($1)    {
d_margin($1)        const D3DVALUE r = (D3DVALUE)RGBA_GETRED(*d_pInpAmbient);
d_margin($1)        const D3DVALUE g = (D3DVALUE)RGBA_GETGREEN(*d_pInpAmbient);
d_margin($1)        const D3DVALUE b = (D3DVALUE)RGBA_GETBLUE(*d_pInpAmbient);
d_margin($1)        d_OutDiffuse.r d_Op light->ambient.r * r $2;
d_margin($1)        d_OutDiffuse.g d_Op light->ambient.g * g $2;
d_margin($1)        d_OutDiffuse.b d_Op light->ambient.b * b $2;
d_margin($1)    }
d_margin($1)    d_LightingFlags |= __LIGHT_DIFFUSECOMPUTED;
d_margin($1)}')dnl
dnl//------------------------------------------------------------------
dnl//           d_Directional7
dnl//
dnl// Generate code to light a vertex using directional or parallel point light.
dnl// Model space and camera space lighting are handled
dnl//
dnl// Arguments:
dnl/    $1  - margin count
dnl//   d_pInpPosition  - input position pointer (D3DVERTEX*)
dnl//   d_TmpPosition   - temporary position buffer (D3DVECTOR). 
dnl//                     Used in camera space lighting
dnl//   d_pInpNormal    - input normal pointer (D3DVECTOR*)
dnl//   d_TmpNormal     - temporary normal buffer (D3DVECTOR)
dnl//                     Used in camera space lighting
dnl//   d_Space         - Defines the coordinate system: modelSpace or cameraSpace
dnl//   d_LightingFlags - DWORD where __LIGHT_ bits are defined
dnl//
dnl// For camera space lighting vertex normal is assumed to be already transformed
dnl//
define(`d_Directional7',`dnl
d_empty_($1)D3DVALUE dot;
d_margin($1)d_UpdateAmbientColor($1)
d_margin($1)if (!(pv->dwVIDIn & D3DFVF_NORMAL))
d_margin($1)    goto l_exit;
d_margin($1)
ifelse(d_Space,modelSpace,`
d_margin($1)dot = VecDot(light->model_direction, (*d_pInpNormal));',`
d_margin($1)dot = VecDot(light->model_direction, d_TmpNormal);')
dnl//   endif 
d_margin($1)
d_margin($1)if (FLOAT_GTZ(dot))
d_margin($1){
ifelse(d_Op,+=,`dnl
d_margin($1)    d_UpdateDiffuseColor($1+1,+=)',`
d_margin($1)    if (!(d_LightingFlags & __LIGHT_DIFFUSECOMPUTED))
d_margin($1)    {
d_margin($1)        d_UpdateDiffuseColor($1+2, d_Op)
d_margin($1)    }
d_margin($1)    else
d_margin($1)    {
d_margin($1)        d_UpdateDiffuseColor($1+2,+=)
d_margin($1)    }')

d_margin($1)    if (light->flags & D3DLIGHTI_COMPUTE_SPECULAR)
d_margin($1)    {
d_margin($1)        D3DVECTOR h;      // halfway vector
d_margin($1)        D3DVECTOR eye;    // incident vector ie vector from eye
d_margin($1)ifelse(d_Space,modelSpace,`
d_margin($1)        if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
d_margin($1)        {
d_margin($1)            // calc vector from vertex to the camera
d_margin($1)            VecSub(pv->lighting.model_eye, (*(D3DVECTOR*)d_pInpPosition), eye);
d_margin($1)            VecNormalizeFast(eye);
d_margin($1)            VecAdd(light->model_direction, eye, h); // calc halfway vector
d_margin($1)            dot = VecDot(h, (*d_pInpNormal));
d_margin($1)        }
d_margin($1)        else
d_margin($1)        {
d_margin($1)            dot = VecDot(light->halfway, (*d_pInpNormal));
d_margin($1)        }',`
dnl//       else 
d_margin($1)ifelse(d_Op,+=,`
d_margin($1)        if (!(d_LightingFlags & __LIGHT_VERTEXTRANSFORMED))')
dnl//       endif 
d_margin($1)        {
d_margin($1)            // For tweening vertex position is already blended
d_margin($1)            d_TransformVertexToCameraSpace($1+3, d_pInpPosition, (&d_TmpPosition), pWeights, pMatrixIndices)
d_margin($1)            d_LightingFlags |= __LIGHT_VERTEXTRANSFORMED;
d_margin($1)        }
d_margin($1)        if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
d_margin($1)        {
d_margin($1)            // calc vector from vertex to the camera
d_margin($1)            VecSub(pv->lighting.model_eye, d_TmpPosition, eye);
d_margin($1)            VecNormalizeFast(eye);
d_margin($1)            VecAdd(light->model_direction, eye, h); // calc halfway vector
d_margin($1)            dot = VecDot(h, d_TmpNormal);
d_margin($1)        }
d_margin($1)        else
d_margin($1)        {
d_margin($1)            dot = VecDot(light->halfway, d_TmpNormal);
d_margin($1)        }')
dnl//       endif 
d_margin($1)        if (FLOAT_GTZ(dot)) 
d_margin($1)        {
d_margin($1)            if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
d_margin($1)                dot *= ISQRTF(VecLenSq(h));
d_margin($1)            d_ComputeSpecular($1+3);
d_margin($1)        }
d_margin($1)    }
d_margin($1)}
d_margin($1)l_exit:;
d_margin($1)')dnl 
dnl//------------------------------------------------------------------
dnl//               d_PointSpot7
dnl//
dnl// Generate code to light a vertex using point spot light.
dnl// Model space and camera space lighting are handled
dnl//
dnl// Arguments:
dnl/    $1  - margin count
dnl//   d_pInpPosition  - input position pointer (D3DVERTEX*)
dnl//   d_TmpPosition   - temporary position buffer (D3DVECTOR). 
dnl//                     Used in camera space lighting
dnl//   d_pInpNormal    - input normal pointer (D3DVECTOR*)
dnl//   d_TmpNormal     - temporary normal buffer (D3DVECTOR)
dnl//                     Used in camera space lighting
dnl//   d_Space         - Defines the coordinate system: modelSpace or cameraSpace
dnl//   d_LightingFlags - DWORD where __LIGHT_ bits are defined
dnl//
dnl// For camera space lighting vertex position is assumed to be already transformed
dnl//
define(`d_PointSpot7',`dnl
d_margin($1)D3DVALUE dot;   // dot product
d_margin($1)D3DVALUE dist;  // Distance from light to the vertex
d_margin($1)D3DVALUE dist2; // Square of the dist
d_margin($1)D3DVECTOR d;    // Direction to light
d_margin($1)D3DVALUE att;   // attenuation

ifelse(d_Space,modelSpace,`dnl
d_margin($1)VecSub(light->model_position, (*(D3DVECTOR*)d_pInpPosition), d);',`dnl
d_margin($1)VecSub(light->model_position, d_TmpPosition, d);')dnl
dnl// endif

d_margin($1)// early out if out of range or exactly on the vertex
d_margin($1)dist2 = d.x*d.x + d.y*d.y + d.z*d.z;
d_margin($1)if (FLOAT_CMP_POS(dist2, >=, light->range_squared) || FLOAT_EQZ(dist2))
d_margin($1)    goto l_exit;

d_margin($1)dot = 0;    // It is possible not to have normals (ambient component only)
d_margin($1)            // So we set dot to zero for this case
d_margin($1)// Calc dot product of light dir with normal.  Note that since we
d_margin($1)// did not normalize the direction the result is scaled by the distance.
ifelse(d_Space,modelSpace,`dnl
d_margin($1)if (pv->dwVIDIn & D3DFVF_NORMAL)
d_margin($1){
d_margin($1)    dot = VecDot(d, (*d_pInpNormal));
d_margin($1)}',`
d_margin($1)if (pv->dwVIDIn & D3DFVF_NORMAL)
d_margin($1){
ifelse(d_Op,+=,`dnl Normal should be transformed by the first light. So do not check.
d_margin($1)    if (!(d_LightingFlags & __LIGHT_NORMALTRANSFORMED))')
d_margin($1)    {
d_margin($1)        // For tweening normal should be already blended
d_margin($1)        d_TransformNormalToCameraSpace($1+1, d_pInpNormal, (&d_TmpNormal), pWeights, pMatrixIndices)
d_margin($1)        d_LightingFlags |= __LIGHT_NORMALTRANSFORMED;
d_margin($1)    }
d_margin($1)    dot = VecDot(d, d_TmpNormal);
d_margin($1)}')dnl

d_margin($1)if (!(light->flags & D3DLIGHTI_AMBIENT_IS_ZERO) || FLOAT_GTZ(dot))
d_margin($1){
d_margin($1)    dist = SQRTF(dist2); 
d_margin($1)    att = light->attenuation0 + 
d_margin($1)          light->attenuation1 * dist + 
d_margin($1)          light->attenuation2 * dist2;

d_margin($1)    if (!FLOAT_EQZ(att))
d_margin($1)        att = (D3DVALUE)1.0/att;
d_margin($1)    else
d_margin($1)        att = (D3DVALUE)FLT_MAX;

d_margin($1)    dist = D3DVAL(1)/dist;
d_margin($1)    if (light->type == D3DLIGHT_SPOT)
d_margin($1)    {
d_margin($1)        D3DVALUE cone_dot;
d_margin($1)        // Calc dot product of direction to light with light direction to
d_margin($1)        // be compared anganst the cone angles to see if we are in the light.
d_margin($1)        // Note that cone_dot is still scaled by dist
d_margin($1)        cone_dot = VecDot(d, light->model_direction)*dist;

d_margin($1)        if (FLOAT_CMP_POS(cone_dot, <=, light->cos_phi_by_2))
d_margin($1)            goto l_exit;

d_margin($1)        // modify att if in the region between phi and theta
d_margin($1)        if (FLOAT_CMP_POS(cone_dot, <, light->cos_theta_by_2))
d_margin($1)        {
d_margin($1)            D3DVALUE val;
d_margin($1)            val = (cone_dot - light->cos_phi_by_2) * light->inv_theta_minus_phi;
d_margin($1)            if (!(light->flags & D3DLIGHTI_LINEAR_FALLOFF)) 
d_margin($1)            {
d_margin($1)                val = POWF(val, light->falloff);
d_margin($1)            }
d_margin($1)            att *= val;
d_margin($1)        }
d_margin($1)    }
d_margin($1)    d_UpdateAmbientColor($1+1,* att)
d_margin($1)    if (FLOAT_LEZ(dot))
d_margin($1)        goto l_exit;

d_margin($1)    dot *= dist*att;
ifelse(d_Op,+=,`dnl
d_margin($1)    d_UpdateDiffuseColor($1+1,+=)',`
d_margin($1)    if (!(d_LightingFlags & __LIGHT_DIFFUSECOMPUTED))
d_margin($1)    {
d_margin($1)        d_UpdateDiffuseColor($1+2, d_Op)
d_margin($1)    }
d_margin($1)    else
d_margin($1)    {
d_margin($1)        d_UpdateDiffuseColor($1+2,+=)
d_margin($1)    }')

d_margin($1)    if (light->flags & D3DLIGHTI_COMPUTE_SPECULAR)
d_margin($1)    {
d_margin($1)        D3DVECTOR eye;
d_margin($1)        D3DVECTOR h;
d_margin($1)        // normalize light direction
d_margin($1)        d.x *= dist;
d_margin($1)        d.y *= dist;
d_margin($1)        d.z *= dist;

d_margin($1)        // calc vector from vertex to the camera
dnl
ifelse(d_Space,modelSpace,`dnl
dnl
d_margin($1)        if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
d_margin($1)        {
d_margin($1)            VecSub(pv->lighting.model_eye, (*(D3DVECTOR*)d_pInpPosition), eye);
d_margin($1)            VecNormalizeFast(eye);
d_margin($1)            VecAdd(d, eye, h);          // halfway vector
d_margin($1)        }
d_margin($1)        else
d_margin($1)        {
d_margin($1)            VecAdd(d, pv->lighting.directionToCamera, h);
d_margin($1)        }
d_margin($1)        VecNormalizeFast(h);
d_margin($1)        dot = VecDot(h, *d_pInpNormal);',`dnl
dnl
dnl// else
dnl
d_margin($1)        if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
d_margin($1)        {
d_margin($1)            VecSub(pv->lighting.model_eye, d_TmpPosition, eye);
d_margin($1)            VecNormalizeFast(eye);
d_margin($1)            VecAdd(d, eye, h);          // halfway vector
d_margin($1)        }
d_margin($1)        else
d_margin($1)        {
d_margin($1)            h.x = d.x;
d_margin($1)            h.y = d.y;
d_margin($1)            h.z = d.z - 1.0f;
d_margin($1)        }
d_margin($1)        VecNormalizeFast(h);
d_margin($1)        dot = VecDot(h, d_TmpNormal);')dnl
dnl
dnl// endif

d_margin($1)        d_ComputeSpecular($1+2,att)
d_margin($1)    }
d_margin($1)l_exit:;
d_margin($1)}')dnl
dnl//------------------------------------------------------------------
dnl//               d_LightVertices
dnl//
dnl//   Generate code to light vertices in a small batch using directional or
dnl//   parallel point light.
dnl//   Handles strided and non-strided cases
dnl//
dnl// Arguments:
dnl//   $1   - function name
dnl//   $2   - Light type: d_Directional7 or d_PointSpot7
dnl// 
define(`d_LightVertices',`dnl
//---------------------------------------------------------------------
void $1(LPD3DFE_PROCESSVERTICES pv, 
        DWORD dwVerCount,
        BATCHBUFFER *pBatchBuffer,
        D3DI_LIGHT *light, 
        D3DVERTEX *pCoord,
        D3DVALUE* pWeights,
        BYTE* pMatrixIndices,
        D3DVECTOR *pNormal,
        DWORD *pDiffuse,
        DWORD *pSpecular)
{
    // Setup vertex data pointers
    DWORD dwFlags = pv->dwFlags;
    DWORD *pColors[2] = {pDiffuse, pSpecular};
    DWORD **ppEmissiveSource = pColors + pv->lighting.dwEmissiveSrcIndex;
    DWORD **ppAmbientSource  = pColors + pv->lighting.dwAmbientSrcIndex;
    DWORD **ppSpecularSource = pColors + pv->lighting.dwSpecularSrcIndex;;
    DWORD **ppDiffuseSource  = pColors + pv->lighting.dwDiffuseSrcIndex;
    for (DWORD i = dwVerCount; i; i--)
    {
        $2(2)
        NEXT(pCoord, pv->position.dwStride, D3DVERTEX);
        NEXT(pNormal, pv->normal.dwStride, D3DVECTOR);
        NEXT(pWeights, pv->weights.dwStride, D3DVALUE);
        NEXT(pMatrixIndices, pv->matrixIndices.dwStride, BYTE);
        if (dwFlags & D3DPV_DOCOLORVERTEX)
        {
            NEXT(pColors[0], pv->diffuse.dwStride, DWORD);
            NEXT(pColors[1], pv->specular.dwStride, DWORD);

        }
        pBatchBuffer++;
    }
}') dnl

//--------------------------------------------------------------------------
// This batch buffer used to hold temporary vertex data for every small loop
//
const DWORD BATCH_SIZE = 10;    // Number of vertices in the batch
struct BATCHBUFFER
{
    D3DVALUE    sx,sy,sz,rhw;   // Screen coordinates
    D3DFE_COLOR diffuse;
    D3DFE_COLOR specular;
    D3DVECTOR   position;       // Vertex position in the camera space
    D3DVECTOR   normal;         // Vertex normal in the camera space
    DWORD       dwFlags;        // 8 low bits are the same as lighting 
                                // flags from D3DFE
};
dnl//======================================================================
dnl// Generate light functions for batch processing
dnl//
dnl
define(`d_LightingFlags',pBatchBuffer->dwFlags)dnl
define(`d_pInpAmbient',*ppAmbientSource)dnl
define(`d_pInpDiffuse',*ppDiffuseSource)dnl
define(`d_pInpSpecular',*ppSpecularSource)dnl
define(`d_OutDiffuse',pBatchBuffer->diffuse)dnl
define(`d_OutSpecular',pBatchBuffer->specular)dnl
define(`d_pInpPosition',`pCoord')dnl
define(`d_TmpPosition',`'pBatchBuffer->position)dnl
define(`d_pInpNormal',`pNormal')dnl
define(`d_TmpNormal',`pBatchBuffer->normal')dnl
dnl
define(`d_Op',=)dnl
define(`d_Space',cameraSpace)dnl
d_LightVertices(DirectionalFirst,`d_Directional7')
d_LightVertices(PointSpotFirst,`d_PointSpot7')
dnl
define(`d_Space',modelSpace)dnl
d_LightVertices(DirectionalFirstModel,`d_Directional7')
d_LightVertices(PointSpotFirstModel,`d_PointSpot7')
dnl
define(`d_Op',+=)dnl
dnl
define(`d_Space',cameraSpace)dnl
d_LightVertices(DirectionalNext,`d_Directional7')
d_LightVertices(PointSpotNext,`d_PointSpot7')
dnl
define(`d_Space',modelSpace)dnl
d_LightVertices(DirectionalNextModel,`d_Directional7')
d_LightVertices(PointSpotNextModel,`d_PointSpot7')
dnl//======================================================================
dnl// Generate light functions for one vertex processing
//-------------------------------------------------------------------------
// Directional light, computed in the   camera space
//
define(`d_LightingFlags',pv->lighting.dwLightingFlags)dnl
define(`d_pInpAmbient',(&pv->lighting.vertexAmbient))dnl
define(`d_pInpDiffuse',(&pv->lighting.vertexDiffuse))dnl
define(`d_pInpSpecular',(&pv->lighting.vertexSpecular))dnl
define(`d_OutDiffuse',pv->lighting.diffuse)dnl
define(`d_OutSpecular',pv->lighting.specular)dnl
define(`d_pInpPosition',`(pInpCoord)')dnl
define(`d_TmpPosition',`'*(D3DVERTEX*)pEyeSpaceData)dnl
define(`d_pInpNormal',`(pInpNormal)')dnl
define(`d_TmpNormal',`pEyeSpaceData->dvNormal')dnl
define(`d_Space',cameraSpace)dnl
dnl
void Directional7(LPD3DFE_PROCESSVERTICES pv, 
                  D3DI_LIGHT *light, 
                  D3DVERTEX *pInpCoord, 
                  D3DVALUE *pWeights,
                  BYTE* pMatrixIndices,
                  D3DVECTOR *pInpNormal,
                  D3DLIGHTINGELEMENT *pEyeSpaceData)
{
    DWORD dwFlags = pv->dwFlags;
    d_Directional7(1)
}
//---------------------------------------------------------------------
// Directional light, computed in the model space
//
define(`d_Space',modelSpace)dnl
dnl
void Directional7Model(LPD3DFE_PROCESSVERTICES pv, 
                       D3DI_LIGHT *light, 
                       D3DVERTEX *pInpCoord, 
                       D3DVALUE *pWeights,
                       BYTE* pMatrixIndices,
                       D3DVECTOR *pInpNormal,
                       D3DLIGHTINGELEMENT *pEyeSpaceData)
{
    DWORD dwFlags = pv->dwFlags;
    d_Directional7(1)
}
//---------------------------------------------------------------------
// Point-spot light, computed in the camera space
//
define(`d_Space',cameraSpace)dnl
void PointSpot7(LPD3DFE_PROCESSVERTICES pv, 
                D3DI_LIGHT *light, 
                D3DVERTEX *pInpCoord, 
                D3DVALUE *pWeights,
                BYTE* pMatrixIndices,
                D3DVECTOR *pInpNormal,
                D3DLIGHTINGELEMENT *pEyeSpaceData)
{
    DWORD dwFlags = pv->dwFlags;
    d_PointSpot7(1)
}
//---------------------------------------------------------------------
// Point-spot light, computed in the model space
//
define(`d_Space',modelSpace)dnl
void PointSpot7Model(LPD3DFE_PROCESSVERTICES pv, 
                     D3DI_LIGHT *light, 
                     D3DVERTEX *pInpCoord, 
                     D3DVALUE *pWeights,
                     BYTE* pMatrixIndices,
                     D3DVECTOR *pInpNormal,
                     D3DLIGHTINGELEMENT *pEyeSpaceData)
{
    DWORD dwFlags = pv->dwFlags;
    d_PointSpot7(1)
}
//--------------------------------------------------------------------------
// Prototype to transform vertices in batches
//
typedef DWORD (*PFN_TRANSFORMLOOP)(LPD3DFE_PROCESSVERTICES pv, 
                                   DWORD dwVerCount,
                                   D3DVERTEX *in,
                                   D3DVALUE* pWeights,
                                   BYTE* pMatrixIndices,
                                   D3DTLVERTEX **ppOut,
                                   D3DFE_CLIPCODE **ppClipCodes);
//---------------------------------------------------------------------
// Transform vertices in a batch with clipping
//
// Arguments:
//      dwVerCount  - number of vertices in the batch
//      in          - pointer to the input coordinates
//      ppOut       - pointer to the output vertices
//      ppClipVodes - pointer to the clip code buffer
// Returns:
//      Number of processed vertices
// Notes:
//      ppOut and ppClipCodes will be set to the next vertex after the batch
//
DWORD TransformClip(LPD3DFE_PROCESSVERTICES pv, 
                  DWORD dwVerCount,
                  D3DVERTEX *in,
                  D3DVALUE* pWeights,
                  BYTE* pMatrixIndices,
                  D3DTLVERTEX **ppOut,
                  D3DFE_CLIPCODE **ppClipCodes)
{
   float x, y, z, w;
   D3DMATRIX *m = (D3DMATRIX*)&pv->mCTM[0];
   DWORD dwInpVerSize =  pv->position.dwStride;
   DWORD dwOutVerSize =  pv->dwOutputSize;
   D3DFE_CLIPCODE *pClipCodes = *ppClipCodes;
   D3DTLVERTEX *out = *ppOut;
   DWORD dwDeviceFlags = pv->dwDeviceFlags;

   for (DWORD i = dwVerCount; i; i--)
   {
        // Transform vertex to the clipping space 
        d_TransformVertex(2, in, m, x, y, z, w, pWeights, pMatrixIndices)

        DWORD clip;
        // Compute clip code
        d_ComputeClipCode(2)
        if (clip == 0)
        {
	        pv->dwClipIntersection = 0;
            *pClipCodes++ = 0;
            w = D3DVAL(1)/w;
        }
        else
        {
            if (dwDeviceFlags & D3DDEV_GUARDBAND)
            {
                // We do guardband check in the projection space, so
                // we transform X and Y of the vertex there
                d_ComputeClipCodeGB(4)
                if ((clip & ~__D3DCS_INGUARDBAND) == 0)
                {
                    // If vertex is inside the guardband we have to compute 
                    // screen coordinates
                    w = D3DVAL(1)/w;
                    *pClipCodes++ = (D3DFE_CLIPCODE)clip;
	                pv->dwClipIntersection &= clip;
	                pv->dwClipUnion |= clip;
                    goto l_DoScreenCoord;
                }
            }
            if (pv->dwFlags & D3DPV_ONEPASSCLIPPING)
            {
                return dwVerCount - i;
            }
	        pv->dwClipIntersection &= clip;
	        pv->dwClipUnion |= clip;
            *pClipCodes++ = (D3DFE_CLIPCODE)clip;
            // If vertex is outside the frustum we can not compute screen
            // coordinates
            out->sx = x;
            out->sy = y;
            out->sz = z;
            out->rhw = w;
            goto l_Continue;
        }

    l_DoScreenCoord:

        d_ComputeScreenCoordinates(2, x, y, z, w, out)

   l_Continue:
       NEXT(in, dwInpVerSize, D3DVERTEX);
       NEXT(out, dwOutVerSize, D3DTLVERTEX);
       NEXT(pWeights, pv->weights.dwStride, D3DVALUE);
       NEXT(pMatrixIndices, pv->matrixIndices.dwStride, BYTE);
   }
   *ppClipCodes = pClipCodes;
   *ppOut = out;
   return dwVerCount;
}
//---------------------------------------------------------------------
// Transform vertices in a batch without clipping
//
// Arguments:
//      dwVerCount  - number of vertices in the batch
//      in          - pointer to the input coordinates
//      ppOut       - pointer to the output vertices
//      ppClipVodes - pointer to the clip code buffer
// Returns:
//      Number of processed vertices
// Notes:
//      ppOut and ppClipCodes will be set to the next vertex after the batch
//
DWORD TransformNoClip(LPD3DFE_PROCESSVERTICES pv, 
                     DWORD dwVerCount,
                     D3DVERTEX *in,
                     D3DVALUE* pWeights,
                     BYTE* pMatrixIndices,
                     D3DTLVERTEX **ppOut,
                     D3DFE_CLIPCODE **pClipCodes)
{
   float x, y, z, w;
   D3DMATRIX *m = (D3DMATRIX*)&pv->mCTM[0];
   DWORD dwInpVerSize =  pv->position.dwStride;
   DWORD dwOutVerSize =  pv->dwOutputSize;
   D3DTLVERTEX *out = *ppOut;

   for (DWORD i = dwVerCount; i; i--)
   {
        // Transform vertex to the clipping space
        d_TransformVertex(2, in, m, x, y, z, w, pWeights, pMatrixIndices)

        // We have to check this only for DONOTCLIP case, because otherwise
        // the vertex with "we = 0" will be clipped and screen coordinates 
        // will not be computed
        // "clip" is not zero, if "w" is zero.
        if (!FLOAT_EQZ(w))
            w = D3DVAL(1)/w;
        else
            w = __HUGE_PWR2;

        d_ComputeScreenCoordinates(2, x, y, z, w, out)

       NEXT(in, dwInpVerSize, D3DVERTEX);
       NEXT(pWeights, pv->weights.dwStride, D3DVALUE);
       NEXT(pMatrixIndices, pv->matrixIndices.dwStride, BYTE);
       NEXT(out, dwOutVerSize, D3DTLVERTEX);
   }
   *ppOut = out;
   return dwVerCount;
}
//---------------------------------------------------------------------
// Transforms, lights vertices, computes clip codes
// Processing is done in small batches (BATCH_SIZE).
//
// The following fields from pv are used:
//   dwFlags
//   dwNumVertices
//   all pointer and strides
//   position.lpvStrides
//   dwVIDIn
//   dwVIDOut
//   lpvOut
//   lpClipFlags
//   nTexCoord
// Returns:
//   returns dwClipIntersection or 0 (if D3DDEV_DONOTCLIP is set)
// Side effects:
//   dwClipUnion, dwClipIntersection are set only if D3DDEV_DONOTCLIP is not set
//
#undef DPF_MODNAME
#define DPF_MODNAME "ProcessVerticesLoops"
DWORD ProcessVerticesLoop(LPD3DFE_PROCESSVERTICES pv)
{
    D3DFE_CLIPCODE *hout = pv->lpClipFlags;
    D3DTLVERTEX *out  = (D3DTLVERTEX*)pv->lpvOut;
    D3DMATRIXI *m = &pv->mCTM[0];
    DWORD dwNumVertices = pv->dwNumVertices;
    D3DVALUE *pOutTexture  = (D3DVALUE*)((char*)out + pv->texOffsetOut);
    DWORD *pOutDiffuse  = (DWORD*)((char*)out + pv->diffuseOffsetOut);
    DWORD *pOutSpecular = (DWORD*)((char*)out + pv->specularOffsetOut);
    float* pOutPointSize = (float*)((char*)out + pv->pointSizeOffsetOut);
    DWORD dwNumTexCoord = pv->nOutTexCoord;
    DWORD *pOutFogFactor = pOutSpecular;
    PFN_TRANSFORMLOOP pfnTransform;
    float PointSizeRs = *(float*)&pv->lpdwRStates[D3DRS_POINTSIZE];
    float PointSizeMin = *(float*)&pv->lpdwRStates[D3DRS_POINTSIZE_MIN];
    float A, B, C;  // Point size scales
    BOOL  bDoPointScale = FALSE;

    d_Setup()

    if (pv->lpdwRStates[D3DRS_POINTSCALEENABLE] != 0)
    {
        bDoPointScale = TRUE;
        A = *(float*)&pv->lpdwRStates[D3DRS_POINTSCALE_A];
        B = *(float*)&pv->lpdwRStates[D3DRS_POINTSCALE_B];
        C = *(float*)&pv->lpdwRStates[D3DRS_POINTSCALE_C];
    }

    if (pv->dwFlags & D3DPV_DONOTCOPYTEXTURE)
        dwNumTexCoord = 0;

    BATCHBUFFER batchBuffer[BATCH_SIZE];
    DWORD dwInpVerSizeBatch = dwInpVerSize * BATCH_SIZE;
    DWORD dwOutVerSizeBatch = dwOutVerSize * BATCH_SIZE;
    DWORD dwNormalStrideBatch = pv->normal.dwStride * BATCH_SIZE;
    DWORD dwWeightsStrideBatch = pv->weights.dwStride * BATCH_SIZE;
    DWORD dwMatrixIndicesStrideBatch = pv->matrixIndices.dwStride * BATCH_SIZE;
    if (!(dwDeviceFlags & D3DDEV_DONOTCLIP))
    {
        pfnTransform = TransformClip;
        pv->dwClipIntersection = ~0;
        pv->dwClipUnion = 0;
    }
    else
    {
        pfnTransform = TransformNoClip;
        pv->dwClipIntersection = 0;
        pv->dwClipUnion = 0;
    }

    // When we do tweening we make "in" and "inNormal" pointers to point
    // to the tweened value. We also change position and normal stride.
    // But need to restore the strides later
    UINT oldPositionStride = pv->position.dwStride;
    UINT oldNormalStride = pv->normal.dwStride;

    if (pv->dwFlags & (D3DPV_POSITION_TWEENING | 
                       D3DPV_NORMAL_TWEENING))
    {
        pv->tweenFactor = *(float*)&pv->lpdwRStates[D3DRS_TWEENFACTOR];
        // Replace strides because we will use blended positions and normals
        if (pv->dwFlags & D3DPV_POSITION_TWEENING)
            pv->position.dwStride = sizeof(D3DVECTOR);
        if (pv->dwFlags & D3DPV_NORMAL_TWEENING)
            pv->normal.dwStride = sizeof(D3DVECTOR);
    }

    // Input vertex pointers for tweening
    D3DVECTOR* inT = in;
    D3DVECTOR* inNormalT = inNormal;

    // These two arrays are used when we do tweening.
    // We blend positions and normals in model space using tweenFactor
    // and then transform then to the camera (clipping) space
    //
    D3DVECTOR   posT[BATCH_SIZE];   // Blended position in model space
    D3DVECTOR   normT[BATCH_SIZE];  // Blended normal in model space

    do
    {
        DWORD count1 = min(dwNumVertices, BATCH_SIZE);

        // Count of vertices to process after transformation. It could be less 
        // than "count1" because of clipping
        DWORD count;    

        if (pv->dwFlags & D3DPV_POSITION_TWEENING)
        {
            // Blend vertices in the model space
            for (UINT i=0; i < count1; i++)
            {
                DoBlending(pv->tweenFactor, inT, in2, &posT[i]);
                inT  = (D3DVECTOR*)((BYTE*)inT  + oldPositionStride);
                in2 = (D3DVECTOR*)((BYTE*)in2 + pv->position2.dwStride);
            }
            // Substitute input pointer
            in = posT;
        }
        if (pv->dwFlags & D3DPV_NORMAL_TWEENING)
        {
            for (UINT i=0; i < count1; i++)
            {
                DoBlending(pv->tweenFactor, inNormalT, inNormal2, &normT[i]);
                inNormalT  = (D3DVECTOR*)((BYTE*)inNormalT  + oldNormalStride);
                inNormal2 = (D3DVECTOR*)((BYTE*)inNormal2 + pv->normal2.dwStride);
            }
            // Substitute input pointer
            inNormal = normT;
        }

        count = (*pfnTransform)(pv, count1, (D3DVERTEX*)in, 
                                inWeights, inMatrixIndices, &out, &hout);

        if (pv->dwFlags & (D3DPV_FOG | D3DPV_LIGHTING) ||
            bDoPointScale ||
            pv->dwDeviceFlags & (D3DDEV_POSITIONINCAMERASPACE | D3DDEV_NORMALINCAMERASPACE))
        {
            memset(batchBuffer, 0, sizeof(batchBuffer));
        }
        // Compute camera space position if needed
        if (pv->dwDeviceFlags & (D3DDEV_POSITIONINCAMERASPACE | D3DDEV_NORMALINCAMERASPACE) ||
            bDoPointScale)
        {
            BATCHBUFFER *buf = batchBuffer;
            D3DVECTOR* pVertex = in;
            D3DVECTOR* pNormal = inNormal;
            D3DVALUE*  pWeights = inWeights;
            BYTE*      pMatrixIndices = inMatrixIndices;
            for (DWORD i=count; i; i--)
            {
                if (pv->dwDeviceFlags & D3DDEV_POSITIONINCAMERASPACE || 
                    bDoPointScale)
                {
                    d_TransformVertexToCameraSpace(5, pVertex, ((D3DVERTEX*)&buf->position), pWeights, pMatrixIndices)
                    buf->dwFlags |= __LIGHT_VERTEXTRANSFORMED;
                }
                if (pv->dwDeviceFlags & D3DDEV_NORMALINCAMERASPACE)
                {
                    d_TransformNormalToCameraSpace(5, pNormal, ((D3DVERTEX*)&buf->normal), pWeights, pMatrixIndices)
                    buf->dwFlags |= __LIGHT_NORMALTRANSFORMED;
                    NEXT(pNormal, pv->normal.dwStride, D3DVECTOR);
                }
                NEXT(pVertex, pv->position.dwStride, D3DVECTOR);
                NEXT(pWeights, pv->weights.dwStride, D3DVALUE);
                NEXT(pMatrixIndices, pv->matrixIndices.dwStride, BYTE);
                buf++;
            }
        }
        if (pv->dwFlags & D3DPV_LIGHTING)
        {
            // Light vertices. Output goes to the batch buffer
            D3DI_LIGHT *light = pv->lighting.activeLights;
            if (light)
            {
                light->pfnLightFirst(pv, count, batchBuffer, light, (D3DVERTEX*)in, 
                                     inWeights, inMatrixIndices, inNormal, 
                                     inDiffuse, inSpecular);
                while(light = light->next)
                {
                    light->pfnLightNext(pv, count, batchBuffer, light, (D3DVERTEX*)in, 
                                        inWeights, inMatrixIndices, inNormal, 
                                        inDiffuse, inSpecular);
                }
            }
            // Copy vertices from the batch buffer to the output
            BATCHBUFFER *buf = batchBuffer;
dnl
define(`d_OutDiffuse',buf->diffuse)dnl
define(`d_OutSpecular',buf->specular)dnl
define(`d_dwOutSpecular',*pOutSpecular)dnl
define(`d_dwOutDiffuse',*pOutDiffuse)dnl
define(`d_LightingFlags',buf->dwFlags)dnl
dnl
            if (pv->dwFlags & D3DPV_DOCOLORVERTEX)
            {
                for (DWORD i = count; i; i--)
                {
                    d_MakeOutputColors(5)
                    buf++;
                    NEXT(pOutSpecular, dwOutVerSize, DWORD);
                    NEXT(pOutDiffuse, dwOutVerSize, DWORD);
                    NEXT(inDiffuse,  pv->diffuse.dwStride, DWORD);
                    NEXT(inSpecular, pv->specular.dwStride, DWORD);
                }
            }
            else
            {
                for (DWORD i = count; i; i--)
                {
                    d_MakeOutputColorsNoColorVertex(5)
                    buf++;
                    NEXT(pOutSpecular, dwOutVerSize, DWORD);
                    NEXT(pOutDiffuse, dwOutVerSize, DWORD);
                    NEXT(inDiffuse,  pv->diffuse.dwStride, DWORD);
                    NEXT(inSpecular, pv->specular.dwStride, DWORD);
                }
            }
        }
        else
        {
            // If there is no lighting, we have to copy vertex color or 
            // default color to the output
            if (!(pv->dwFlags & D3DPV_DONOTCOPYDIFFUSE))
            {
                if (pv->dwVIDIn & D3DFVF_DIFFUSE)    
                {
                    for (DWORD i = count; i; i--)
                    {
                        *pOutDiffuse = *inDiffuse;
                        NEXT(pOutDiffuse, dwOutVerSize, DWORD);
                        NEXT(inDiffuse,  pv->diffuse.dwStride, DWORD);
                    }
                }
                else
                {
                    for (DWORD i = count; i; i--)
                    {
                        *pOutDiffuse = __DEFAULT_DIFFUSE;
                        NEXT(pOutDiffuse, dwOutVerSize, DWORD);
                    }
                }
            }
            if (!(pv->dwFlags & D3DPV_DONOTCOPYSPECULAR))
            {
                if (pv->dwVIDIn & D3DFVF_SPECULAR)    
                {
                    for (DWORD i = count; i; i--)
                    {
                        *pOutSpecular = *inSpecular;
                        NEXT(pOutSpecular, dwOutVerSize, DWORD);
                        NEXT(inSpecular,  pv->specular.dwStride, DWORD);
                    }
                }
                else
                {
                    for (DWORD i = count; i; i--)
                    {
                        *pOutSpecular = __DEFAULT_SPECULAR;
                        NEXT(pOutSpecular, dwOutVerSize, DWORD);
                    }
                }
            }
        }

        if (pv->dwFlags & D3DPV_FOG)
        {
            BATCHBUFFER* buf = batchBuffer;
            D3DVECTOR* pVertex = in;
            D3DVALUE*  pWeights = inWeights;
            BYTE*      pMatrixIndices = inMatrixIndices;
            for (DWORD i = count; i; i--)
            {
                D3DVALUE dist;
                // Vertex is already transformed to the camera space
                if (dwDeviceFlags & D3DDEV_RANGEBASEDFOG)
                    dist = SQRTF(buf->position.x*buf->position.x + 
                                 buf->position.y*buf->position.y + 
                                 buf->position.z*buf->position.z);
                else
                    dist = ABSF(buf->position.z);

                ComputeFogFactor(pv, dist, pOutFogFactor);

                NEXT(pVertex, pv->position.dwStride, D3DVECTOR);
                NEXT(pWeights, pv->weights.dwStride, D3DVALUE);
                NEXT(pMatrixIndices, pv->matrixIndices.dwStride, BYTE);
                NEXT(pOutFogFactor, dwOutVerSize, DWORD);
                buf++;
            }
        }
 
        if (pv->dwVIDOut & D3DFVF_PSIZE)
        {
            float PointSize;
            BATCHBUFFER *buf = batchBuffer;
            for (DWORD i = count; i; i--)
            {
                if (pv->dwVIDIn & D3DFVF_PSIZE)
                    PointSize = *inPointSize;
                else
                    PointSize = PointSizeRs;

                if (bDoPointScale)
                {
                    float dist = SQRTF(buf->position.x*buf->position.x + 
                                       buf->position.y*buf->position.y + 
                                       buf->position.z*buf->position.z);
                    float v = A + B*dist + C*dist*dist;
                    if (v <=  0)
                    {
                        PointSize = pv->PointSizeMax;
                    }
                    else
                    {
                        // Clamping of the point size to [PointSizeMin, PointSizeMax]
                        // will be done by hardware or when we expand points
                        float PointSizeScale = pv->vcache.dvHeight * (float)sqrt(1.0/v);
                        PointSize *= PointSizeScale;
                    }
                    buf++;
                }
                *pOutPointSize = PointSize;
                NEXT(pOutPointSize, dwOutVerSize, float);
                NEXT(inPointSize, pv->psize.dwStride, float);
            }
        }

        // Process texture coordinates
        if (dwNumTexCoord != 0)
        {
            if (pv->dwDeviceFlags & D3DDEV_STRIDE) 
            {
                if (!(pv->dwDeviceFlags & (D3DDEV_TEXTURETRANSFORM | D3DDEV_REMAPTEXTUREINDICES)))
                {
                    for (DWORD i=count; i; i--)
                    {
                        D3DVALUE *pTexture = pOutTexture;
                        for (DWORD k=0; k < dwNumTexCoord; k++)                                
                        {                                                                      
                            const DWORD dwSize = pv->dwTextureCoordSize[k];
                            memcpy(pTexture, inTexture[k], dwSize);                           
                            pTexture = (D3DVALUE*)((char*)pTexture + dwSize);
                            NEXT(inTexture[k], pv->textures[k].dwStride, D3DVALUE);
                        }
                        NEXT(pOutTexture, dwOutVerSize, D3DVALUE);
                    }
                }
                else
                {
                    if (!(pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES))
                    {
                        D3DVALUE *pOut = pOutTexture;
                        for (DWORD k=0; k < dwNumTexCoord; k++)                                
                        {
                            const DWORD dwSize = pv->dwTextureCoordSize[k];
                            const DWORD dwInpSize = pv->dwInpTextureCoordSize[k];
                            const DWORD dwStride = pv->textures[k].dwStride;                   
                            D3DVALUE *pInpTexture = inTexture[k];
                            if (pv->pmTexture[k] == NULL)
                            {
                                D3DVALUE *pOutTmp = pOut;
                                for (DWORD i=count; i; i--)
                                {
                                    memcpy(pOutTmp, pInpTexture, dwSize);
                                    NEXT(pInpTexture, dwStride, D3DVALUE);
                                    NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                                }
                            }
                            else
                            {
                                const DWORD n = dwSize >> 2; // Number of input tex. coord.
                                const DWORD m = dwInpSize >> 2; // Number of input tex. coord.
                                (*(g_pfnTextureTransformLoop[MakeTexTransformFuncIndex(m, n)]))
                                    (pInpTexture, pOut, pv->pmTexture[k], count, 
                                     dwStride, dwOutVerSize);
                            }
                            NEXT(pOut, dwSize, D3DVALUE);
                            NEXT(inTexture[k], dwStride*BATCH_SIZE, D3DVALUE);
                        }
                        NEXT(pOutTexture, dwOutVerSizeBatch, D3DVALUE);
                    }
                    else
                    {
                        D3DVALUE *pOut = pOutTexture;
                        for (DWORD k=0; k < pv->dwNumTextureStages; k++)
                        {
                            const LPD3DFE_TEXTURESTAGE pStage = &pv->textureStage[k];
                            const DWORD dwOutTexSize = pv->dwTextureCoordSize[k];
                            DWORD dwStride;
                            D3DVALUE *pIn;
                            D3DVECTOR reflectionVector[BATCH_SIZE];
                            if (pStage->dwTexGenMode == 0)
                            {
                                const DWORD dwInpIndex = pStage->dwInpCoordIndex;
                                pIn = inTexture[dwInpIndex];
                                dwStride = pv->textures[dwInpIndex].dwStride;
                            }
                            else
                            if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACEPOSITION)
                            {
                                pIn = (D3DVALUE*)&batchBuffer[0].position;
                                dwStride = sizeof(BATCHBUFFER);
                            }
                            else
                            if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACENORMAL)
                            {
                                pIn = (D3DVALUE*)&batchBuffer[0].normal;
                                dwStride = sizeof(BATCHBUFFER);
                            }
                            else // D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
                            {
                                if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
                                {
                                    for (DWORD i=0; i < count; i++)
                                    {
                                        ComputeReflectionVector(&batchBuffer[i].position,
                                                                &batchBuffer[i].normal,
                                                                &reflectionVector[i]);
                                    }
                                }
                                else
                                {
                                    for (DWORD i=0; i < count; i++)
                                    {
                                        ComputeReflectionVectorInfiniteViewer(&batchBuffer[i].normal,
                                                                              &reflectionVector[i]);
                                    }
                                }
                                pIn = (D3DVALUE*)reflectionVector;
                                dwStride = sizeof(D3DVECTOR);
                            }
                            if (pStage->bDoTextureProjection)
                            {
                                // We need to do emulation of texture projection
                                if (pStage->pmTextureTransform == NULL)
                                {
                                    D3DVALUE *pOutTmp = pOut;
                                    for (DWORD i=count; i; i--)
                                    {
                                        DoTextureProjection(pIn, pOutTmp, dwOutTexSize);
                                        NEXT(pIn, dwStride, D3DVALUE);
                                        NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                                    }
                                }
                                else
                                {
                                    D3DVALUE *pOutTmp = pOut;
                                    for (DWORD i=count; i; i--)
                                    {
                                        float TmpOutputTexture[4];
                                        (*(g_pfnTextureTransform[pStage->dwTexTransformFuncIndex]))
                                              (pIn, TmpOutputTexture, pStage->pmTextureTransform);
                                        DoTextureProjection(TmpOutputTexture, pOutTmp, dwOutTexSize);
                                        NEXT(pIn, dwStride, D3DVALUE);
                                        NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                                    }
                                }
                            }
                            else
                            if (pStage->pmTextureTransform == NULL)
                            {
                                D3DVALUE *pOutTmp = pOut;
                                for (DWORD i=count; i; i--)
                                {
                                    memcpy(pOutTmp, pIn, dwOutTexSize);
                                    NEXT(pIn, dwStride, D3DVALUE);
                                    NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                                }
                            }
                            else
                            {
                                (*(g_pfnTextureTransformLoop[pStage->dwTexTransformFuncIndex]))
                                    (pIn, pOut, pStage->pmTextureTransform, count, 
                                     dwStride, dwOutVerSize);
                            }
                            NEXT(pOut, dwOutTexSize, D3DVALUE);
                        }
                        NEXT(pOutTexture, dwOutVerSizeBatch, D3DVALUE);
                        for (DWORD m=0; m < pv->nTexCoord; m++)
                        {
	                         NEXT(inTexture[m], pv->textures[m].dwStride*BATCH_SIZE, D3DVALUE);
                        }
                     }
                }
            }
            else
            {
                if (!(pv->dwDeviceFlags & (D3DDEV_TEXTURETRANSFORM | D3DDEV_REMAPTEXTUREINDICES)))
                {
                    for (DWORD i=count; i; i--)
                    {
                        memcpy(pOutTexture, inTexture[0], pv->dwTextureCoordSizeTotal);
                        NEXT(pOutTexture, dwOutVerSize, D3DVALUE);
                        NEXT(inTexture[0], dwInpVerSize, D3DVALUE);
                    }
                }
                else
                if (!(pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES))
                {
                    D3DVALUE *pIn = inTexture[0];
                    D3DVALUE *pOut = pOutTexture;                                        
                    for (DWORD k=0; k < dwNumTexCoord; k++)
                    {
                        const DWORD dwSize = pv->dwTextureCoordSize[k];
                        const DWORD dwInpSize = pv->dwInpTextureCoordSize[k];
                        if (pv->pmTexture[k] == NULL)
                        {
                            D3DVALUE *pOutTmp = pOut;
                            D3DVALUE *pInpTmp = pIn;
                            for (DWORD i=count; i; i--)
                            {
                                memcpy(pOutTmp, pInpTmp, dwSize);                                           
                                NEXT(pInpTmp,  dwInpVerSize, D3DVALUE);
                                NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                            }
                        }
                        else
                        {
                            const DWORD n = dwSize >> 2; // Number of output tex. coord.
                            const DWORD m = dwInpSize >> 2; // Number of input tex. coord.
                            (*(g_pfnTextureTransformLoop[MakeTexTransformFuncIndex(m, n)]))
                                (pIn, pOut, pv->pmTexture[k], count, dwInpVerSize, dwOutVerSize);
                        }
                        NEXT(pIn, dwInpSize, D3DVALUE);
                        NEXT(pOut, dwSize, D3DVALUE);
                    }
                    NEXT(inTexture[0], dwInpVerSizeBatch, D3DVALUE);
                    NEXT(pOutTexture,  dwOutVerSizeBatch, D3DVALUE);
                }
                else
                {
                    D3DVALUE *pOut = pOutTexture;
                    for (DWORD i=0; i < pv->dwNumTextureStages; i++)
                    {
                        LPD3DFE_TEXTURESTAGE pStage = &pv->textureStage[i];
                        const DWORD dwSize = pv->dwTextureCoordSize[i];
                        D3DVALUE *pIn;
                        DWORD dwStride;
                        D3DVECTOR reflectionVector[BATCH_SIZE];
                        if (pStage->dwTexGenMode == 0)
                        {
                            pIn = (D3DVALUE*)((BYTE*)inTexture[0] + pStage->dwInpOffset);
                            dwStride = dwInpVerSize;
                        }
                        else
                        if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACEPOSITION)
                        {
                            pIn = (D3DVALUE*)&batchBuffer[0].position;
                            dwStride = sizeof(BATCHBUFFER);
                        }
                        else
                        if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACENORMAL)
                        {
                            pIn = (D3DVALUE*)&batchBuffer[0].normal;
                            dwStride = sizeof(BATCHBUFFER);
                        }
                        else // D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
                        {
                            if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
                            {
                                for (DWORD i=0; i < count; i++)
                                {
                                    ComputeReflectionVector(&batchBuffer[i].position,
                                                            &batchBuffer[i].normal,
                                                            &reflectionVector[i]);
                                }
                            }
                            else
                            {
                                for (DWORD i=0; i < count; i++)
                                {
                                    ComputeReflectionVectorInfiniteViewer(&batchBuffer[i].normal,
                                                                          &reflectionVector[i]);
                                }
                            }
                            pIn = (D3DVALUE*)reflectionVector;
                            dwStride = sizeof(D3DVECTOR);
                        }
                        if (pStage->bDoTextureProjection)
                        {
                            // We need to do emulation of texture projection
                            if (pStage->pmTextureTransform == NULL)
                            {
                                D3DVALUE *pOutTmp = pOut;
                                for (DWORD i=count; i; i--)
                                {
                                    DoTextureProjection(pIn, pOutTmp, dwSize);
                                    NEXT(pIn,  dwStride, D3DVALUE);
                                    NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                                }
                            }
                            else
                            {
                                D3DVALUE *pOutTmp = pOut;
                                for (DWORD i=count; i; i--)
                                {
                                    float TmpOutputTexture[4];
                                    (*(g_pfnTextureTransform[pStage->dwTexTransformFuncIndex]))
                                        (pIn, TmpOutputTexture, pStage->pmTextureTransform);
                                    DoTextureProjection(TmpOutputTexture, pOutTmp, dwSize);
                                    NEXT(pIn, dwStride, D3DVALUE);
                                    NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                                }
                            }
                        }
                        else
                        if (pStage->pmTextureTransform == NULL)
                        {
                            D3DVALUE *pOutTmp = pOut;
                            for (DWORD i=count; i; i--)
                            {
                                memcpy(pOutTmp, pIn, dwSize);
                                NEXT(pIn,  dwStride, D3DVALUE);
                                NEXT(pOutTmp, dwOutVerSize, D3DVALUE);
                            }
                        }
                        else
                        {
                            (*(g_pfnTextureTransformLoop[pStage->dwTexTransformFuncIndex]))
                                (pIn, pOut, pStage->pmTextureTransform, count, dwStride, dwOutVerSize);
                        }
                        NEXT(pOut, dwSize, D3DVALUE);
                    }
                    NEXT(inTexture[0], dwInpVerSizeBatch, D3DVALUE);
                    NEXT(pOutTexture,  dwOutVerSizeBatch, D3DVALUE);
                }
            }
        }
        if (count != count1)
        {
            pv->dwFirstClippedVertex = pv->dwNumVertices - dwNumVertices + count;
            break;
        }
     
        NEXT(inNormal, dwNormalStrideBatch, D3DVECTOR);
        NEXT(in, dwInpVerSizeBatch, D3DVECTOR);
        NEXT(inWeights, dwWeightsStrideBatch, D3DVALUE);
        NEXT(inMatrixIndices, dwMatrixIndicesStrideBatch, BYTE);

        dwNumVertices -= count;
    } while (dwNumVertices);

    // Restore original strides, because they could changed for tweening
    pv->position.dwStride = oldPositionStride;
    pv->normal.dwStride = oldNormalStride;

    return pv->dwClipIntersection;
}