dlls/d3dx8/math.c

   1 /*
   2  * Copyright 2007 David Adam
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <stdarg.h>
  22 #include <assert.h>
  23
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "d3dx8.h"
  30
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(d3dx8);
  34
  35 /*_________________D3DXColor____________________*/
  36
  37 D3DXCOLOR* WINAPI D3DXColorAdjustContrast(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
  38 {
  39     pout->r = 0.5f + s * (pc->r - 0.5f);
  40     pout->g = 0.5f + s * (pc->g - 0.5f);
  41     pout->b = 0.5f + s * (pc->b - 0.5f);
  42     pout->a = pc->a;
  43     return pout;
  44 }
  45
  46 D3DXCOLOR* WINAPI D3DXColorAdjustSaturation(D3DXCOLOR *pout, CONST D3DXCOLOR *pc, FLOAT s)
  47 {
  48     FLOAT grey;
  49
  50     grey = pc->r * 0.2125f + pc->g * 0.7154f + pc->b * 0.0721f;
  51     pout->r = grey + s * (pc->r - grey);
  52     pout->g = grey + s * (pc->g - grey);
  53     pout->b = grey + s * (pc->b - grey);
  54     pout->a = pc->a;
  55     return pout;
  56 }
  57
  58 /*_________________D3DXMatrix____________________*/
  59
  60 D3DXMATRIX* WINAPI D3DXMatrixAffineTransformation(D3DXMATRIX *pout, float scaling, D3DXVECTOR3 *rotationcenter, D3DXQUATERNION *rotation, D3DXVECTOR3 *translation)
  61 {
  62     D3DXMATRIX m1, m2, m3, m4, m5, p1, p2, p3;
  63
  64     D3DXMatrixScaling(&m1, scaling, scaling, scaling);
  65     if ( !rotationcenter )
  66     {
  67      D3DXMatrixIdentity(&m2);
  68      D3DXMatrixIdentity(&m4);
  69     }
  70     else
  71     {
  72      D3DXMatrixTranslation(&m2, -rotationcenter->x, -rotationcenter->y, -rotationcenter->z);
  73      D3DXMatrixTranslation(&m4, rotationcenter->x, rotationcenter->y, rotationcenter->z);
  74     }
  75     if ( !rotation )
  76     {
  77      D3DXMatrixIdentity(&m3);
  78     }
  79     else
  80     {
  81      D3DXMatrixRotationQuaternion(&m3, rotation);
  82     }
  83     if ( !translation )
  84     {
  85      D3DXMatrixIdentity(&m5);
  86     }
  87     else
  88     {
  89      D3DXMatrixTranslation(&m5, translation->x, translation->y, translation->z);
  90     }
  91     D3DXMatrixMultiply(&p1, &m1, &m2);
  92     D3DXMatrixMultiply(&p2, &p1, &m3);
  93     D3DXMatrixMultiply(&p3, &p2, &m4);
  94     D3DXMatrixMultiply(pout, &p3, &m5);
  95     return pout;
  96 }
  97
  98 FLOAT WINAPI D3DXMatrixfDeterminant(CONST D3DXMATRIX *pm)
  99 {
 100     D3DXVECTOR4 minor, v1, v2, v3;
 101     FLOAT det;
 102
 103     v1.x = pm->u.m[0][0]; v1.y = pm->u.m[1][0]; v1.z = pm->u.m[2][0]; v1.w = pm->u.m[3][0];
 104     v2.x = pm->u.m[0][1]; v2.y = pm->u.m[1][1]; v2.z = pm->u.m[2][1]; v2.w = pm->u.m[3][1];
 105     v3.x = pm->u.m[0][2]; v3.y = pm->u.m[1][2]; v3.z = pm->u.m[2][2]; v3.w = pm->u.m[3][2];
 106     D3DXVec4Cross(&minor,&v1,&v2,&v3);
 107     det =  - (pm->u.m[0][3] * minor.x + pm->u.m[1][3] * minor.y + pm->u.m[2][3] * minor.z + pm->u.m[3][3] * minor.w);
 108     return det;
 109 }
 110
 111 D3DXMATRIX* WINAPI D3DXMatrixInverse(D3DXMATRIX *pout, FLOAT *pdeterminant, CONST D3DXMATRIX *pm)
 112 {
 113     int a, i, j;
 114     D3DXVECTOR4 v, vec[3];
 115     FLOAT cofactor, det;
 116
 117     det = D3DXMatrixfDeterminant(pm);
 118     if ( !det ) return NULL;
 119     if ( pdeterminant ) *pdeterminant = det;
 120     for (i=0; i<4; i++)
 121     {
 122      for (j=0; j<4; j++)
 123      {
 124       if (j != i )
 125       {
 126        a = j;
 127        if ( j > i ) a = a-1;
 128        vec[a].x = pm->u.m[j][0];
 129        vec[a].y = pm->u.m[j][1];
 130        vec[a].z = pm->u.m[j][2];
 131        vec[a].w = pm->u.m[j][3];
 132       }
 133      }
 134     D3DXVec4Cross(&v, &vec[0], &vec[1], &vec[2]);
 135     for (j=0; j<4; j++)
 136     {
 137      switch(j)
 138      {
 139       case 0: cofactor = v.x; break;
 140       case 1: cofactor = v.y; break;
 141       case 2: cofactor = v.z; break;
 142       case 3: cofactor = v.w; break;
 143      }
 144     pout->u.m[j][i] = pow(-1.0f, i) * cofactor / det;
 145     }
 146    }
 147     return pout;
 148 }
 149
 150 D3DXMATRIX* WINAPI D3DXMatrixLookAtLH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
 151 {
 152     D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
 153
 154     D3DXVec3Subtract(&vec2, pat, peye);
 155     D3DXVec3Normalize(&vec, &vec2);
 156     D3DXVec3Cross(&right, pup, &vec);
 157     D3DXVec3Cross(&up, &vec, &right);
 158     D3DXVec3Normalize(&rightn, &right);
 159     D3DXVec3Normalize(&upn, &up);
 160     pout->u.m[0][0] = rightn.x;
 161     pout->u.m[1][0] = rightn.y;
 162     pout->u.m[2][0] = rightn.z;
 163     pout->u.m[3][0] = -D3DXVec3Dot(&rightn,peye);
 164     pout->u.m[0][1] = upn.x;
 165     pout->u.m[1][1] = upn.y;
 166     pout->u.m[2][1] = upn.z;
 167     pout->u.m[3][1] = -D3DXVec3Dot(&upn, peye);
 168     pout->u.m[0][2] = vec.x;
 169     pout->u.m[1][2] = vec.y;
 170     pout->u.m[2][2] = vec.z;
 171     pout->u.m[3][2] = -D3DXVec3Dot(&vec, peye);
 172     pout->u.m[0][3] = 0.0f;
 173     pout->u.m[1][3] = 0.0f;
 174     pout->u.m[2][3] = 0.0f;
 175     pout->u.m[3][3] = 1.0f;
 176     return pout;
 177 }
 178
 179 D3DXMATRIX* WINAPI D3DXMatrixLookAtRH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
 180 {
 181     D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
 182
 183     D3DXVec3Subtract(&vec2, pat, peye);
 184     D3DXVec3Normalize(&vec, &vec2);
 185     D3DXVec3Cross(&right, pup, &vec);
 186     D3DXVec3Cross(&up, &vec, &right);
 187     D3DXVec3Normalize(&rightn, &right);
 188     D3DXVec3Normalize(&upn, &up);
 189     pout->u.m[0][0] = -rightn.x;
 190     pout->u.m[1][0] = -rightn.y;
 191     pout->u.m[2][0] = -rightn.z;
 192     pout->u.m[3][0] = D3DXVec3Dot(&rightn,peye);
 193     pout->u.m[0][1] = upn.x;
 194     pout->u.m[1][1] = upn.y;
 195     pout->u.m[2][1] = upn.z;
 196     pout->u.m[3][1] = -D3DXVec3Dot(&upn, peye);
 197     pout->u.m[0][2] = -vec.x;
 198     pout->u.m[1][2] = -vec.y;
 199     pout->u.m[2][2] = -vec.z;
 200     pout->u.m[3][2] = D3DXVec3Dot(&vec, peye);
 201     pout->u.m[0][3] = 0.0f;
 202     pout->u.m[1][3] = 0.0f;
 203     pout->u.m[2][3] = 0.0f;
 204     pout->u.m[3][3] = 1.0f;
 205     return pout;
 206 }
 207
 208 D3DXMATRIX* WINAPI D3DXMatrixMultiply(D3DXMATRIX *pout, CONST D3DXMATRIX *pm1, CONST D3DXMATRIX *pm2)
 209 {
 210     int i,j;
 211
 212     for (i=0; i<4; i++)
 213     {
 214      for (j=0; j<4; j++)
 215      {
 216       pout->u.m[i][j] = pm1->u.m[i][0] * pm2->u.m[0][j] + pm1->u.m[i][1] * pm2->u.m[1][j] + pm1->u.m[i][2] * pm2->u.m[2][j] + pm1->u.m[i][3] * pm2->u.m[3][j];
 217      }
 218     }
 219     return pout;
 220 }
 221
 222 D3DXMATRIX* WINAPI D3DXMatrixMultiplyTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm1, CONST D3DXMATRIX *pm2)
 223 {
 224     D3DXMATRIX temp;
 225
 226     D3DXMatrixMultiply(&temp, pm1, pm2);
 227     D3DXMatrixTranspose(pout, &temp);
 228     return pout;
 229 }
 230
 231 D3DXMATRIX* WINAPI D3DXMatrixOrthoLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
 232 {
 233     D3DXMatrixIdentity(pout);
 234     pout->u.m[0][0] = 2.0f / w;
 235     pout->u.m[1][1] = 2.0f / h;
 236     pout->u.m[2][2] = 1.0f / (zf - zn);
 237     pout->u.m[3][2] = zn / (zn - zf);
 238     return pout;
 239 }
 240
 241 D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
 242 {
 243     D3DXMatrixIdentity(pout);
 244     pout->u.m[0][0] = 2.0f / (r - l);
 245     pout->u.m[1][1] = 2.0f / (t - b);
 246     pout->u.m[2][2] = 1.0f / (zf -zn);
 247     pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
 248     pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
 249     pout->u.m[3][2] = zn / (zn -zf);
 250     return pout;
 251 }
 252
 253 D3DXMATRIX* WINAPI D3DXMatrixOrthoOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
 254 {
 255     D3DXMatrixIdentity(pout);
 256     pout->u.m[0][0] = 2.0f / (r - l);
 257     pout->u.m[1][1] = 2.0f / (t - b);
 258     pout->u.m[2][2] = 1.0f / (zn -zf);
 259     pout->u.m[3][0] = -1.0f -2.0f *l / (r - l);
 260     pout->u.m[3][1] = 1.0f + 2.0f * t / (b - t);
 261     pout->u.m[3][2] = zn / (zn -zf);
 262     return pout;
 263 }
 264
 265 D3DXMATRIX* WINAPI D3DXMatrixOrthoRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
 266 {
 267     D3DXMatrixIdentity(pout);
 268     pout->u.m[0][0] = 2.0f / w;
 269     pout->u.m[1][1] = 2.0f / h;
 270     pout->u.m[2][2] = 1.0f / (zn - zf);
 271     pout->u.m[3][2] = zn / (zn - zf);
 272     return pout;
 273 }
 274
 275 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
 276 {
 277     D3DXMatrixIdentity(pout);
 278     pout->u.m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
 279     pout->u.m[1][1] = 1.0f / tan(fovy/2.0f);
 280     pout->u.m[2][2] = zf / (zf - zn);
 281     pout->u.m[2][3] = 1.0f;
 282     pout->u.m[3][2] = (zf * zn) / (zn - zf);
 283     pout->u.m[3][3] = 0.0f;
 284     return pout;
 285 }
 286
 287 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
 288 {
 289     D3DXMatrixIdentity(pout);
 290     pout->u.m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
 291     pout->u.m[1][1] = 1.0f / tan(fovy/2.0f);
 292     pout->u.m[2][2] = zf / (zn - zf);
 293     pout->u.m[2][3] = -1.0f;
 294     pout->u.m[3][2] = (zf * zn) / (zn - zf);
 295     pout->u.m[3][3] = 0.0f;
 296     return pout;
 297 }
 298
 299 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
 300 {
 301     D3DXMatrixIdentity(pout);
 302     pout->u.m[0][0] = 2.0f * zn / w;
 303     pout->u.m[1][1] = 2.0f * zn / h;
 304     pout->u.m[2][2] = zf / (zf - zn);
 305     pout->u.m[3][2] = (zn * zf) / (zn - zf);
 306     pout->u.m[2][3] = 1.0f;
 307     pout->u.m[3][3] = 0.0f;
 308     return pout;
 309 }
 310
 311 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterLH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
 312 {
 313     D3DXMatrixIdentity(pout);
 314     pout->u.m[0][0] = 2.0f * zn / (r - l);
 315     pout->u.m[1][1] = -2.0f * zn / (b - t);
 316     pout->u.m[2][0] = -1.0f - 2.0f * l / (r - l);
 317     pout->u.m[2][1] = 1.0f + 2.0f * t / (b - t);
 318     pout->u.m[2][2] = - zf / (zn - zf);
 319     pout->u.m[3][2] = (zn * zf) / (zn -zf);
 320     pout->u.m[2][3] = 1.0f;
 321     pout->u.m[3][3] = 0.0f;
 322     return pout;
 323 }
 324
 325 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveOffCenterRH(D3DXMATRIX *pout, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf)
 326 {
 327     D3DXMatrixIdentity(pout);
 328     pout->u.m[0][0] = 2.0f * zn / (r - l);
 329     pout->u.m[1][1] = -2.0f * zn / (b - t);
 330     pout->u.m[2][0] = 1.0f + 2.0f * l / (r - l);
 331     pout->u.m[2][1] = -1.0f -2.0f * t / (b - t);
 332     pout->u.m[2][2] = zf / (zn - zf);
 333     pout->u.m[3][2] = (zn * zf) / (zn -zf);
 334     pout->u.m[2][3] = -1.0f;
 335     pout->u.m[3][3] = 0.0f;
 336     return pout;
 337 }
 338
 339 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
 340 {
 341     D3DXMatrixIdentity(pout);
 342     pout->u.m[0][0] = 2.0f * zn / w;
 343     pout->u.m[1][1] = 2.0f * zn / h;
 344     pout->u.m[2][2] = zf / (zn - zf);
 345     pout->u.m[3][2] = (zn * zf) / (zn - zf);
 346     pout->u.m[2][3] = -1.0f;
 347     pout->u.m[3][3] = 0.0f;
 348     return pout;
 349 }
 350
 351 D3DXMATRIX* WINAPI D3DXMatrixReflect(D3DXMATRIX *pout, CONST D3DXPLANE *pplane)
 352 {
 353     D3DXPLANE Nplane;
 354
 355     D3DXPlaneNormalize(&Nplane, pplane);
 356     D3DXMatrixIdentity(pout);
 357     pout->u.m[0][0] = 1.0f - 2.0f * Nplane.a * Nplane.a;
 358     pout->u.m[0][1] = -2.0f * Nplane.a * Nplane.b;
 359     pout->u.m[0][2] = -2.0f * Nplane.a * Nplane.c;
 360     pout->u.m[1][0] = -2.0f * Nplane.a * Nplane.b;
 361     pout->u.m[1][1] = 1.0f - 2.0f * Nplane.b * Nplane.b;
 362     pout->u.m[1][2] = -2.0f * Nplane.b * Nplane.c;
 363     pout->u.m[2][0] = -2.0f * Nplane.c * Nplane.a;
 364     pout->u.m[2][1] = -2.0f * Nplane.c * Nplane.b;
 365     pout->u.m[2][2] = 1.0f - 2.0f * Nplane.c * Nplane.c;
 366     pout->u.m[3][0] = -2.0f * Nplane.d * Nplane.a;
 367     pout->u.m[3][1] = -2.0f * Nplane.d * Nplane.b;
 368     pout->u.m[3][2] = -2.0f * Nplane.d * Nplane.c;
 369     return pout;
 370 }
 371
 372 D3DXMATRIX* WINAPI D3DXMatrixRotationAxis(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pv, FLOAT angle)
 373 {
 374     D3DXVECTOR3 v;
 375
 376     D3DXVec3Normalize(&v,pv);
 377     D3DXMatrixIdentity(pout);
 378     pout->u.m[0][0] = (1.0f - cos(angle)) * v.x * v.x + cos(angle);
 379     pout->u.m[1][0] = (1.0f - cos(angle)) * v.x * v.y - sin(angle) * v.z;
 380     pout->u.m[2][0] = (1.0f - cos(angle)) * v.x * v.z + sin(angle) * v.y;
 381     pout->u.m[0][1] = (1.0f - cos(angle)) * v.y * v.x + sin(angle) * v.z;
 382     pout->u.m[1][1] = (1.0f - cos(angle)) * v.y * v.y + cos(angle);
 383     pout->u.m[2][1] = (1.0f - cos(angle)) * v.y * v.z - sin(angle) * v.x;
 384     pout->u.m[0][2] = (1.0f - cos(angle)) * v.z * v.x - sin(angle) * v.y;
 385     pout->u.m[1][2] = (1.0f - cos(angle)) * v.z * v.y + sin(angle) * v.x;
 386     pout->u.m[2][2] = (1.0f - cos(angle)) * v.z * v.z + cos(angle);
 387     return pout;
 388 }
 389
 390 D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion(D3DXMATRIX *pout, CONST D3DXQUATERNION *pq)
 391 {
 392     D3DXMatrixIdentity(pout);
 393     pout->u.m[0][0] = 1.0f - 2.0f * (pq->y * pq->y + pq->z * pq->z);
 394     pout->u.m[0][1] = 2.0f * (pq->x *pq->y + pq->z * pq->w);
 395     pout->u.m[0][2] = 2.0f * (pq->x * pq->z - pq->y * pq->w);
 396     pout->u.m[1][0] = 2.0f * (pq->x * pq->y - pq->z * pq->w);
 397     pout->u.m[1][1] = 1.0f - 2.0f * (pq->x * pq->x + pq->z * pq->z);
 398     pout->u.m[1][2] = 2.0f * (pq->y *pq->z + pq->x *pq->w);
 399     pout->u.m[2][0] = 2.0f * (pq->x * pq->z + pq->y * pq->w);
 400     pout->u.m[2][1] = 2.0f * (pq->y *pq->z - pq->x *pq->w);
 401     pout->u.m[2][2] = 1.0f - 2.0f * (pq->x * pq->x + pq->y * pq->y);
 402     return pout;
 403 }
 404
 405 D3DXMATRIX* WINAPI D3DXMatrixRotationX(D3DXMATRIX *pout, FLOAT angle)
 406 {
 407     D3DXMatrixIdentity(pout);
 408     pout->u.m[1][1] = cos(angle);
 409     pout->u.m[2][2] = cos(angle);
 410     pout->u.m[1][2] = sin(angle);
 411     pout->u.m[2][1] = -sin(angle);
 412     return pout;
 413 }
 414
 415 D3DXMATRIX* WINAPI D3DXMatrixRotationY(D3DXMATRIX *pout, FLOAT angle)
 416 {
 417     D3DXMatrixIdentity(pout);
 418     pout->u.m[0][0] = cos(angle);
 419     pout->u.m[2][2] = cos(angle);
 420     pout->u.m[0][2] = -sin(angle);
 421     pout->u.m[2][0] = sin(angle);
 422     return pout;
 423 }
 424
 425 D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll(D3DXMATRIX *pout, FLOAT yaw, FLOAT pitch, FLOAT roll)
 426 {
 427     D3DXMATRIX m, pout1, pout2, pout3;
 428
 429     D3DXMatrixIdentity(&pout3);
 430     D3DXMatrixRotationZ(&m,roll);
 431     D3DXMatrixMultiply(&pout2,&pout3,&m);
 432     D3DXMatrixRotationX(&m,pitch);
 433     D3DXMatrixMultiply(&pout1,&pout2,&m);
 434     D3DXMatrixRotationY(&m,yaw);
 435     D3DXMatrixMultiply(pout,&pout1,&m);
 436     return pout;
 437 }
 438 D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle)
 439 {
 440     D3DXMatrixIdentity(pout);
 441     pout->u.m[0][0] = cos(angle);
 442     pout->u.m[1][1] = cos(angle);
 443     pout->u.m[0][1] = sin(angle);
 444     pout->u.m[1][0] = -sin(angle);
 445     return pout;
 446 }
 447
 448 D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz)
 449 {
 450     D3DXMatrixIdentity(pout);
 451     pout->u.m[0][0] = sx;
 452     pout->u.m[1][1] = sy;
 453     pout->u.m[2][2] = sz;
 454     return pout;
 455 }
 456
 457 D3DXMATRIX* WINAPI D3DXMatrixShadow(D3DXMATRIX *pout, CONST D3DXVECTOR4 *plight, CONST D3DXPLANE *pplane)
 458 {
 459     D3DXPLANE Nplane;
 460     FLOAT dot;
 461
 462     D3DXPlaneNormalize(&Nplane, pplane);
 463     dot = D3DXPlaneDot(&Nplane, plight);
 464     pout->u.m[0][0] = dot - Nplane.a * plight->x;
 465     pout->u.m[0][1] = -Nplane.a * plight->y;
 466     pout->u.m[0][2] = -Nplane.a * plight->z;
 467     pout->u.m[0][3] = -Nplane.a * plight->w;
 468     pout->u.m[1][0] = -Nplane.b * plight->x;
 469     pout->u.m[1][1] = dot - Nplane.b * plight->y;
 470     pout->u.m[1][2] = -Nplane.b * plight->z;
 471     pout->u.m[1][3] = -Nplane.b * plight->w;
 472     pout->u.m[2][0] = -Nplane.c * plight->x;
 473     pout->u.m[2][1] = -Nplane.c * plight->y;
 474     pout->u.m[2][2] = dot - Nplane.c * plight->z;
 475     pout->u.m[2][3] = -Nplane.c * plight->w;
 476     pout->u.m[3][0] = -Nplane.d * plight->x;
 477     pout->u.m[3][1] = -Nplane.d * plight->y;
 478     pout->u.m[3][2] = -Nplane.d * plight->z;
 479     pout->u.m[3][3] = dot - Nplane.d * plight->w;
 480     return pout;
 481 }
 482
 483 D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z)
 484 {
 485     D3DXMatrixIdentity(pout);
 486     pout->u.m[3][0] = x;
 487     pout->u.m[3][1] = y;
 488     pout->u.m[3][2] = z;
 489     return pout;
 490 }
 491
 492 D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm)
 493 {
 494     int i,j;
 495
 496     for (i=0; i<4; i++)
 497     {
 498      for (j=0; j<4; j++)
 499      {
 500       pout->u.m[i][j] = pm->u.m[j][i];
 501      }
 502     }
 503     return pout;
 504 }
 505
 506 /*_________________D3DXPLANE________________*/
 507
 508 D3DXPLANE* WINAPI D3DXPlaneFromPointNormal(D3DXPLANE *pout, CONST D3DXVECTOR3 *pvpoint, CONST D3DXVECTOR3 *pvnormal)
 509 {
 510     pout->a = pvnormal->x;
 511     pout->b = pvnormal->y;
 512     pout->c = pvnormal->z;
 513     pout->d = -D3DXVec3Dot(pvpoint, pvnormal);
 514     return pout;
 515 }
 516
 517 D3DXPLANE* WINAPI D3DXPlaneFromPoints(D3DXPLANE *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3)
 518 {
 519     D3DXVECTOR3 edge1, edge2, normal, Nnormal;
 520
 521     edge1.x = 0.0f; edge1.y = 0.0f; edge1.z = 0.0f;
 522     edge2.x = 0.0f; edge2.y = 0.0f; edge2.z = 0.0f;
 523     D3DXVec3Subtract(&edge1, pv2, pv1);
 524     D3DXVec3Subtract(&edge2, pv3, pv1);
 525     D3DXVec3Cross(&normal, &edge1, &edge2);
 526     D3DXVec3Normalize(&Nnormal, &normal);
 527     D3DXPlaneFromPointNormal(pout, pv1, &Nnormal);
 528     return pout;
 529 }
 530
 531 D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine(D3DXVECTOR3 *pout, CONST D3DXPLANE *pp, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
 532 {
 533     D3DXVECTOR3 direction, normal;
 534     FLOAT dot, temp;
 535
 536     normal.x = pp->a;
 537     normal.y = pp->b;
 538     normal.z = pp->c;
 539     direction.x = pv2->x - pv1->x;
 540     direction.y = pv2->y - pv1->y;
 541     direction.z = pv2->z - pv1->z;
 542     dot = D3DXVec3Dot(&normal, &direction);
 543     if ( !dot ) return NULL;
 544     temp = ( pp->d + D3DXVec3Dot(&normal, pv1) ) / dot;
 545     pout->x = pv1->x - temp * direction.x;
 546     pout->y = pv1->y - temp * direction.y;
 547     pout->z = pv1->z - temp * direction.z;
 548     return pout;
 549 }
 550
 551 D3DXPLANE* WINAPI D3DXPlaneNormalize(D3DXPLANE *pout, CONST D3DXPLANE *pp)
 552 {
 553     FLOAT norm;
 554
 555     norm = sqrt(pp->a * pp->a + pp->b * pp->b + pp->c * pp->c);
 556     if ( norm )
 557     {
 558      pout->a = pp->a / norm;
 559      pout->b = pp->b / norm;
 560      pout->c = pp->c / norm;
 561      pout->d = pp->d / norm;
 562     }
 563     else
 564     {
 565      pout->a = 0.0f;
 566      pout->b = 0.0f;
 567      pout->c = 0.0f;
 568      pout->d = 0.0f;
 569     }
 570     return pout;
 571 }
 572
 573 D3DXPLANE* WINAPI D3DXPlaneTransform(D3DXPLANE *pout, CONST D3DXPLANE *pplane, CONST D3DXMATRIX *pm)
 574 {
 575      pout->a = pm->u.m[0][0] * pplane->a + pm->u.m[1][0] * pplane->b + pm->u.m[2][0] * pplane->c + pm->u.m[3][0] * pplane->d;
 576      pout->b = pm->u.m[0][1] * pplane->a + pm->u.m[1][1] * pplane->b + pm->u.m[2][1] * pplane->c + pm->u.m[3][1] * pplane->d;
 577      pout->c = pm->u.m[0][2] * pplane->a + pm->u.m[1][2] * pplane->b + pm->u.m[2][2] * pplane->c + pm->u.m[3][2] * pplane->d;
 578      pout->d = pm->u.m[0][3] * pplane->a + pm->u.m[1][3] * pplane->b + pm->u.m[2][3] * pplane->c + pm->u.m[3][3] * pplane->d;
 579     return pout;
 580 }
 581
 582 /*_________________D3DXQUATERNION________________*/
 583
 584 D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, FLOAT f, FLOAT g)
 585 {
 586     D3DXQUATERNION temp1, temp2;
 587     D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq2, f + g), D3DXQuaternionSlerp(&temp2, pq1, pq3, f+g), g / (f + g));
 588     return pout;
 589 }
 590
 591 D3DXQUATERNION* WINAPI D3DXQuaternionInverse(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 592 {
 593     D3DXQUATERNION temp;
 594     FLOAT norm;
 595
 596     norm = D3DXQuaternionLengthSq(pq);
 597     if ( !norm )
 598     {
 599      pout->x = 0.0f;
 600      pout->y = 0.0f;
 601      pout->z = 0.0f;
 602      pout->w = 0.0f;
 603     }
 604     else
 605     {
 606     D3DXQuaternionConjugate(&temp, pq);
 607     pout->x = temp.x / norm;
 608     pout->y = temp.y / norm;
 609     pout->z = temp.z / norm;
 610     pout->w = temp.w / norm;
 611     }
 612     return pout;
 613 }
 614
 615 D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
 616 {
 617     pout->x = pq2->w * pq1->x + pq2->x * pq1->w + pq2->y * pq1->z - pq2->z * pq1->y;
 618     pout->y = pq2->w * pq1->y - pq2->x * pq1->z + pq2->y * pq1->w + pq2->z * pq1->x;
 619     pout->z = pq2->w * pq1->z + pq2->x * pq1->y - pq2->y * pq1->x + pq2->z * pq1->w;
 620     pout->w = pq2->w * pq1->w - pq2->x * pq1->x - pq2->y * pq1->y - pq2->z * pq1->z;
 621     return pout;
 622 }
 623
 624 D3DXQUATERNION* WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 625 {
 626     FLOAT norm;
 627
 628     norm = D3DXQuaternionLength(pq);
 629     if ( !norm )
 630     {
 631      pout->x = 0.0f;
 632      pout->y = 0.0f;
 633      pout->z = 0.0f;
 634      pout->w = 0.0f;
 635     }
 636     else
 637     {
 638      pout->x = pq->x / norm;
 639      pout->y = pq->y / norm;
 640      pout->z = pq->z / norm;
 641      pout->w = pq->w / norm;
 642     }
 643     return pout;
 644 }
 645
 646 D3DXQUATERNION* WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, FLOAT t)
 647 {
 648     FLOAT dot, epsilon;
 649
 650     epsilon = 1.0f;
 651     dot = D3DXQuaternionDot(pq1, pq2);
 652     if ( dot < 0.0f) epsilon = -1.0f;
 653     pout->x = (1.0f - t) * pq1->x + epsilon * t * pq2->x;
 654     pout->y = (1.0f - t) * pq1->y + epsilon * t * pq2->y;
 655     pout->z = (1.0f - t) * pq1->z + epsilon * t * pq2->z;
 656     pout->w = (1.0f - t) * pq1->w + epsilon * t * pq2->w;
 657     return pout;
 658 }
 659
 660 D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, CONST D3DXQUATERNION *pq4, FLOAT t)
 661 {
 662     D3DXQUATERNION temp1, temp2;
 663
 664     D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq4, t), D3DXQuaternionSlerp(&temp2, pq2, pq3, t), 2.0f * t * (1.0f - t));
 665     return pout;
 666 }
 667
 668 /*_________________D3DXVec2_____________________*/
 669
 670 D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT f, FLOAT g)
 671 {
 672     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 673     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 674     return pout;
 675 }
 676
 677 D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT s)
 678 {
 679     pout->x = 0.5f * (2.0f * pv1->x + (pv2->x - pv0->x) *s + (2.0f *pv0->x - 5.0f * pv1->x + 4.0f * pv2->x - pv3->x) * s * s + (pv3->x -3.0f * pv2->x + 3.0f * pv1->x - pv0->x) * s * s * s);
 680     pout->y = 0.5f * (2.0f * pv1->y + (pv2->y - pv0->y) *s + (2.0f *pv0->y - 5.0f * pv1->y + 4.0f * pv2->y - pv3->y) * s * s + (pv3->y -3.0f * pv2->y + 3.0f * pv1->y - pv0->y) * s * s * s);
 681     return pout;
 682 }
 683
 684 D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s)
 685 {
 686     FLOAT h1, h2, h3, h4;
 687
 688     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 689     h2 = s * s * s - 2.0f * s * s + s;
 690     h3 = -2.0f * s * s * s + 3.0f * s * s;
 691     h4 = s * s * s - s * s;
 692
 693     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 694     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 695     return pout;
 696 }
 697
 698 D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv)
 699 {
 700     FLOAT norm;
 701
 702     norm = D3DXVec2Length(pv);
 703     if ( !norm )
 704     {
 705      pout->x = 0.0f;
 706      pout->y = 0.0f;
 707     }
 708     else
 709     {
 710      pout->x = pv->x / norm;
 711      pout->y = pv->y / norm;
 712     }
 713     return pout;
 714 }
 715
 716 D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 717 {
 718     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y  + pm->u.m[3][0];
 719     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y  + pm->u.m[3][1];
 720     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y  + pm->u.m[3][2];
 721     pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y  + pm->u.m[3][3];
 722     return pout;
 723 }
 724
 725 D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 726 {
 727     FLOAT norm;
 728
 729     norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
 730     if ( norm )
 731     {
 732      pout->x = (pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[3][0]) / norm;
 733      pout->y = (pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[3][1]) / norm;
 734     }
 735     else
 736     {
 737      pout->x = 0.0f;
 738      pout->y = 0.0f;
 739     }
 740     return pout;
 741 }
 742
 743 D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 744 {
 745     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y;
 746     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y;
 747     return pout;
 748 }
 749
 750 /*_________________D3DXVec3_____________________*/
 751
 752 D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g)
 753 {
 754     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 755     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 756     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
 757     return pout;
 758 }
 759
 760 D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s)
 761 {
 762     pout->x = 0.5f * (2.0f * pv1->x + (pv2->x - pv0->x) *s + (2.0f *pv0->x - 5.0f * pv1->x + 4.0f * pv2->x - pv3->x) * s * s + (pv3->x -3.0f * pv2->x + 3.0f * pv1->x - pv0->x) * s * s * s);
 763     pout->y = 0.5f * (2.0f * pv1->y + (pv2->y - pv0->y) *s + (2.0f *pv0->y - 5.0f * pv1->y + 4.0f * pv2->y - pv3->y) * s * s + (pv3->y -3.0f * pv2->y + 3.0f * pv1->y - pv0->y) * s * s * s);
 764     pout->z = 0.5f * (2.0f * pv1->z + (pv2->z - pv0->z) *s + (2.0f *pv0->z - 5.0f * pv1->z + 4.0f * pv2->z - pv3->z) * s * s + (pv3->z -3.0f * pv2->z + 3.0f * pv1->z - pv0->z) * s * s * s);
 765     return pout;
 766 }
 767
 768 D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s)
 769 {
 770     FLOAT h1, h2, h3, h4;
 771
 772     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 773     h2 = s * s * s - 2.0f * s * s + s;
 774     h3 = -2.0f * s * s * s + 3.0f * s * s;
 775     h4 = s * s * s - s * s;
 776
 777     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 778     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 779     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
 780     return pout;
 781 }
 782
 783 D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv)
 784 {
 785     FLOAT norm;
 786
 787     norm = D3DXVec3Length(pv);
 788     if ( !norm )
 789     {
 790      pout->x = 0.0f;
 791      pout->y = 0.0f;
 792      pout->z = 0.0f;
 793     }
 794     else
 795     {
 796      pout->x = pv->x / norm;
 797      pout->y = pv->y / norm;
 798      pout->z = pv->z / norm;
 799     }
 800     return pout;
 801 }
 802
 803 D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
 804 {
 805     D3DXMATRIX m1, m2;
 806     D3DXVECTOR3 vec;
 807
 808     D3DXMatrixMultiply(&m1, pworld, pview);
 809     D3DXMatrixMultiply(&m2, &m1, pprojection);
 810     D3DXVec3TransformCoord(&vec, pv, &m2);
 811     pout->x = pviewport->X +  ( 1.0f + vec.x ) * pviewport->Width / 2.0f;
 812     pout->y = pviewport->Y +  ( 1.0f - vec.y ) * pviewport->Height / 2.0f;
 813     pout->z = pviewport->MinZ + vec.z * ( pviewport->MaxZ - pviewport->MinZ );
 814     return pout;
 815 }
 816
 817 D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
 818 {
 819     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z + pm->u.m[3][0];
 820     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z + pm->u.m[3][1];
 821     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z + pm->u.m[3][2];
 822     pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[2][3] * pv->z + pm->u.m[3][3];
 823     return pout;
 824 }
 825
 826 D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
 827 {
 828     FLOAT norm;
 829
 830     norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[2][3] *pv->z + pm->u.m[3][3];
 831
 832     if ( norm )
 833     {
 834      pout->x = (pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z + pm->u.m[3][0]) / norm;
 835      pout->y = (pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z + pm->u.m[3][1]) / norm;
 836      pout->z = (pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z + pm->u.m[3][2]) / norm;
 837     }
 838     else
 839     {
 840      pout->x = 0.0f;
 841      pout->y = 0.0f;
 842      pout->z = 0.0f;
 843     }
 844     return pout;
 845 }
 846
 847 D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
 848 {
 849     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z;
 850     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z;
 851     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z;
 852     return pout;
 853
 854 }
 855
 856 D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
 857 {
 858     D3DXMATRIX m1, m2, m3;
 859     D3DXVECTOR3 vec;
 860
 861     D3DXMatrixMultiply(&m1, pworld, pview);
 862     D3DXMatrixMultiply(&m2, &m1, pprojection);
 863     D3DXMatrixInverse(&m3, NULL, &m2);
 864     vec.x = 2.0f * ( pv->x - pviewport->X ) / pviewport->Width - 1.0f;
 865     vec.y = 1.0f - 2.0f * ( pv->y - pviewport->Y ) / pviewport->Height;
 866     vec.z = ( pv->z - pviewport->MinZ) / ( pviewport->MaxZ - pviewport->MinZ );
 867     D3DXVec3TransformCoord(pout, &vec, &m3);
 868     return pout;
 869 }
 870
 871 /*_________________D3DXVec4_____________________*/
 872
 873 D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g)
 874 {
 875     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 876     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 877     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
 878     pout->w = (1.0f-f-g) * (pv1->w) + f * (pv2->w) + g * (pv3->w);
 879     return pout;
 880 }
 881
 882 D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s)
 883 {
 884     pout->x = 0.5f * (2.0f * pv1->x + (pv2->x - pv0->x) *s + (2.0f *pv0->x - 5.0f * pv1->x + 4.0f * pv2->x - pv3->x) * s * s + (pv3->x -3.0f * pv2->x + 3.0f * pv1->x - pv0->x) * s * s * s);
 885     pout->y = 0.5f * (2.0f * pv1->y + (pv2->y - pv0->y) *s + (2.0f *pv0->y - 5.0f * pv1->y + 4.0f * pv2->y - pv3->y) * s * s + (pv3->y -3.0f * pv2->y + 3.0f * pv1->y - pv0->y) * s * s * s);
 886     pout->z = 0.5f * (2.0f * pv1->z + (pv2->z - pv0->z) *s + (2.0f *pv0->z - 5.0f * pv1->z + 4.0f * pv2->z - pv3->z) * s * s + (pv3->z -3.0f * pv2->z + 3.0f * pv1->z - pv0->z) * s * s * s);
 887     pout->w = 0.5f * (2.0f * pv1->w + (pv2->w - pv0->w) *s + (2.0f *pv0->w - 5.0f * pv1->w + 4.0f * pv2->w - pv3->w) * s * s + (pv3->w -3.0f * pv2->w + 3.0f * pv1->w - pv0->w) * s * s * s);
 888     return pout;
 889 }
 890
 891 D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3)
 892 {
 893     pout->x = pv1->y * (pv2->z * pv3->w - pv3->z * pv2->w) - pv1->z * (pv2->y * pv3->w - pv3->y * pv2->w) + pv1->w * (pv2->y * pv3->z - pv2->z *pv3->y);
 894     pout->y = -(pv1->x * (pv2->z * pv3->w - pv3->z * pv2->w) - pv1->z * (pv2->x * pv3->w - pv3->x * pv2->w) + pv1->w * (pv2->x * pv3->z - pv3->x * pv2->z));
 895     pout->z = pv1->x * (pv2->y * pv3->w - pv3->y * pv2->w) - pv1->y * (pv2->x *pv3->w - pv3->x * pv2->w) + pv1->w * (pv2->x * pv3->y - pv3->x * pv2->y);
 896     pout->w = -(pv1->x * (pv2->y * pv3->z - pv3->y * pv2->z) - pv1->y * (pv2->x * pv3->z - pv3->x *pv2->z) + pv1->z * (pv2->x * pv3->y - pv3->x * pv2->y));
 897     return pout;
 898 }
 899
 900 D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s)
 901 {
 902     FLOAT h1, h2, h3, h4;
 903
 904     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 905     h2 = s * s * s - 2.0f * s * s + s;
 906     h3 = -2.0f * s * s * s + 3.0f * s * s;
 907     h4 = s * s * s - s * s;
 908
 909     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 910     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 911     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
 912     pout->w = h1 * (pv1->w) + h2 * (pt1->w) + h3 * (pv2->w) + h4 * (pt2->w);
 913     return pout;
 914 }
 915
 916 D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv)
 917 {
 918     FLOAT norm;
 919
 920     norm = D3DXVec4Length(pv);
 921     if ( !norm )
 922     {
 923      pout->x = 0.0f;
 924      pout->y = 0.0f;
 925      pout->z = 0.0f;
 926      pout->w = 0.0f;
 927     }
 928     else
 929     {
 930      pout->x = pv->x / norm;
 931      pout->y = pv->y / norm;
 932      pout->z = pv->z / norm;
 933      pout->w = pv->w / norm;
 934     }
 935     return pout;
 936 }
 937
 938 D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm)
 939 {
 940     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z + pm->u.m[3][0] * pv->w;
 941     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z + pm->u.m[3][1] * pv->w;
 942     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z + pm->u.m[3][2] * pv->w;
 943     pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[2][3] * pv->z + pm->u.m[3][3] * pv->w;
 944     return pout;
 945 }