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 D3DXMatrixTransformation(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pscalingcenter, CONST D3DXQUATERNION *pscalingrotation, CONST D3DXVECTOR3 *pscaling, CONST D3DXVECTOR3 *protationcenter, CONST D3DXQUATERNION *protation, CONST D3DXVECTOR3 *ptranslation)
 484 {
 485     D3DXMATRIX m1, m2, m3, m4, m5, m6, m7, p1, p2, p3, p4, p5;
 486     D3DXQUATERNION prc;
 487     D3DXVECTOR3 psc, pt;
 488
 489     if ( !pscalingcenter )
 490     {
 491      psc.x = 0.0f;
 492      psc.y = 0.0f;
 493      psc.z = 0.0f;
 494     }
 495     else
 496     {
 497      psc.x = pscalingcenter->x;
 498      psc.y = pscalingcenter->y;
 499      psc.z = pscalingcenter->z;
 500     }
 501     if ( !protationcenter )
 502     {
 503      prc.x = 0.0f;
 504      prc.y = 0.0f;
 505      prc.z = 0.0f;
 506     }
 507     else
 508     {
 509      prc.x = protationcenter->x;
 510      prc.y = protationcenter->y;
 511      prc.z = protationcenter->z;
 512     }
 513     if ( !ptranslation )
 514     {
 515      pt.x = 0.0f;
 516      pt.y = 0.0f;
 517      pt.z = 0.0f;
 518     }
 519     else
 520     {
 521      pt.x = ptranslation->x;
 522      pt.y = ptranslation->y;
 523      pt.z = ptranslation->z;
 524     }
 525     D3DXMatrixTranslation(&m1, -psc.x, -psc.y, -psc.z);
 526     if ( !pscalingrotation )
 527     {
 528      D3DXMatrixIdentity(&m2);
 529      D3DXMatrixIdentity(&m4);
 530     }
 531     else
 532     {
 533      D3DXMatrixRotationQuaternion(&m4, pscalingrotation);
 534      D3DXMatrixInverse(&m2, NULL, &m4);
 535     }
 536     if ( !pscaling )
 537     {
 538      D3DXMatrixIdentity(&m3);
 539     }
 540     else
 541     {
 542     D3DXMatrixScaling(&m3, pscaling->x, pscaling->y, pscaling->z);
 543     }
 544     if ( !protation )
 545     {
 546      D3DXMatrixIdentity(&m6);
 547     }
 548     else
 549     {
 550      D3DXMatrixRotationQuaternion(&m6, protation);
 551     }
 552     D3DXMatrixTranslation(&m5, psc.x - prc.x,  psc.y - prc.y,  psc.z - prc.z);
 553     D3DXMatrixTranslation(&m7, prc.x + pt.x, prc.y + pt.y, prc.z + pt.z);
 554     D3DXMatrixMultiply(&p1, &m1, &m2);
 555     D3DXMatrixMultiply(&p2, &p1, &m3);
 556     D3DXMatrixMultiply(&p3, &p2, &m4);
 557     D3DXMatrixMultiply(&p4, &p3, &m5);
 558     D3DXMatrixMultiply(&p5, &p4, &m6);
 559     D3DXMatrixMultiply(pout, &p5, &m7);
 560     return pout;
 561 }
 562
 563 D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z)
 564 {
 565     D3DXMatrixIdentity(pout);
 566     pout->u.m[3][0] = x;
 567     pout->u.m[3][1] = y;
 568     pout->u.m[3][2] = z;
 569     return pout;
 570 }
 571
 572 D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm)
 573 {
 574     int i,j;
 575
 576     for (i=0; i<4; i++)
 577     {
 578      for (j=0; j<4; j++)
 579      {
 580       pout->u.m[i][j] = pm->u.m[j][i];
 581      }
 582     }
 583     return pout;
 584 }
 585
 586 /*_________________D3DXPLANE________________*/
 587
 588 D3DXPLANE* WINAPI D3DXPlaneFromPointNormal(D3DXPLANE *pout, CONST D3DXVECTOR3 *pvpoint, CONST D3DXVECTOR3 *pvnormal)
 589 {
 590     pout->a = pvnormal->x;
 591     pout->b = pvnormal->y;
 592     pout->c = pvnormal->z;
 593     pout->d = -D3DXVec3Dot(pvpoint, pvnormal);
 594     return pout;
 595 }
 596
 597 D3DXPLANE* WINAPI D3DXPlaneFromPoints(D3DXPLANE *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3)
 598 {
 599     D3DXVECTOR3 edge1, edge2, normal, Nnormal;
 600
 601     edge1.x = 0.0f; edge1.y = 0.0f; edge1.z = 0.0f;
 602     edge2.x = 0.0f; edge2.y = 0.0f; edge2.z = 0.0f;
 603     D3DXVec3Subtract(&edge1, pv2, pv1);
 604     D3DXVec3Subtract(&edge2, pv3, pv1);
 605     D3DXVec3Cross(&normal, &edge1, &edge2);
 606     D3DXVec3Normalize(&Nnormal, &normal);
 607     D3DXPlaneFromPointNormal(pout, pv1, &Nnormal);
 608     return pout;
 609 }
 610
 611 D3DXVECTOR3* WINAPI D3DXPlaneIntersectLine(D3DXVECTOR3 *pout, CONST D3DXPLANE *pp, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2)
 612 {
 613     D3DXVECTOR3 direction, normal;
 614     FLOAT dot, temp;
 615
 616     normal.x = pp->a;
 617     normal.y = pp->b;
 618     normal.z = pp->c;
 619     direction.x = pv2->x - pv1->x;
 620     direction.y = pv2->y - pv1->y;
 621     direction.z = pv2->z - pv1->z;
 622     dot = D3DXVec3Dot(&normal, &direction);
 623     if ( !dot ) return NULL;
 624     temp = ( pp->d + D3DXVec3Dot(&normal, pv1) ) / dot;
 625     pout->x = pv1->x - temp * direction.x;
 626     pout->y = pv1->y - temp * direction.y;
 627     pout->z = pv1->z - temp * direction.z;
 628     return pout;
 629 }
 630
 631 D3DXPLANE* WINAPI D3DXPlaneNormalize(D3DXPLANE *pout, CONST D3DXPLANE *pp)
 632 {
 633     FLOAT norm;
 634
 635     norm = sqrt(pp->a * pp->a + pp->b * pp->b + pp->c * pp->c);
 636     if ( norm )
 637     {
 638      pout->a = pp->a / norm;
 639      pout->b = pp->b / norm;
 640      pout->c = pp->c / norm;
 641      pout->d = pp->d / norm;
 642     }
 643     else
 644     {
 645      pout->a = 0.0f;
 646      pout->b = 0.0f;
 647      pout->c = 0.0f;
 648      pout->d = 0.0f;
 649     }
 650     return pout;
 651 }
 652
 653 D3DXPLANE* WINAPI D3DXPlaneTransform(D3DXPLANE *pout, CONST D3DXPLANE *pplane, CONST D3DXMATRIX *pm)
 654 {
 655      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;
 656      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;
 657      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;
 658      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;
 659     return pout;
 660 }
 661
 662 /*_________________D3DXQUATERNION________________*/
 663
 664 D3DXQUATERNION* WINAPI D3DXQuaternionBaryCentric(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, FLOAT f, FLOAT g)
 665 {
 666     D3DXQUATERNION temp1, temp2;
 667     D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq2, f + g), D3DXQuaternionSlerp(&temp2, pq1, pq3, f+g), g / (f + g));
 668     return pout;
 669 }
 670
 671 D3DXQUATERNION* WINAPI D3DXQuaternionExp(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 672 {
 673     FLOAT norm;
 674
 675     norm = sqrt(pq->x * pq->x + pq->y * pq->y + pq->z * pq->z);
 676     if (norm )
 677     {
 678      pout->x = sin(norm) * pq->x / norm;
 679      pout->y = sin(norm) * pq->y / norm;
 680      pout->z = sin(norm) * pq->z / norm;
 681      pout->w = cos(norm);
 682     }
 683     else
 684     {
 685      pout->x = 0.0f;
 686      pout->y = 0.0f;
 687      pout->z = 0.0f;
 688      pout->w = 1.0f;
 689     }
 690     return pout;
 691 }
 692
 693 D3DXQUATERNION* WINAPI D3DXQuaternionInverse(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 694 {
 695     D3DXQUATERNION temp;
 696     FLOAT norm;
 697
 698     norm = D3DXQuaternionLengthSq(pq);
 699     if ( !norm )
 700     {
 701      pout->x = 0.0f;
 702      pout->y = 0.0f;
 703      pout->z = 0.0f;
 704      pout->w = 0.0f;
 705     }
 706     else
 707     {
 708     D3DXQuaternionConjugate(&temp, pq);
 709     pout->x = temp.x / norm;
 710     pout->y = temp.y / norm;
 711     pout->z = temp.z / norm;
 712     pout->w = temp.w / norm;
 713     }
 714     return pout;
 715 }
 716
 717 D3DXQUATERNION* WINAPI D3DXQuaternionLn(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 718 {
 719     FLOAT norm, normvec, theta;
 720
 721     norm = D3DXQuaternionLengthSq(pq);
 722     if ( norm > 1.0001f )
 723     {
 724      pout->x = pq->x;
 725      pout->y = pq->y;
 726      pout->z = pq->z;
 727      pout->w = 0.0f;
 728     }
 729     else if( norm > 0.99999f)
 730     {
 731      normvec = sqrt( pq->x * pq->x + pq->y * pq->y + pq->z * pq->z );
 732      theta = atan2(normvec, pq->w) / normvec;
 733      pout->x = theta * pq->x;
 734      pout->y = theta * pq->y;
 735      pout->z = theta * pq->z;
 736      pout->w = 0.0f;
 737     }
 738     else
 739     {
 740      FIXME("The quaternion (%f, %f, %f, %f) has a norm <1. This should not happen. Windows returns a result anyway. This case is not implemented yet.\n", pq->x, pq->y, pq->z, pq->w);
 741     }
 742     return pout;
 743 }
 744
 745 D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
 746 {
 747     pout->x = pq2->w * pq1->x + pq2->x * pq1->w + pq2->y * pq1->z - pq2->z * pq1->y;
 748     pout->y = pq2->w * pq1->y - pq2->x * pq1->z + pq2->y * pq1->w + pq2->z * pq1->x;
 749     pout->z = pq2->w * pq1->z + pq2->x * pq1->y - pq2->y * pq1->x + pq2->z * pq1->w;
 750     pout->w = pq2->w * pq1->w - pq2->x * pq1->x - pq2->y * pq1->y - pq2->z * pq1->z;
 751     return pout;
 752 }
 753
 754 D3DXQUATERNION* WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 755 {
 756     FLOAT norm;
 757
 758     norm = D3DXQuaternionLength(pq);
 759     if ( !norm )
 760     {
 761      pout->x = 0.0f;
 762      pout->y = 0.0f;
 763      pout->z = 0.0f;
 764      pout->w = 0.0f;
 765     }
 766     else
 767     {
 768      pout->x = pq->x / norm;
 769      pout->y = pq->y / norm;
 770      pout->z = pq->z / norm;
 771      pout->w = pq->w / norm;
 772     }
 773     return pout;
 774 }
 775
 776 D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis(D3DXQUATERNION *pout, CONST D3DXVECTOR3 *pv, FLOAT angle)
 777 {
 778     D3DXVECTOR3 temp;
 779
 780     D3DXVec3Normalize(&temp, pv);
 781     pout->x = sin( angle / 2.0f ) * temp.x;
 782     pout->y = sin( angle / 2.0f ) * temp.y;
 783     pout->z = sin( angle / 2.0f ) * temp.z;
 784     pout->w = cos( angle / 2.0f );
 785     return pout;
 786 }
 787
 788 D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix(D3DXQUATERNION *pout, CONST D3DXMATRIX *pm)
 789 {
 790     int i, maxi;
 791     FLOAT maxdiag, S, trace;
 792
 793     trace = pm->u.m[0][0] + pm->u.m[1][1] + pm->u.m[2][2] + 1.0f;
 794     if ( trace > 0.0f)
 795     {
 796      pout->x = ( pm->u.m[1][2] - pm->u.m[2][1] ) / ( 2.0f * sqrt(trace) );
 797      pout->y = ( pm->u.m[2][0] - pm->u.m[0][2] ) / ( 2.0f * sqrt(trace) );
 798      pout->z = ( pm->u.m[0][1] - pm->u.m[1][0] ) / ( 2.0f * sqrt(trace) );
 799      pout->w = sqrt(trace) / 2.0f;
 800      return pout;
 801      }
 802     maxi = 0;
 803     maxdiag = pm->u.m[0][0];
 804     for (i=1; i<3; i++)
 805     {
 806      if ( pm->u.m[i][i] > maxdiag )
 807      {
 808       maxi = i;
 809       maxdiag = pm->u.m[i][i];
 810      }
 811     }
 812     switch( maxi )
 813     {
 814      case 0:
 815        S = 2.0f * sqrt(1.0f + pm->u.m[0][0] - pm->u.m[1][1] - pm->u.m[2][2]);
 816        pout->x = 0.25f * S;
 817        pout->y = ( pm->u.m[0][1] + pm->u.m[1][0] ) / S;
 818        pout->z = ( pm->u.m[0][2] + pm->u.m[2][0] ) / S;
 819        pout->w = ( pm->u.m[1][2] - pm->u.m[2][1] ) / S;
 820      break;
 821      case 1:
 822        S = 2.0f * sqrt(1.0f + pm->u.m[1][1] - pm->u.m[0][0] - pm->u.m[2][2]);
 823        pout->x = ( pm->u.m[0][1] + pm->u.m[1][0] ) / S;
 824        pout->y = 0.25f * S;
 825        pout->z = ( pm->u.m[1][2] + pm->u.m[2][1] ) / S;
 826        pout->w = ( pm->u.m[2][0] - pm->u.m[0][2] ) / S;
 827      break;
 828      case 2:
 829        S = 2.0f * sqrt(1.0f + pm->u.m[2][2] - pm->u.m[0][0] - pm->u.m[1][1]);
 830        pout->x = ( pm->u.m[0][2] + pm->u.m[2][0] ) / S;
 831        pout->y = ( pm->u.m[1][2] + pm->u.m[2][1] ) / S;
 832        pout->z = 0.25f * S;
 833        pout->w = ( pm->u.m[0][1] - pm->u.m[1][0] ) / S;
 834      break;
 835     }
 836     return pout;
 837 }
 838
 839 D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *pout, FLOAT yaw, FLOAT pitch, FLOAT roll)
 840 {
 841     pout->x = sin( yaw / 2.0f) * cos(pitch / 2.0f) * sin(roll / 2.0f) + cos(yaw / 2.0f) * sin(pitch / 2.0f) * cos(roll / 2.0f);
 842     pout->y = sin( yaw / 2.0f) * cos(pitch / 2.0f) * cos(roll / 2.0f) - cos(yaw / 2.0f) * sin(pitch / 2.0f) * sin(roll / 2.0f);
 843     pout->z = cos(yaw / 2.0f) * cos(pitch / 2.0f) * sin(roll / 2.0f) - sin( yaw / 2.0f) * sin(pitch / 2.0f) * cos(roll / 2.0f);
 844     pout->w = cos( yaw / 2.0f) * cos(pitch / 2.0f) * cos(roll / 2.0f) + sin(yaw / 2.0f) * sin(pitch / 2.0f) * sin(roll / 2.0f);
 845     return pout;
 846 }
 847
 848 D3DXQUATERNION* WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, FLOAT t)
 849 {
 850     FLOAT dot, epsilon;
 851
 852     epsilon = 1.0f;
 853     dot = D3DXQuaternionDot(pq1, pq2);
 854     if ( dot < 0.0f) epsilon = -1.0f;
 855     pout->x = (1.0f - t) * pq1->x + epsilon * t * pq2->x;
 856     pout->y = (1.0f - t) * pq1->y + epsilon * t * pq2->y;
 857     pout->z = (1.0f - t) * pq1->z + epsilon * t * pq2->z;
 858     pout->w = (1.0f - t) * pq1->w + epsilon * t * pq2->w;
 859     return pout;
 860 }
 861
 862 D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, CONST D3DXQUATERNION *pq4, FLOAT t)
 863 {
 864     D3DXQUATERNION temp1, temp2;
 865
 866     D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq4, t), D3DXQuaternionSlerp(&temp2, pq2, pq3, t), 2.0f * t * (1.0f - t));
 867     return pout;
 868 }
 869
 870 void WINAPI D3DXQuaternionToAxisAngle(CONST D3DXQUATERNION *pq, D3DXVECTOR3 *paxis, FLOAT *pangle)
 871 {
 872     FLOAT norm;
 873
 874     *pangle = 0.0f;
 875     norm = D3DXQuaternionLength(pq);
 876     if ( norm )
 877     {
 878      paxis->x = pq->x / norm;
 879      paxis->y = pq->y / norm;
 880      paxis->z = pq->z / norm;
 881      if ( fabs( pq->w ) <= 1.0f ) *pangle = 2.0f * acos(pq->w);
 882     }
 883     else
 884     {
 885      paxis->x = 1.0f;
 886      paxis->y = 0.0f;
 887      paxis->z = 0.0f;
 888     }
 889 }
 890
 891 /*_________________D3DXVec2_____________________*/
 892
 893 D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT f, FLOAT g)
 894 {
 895     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 896     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 897     return pout;
 898 }
 899
 900 D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT s)
 901 {
 902     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);
 903     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);
 904     return pout;
 905 }
 906
 907 D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s)
 908 {
 909     FLOAT h1, h2, h3, h4;
 910
 911     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 912     h2 = s * s * s - 2.0f * s * s + s;
 913     h3 = -2.0f * s * s * s + 3.0f * s * s;
 914     h4 = s * s * s - s * s;
 915
 916     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 917     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 918     return pout;
 919 }
 920
 921 D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv)
 922 {
 923     FLOAT norm;
 924
 925     norm = D3DXVec2Length(pv);
 926     if ( !norm )
 927     {
 928      pout->x = 0.0f;
 929      pout->y = 0.0f;
 930     }
 931     else
 932     {
 933      pout->x = pv->x / norm;
 934      pout->y = pv->y / norm;
 935     }
 936     return pout;
 937 }
 938
 939 D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 940 {
 941     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y  + pm->u.m[3][0];
 942     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y  + pm->u.m[3][1];
 943     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y  + pm->u.m[3][2];
 944     pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y  + pm->u.m[3][3];
 945     return pout;
 946 }
 947
 948 D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 949 {
 950     FLOAT norm;
 951
 952     norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
 953     if ( norm )
 954     {
 955      pout->x = (pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[3][0]) / norm;
 956      pout->y = (pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[3][1]) / norm;
 957     }
 958     else
 959     {
 960      pout->x = 0.0f;
 961      pout->y = 0.0f;
 962     }
 963     return pout;
 964 }
 965
 966 D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 967 {
 968     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y;
 969     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y;
 970     return pout;
 971 }
 972
 973 /*_________________D3DXVec3_____________________*/
 974
 975 D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g)
 976 {
 977     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 978     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 979     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
 980     return pout;
 981 }
 982
 983 D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s)
 984 {
 985     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);
 986     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);
 987     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);
 988     return pout;
 989 }
 990
 991 D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s)
 992 {
 993     FLOAT h1, h2, h3, h4;
 994
 995     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 996     h2 = s * s * s - 2.0f * s * s + s;
 997     h3 = -2.0f * s * s * s + 3.0f * s * s;
 998     h4 = s * s * s - s * s;
 999
1000     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1001     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1002     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1003     return pout;
1004 }
1005
1006 D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv)
1007 {
1008     FLOAT norm;
1009
1010     norm = D3DXVec3Length(pv);
1011     if ( !norm )
1012     {
1013      pout->x = 0.0f;
1014      pout->y = 0.0f;
1015      pout->z = 0.0f;
1016     }
1017     else
1018     {
1019      pout->x = pv->x / norm;
1020      pout->y = pv->y / norm;
1021      pout->z = pv->z / norm;
1022     }
1023     return pout;
1024 }
1025
1026 D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1027 {
1028     D3DXMATRIX m1, m2;
1029     D3DXVECTOR3 vec;
1030
1031     D3DXMatrixMultiply(&m1, pworld, pview);
1032     D3DXMatrixMultiply(&m2, &m1, pprojection);
1033     D3DXVec3TransformCoord(&vec, pv, &m2);
1034     pout->x = pviewport->X +  ( 1.0f + vec.x ) * pviewport->Width / 2.0f;
1035     pout->y = pviewport->Y +  ( 1.0f - vec.y ) * pviewport->Height / 2.0f;
1036     pout->z = pviewport->MinZ + vec.z * ( pviewport->MaxZ - pviewport->MinZ );
1037     return pout;
1038 }
1039
1040 D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1041 {
1042     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];
1043     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];
1044     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];
1045     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];
1046     return pout;
1047 }
1048
1049 D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1050 {
1051     FLOAT norm;
1052
1053     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];
1054
1055     if ( norm )
1056     {
1057      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;
1058      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;
1059      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;
1060     }
1061     else
1062     {
1063      pout->x = 0.0f;
1064      pout->y = 0.0f;
1065      pout->z = 0.0f;
1066     }
1067     return pout;
1068 }
1069
1070 D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1071 {
1072     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z;
1073     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z;
1074     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z;
1075     return pout;
1076
1077 }
1078
1079 D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1080 {
1081     D3DXMATRIX m1, m2, m3;
1082     D3DXVECTOR3 vec;
1083
1084     D3DXMatrixMultiply(&m1, pworld, pview);
1085     D3DXMatrixMultiply(&m2, &m1, pprojection);
1086     D3DXMatrixInverse(&m3, NULL, &m2);
1087     vec.x = 2.0f * ( pv->x - pviewport->X ) / pviewport->Width - 1.0f;
1088     vec.y = 1.0f - 2.0f * ( pv->y - pviewport->Y ) / pviewport->Height;
1089     vec.z = ( pv->z - pviewport->MinZ) / ( pviewport->MaxZ - pviewport->MinZ );
1090     D3DXVec3TransformCoord(pout, &vec, &m3);
1091     return pout;
1092 }
1093
1094 /*_________________D3DXVec4_____________________*/
1095
1096 D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g)
1097 {
1098     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1099     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1100     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1101     pout->w = (1.0f-f-g) * (pv1->w) + f * (pv2->w) + g * (pv3->w);
1102     return pout;
1103 }
1104
1105 D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s)
1106 {
1107     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);
1108     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);
1109     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);
1110     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);
1111     return pout;
1112 }
1113
1114 D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3)
1115 {
1116     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);
1117     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));
1118     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);
1119     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));
1120     return pout;
1121 }
1122
1123 D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s)
1124 {
1125     FLOAT h1, h2, h3, h4;
1126
1127     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1128     h2 = s * s * s - 2.0f * s * s + s;
1129     h3 = -2.0f * s * s * s + 3.0f * s * s;
1130     h4 = s * s * s - s * s;
1131
1132     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1133     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1134     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1135     pout->w = h1 * (pv1->w) + h2 * (pt1->w) + h3 * (pv2->w) + h4 * (pt2->w);
1136     return pout;
1137 }
1138
1139 D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv)
1140 {
1141     FLOAT norm;
1142
1143     norm = D3DXVec4Length(pv);
1144     if ( !norm )
1145     {
1146      pout->x = 0.0f;
1147      pout->y = 0.0f;
1148      pout->z = 0.0f;
1149      pout->w = 0.0f;
1150     }
1151     else
1152     {
1153      pout->x = pv->x / norm;
1154      pout->y = pv->y / norm;
1155      pout->z = pv->z / norm;
1156      pout->w = pv->w / norm;
1157     }
1158     return pout;
1159 }
1160
1161 D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm)
1162 {
1163     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;
1164     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;
1165     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;
1166     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;
1167     return pout;
1168 }