git.oblomov.eu Git - wine/blob - 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     temp.x = 0.0f;
 699     temp.y = 0.0f;
 700     temp.z = 0.0f;
 701     temp.w = 0.0f;
 702
 703     norm = D3DXQuaternionLengthSq(pq);
 704     if ( !norm )
 705     {
 706      pout->x = 0.0f;
 707      pout->y = 0.0f;
 708      pout->z = 0.0f;
 709      pout->w = 0.0f;
 710     }
 711     else
 712     {
 713     D3DXQuaternionConjugate(&temp, pq);
 714     pout->x = temp.x / norm;
 715     pout->y = temp.y / norm;
 716     pout->z = temp.z / norm;
 717     pout->w = temp.w / norm;
 718     }
 719     return pout;
 720 }
 721
 722 D3DXQUATERNION* WINAPI D3DXQuaternionLn(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 723 {
 724     FLOAT norm, normvec, theta;
 725
 726     norm = D3DXQuaternionLengthSq(pq);
 727     if ( norm > 1.0001f )
 728     {
 729      pout->x = pq->x;
 730      pout->y = pq->y;
 731      pout->z = pq->z;
 732      pout->w = 0.0f;
 733     }
 734     else if( norm > 0.99999f)
 735     {
 736      normvec = sqrt( pq->x * pq->x + pq->y * pq->y + pq->z * pq->z );
 737      theta = atan2(normvec, pq->w) / normvec;
 738      pout->x = theta * pq->x;
 739      pout->y = theta * pq->y;
 740      pout->z = theta * pq->z;
 741      pout->w = 0.0f;
 742     }
 743     else
 744     {
 745      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);
 746     }
 747     return pout;
 748 }
 749
 750 D3DXQUATERNION* WINAPI D3DXQuaternionMultiply(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2)
 751 {
 752     pout->x = pq2->w * pq1->x + pq2->x * pq1->w + pq2->y * pq1->z - pq2->z * pq1->y;
 753     pout->y = pq2->w * pq1->y - pq2->x * pq1->z + pq2->y * pq1->w + pq2->z * pq1->x;
 754     pout->z = pq2->w * pq1->z + pq2->x * pq1->y - pq2->y * pq1->x + pq2->z * pq1->w;
 755     pout->w = pq2->w * pq1->w - pq2->x * pq1->x - pq2->y * pq1->y - pq2->z * pq1->z;
 756     return pout;
 757 }
 758
 759 D3DXQUATERNION* WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 760 {
 761     FLOAT norm;
 762
 763     norm = D3DXQuaternionLength(pq);
 764     if ( !norm )
 765     {
 766      pout->x = 0.0f;
 767      pout->y = 0.0f;
 768      pout->z = 0.0f;
 769      pout->w = 0.0f;
 770     }
 771     else
 772     {
 773      pout->x = pq->x / norm;
 774      pout->y = pq->y / norm;
 775      pout->z = pq->z / norm;
 776      pout->w = pq->w / norm;
 777     }
 778     return pout;
 779 }
 780
 781 D3DXQUATERNION* WINAPI D3DXQuaternionRotationAxis(D3DXQUATERNION *pout, CONST D3DXVECTOR3 *pv, FLOAT angle)
 782 {
 783     D3DXVECTOR3 temp;
 784
 785     D3DXVec3Normalize(&temp, pv);
 786     pout->x = sin( angle / 2.0f ) * temp.x;
 787     pout->y = sin( angle / 2.0f ) * temp.y;
 788     pout->z = sin( angle / 2.0f ) * temp.z;
 789     pout->w = cos( angle / 2.0f );
 790     return pout;
 791 }
 792
 793 D3DXQUATERNION* WINAPI D3DXQuaternionRotationMatrix(D3DXQUATERNION *pout, CONST D3DXMATRIX *pm)
 794 {
 795     int i, maxi;
 796     FLOAT maxdiag, S, trace;
 797
 798     trace = pm->u.m[0][0] + pm->u.m[1][1] + pm->u.m[2][2] + 1.0f;
 799     if ( trace > 0.0f)
 800     {
 801      pout->x = ( pm->u.m[1][2] - pm->u.m[2][1] ) / ( 2.0f * sqrt(trace) );
 802      pout->y = ( pm->u.m[2][0] - pm->u.m[0][2] ) / ( 2.0f * sqrt(trace) );
 803      pout->z = ( pm->u.m[0][1] - pm->u.m[1][0] ) / ( 2.0f * sqrt(trace) );
 804      pout->w = sqrt(trace) / 2.0f;
 805      return pout;
 806      }
 807     maxi = 0;
 808     maxdiag = pm->u.m[0][0];
 809     for (i=1; i<3; i++)
 810     {
 811      if ( pm->u.m[i][i] > maxdiag )
 812      {
 813       maxi = i;
 814       maxdiag = pm->u.m[i][i];
 815      }
 816     }
 817     switch( maxi )
 818     {
 819      case 0:
 820        S = 2.0f * sqrt(1.0f + pm->u.m[0][0] - pm->u.m[1][1] - pm->u.m[2][2]);
 821        pout->x = 0.25f * S;
 822        pout->y = ( pm->u.m[0][1] + pm->u.m[1][0] ) / S;
 823        pout->z = ( pm->u.m[0][2] + pm->u.m[2][0] ) / S;
 824        pout->w = ( pm->u.m[1][2] - pm->u.m[2][1] ) / S;
 825      break;
 826      case 1:
 827        S = 2.0f * sqrt(1.0f + pm->u.m[1][1] - pm->u.m[0][0] - pm->u.m[2][2]);
 828        pout->x = ( pm->u.m[0][1] + pm->u.m[1][0] ) / S;
 829        pout->y = 0.25f * S;
 830        pout->z = ( pm->u.m[1][2] + pm->u.m[2][1] ) / S;
 831        pout->w = ( pm->u.m[2][0] - pm->u.m[0][2] ) / S;
 832      break;
 833      case 2:
 834        S = 2.0f * sqrt(1.0f + pm->u.m[2][2] - pm->u.m[0][0] - pm->u.m[1][1]);
 835        pout->x = ( pm->u.m[0][2] + pm->u.m[2][0] ) / S;
 836        pout->y = ( pm->u.m[1][2] + pm->u.m[2][1] ) / S;
 837        pout->z = 0.25f * S;
 838        pout->w = ( pm->u.m[0][1] - pm->u.m[1][0] ) / S;
 839      break;
 840     }
 841     return pout;
 842 }
 843
 844 D3DXQUATERNION* WINAPI D3DXQuaternionRotationYawPitchRoll(D3DXQUATERNION *pout, FLOAT yaw, FLOAT pitch, FLOAT roll)
 845 {
 846     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);
 847     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);
 848     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);
 849     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);
 850     return pout;
 851 }
 852
 853 D3DXQUATERNION* WINAPI D3DXQuaternionSlerp(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, FLOAT t)
 854 {
 855     FLOAT dot, epsilon;
 856
 857     epsilon = 1.0f;
 858     dot = D3DXQuaternionDot(pq1, pq2);
 859     if ( dot < 0.0f) epsilon = -1.0f;
 860     pout->x = (1.0f - t) * pq1->x + epsilon * t * pq2->x;
 861     pout->y = (1.0f - t) * pq1->y + epsilon * t * pq2->y;
 862     pout->z = (1.0f - t) * pq1->z + epsilon * t * pq2->z;
 863     pout->w = (1.0f - t) * pq1->w + epsilon * t * pq2->w;
 864     return pout;
 865 }
 866
 867 D3DXQUATERNION* WINAPI D3DXQuaternionSquad(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq1, CONST D3DXQUATERNION *pq2, CONST D3DXQUATERNION *pq3, CONST D3DXQUATERNION *pq4, FLOAT t)
 868 {
 869     D3DXQUATERNION temp1, temp2;
 870
 871     D3DXQuaternionSlerp(pout, D3DXQuaternionSlerp(&temp1, pq1, pq4, t), D3DXQuaternionSlerp(&temp2, pq2, pq3, t), 2.0f * t * (1.0f - t));
 872     return pout;
 873 }
 874
 875 void WINAPI D3DXQuaternionToAxisAngle(CONST D3DXQUATERNION *pq, D3DXVECTOR3 *paxis, FLOAT *pangle)
 876 {
 877     FLOAT norm;
 878
 879     *pangle = 0.0f;
 880     norm = D3DXQuaternionLength(pq);
 881     if ( norm )
 882     {
 883      paxis->x = pq->x / norm;
 884      paxis->y = pq->y / norm;
 885      paxis->z = pq->z / norm;
 886      if ( fabs( pq->w ) <= 1.0f ) *pangle = 2.0f * acos(pq->w);
 887     }
 888     else
 889     {
 890      paxis->x = 1.0f;
 891      paxis->y = 0.0f;
 892      paxis->z = 0.0f;
 893     }
 894 }
 895
 896 /*_________________D3DXVec2_____________________*/
 897
 898 D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT f, FLOAT g)
 899 {
 900     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 901     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 902     return pout;
 903 }
 904
 905 D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT s)
 906 {
 907     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);
 908     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);
 909     return pout;
 910 }
 911
 912 D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s)
 913 {
 914     FLOAT h1, h2, h3, h4;
 915
 916     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 917     h2 = s * s * s - 2.0f * s * s + s;
 918     h3 = -2.0f * s * s * s + 3.0f * s * s;
 919     h4 = s * s * s - s * s;
 920
 921     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 922     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 923     return pout;
 924 }
 925
 926 D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv)
 927 {
 928     FLOAT norm;
 929
 930     norm = D3DXVec2Length(pv);
 931     if ( !norm )
 932     {
 933      pout->x = 0.0f;
 934      pout->y = 0.0f;
 935     }
 936     else
 937     {
 938      pout->x = pv->x / norm;
 939      pout->y = pv->y / norm;
 940     }
 941     return pout;
 942 }
 943
 944 D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 945 {
 946     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y  + pm->u.m[3][0];
 947     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y  + pm->u.m[3][1];
 948     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y  + pm->u.m[3][2];
 949     pout->w = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y  + pm->u.m[3][3];
 950     return pout;
 951 }
 952
 953 D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 954 {
 955     FLOAT norm;
 956
 957     norm = pm->u.m[0][3] * pv->x + pm->u.m[1][3] * pv->y + pm->u.m[3][3];
 958     if ( norm )
 959     {
 960      pout->x = (pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[3][0]) / norm;
 961      pout->y = (pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[3][1]) / norm;
 962     }
 963     else
 964     {
 965      pout->x = 0.0f;
 966      pout->y = 0.0f;
 967     }
 968     return pout;
 969 }
 970
 971 D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 972 {
 973     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y;
 974     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y;
 975     return pout;
 976 }
 977
 978 /*_________________D3DXVec3_____________________*/
 979
 980 D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g)
 981 {
 982     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 983     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 984     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
 985     return pout;
 986 }
 987
 988 D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s)
 989 {
 990     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);
 991     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);
 992     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);
 993     return pout;
 994 }
 995
 996 D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s)
 997 {
 998     FLOAT h1, h2, h3, h4;
 999
1000     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1001     h2 = s * s * s - 2.0f * s * s + s;
1002     h3 = -2.0f * s * s * s + 3.0f * s * s;
1003     h4 = s * s * s - s * s;
1004
1005     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1006     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1007     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1008     return pout;
1009 }
1010
1011 D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv)
1012 {
1013     FLOAT norm;
1014
1015     norm = D3DXVec3Length(pv);
1016     if ( !norm )
1017     {
1018      pout->x = 0.0f;
1019      pout->y = 0.0f;
1020      pout->z = 0.0f;
1021     }
1022     else
1023     {
1024      pout->x = pv->x / norm;
1025      pout->y = pv->y / norm;
1026      pout->z = pv->z / norm;
1027     }
1028     return pout;
1029 }
1030
1031 D3DXVECTOR3* WINAPI D3DXVec3Project(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1032 {
1033     D3DXMATRIX m1, m2;
1034     D3DXVECTOR3 vec;
1035
1036     D3DXMatrixMultiply(&m1, pworld, pview);
1037     D3DXMatrixMultiply(&m2, &m1, pprojection);
1038     D3DXVec3TransformCoord(&vec, pv, &m2);
1039     pout->x = pviewport->X +  ( 1.0f + vec.x ) * pviewport->Width / 2.0f;
1040     pout->y = pviewport->Y +  ( 1.0f - vec.y ) * pviewport->Height / 2.0f;
1041     pout->z = pviewport->MinZ + vec.z * ( pviewport->MaxZ - pviewport->MinZ );
1042     return pout;
1043 }
1044
1045 D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1046 {
1047     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];
1048     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];
1049     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];
1050     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];
1051     return pout;
1052 }
1053
1054 D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1055 {
1056     FLOAT norm;
1057
1058     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];
1059
1060     if ( norm )
1061     {
1062      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;
1063      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;
1064      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;
1065     }
1066     else
1067     {
1068      pout->x = 0.0f;
1069      pout->y = 0.0f;
1070      pout->z = 0.0f;
1071     }
1072     return pout;
1073 }
1074
1075 D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
1076 {
1077     pout->x = pm->u.m[0][0] * pv->x + pm->u.m[1][0] * pv->y + pm->u.m[2][0] * pv->z;
1078     pout->y = pm->u.m[0][1] * pv->x + pm->u.m[1][1] * pv->y + pm->u.m[2][1] * pv->z;
1079     pout->z = pm->u.m[0][2] * pv->x + pm->u.m[1][2] * pv->y + pm->u.m[2][2] * pv->z;
1080     return pout;
1081
1082 }
1083
1084 D3DXVECTOR3* WINAPI D3DXVec3Unproject(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DVIEWPORT8 *pviewport, CONST D3DXMATRIX *pprojection, CONST D3DXMATRIX *pview, CONST D3DXMATRIX *pworld)
1085 {
1086     D3DXMATRIX m1, m2, m3;
1087     D3DXVECTOR3 vec;
1088
1089     D3DXMatrixMultiply(&m1, pworld, pview);
1090     D3DXMatrixMultiply(&m2, &m1, pprojection);
1091     D3DXMatrixInverse(&m3, NULL, &m2);
1092     vec.x = 2.0f * ( pv->x - pviewport->X ) / pviewport->Width - 1.0f;
1093     vec.y = 1.0f - 2.0f * ( pv->y - pviewport->Y ) / pviewport->Height;
1094     vec.z = ( pv->z - pviewport->MinZ) / ( pviewport->MaxZ - pviewport->MinZ );
1095     D3DXVec3TransformCoord(pout, &vec, &m3);
1096     return pout;
1097 }
1098
1099 /*_________________D3DXVec4_____________________*/
1100
1101 D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g)
1102 {
1103     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
1104     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
1105     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
1106     pout->w = (1.0f-f-g) * (pv1->w) + f * (pv2->w) + g * (pv3->w);
1107     return pout;
1108 }
1109
1110 D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s)
1111 {
1112     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);
1113     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);
1114     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);
1115     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);
1116     return pout;
1117 }
1118
1119 D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3)
1120 {
1121     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);
1122     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));
1123     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);
1124     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));
1125     return pout;
1126 }
1127
1128 D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s)
1129 {
1130     FLOAT h1, h2, h3, h4;
1131
1132     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
1133     h2 = s * s * s - 2.0f * s * s + s;
1134     h3 = -2.0f * s * s * s + 3.0f * s * s;
1135     h4 = s * s * s - s * s;
1136
1137     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
1138     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
1139     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
1140     pout->w = h1 * (pv1->w) + h2 * (pt1->w) + h3 * (pv2->w) + h4 * (pt2->w);
1141     return pout;
1142 }
1143
1144 D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv)
1145 {
1146     FLOAT norm;
1147
1148     norm = D3DXVec4Length(pv);
1149     if ( !norm )
1150     {
1151      pout->x = 0.0f;
1152      pout->y = 0.0f;
1153      pout->z = 0.0f;
1154      pout->w = 0.0f;
1155     }
1156     else
1157     {
1158      pout->x = pv->x / norm;
1159      pout->y = pv->y / norm;
1160      pout->z = pv->z / norm;
1161      pout->w = pv->w / norm;
1162     }
1163     return pout;
1164 }
1165
1166 D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm)
1167 {
1168     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;
1169     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;
1170     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;
1171     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;
1172     return pout;
1173 }