976 lines
40 KiB
Plaintext
976 lines
40 KiB
Plaintext
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
|