able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dxg/d3d8/tnl/pvvid.mh

976 lines
40 KiB
Plaintext
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
dnl/*==========================================================================
dnl *
dnl * Copyright (C) 1998 Microsoft Corporation. All Rights Reserved.
dnl *
dnl * File: pvvid.h
dnl * Content: Common defines for the geometry inner loop
dnl *
dnl ***************************************************************************/
#define NEXT(pointer, stride, type) pointer = (type*)((char*)pointer + stride);
dnl
dnl//--------------------------------------------------------------------------
dnl d_forloop
dnl FOR loop
dnl
dnl Arguments:
dnl $1 - loop variable
dnl $2 - start value
dnl $3 - end value
dnl $4 - loop body
dnl
define(`d_forloop',
`pushdef(`$1', `$2')d_forloopi(`$1', `$2', `$3', `$4')popdef(`$1')')dnl
define(`d_forloopi', `$4`'ifelse($1, `$3', ,
`define(`$1', incr($1))d_forloopi(`$1', `$2', `$3', `$4')')')dnl
dnl//--------------------------------------------------------------------------
dnl d_margin
dnl
dnl Repeats spaces ($1)*4 times
dnl Arguments:
dnl $1 - margin
dnl
define(`d_margin',`d_forloop(`i',1,eval(($1)*4),` ')')dnl
dnl
dnl//--------------------------------------------------------------------------
define(`d_empty_',`')dnl
dnl//--------------------------------------------------------------------------
dnl// d_TransformVertex
dnl//
dnl// $1 - margin count
dnl// $2 - input vector (D3DVECTOR*)
dnl// $3 - matrix (D3DMATRIX*)
dnl// $4 - output x
dnl// $5 - output y
dnl// $6 - output z
dnl// $7 - output w
dnl// $8 - pointer to weights
dnl// $9 - pointer to matrix indices (BYTE*)
dnl//
define(`d_TransformVertex',`dnl
d_empty_($1)if (pv->dwNumVerBlends == 0)
d_margin($1){
d_margin($1) $4 = $2->x*$3->_11 + $2->y*$3->_21 + $2->z*$3->_31 + $3->_41;
d_margin($1) $5 = $2->x*$3->_12 + $2->y*$3->_22 + $2->z*$3->_32 + $3->_42;
d_margin($1) $6 = $2->x*$3->_13 + $2->y*$3->_23 + $2->z*$3->_33 + $3->_43;
d_margin($1) $7 = $2->x*$3->_14 + $2->y*$3->_24 + $2->z*$3->_34 + $3->_44;
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) D3DVALUE* pWeight = (D3DVALUE*)($8);
d_margin($1) D3DVALUE weight = 0; // Sum of all vertex weights
d_margin($1) D3DVALUE xx, yy, zz, ww;
d_margin($1) xx = 0;
d_margin($1) yy = 0;
d_margin($1) zz = 0;
d_margin($1) ww = 0;
d_margin($1) for (DWORD i=0; i <= pv->dwNumWeights; i++)
d_margin($1) {
d_margin($1) D3DVALUE t;
d_margin($1) if (i == pv->dwNumWeights)
d_margin($1) t = 1.0f - weight;
d_margin($1) else
d_margin($1) {
d_margin($1) t = pWeight[i];
d_margin($1) weight += t;
d_margin($1) }
d_margin($1) D3DMATRIXI *m = pv->GetMatrixCTM(($9)[i]);
d_margin($1) xx += ($2->x*m->_11 + $2->y*m->_21 + $2->z*m->_31 + m->_41) * t;
d_margin($1) yy += ($2->x*m->_12 + $2->y*m->_22 + $2->z*m->_32 + m->_42) * t;
d_margin($1) zz += ($2->x*m->_13 + $2->y*m->_23 + $2->z*m->_33 + m->_43) * t;
d_margin($1) ww += ($2->x*m->_14 + $2->y*m->_24 + $2->z*m->_34 + m->_44) * t;
d_margin($1) }
d_margin($1) $4 = xx;
d_margin($1) $5 = yy;
d_margin($1) $6 = zz;
d_margin($1) $7 = ww;
d_margin($1)}') dnl
dnl//--------------------------------------------------------------------------
dnl// d_TransformVertexToCameraSpace
dnl//
dnl// This part of code transforms vertex and normal to the camera space to do
dnl// lighting there
dnl//
dnl// Input:
dnl// $1 - margin count
dnl// $2 - pointer to the vertex coordinates (D3DVERTEX*)
dnl// $3 - pointer to the output vertex (D3DVERTEX*)
dnl// $4 - pointer to the input weights
dnl// $5 - pointer to the input matrix indices (BYTE*)
dnl//
define(`d_TransformVertexToCameraSpace',`dnl
d_empty_($1)if (pv->dwNumVerBlends == 0)
d_margin($1){
d_margin($1) $3->x = $2->x*pv->mWV[0]._11 +
d_margin($1) $2->y*pv->mWV[0]._21 +
d_margin($1) $2->z*pv->mWV[0]._31 + pv->mWV[0]._41;
d_margin($1) $3->y = $2->x*pv->mWV[0]._12 +
d_margin($1) $2->y*pv->mWV[0]._22 +
d_margin($1) $2->z*pv->mWV[0]._32 + pv->mWV[0]._42;
d_margin($1) $3->z = $2->x*pv->mWV[0]._13 +
d_margin($1) $2->y*pv->mWV[0]._23 +
d_margin($1) $2->z*pv->mWV[0]._33 + pv->mWV[0]._43;
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) D3DVALUE* pWeight = (D3DVALUE*)($4);
d_margin($1) D3DVALUE weight = 0;
d_margin($1) $3->x = 0;
d_margin($1) $3->y = 0;
d_margin($1) $3->z = 0;
d_margin($1) for (DWORD i=0; i <= pv->dwNumWeights; i++)
d_margin($1) {
d_margin($1) D3DVALUE t;
d_margin($1) if (i == pv->dwNumWeights)
d_margin($1) t = 1.0f - weight;
d_margin($1) else
d_margin($1) {
d_margin($1) t = pWeight[i];
d_margin($1) weight += t;
d_margin($1) }
d_margin($1) D3DMATRIXI *m = pv->GetMatrixWV(($5)[i]);
d_margin($1) $3->x += ($2->x*m->_11 + $2->y*m->_21 + $2->z*m->_31 + m->_41) * t;
d_margin($1) $3->y += ($2->x*m->_12 + $2->y*m->_22 + $2->z*m->_32 + m->_42) * t;
d_margin($1) $3->z += ($2->x*m->_13 + $2->y*m->_23 + $2->z*m->_33 + m->_43) * t;
d_margin($1) }
d_margin($1)}') dnl
dnl//--------------------------------------------------------------------------
dnl// d_TransformNormalToCameraSpace
dnl//
dnl// This part of code transforms vertex and normal to the camera space to do
dnl// lighting there
dnl//
dnl// Input:
dnl// $1 - margin count
dnl// $2 - pointer to the normal (D3DVECTOR*)
dnl// $3 - pointer to the output normal (D3DVECTOR*)
dnl// $4 - pointer to the input weights
dnl// $5 - pointer to the input matrix indices (BYTE*)
dnl//
define(`d_TransformNormalToCameraSpace',`dnl
d_empty_($1)// Transform vertex normal to the eye space
d_margin($1)// We use inverse transposed matrix
d_margin($1)if (pv->dwNumVerBlends == 0)
d_margin($1){
d_margin($1) $3->x = $2->x*pv->mWVI[0]._11 + $2->y*pv->mWVI[0]._12 + $2->z*pv->mWVI[0]._13;
d_margin($1) $3->y = $2->x*pv->mWVI[0]._21 + $2->y*pv->mWVI[0]._22 + $2->z*pv->mWVI[0]._23;
d_margin($1) $3->z = $2->x*pv->mWVI[0]._31 + $2->y*pv->mWVI[0]._32 + $2->z*pv->mWVI[0]._33;
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) D3DVALUE* pWeight = (D3DVALUE*)($4);
d_margin($1) D3DVALUE weight = 0;
d_margin($1) $3->x = 0;
d_margin($1) $3->y = 0;
d_margin($1) $3->z = 0;
d_margin($1) for (DWORD i=0; i <= pv->dwNumWeights; i++)
d_margin($1) {
d_margin($1) D3DVALUE t;
d_margin($1) if (i == pv->dwNumWeights)
d_margin($1) t = 1.0f - weight;
d_margin($1) else
d_margin($1) {
d_margin($1) t = pWeight[i];
d_margin($1) weight += t;
d_margin($1) }
d_margin($1) D3DMATRIXI *m = pv->GetMatrixWVI(($5)[i]);
d_margin($1) $3->x += ($2->x*m->_11 + $2->y*m->_12 + $2->z*m->_13) * t;
d_margin($1) $3->y += ($2->x*m->_21 + $2->y*m->_22 + $2->z*m->_23) * t;
d_margin($1) $3->z += ($2->x*m->_31 + $2->y*m->_32 + $2->z*m->_33) * t;
d_margin($1) }
d_margin($1)}
d_margin($1)if (pv->dwDeviceFlags & D3DDEV_NORMALIZENORMALS)
d_margin($1) VecNormalizeFast(*$3);') dnl
dnl//--------------------------------------------------------------------------
dnl// d_ComputeClipCode
dnl// Arguments:
dnl// $1 - margin count
dnl// x,y,z,w should be defined as float
dnl// Output:
dnl// clip should be defined as int
dnl//
define(`d_ComputeClipCode',`dnl
d_empty_($1){
d_margin($1) D3DVALUE xx = w - x;
d_margin($1) D3DVALUE yy = w - y;
d_margin($1) D3DVALUE zz = w - z;
d_margin($1) clip =((ASINT32(x) & 0x80000000) >> (32-D3DCS_LEFTBIT)) |
d_margin($1) ((ASINT32(y) & 0x80000000) >> (32-D3DCS_BOTTOMBIT)) |
d_margin($1) ((ASINT32(z) & 0x80000000) >> (32-D3DCS_FRONTBIT)) |
d_margin($1) ((ASINT32(xx) & 0x80000000) >> (32-D3DCS_RIGHTBIT)) |
d_margin($1) ((ASINT32(yy) & 0x80000000) >> (32-D3DCS_TOPBIT)) |
d_margin($1) ((ASINT32(zz) & 0x80000000) >> (32-D3DCS_BACKBIT));
d_margin($1) if (pv->dwMaxUserClipPlanes)
d_margin($1) {
d_margin($1) DWORD dwClipBit = D3DCS_PLANE0;
d_margin($1) for (DWORD i=0; i < pv->dwMaxUserClipPlanes; i++)
d_margin($1) {
d_margin($1) if (x*pv->userClipPlane[i].x +
d_margin($1) y*pv->userClipPlane[i].y +
d_margin($1) z*pv->userClipPlane[i].z +
d_margin($1) w*pv->userClipPlane[i].w < 0)
d_margin($1) {
d_margin($1) clip |= dwClipBit;
d_margin($1) }
d_margin($1) dwClipBit <<= 1;
d_margin($1) }
d_margin($1) }
d_margin($1)}') dnl
dnl//--------------------------------------------------------------------------
dnl// d_ComputeClipCodeGB
dnl//
dnl// Arguments:
dnl// $1 - margin count
dnl// x,y,z,w should be defined as float
dnl// Output:
dnl// clip should be defined as int
define(`d_ComputeClipCodeGB',`dnl
d_empty_($1)// We do guardband check in the projection space, so
d_margin($1)// we transform X and Y of the vertex there
d_margin($1)D3DVALUE xnew = x * pv->vcache.gb11 + w * pv->vcache.gb41;
d_margin($1)D3DVALUE ynew = y * pv->vcache.gb22 + w * pv->vcache.gb42;
d_margin($1)D3DVALUE xx1 = w - xnew;
d_margin($1)D3DVALUE yy1 = w - ynew;
d_margin($1)clip |= ((ASINT32(xnew) & 0x80000000) >> (32-D3DCLIPGB_LEFTBIT)) |
d_margin($1) ((ASINT32(ynew) & 0x80000000) >> (32-D3DCLIPGB_BOTTOMBIT)) |
d_margin($1) ((ASINT32(xx1) & 0x80000000) >> (32-D3DCLIPGB_RIGHTBIT)) |
d_margin($1) ((ASINT32(yy1) & 0x80000000) >> (32-D3DCLIPGB_TOPBIT));') dnl
dnl//--------------------------------------------------------------------------
dnl// d_ComputeScreenCoordinatesNoOutput
dnl//
dnl// Computes screen coordinates
dnl// Arguments:
dnl// $1 - margin count
dnl// $2 - x in the clipping space
dnl// $3 - y in the clipping space
dnl// $4 - z in the clipping space
dnl// $5 - 1/w in the clipping space
dnl// $6 - output1 x
dnl// $7 - output1 y
dnl// $8 - output1 z
dnl//
define(`d_ComputeScreenCoordinatesNoOutput',`dnl
d_empty_($1)$6 = $2 * $5 * pv->vcache.scaleX + pv->vcache.offsetX;
d_margin($1)$7 = $3 * $5 * pv->vcache.scaleY + pv->vcache.offsetY;
d_margin($1)$8 = $4*pv->vcache.scaleZ*$5 + pv->vcache.offsetZ;') dnl
dnl//--------------------------------------------------------------------------
dnl// d_ComputeScreenCoordinates
dnl//
dnl// Computes screen coordinates and output them
dnl// Arguments:
dnl// $1 - margin count
dnl// $2 - x in the clipping space
dnl// $3 - y in the clipping space
dnl// $4 - z in the clipping space
dnl// $5 - 1/w in the clipping space
dnl// $6 - pointer to the D3DTLVERTEX (sx, sy, sz, rhw will be set
dnl//
dnl// Local variables x,y,z should be declared as float
dnl//
define(`d_ComputeScreenCoordinates',`dnl
d_empty_($1)d_ComputeScreenCoordinatesNoOutput($1,$2,$3,$4,$5,x,y,z)
d_margin($1)$6->sx = x;
d_margin($1)$6->sy = y;
d_margin($1)$6->sz = z;
d_margin($1)$6->rhw = $5;') dnl
dnl//---------------------------------------------------------------------
dnl// d_MakeOutputColors
dnl//
dnl// - Finishes computing of diffuse color, by computing emissive and ambient
dnl// scene colors
dnl// - Converts diffuse and specular colors to DWORDs and writes them to the
dnl// d_dwOutDiffuse and d_dwOutSpecular
dnl//
dnl// $1 - margin count
dnl// d_LightingFlags - DWORD
dnl// d_OutDiffuse - temporary output diffuse color, (D3DFE_COLOR)
dnl// d_OutSpecular - temporary output specular color, (D3DFE_COLOR)
dnl// d_dwOutDiffuse - output diffuse color, (DWORD)
dnl// d_dwOutSpecular - output specular color, (DWORD)
dnl//
define(`d_MakeOutputColors',`dnl
d_empty_($1)if (pv->dwFlags & (D3DPV_COLORVERTEX_A | D3DPV_COLORVERTEX_E))
d_margin($1){
d_margin($1) if (!(d_LightingFlags & __LIGHT_DIFFUSECOMPUTED))
d_margin($1) {
d_margin($1) d_OutDiffuse.r = 0;
d_margin($1) d_OutDiffuse.g = 0;
d_margin($1) d_OutDiffuse.b = 0;
d_margin($1) }
d_margin($1) if (pv->dwFlags & D3DPV_COLORVERTEX_A)
d_margin($1) {
d_margin($1) DWORD color = **ppAmbientSource;
d_margin($1) d_OutDiffuse.r += RGBA_GETRED (color) * pv->lighting.ambientScene.r;
d_margin($1) d_OutDiffuse.g += RGBA_GETGREEN(color) * pv->lighting.ambientScene.g;
d_margin($1) d_OutDiffuse.b += RGBA_GETBLUE (color) * pv->lighting.ambientScene.b;
d_margin($1) }
d_margin($1) else
d_margin($1) {
d_margin($1) d_OutDiffuse.r += pv->lighting.ambientSceneScaled.r * pv->lighting.material.Ambient.r;
d_margin($1) d_OutDiffuse.g += pv->lighting.ambientSceneScaled.g * pv->lighting.material.Ambient.g;
d_margin($1) d_OutDiffuse.b += pv->lighting.ambientSceneScaled.b * pv->lighting.material.Ambient.b;
d_margin($1) }
d_margin($1) if (pv->dwFlags & D3DPV_COLORVERTEX_E)
d_margin($1) {
d_margin($1) DWORD color = **ppEmissiveSource;
d_margin($1) d_OutDiffuse.r += RGBA_GETRED (color);
d_margin($1) d_OutDiffuse.g += RGBA_GETGREEN(color);
d_margin($1) d_OutDiffuse.b += RGBA_GETBLUE (color);
d_margin($1) }
d_margin($1) else
d_margin($1) {
d_margin($1) d_OutDiffuse.r += pv->lighting.material.Emissive.r * D3DVAL(255);
d_margin($1) d_OutDiffuse.g += pv->lighting.material.Emissive.g * D3DVAL(255);
d_margin($1) d_OutDiffuse.b += pv->lighting.material.Emissive.b * D3DVAL(255);
d_margin($1) }
d_margin($1) d_LightingFlags |= __LIGHT_DIFFUSECOMPUTED;
d_margin($1)}
d_margin($1)if (d_LightingFlags & __LIGHT_DIFFUSECOMPUTED)
d_margin($1){
d_margin($1) if (!(pv->dwFlags & (D3DPV_COLORVERTEX_A | D3DPV_COLORVERTEX_E)))
d_margin($1) {
d_margin($1) d_OutDiffuse.r += pv->lighting.diffuse0.r;
d_margin($1) d_OutDiffuse.g += pv->lighting.diffuse0.g;
d_margin($1) d_OutDiffuse.b += pv->lighting.diffuse0.b;
d_margin($1) }
d_margin($1) int r = FTOI(d_OutDiffuse.r);
d_margin($1) int g = FTOI(d_OutDiffuse.g);
d_margin($1) int b = FTOI(d_OutDiffuse.b);
d_margin($1) if (r < 0) r = 0; else if (r > 255) r = 255;
d_margin($1) if (g < 0) g = 0; else if (g > 255) g = 255;
d_margin($1) if (b < 0) b = 0; else if (b > 255) b = 255;
d_margin($1) if (!(pv->dwFlags & D3DPV_COLORVERTEX_D))
d_margin($1) d_dwOutDiffuse = pv->lighting.alpha + (r<<16) + (g<<8) + b;
d_margin($1) else
d_margin($1) d_dwOutDiffuse = (**ppDiffuseSource & 0xFF000000) + (r<<16) + (g<<8) + b;
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) if (!(pv->dwFlags & D3DPV_COLORVERTEX_D))
d_margin($1) d_dwOutDiffuse = pv->lighting.alpha + pv->lighting.dwDiffuse0;
d_margin($1) else
d_margin($1) d_dwOutDiffuse = pv->lighting.dwDiffuse0 + (**ppDiffuseSource & 0xFF000000);
d_margin($1)}
d_margin($1)
d_margin($1)if (d_LightingFlags & __LIGHT_SPECULARCOMPUTED)
d_margin($1){
d_margin($1) int r = FTOI(d_OutSpecular.r);
d_margin($1) int g = FTOI(d_OutSpecular.g);
d_margin($1) int b = FTOI(d_OutSpecular.b);
d_margin($1) if (r < 0) r = 0; else if (r > 255) r = 255;
d_margin($1) if (g < 0) g = 0; else if (g > 255) g = 255;
d_margin($1) if (b < 0) b = 0; else if (b > 255) b = 255;
d_margin($1) if (!(pv->dwFlags & D3DPV_COLORVERTEX_S))
d_margin($1) d_dwOutSpecular = pv->lighting.alphaSpecular + (r<<16) + (g<<8) + b;
d_margin($1) else
d_margin($1) d_dwOutSpecular = (**ppSpecularSource & 0xFF000000) + (r<<16) + (g<<8) + b;
d_margin($1)}
d_margin($1)else
d_margin($1)if (!(pv->dwFlags & D3DPV_DONOTCOPYSPECULAR))
d_margin($1){
d_margin($1) if (!(pv->dwDeviceFlags & D3DDEV_SPECULARENABLE))
d_margin($1) if (pv->dwVIDIn & D3DFVF_SPECULAR)
d_margin($1) d_dwOutSpecular = *inSpecular;
d_margin($1) else
d_margin($1) d_dwOutSpecular = __DEFAULT_SPECULAR;
d_margin($1) else
d_margin($1) if (!(pv->dwFlags & D3DPV_COLORVERTEX_S))
d_margin($1) d_dwOutSpecular = pv->lighting.alphaSpecular;
d_margin($1) else
d_margin($1) d_dwOutSpecular = (**ppSpecularSource & 0xFF000000);
d_margin($1)}')
dnl//---------------------------------------------------------------------
dnl// d_MakeOutputColorsNoColorVertex
dnl//
dnl// - Finishes computing of diffuse color, by computing emissive and ambient
dnl// scene colors
dnl// - Converts diffuse and specular colors to DWORDs and writes them to the
dnl// d_dwOutDiffuse and d_dwOutSpecular
dnl//
dnl// $1 - margin count
dnl// d_LightingFlags - DWORD
dnl// d_OutDiffuse - temporary output diffuse color, (D3DFE_COLOR)
dnl// d_OutSpecular - temporary output specular color, (D3DFE_COLOR)
dnl// d_dwOutDiffuse - output diffuse color, (DWORD)
dnl// d_dwOutSpecular - output specular color, (DWORD)
dnl//
define(`d_MakeOutputColorsNoColorVertex',`dnl
d_margin($1)if (d_LightingFlags & __LIGHT_DIFFUSECOMPUTED)
d_margin($1){
d_margin($1) d_OutDiffuse.r += pv->lighting.diffuse0.r;
d_margin($1) d_OutDiffuse.g += pv->lighting.diffuse0.g;
d_margin($1) d_OutDiffuse.b += pv->lighting.diffuse0.b;
d_margin($1) int r = FTOI(d_OutDiffuse.r);
d_margin($1) int g = FTOI(d_OutDiffuse.g);
d_margin($1) int b = FTOI(d_OutDiffuse.b);
d_margin($1) if (r < 0) r = 0; else if (r > 255) r = 255;
d_margin($1) if (g < 0) g = 0; else if (g > 255) g = 255;
d_margin($1) if (b < 0) b = 0; else if (b > 255) b = 255;
d_margin($1) d_dwOutDiffuse = pv->lighting.alpha + (r<<16) + (g<<8) + b;
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) d_dwOutDiffuse = pv->lighting.alpha + pv->lighting.dwDiffuse0;
d_margin($1)}
d_margin($1)
d_margin($1)if (d_LightingFlags & __LIGHT_SPECULARCOMPUTED)
d_margin($1){
d_margin($1) int r = FTOI(d_OutSpecular.r);
d_margin($1) int g = FTOI(d_OutSpecular.g);
d_margin($1) int b = FTOI(d_OutSpecular.b);
d_margin($1) if (r < 0) r = 0; else if (r > 255) r = 255;
d_margin($1) if (g < 0) g = 0; else if (g > 255) g = 255;
d_margin($1) if (b < 0) b = 0; else if (b > 255) b = 255;
d_margin($1) d_dwOutSpecular = pv->lighting.alphaSpecular + (r<<16) + (g<<8) + b;
d_margin($1)}
d_margin($1)else
d_margin($1)if (!(pv->dwFlags & D3DPV_DONOTCOPYSPECULAR))
d_margin($1){
d_margin($1) if (!(pv->dwDeviceFlags & D3DDEV_SPECULARENABLE))
d_margin($1) if (pv->dwVIDIn & D3DFVF_SPECULAR)
d_margin($1) d_dwOutSpecular = *inSpecular;
d_margin($1) else
d_margin($1) d_dwOutSpecular = __DEFAULT_SPECULAR;
d_margin($1) else
d_margin($1) d_dwOutSpecular = pv->lighting.alphaSpecular;
d_margin($1)}')
dnl//--------------------------------------------------------------------------
dnl// d_ComputeOutputColors
dnl//
dnl// Compute lighting and fog for a vertex
dnl//
dnl// Arguments:
dnl// $1 - margin count
dnl// $2 - pointer to the vertex coordinates
dnl// $3 - pointer to the vertex normal
dnl// $4 - pointer to the diffuse vertex color (used when there is no lighting)
dnl// $5 - pointer to the specular vertex color (used when there is no lighting)
dnl// $6 - pointer to the input vertex weights
dnl// $7 - pointer to the input matrix indices
dnl// Output:
dnl// vertex diffuse and specular colors in the pv->lighting
dnl//
dnl
define(`d_dwOutDiffuse',pv->lighting.outDiffuse)dnl
define(`d_dwOutSpecular',pv->lighting.outSpecular)dnl
define(`d_OutDiffuse',pv->lighting.diffuse)dnl
define(`d_OutSpecular',pv->lighting.specular)dnl
define(`d_LightingFlags',pv->lighting.dwLightingFlags)dnl
dnl
define(`d_ComputeOutputColors',`dnl
d_empty_($1)pv->lighting.dwLightingFlags = 0;
d_margin($1)if (pv->dwDeviceFlags & D3DDEV_POSITIONINCAMERASPACE)
d_margin($1){
d_margin($1) d_TransformVertexToCameraSpace($1+1, $2, ((D3DVERTEX*)&EyeSpaceData.dvPosition), $6, $7)
d_margin($1) pv->lighting.dwLightingFlags |= __LIGHT_VERTEXTRANSFORMED;
d_margin($1)}
d_margin($1)if (pv->dwDeviceFlags & D3DDEV_NORMALINCAMERASPACE)
d_margin($1){
d_margin($1) d_TransformNormalToCameraSpace($1+1, inNormal, ((D3DVECTOR*)&EyeSpaceData.dvNormal), $6, $7)
d_margin($1) pv->lighting.dwLightingFlags |= __LIGHT_NORMALTRANSFORMED;
d_margin($1)}
d_margin($1)if (pv->dwFlags & D3DPV_LIGHTING)
d_margin($1){
d_margin($1) pv->lighting.diffuse.r = 0;
d_margin($1) pv->lighting.diffuse.g = 0;
d_margin($1) pv->lighting.diffuse.b = 0;
d_margin($1) pv->lighting.specular.r = 0;
d_margin($1) pv->lighting.specular.g = 0;
d_margin($1) pv->lighting.specular.b = 0;
d_margin($1) if (pv->dwFlags & D3DPV_DOCOLORVERTEX)
d_margin($1) {
d_margin($1) if (pv->dwFlags & D3DPV_COLORVERTEX_A)
d_margin($1) pv->lighting.vertexAmbient = **ppAmbientSource;
d_margin($1) if (pv->dwFlags & D3DPV_COLORVERTEX_D)
d_margin($1) pv->lighting.vertexDiffuse = **ppDiffuseSource;
d_margin($1) if (pv->dwFlags & D3DPV_COLORVERTEX_S)
d_margin($1) pv->lighting.vertexSpecular = **ppSpecularSource;
d_margin($1) }
d_margin($1) D3DI_LIGHT *light = pv->lighting.activeLights;
d_margin($1) while (light)
d_margin($1) {
d_margin($1) (*light->lightVertexFunc)(pv, light, (D3DVERTEX*)$2, $6, $7, $3, &EyeSpaceData);
d_margin($1) light = light->next;
d_margin($1) }
d_margin($1) d_MakeOutputColors($1+1)
d_margin($1)}
d_margin($1)else
d_margin($1)if (pv->dwVIDIn & (D3DFVF_DIFFUSE | D3DFVF_SPECULAR))
d_margin($1){
d_margin($1) if (pv->dwVIDIn & D3DFVF_DIFFUSE)
d_margin($1) pv->lighting.outDiffuse = *(DWORD*)($4);
d_margin($1) if (pv->dwVIDIn & D3DFVF_SPECULAR)
d_margin($1) pv->lighting.outSpecular = *(DWORD*)($5);
d_margin($1)}
d_margin($1)if (pv->dwFlags & D3DPV_FOG)
d_margin($1){
d_margin($1) ComputeFog(pv, *(D3DVECTOR*)($2), &EyeSpaceData.dvPosition, $6, $7);
d_margin($1)}') dnl
dnl//--------------------------------------------------------------------------
dnl// d_DoLightingAndFog
dnl//
dnl// Arguments:
dnl// $1 - margin count
dnl// $2 - pointer to the vertex coordinates
dnl// $3 - pointer to the vertex normal
dnl// $4 - pointer to the diffuse vertex color (used when there is no lighting)
dnl// $5 - pointer to the specular vertex color (used when there is no lighting)
dnl// $6 - pointer to output vertex
dnl// $7 - pointer to input vertex weights
dnl// $8 - pointer to input matrix indices
dnl// Output:
dnl// vertex diffuse and specular colors in the pv->lighting
dnl// Pointer to the output will be moved to the next DWORD
dnl//
define(`d_DoLightingAndFog',`dnl
d_empty_($1)d_ComputeOutputColors($1, $2, $3, $4, $5, $7, $8)
d_margin($1)if (!(pv->dwFlags & D3DPV_DONOTCOPYDIFFUSE))
d_margin($1) *(DWORD*)((BYTE*)$6 + pv->diffuseOffsetOut) = pv->lighting.outDiffuse;
d_margin($1)if (!(pv->dwFlags & D3DPV_DONOTCOPYSPECULAR))
d_margin($1) *(DWORD*)((BYTE*)$6 + pv->specularOffsetOut) = pv->lighting.outSpecular;') dnl
dnl//--------------------------------------------------------------------------
dnl// d_CopyTextureCoordStrided
dnl//
dnl// Copies texture coordinates from input to the output
dnl// $1 - margin count
dnl// $2 - pointer to the output texture
dnl//
define(`d_CopyTextureCoordStrided',`dnl
d_empty_($1)D3DVALUE *_pOut = (D3DVALUE*)$2;
d_margin($1)if (!(pv->dwDeviceFlags & (D3DDEV_TEXTURETRANSFORM | D3DDEV_REMAPTEXTUREINDICES)))
d_margin($1){
d_margin($1) for (DWORD k=0; k < pv->nOutTexCoord; k++)
d_margin($1) {
d_margin($1) const DWORD dwSize = pv->dwTextureCoordSize[k];
d_margin($1) memcpy(_pOut, inTexture[k], dwSize);
d_margin($1) NEXT(_pOut, dwSize, D3DVALUE);
d_margin($1) }
d_margin($1)}
d_margin($1)else
d_margin($1)if (!(pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES))
d_margin($1){
d_margin($1) for (DWORD k=0; k < pv->nOutTexCoord; k++)
d_margin($1) {
d_margin($1) const DWORD dwSize = pv->dwTextureCoordSize[k];
d_margin($1) const DWORD dwInpSize = pv->dwInpTextureCoordSize[k];
d_margin($1) if (pv->pmTexture[k] == 0)
d_margin($1) memcpy(_pOut, inTexture[k], dwSize);
d_margin($1) else
d_margin($1) {
d_margin($1) const DWORD m = dwInpSize >> 2; // Number of input tex. coord.
d_margin($1) const DWORD n = dwSize >> 2; // Number of output tex. coord.
d_margin($1) (*(g_pfnTextureTransform[MakeTexTransformFuncIndex(m ,n)]))
d_margin($1) (inTexture[k], _pOut, pv->pmTexture[k]);
d_margin($1) }
d_margin($1) NEXT(_pOut, dwSize, D3DVALUE);
d_margin($1) }
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) D3DVALUE *_pOut = (D3DVALUE*)$2;
d_margin($1) D3DVECTOR reflectionVector;
d_margin($1) for (DWORD i=0; i < pv->dwNumTextureStages; i++)
d_margin($1) {
d_margin($1) LPD3DFE_TEXTURESTAGE pStage = &pv->textureStage[i];
d_margin($1) DWORD dwInpIndex = pStage->dwInpCoordIndex;
d_margin($1) D3DVALUE *_pIn;
d_margin($1) if (pStage->dwTexGenMode == 0)
d_margin($1) _pIn = inTexture[dwInpIndex];
d_margin($1) else
d_margin($1) if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACEPOSITION)
d_margin($1) _pIn = (D3DVALUE*)&EyeSpaceData.dvPosition;
d_margin($1) else
d_margin($1) if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACENORMAL)
d_margin($1) _pIn = (D3DVALUE*)&EyeSpaceData.dvNormal;
d_margin($1) else // D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
d_margin($1) {
d_margin($1) if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
d_margin($1) ComputeReflectionVector((D3DVECTOR*)&EyeSpaceData.dvPosition,
d_margin($1) (D3DVECTOR*)&EyeSpaceData.dvNormal,
d_margin($1) &reflectionVector);
d_margin($1) else
d_margin($1) ComputeReflectionVectorInfiniteViewer((D3DVECTOR*)&EyeSpaceData.dvNormal,
d_margin($1) &reflectionVector);
d_margin($1)
d_margin($1) _pIn = (D3DVALUE*)&reflectionVector;
d_margin($1) }
d_margin($1) DWORD dwSize = pv->dwTextureCoordSize[i];
d_margin($1) if (pStage->bDoTextureProjection)
d_margin($1) {
d_margin($1) // We need to do emulation of texture projection
d_margin($1)
d_margin($1) if (pStage->pmTextureTransform == NULL)
d_margin($1) {
d_margin($1) DoTextureProjection(_pIn, _pOut, dwSize);
d_margin($1) }
d_margin($1) else
d_margin($1) {
d_margin($1) float TmpOutputTexture[4];
d_margin($1) (*(g_pfnTextureTransform[pStage->dwTexTransformFuncIndex]))
d_margin($1) (_pIn, TmpOutputTexture, pStage->pmTextureTransform);
d_margin($1) DoTextureProjection(TmpOutputTexture, _pOut, dwSize);
d_margin($1) }
d_margin($1) }
d_margin($1) else
d_margin($1) if (pStage->pmTextureTransform)
d_margin($1) {
d_margin($1) (*(g_pfnTextureTransform[pStage->dwTexTransformFuncIndex]))(_pIn, _pOut,
d_margin($1) pStage->pmTextureTransform);
d_margin($1) }
d_margin($1) else
d_margin($1) {
d_margin($1) memcpy(_pOut, _pIn, dwSize);
d_margin($1) }
d_margin($1) NEXT(_pOut, dwSize, D3DVALUE);
d_margin($1) }
d_margin($1)}') dnl
dnl//--------------------------------------------------------------------------
dnl// d_CopyTextureCoordFVF
dnl//
dnl// Copies texture coordinates from input to the output
dnl// $1 - margin count
dnl// $2 - pointer to the output vertex
dnl//
define(`d_CopyTextureCoordFVF',`dnl
d_empty_($1)
d_margin($1)if (!(pv->dwDeviceFlags & (D3DDEV_TEXTURETRANSFORM | D3DDEV_REMAPTEXTUREINDICES)))
d_margin($1) memcpy($2, inTexture[0], pv->dwTextureCoordSizeTotal);
d_margin($1)else
d_margin($1)if (!(pv->dwDeviceFlags & D3DDEV_REMAPTEXTUREINDICES))
d_margin($1){
d_margin($1) D3DVALUE *_pIn = inTexture[0];
d_margin($1) D3DVALUE *_pOut = (D3DVALUE*)$2;
d_margin($1) for (DWORD i=0; i < pv->nOutTexCoord; i++)
d_margin($1) {
d_margin($1) const DWORD dwSize = pv->dwTextureCoordSize[i];
d_margin($1) const DWORD dwInpSize = pv->dwInpTextureCoordSize[i];
d_margin($1) if (pv->pmTexture[i])
d_margin($1) {
d_margin($1) const DWORD m = dwInpSize >> 2; // Number of input tex. coord.
d_margin($1) const DWORD n = dwSize >> 2; // Number of output tex. coord.
d_margin($1) (*(g_pfnTextureTransform[MakeTexTransformFuncIndex(m, n)]))
d_margin($1) (_pIn, _pOut, pv->pmTexture[i]);
d_margin($1) }
d_margin($1) else
d_margin($1) memcpy(_pOut, _pIn, dwSize);
d_margin($1) NEXT(_pIn, dwInpSize, D3DVALUE);
d_margin($1) NEXT(_pOut, dwSize, D3DVALUE);
d_margin($1) }
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) D3DVALUE *_pOut = (D3DVALUE*)$2;
d_margin($1) D3DVECTOR reflectionVector;
d_margin($1) for (DWORD i=0; i < pv->dwNumTextureStages; i++)
d_margin($1) {
d_margin($1) LPD3DFE_TEXTURESTAGE pStage = &pv->textureStage[i];
d_margin($1) D3DVALUE *_pIn;
d_margin($1) if (pStage->dwTexGenMode == 0)
d_margin($1) _pIn = (D3DVALUE*)((BYTE*)inTexture[0] + pStage->dwInpOffset);
d_margin($1) else
d_margin($1) if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACEPOSITION)
d_margin($1) _pIn = (D3DVALUE*)&EyeSpaceData.dvPosition;
d_margin($1) else
d_margin($1) if (pStage->dwTexGenMode == D3DTSS_TCI_CAMERASPACENORMAL)
d_margin($1) _pIn = (D3DVALUE*)&EyeSpaceData.dvNormal;
d_margin($1) else // D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
d_margin($1) {
d_margin($1) if (pv->dwDeviceFlags & D3DDEV_LOCALVIEWER)
d_margin($1) ComputeReflectionVector((D3DVECTOR*)&EyeSpaceData.dvPosition,
d_margin($1) (D3DVECTOR*)&EyeSpaceData.dvNormal,
d_margin($1) &reflectionVector);
d_margin($1) else
d_margin($1) ComputeReflectionVectorInfiniteViewer((D3DVECTOR*)&EyeSpaceData.dvNormal,
d_margin($1) &reflectionVector);
d_margin($1) _pIn = (D3DVALUE*)&reflectionVector;
d_margin($1) }
d_margin($1) DWORD dwSize = pv->dwTextureCoordSize[i];
d_margin($1) if (pStage->bDoTextureProjection)
d_margin($1) {
d_margin($1) // We need to do emulation of texture projection
d_margin($1)
d_margin($1) if (pStage->pmTextureTransform == NULL)
d_margin($1) {
d_margin($1) DoTextureProjection(_pIn, _pOut, dwSize);
d_margin($1) }
d_margin($1) else
d_margin($1) {
d_margin($1) float TmpOutputTexture[4];
d_margin($1) (*(g_pfnTextureTransform[pStage->dwTexTransformFuncIndex]))
d_margin($1) (_pIn, TmpOutputTexture, pStage->pmTextureTransform);
d_margin($1) DoTextureProjection(TmpOutputTexture, _pOut, dwSize);
d_margin($1) }
d_margin($1) }
d_margin($1) else
d_margin($1) if (pStage->pmTextureTransform)
d_margin($1) {
d_margin($1) (*(g_pfnTextureTransform[pStage->dwTexTransformFuncIndex]))
d_margin($1) (_pIn, _pOut, pStage->pmTextureTransform);
d_margin($1) }
d_margin($1) else
d_margin($1) {
d_margin($1) memcpy(_pOut, _pIn, dwSize);
d_margin($1) }
d_margin($1) NEXT(_pOut, dwSize, D3DVALUE);
d_margin($1) }
d_margin($1)}') dnl
dnl//--------------------------------------------------------------------------
dnl// d_CopyTextureCoord
dnl//
dnl// Copies texture coordinates from input to the output
dnl// $1 - margin count
dnl// $2 - pointer to the output vertex
dnl//
define(`d_CopyTextureCoord',`dnl
d_empty_($1)if (!(pv->dwFlags & D3DPV_DONOTCOPYTEXTURE))
d_margin($1){
d_margin($1) if (pv->dwDeviceFlags & D3DDEV_STRIDE)
d_margin($1) {
d_margin($1) d_CopyTextureCoordStrided($1+2, $2)
d_margin($1) }
d_margin($1) else
d_margin($1) {
d_margin($1) d_CopyTextureCoordFVF($1+2, $2)
d_margin($1) }
d_margin($1)}') dnl
dnl//------------------------------------------------------------------
dnl// Setup pointers and flags before processing a primitive or vertices
dnl//
dnl//
define(`d_Setup',`
DWORD dwOutVerSize = pv->dwOutputSize;
DWORD dwClipIntersection;
DWORD dwClipUnion;
DWORD inVID = pv->dwVIDIn;
DWORD outVID = pv->dwVIDOut;
DWORD dwDeviceFlags = pv->dwDeviceFlags;
D3DVECTOR *in; // Input position pointer
D3DVECTOR *in2 = NULL; // Input position2 pointer
D3DVALUE *inWeights;
D3DVECTOR *inNormal;
D3DVECTOR *inNormal2 = NULL;
float *inPointSize;
BYTE *inMatrixIndices;
union
{
DWORD colors[2];
struct
{
DWORD *inDiffuse; // inDiffuse and inSpecular should be in his order !!!
DWORD *inSpecular;
};
};
DWORD dwInpVerSize; // Position stride
D3DVALUE *inTexture[8];
DWORD **ppEmissiveSource; // Used when COLORVERTEX_E is set
DWORD **ppAmbientSource; // Used when COLORVERTEX_A is set
DWORD **ppDiffuseSource; // Used when COLORVERTEX_D is set
DWORD **ppSpecularSource; // Used when COLORVERTEX_S is set
in = (D3DVECTOR*)pv->position.lpvData;
dwInpVerSize = pv->position.dwStride;
inTexture[0] = (D3DVALUE*)in; // For DONOTSTRIPELEMENTS we will copy XYZ to
// the output texture coordinates, but it does not matter
if (!(dwDeviceFlags & D3DDEV_STRIDE))
{
inWeights = (D3DVALUE*) ((char*)in + 3*sizeof(float));
inNormal = (D3DVECTOR*) ((char*)in + pv->normalOffset);
inDiffuse = (DWORD*) ((char*)in + pv->diffuseOffset);
inSpecular = (DWORD*) ((char*)in + pv->specularOffset);
inPointSize = (float*) ((char*)in + pv->pointSizeOffset);
inMatrixIndices = (BYTE*)(inWeights + pv->dwNumWeights);
if (pv->nTexCoord)
inTexture[0] = (D3DVALUE*) ((char*)in + pv->texOffset);
}
else
{
inWeights = (D3DVALUE*)pv->weights.lpvData;
inNormal = (D3DVECTOR*)pv->normal.lpvData;
in2 = (D3DVECTOR*)pv->position2.lpvData;
inNormal2 = (D3DVECTOR*)pv->normal2.lpvData;
inDiffuse = (DWORD*)pv->diffuse.lpvData;
inSpecular = (DWORD*)pv->specular.lpvData;
inPointSize = (float*)pv->psize.lpvData;
inMatrixIndices = (BYTE*)pv->matrixIndices.lpvData;
for (DWORD i=0; i < pv->nTexCoord; i++)
inTexture[i] = (D3DVALUE*)pv->textures[i].lpvData;
}
if (!(dwDeviceFlags & D3DDEV_INDEXEDVERTEXBLENDENABLE))
{
inMatrixIndices = pv->MatrixIndices;
pv->matrixIndices.dwStride = 0;
}
pv->lighting.outDiffuse = __DEFAULT_DIFFUSE;
pv->lighting.outSpecular = __DEFAULT_SPECULAR;
pv->lighting.dwLightingFlags = 0;
if (pv->dwFlags & D3DPV_LIGHTING)
{
pv->lighting.diffuse = pv->lighting.diffuse0;
pv->lighting.specular.r = D3DVAL(0);
pv->lighting.specular.g = D3DVAL(0);
pv->lighting.specular.b = D3DVAL(0);
if (pv->dwDeviceFlags & D3DDEV_COLORVERTEX)
{
if (pv->dwVIDIn & D3DFVF_DIFFUSE)
{
if(pv->lighting.dwEmissiveSrcIndex == 0)
{
pv->dwFlags |= D3DPV_COLORVERTEX_E | D3DPV_DOCOLORVERTEX;
ppEmissiveSource = &inDiffuse;
}
if(pv->lighting.dwDiffuseSrcIndex == 0)
{
pv->dwFlags |= D3DPV_COLORVERTEX_D | D3DPV_DOCOLORVERTEX;
ppDiffuseSource = &inDiffuse;
}
if(pv->lighting.dwAmbientSrcIndex == 0)
{
pv->dwFlags |= D3DPV_COLORVERTEX_A | D3DPV_DOCOLORVERTEX;
ppAmbientSource = &inDiffuse;
}
if(pv->lighting.dwSpecularSrcIndex == 0)
{
pv->dwFlags |= D3DPV_COLORVERTEX_S | D3DPV_DOCOLORVERTEX;
ppSpecularSource = &inDiffuse;
}
}
if (pv->dwVIDIn & D3DFVF_SPECULAR)
{
if(pv->lighting.dwEmissiveSrcIndex == 1)
{
pv->dwFlags |= D3DPV_COLORVERTEX_E | D3DPV_DOCOLORVERTEX;
ppEmissiveSource = &inSpecular;
}
if(pv->lighting.dwDiffuseSrcIndex == 1)
{
pv->dwFlags |= D3DPV_COLORVERTEX_D | D3DPV_DOCOLORVERTEX;
ppDiffuseSource = &inSpecular;
}
if(pv->lighting.dwAmbientSrcIndex == 1)
{
pv->dwFlags |= D3DPV_COLORVERTEX_A | D3DPV_DOCOLORVERTEX;
ppAmbientSource = &inSpecular;
}
if(pv->lighting.dwSpecularSrcIndex == 1)
{
pv->dwFlags |= D3DPV_COLORVERTEX_S | D3DPV_DOCOLORVERTEX;
ppSpecularSource = &inSpecular;
}
}
}
}
dwClipUnion = 0;
dwClipIntersection = 0;
if (!(dwDeviceFlags & D3DDEV_DONOTCLIP))
dwClipIntersection = ~0;') dnl
dnl//------------------------------------------------------------------
dnl// d_UpdateInputPointersStrided
dnl//
dnl// Updates input pointers
dnl//
dnl// Arguments:
dnl// $1 - margin counter
dnl//
dnl// Notes:
dnl// Output pointer is changed
dnl//
define(`d_UpdateInputPointersStrided',`dnl
d_empty_($1){
d_margin($1) NEXT(in, dwInpVerSize, D3DVECTOR);
d_margin($1) NEXT(inWeights, pv->weights.dwStride, D3DVALUE);
d_margin($1) NEXT(inMatrixIndices, pv->matrixIndices.dwStride, BYTE);
d_margin($1) NEXT(inPointSize, pv->psize.dwStride, float);
d_margin($1) // This speeds up the xform only case
d_margin($1) if (!(pv->dwFlags & D3DPV_TRANSFORMONLY))
d_margin($1) {
d_margin($1) NEXT(inNormal, pv->normal.dwStride, D3DVECTOR);
d_margin($1) NEXT(inDiffuse, pv->diffuse.dwStride, DWORD);
d_margin($1) NEXT(inSpecular, pv->specular.dwStride, DWORD);
d_margin($1) {
d_margin($1) for (DWORD j=0; j < pv->nTexCoord; j++)
d_margin($1) NEXT(inTexture[j], pv->textures[j].dwStride, D3DVALUE);
d_margin($1) }
d_margin($1) }
d_margin($1)}') dnl
dnl//------------------------------------------------------------------
dnl// d_UpdateInputPointersFVF
dnl//
dnl// Updates input pointers
dnl//
dnl// Arguments:
dnl// $1 - margin counter
dnl// $2 - how many vertices to skip
dnl//
dnl// Notes:
dnl// Output pointer is changed
dnl//
define(`d_UpdateInputPointersFVF',`dnl
d_empty_($1){
d_margin($1) NEXT(in, dwInpVerSize, D3DVECTOR);
d_margin($1) NEXT(inWeights, dwInpVerSize, D3DVALUE);
d_margin($1) NEXT(inPointSize, dwInpVerSize, float);
d_margin($1) // When matrix indices are not present, dwStride is zero
d_margin($1) NEXT(inMatrixIndices, pv->matrixIndices.dwStride, BYTE);
d_margin($1) // This speeds up the xform only case
d_margin($1) if (!(pv->dwFlags & D3DPV_TRANSFORMONLY))
d_margin($1) {
d_margin($1) NEXT(inNormal, dwInpVerSize, D3DVECTOR);
d_margin($1) NEXT(inDiffuse, dwInpVerSize, DWORD);
d_margin($1) NEXT(inSpecular, dwInpVerSize, DWORD);
d_margin($1) NEXT(inTexture[0], dwInpVerSize, D3DVALUE);
d_margin($1) }
d_margin($1)}') dnl
dnl//------------------------------------------------------------------
dnl// d_CopyTextureCoordUpdateInputPointers
dnl//
dnl// Copies texture coordinates to the output and updates input pointers
dnl//
dnl// Arguments:
dnl// $1 - margin counter
dnl// $2 - pointer to the output texture
dnl//
dnl// Notes:
dnl// Output pointer is changed
dnl//
define(`d_CopyTextureCoordUpdateInputPointers',`dnl
d_empty_($1)if (pv->dwDeviceFlags & D3DDEV_STRIDE)
d_margin($1){
d_margin($1) if (!(pv->dwFlags & D3DPV_DONOTCOPYTEXTURE))
d_margin($1) {
d_margin($1) d_CopyTextureCoordStrided($1+2, $2)
d_margin($1) }
d_margin($1) d_UpdateInputPointersStrided($1+1)
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) if (!(pv->dwFlags & D3DPV_DONOTCOPYTEXTURE))
d_margin($1) {
d_margin($1) d_CopyTextureCoordFVF($1+2, $2)
d_margin($1) }
d_margin($1) d_UpdateInputPointersFVF($1+1)
d_margin($1)}') dnl
dnl//------------------------------------------------------------------
dnl// d_UpdateInputPointers
dnl//
dnl// Updates input pointers
dnl//
dnl// Arguments:
dnl// $1 - margin counter
dnl//
dnl// Notes:
dnl// Output pointer is changed
dnl//
define(`d_UpdateInputPointers',`dnl
d_empty_($1)if (pv->dwDeviceFlags & D3DDEV_STRIDE)
d_margin($1){
d_margin($1) d_UpdateInputPointersStrided($1+1)
d_margin($1)}
d_margin($1)else
d_margin($1){
d_margin($1) d_UpdateInputPointersFVF($1+1)
d_margin($1)}') dnl
Reference in a new issue Copy permalink