1354 lines
56 KiB
Plaintext
1354 lines
56 KiB
Plaintext
|
/*==========================================================================;
|
||
|
|
*
|
||
|
|
* 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;
|
||
|
|
}
|
||
|
|
|