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 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "d3dx8.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(d3dx8);
  31
  32 /*_________________D3DXMatrix____________________*/
  33
  34 FLOAT WINAPI D3DXMatrixfDeterminant(CONST D3DXMATRIX *pm)
  35 {
  36     D3DXVECTOR4 minor, v1, v2, v3;
  37     FLOAT det;
  38
  39     v1.x = pm->m[0][0]; v1.y = pm->m[1][0]; v1.z = pm->m[2][0]; v1.w = pm->m[3][0];
  40     v2.x = pm->m[0][1]; v2.y = pm->m[1][1]; v2.z = pm->m[2][1]; v2.w = pm->m[3][1];
  41     v3.x = pm->m[0][2]; v3.y = pm->m[1][2]; v3.z = pm->m[2][2]; v3.w = pm->m[3][2];
  42     D3DXVec4Cross(&minor,&v1,&v2,&v3);
  43     det =  - (pm->m[0][3] * minor.x + pm->m[1][3] * minor.y + pm->m[2][3] * minor.z + pm->m[3][3] * minor.w);
  44     return det;
  45 }
  46
  47 D3DXMATRIX* WINAPI D3DXMatrixLookAtLH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
  48 {
  49     D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
  50
  51     D3DXVec3Subtract(&vec2, pat, peye);
  52     D3DXVec3Normalize(&vec, &vec2);
  53     D3DXVec3Cross(&right, pup, &vec);
  54     D3DXVec3Cross(&up, &vec, &right);
  55     D3DXVec3Normalize(&rightn, &right);
  56     D3DXVec3Normalize(&upn, &up);
  57     pout->m[0][0] = rightn.x;
  58     pout->m[1][0] = rightn.y;
  59     pout->m[2][0] = rightn.z;
  60     pout->m[3][0] = -D3DXVec3Dot(&rightn,peye);
  61     pout->m[0][1] = upn.x;
  62     pout->m[1][1] = upn.y;
  63     pout->m[2][1] = upn.z;
  64     pout->m[3][1] = -D3DXVec3Dot(&upn, peye);
  65     pout->m[0][2] = vec.x;
  66     pout->m[1][2] = vec.y;
  67     pout->m[2][2] = vec.z;
  68     pout->m[3][2] = -D3DXVec3Dot(&vec, peye);
  69     pout->m[0][3] = 0.0f;
  70     pout->m[1][3] = 0.0f;
  71     pout->m[2][3] = 0.0f;
  72     pout->m[3][3] = 1.0f;
  73     return pout;
  74 }
  75
  76 D3DXMATRIX* WINAPI D3DXMatrixLookAtRH(D3DXMATRIX *pout, CONST D3DXVECTOR3 *peye, CONST D3DXVECTOR3 *pat, CONST D3DXVECTOR3 *pup)
  77 {
  78     D3DXVECTOR3 right, rightn, up, upn, vec, vec2;
  79
  80     D3DXVec3Subtract(&vec2, pat, peye);
  81     D3DXVec3Normalize(&vec, &vec2);
  82     D3DXVec3Cross(&right, pup, &vec);
  83     D3DXVec3Cross(&up, &vec, &right);
  84     D3DXVec3Normalize(&rightn, &right);
  85     D3DXVec3Normalize(&upn, &up);
  86     pout->m[0][0] = -rightn.x;
  87     pout->m[1][0] = -rightn.y;
  88     pout->m[2][0] = -rightn.z;
  89     pout->m[3][0] = D3DXVec3Dot(&rightn,peye);
  90     pout->m[0][1] = upn.x;
  91     pout->m[1][1] = upn.y;
  92     pout->m[2][1] = upn.z;
  93     pout->m[3][1] = -D3DXVec3Dot(&upn, peye);
  94     pout->m[0][2] = -vec.x;
  95     pout->m[1][2] = -vec.y;
  96     pout->m[2][2] = -vec.z;
  97     pout->m[3][2] = D3DXVec3Dot(&vec, peye);
  98     pout->m[0][3] = 0.0f;
  99     pout->m[1][3] = 0.0f;
 100     pout->m[2][3] = 0.0f;
 101     pout->m[3][3] = 1.0f;
 102     return pout;
 103 }
 104
 105 D3DXMATRIX* WINAPI D3DXMatrixMultiply(D3DXMATRIX *pout, CONST D3DXMATRIX *pm1, CONST D3DXMATRIX *pm2)
 106 {
 107     int i,j;
 108
 109     for (i=0; i<4; i++)
 110     {
 111      for (j=0; j<4; j++)
 112      {
 113       pout->m[i][j] = pm1->m[i][0] * pm2->m[0][j] + pm1->m[i][1] * pm2->m[1][j] + pm1->m[i][2] * pm2->m[2][j] + pm1->m[i][3] * pm2->m[3][j];
 114      }
 115     }
 116     return pout;
 117 }
 118
 119 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovLH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
 120 {
 121     D3DXMatrixIdentity(pout);
 122     pout->m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
 123     pout->m[1][1] = 1.0f / tan(fovy/2.0f);
 124     pout->m[2][2] = zf / (zf - zn);
 125     pout->m[2][3] = 1.0f;
 126     pout->m[3][2] = (zf * zn) / (zn - zf);
 127     pout->m[3][3] = 0.0f;
 128     return pout;
 129 }
 130
 131 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveFovRH(D3DXMATRIX *pout, FLOAT fovy, FLOAT aspect, FLOAT zn, FLOAT zf)
 132 {
 133     D3DXMatrixIdentity(pout);
 134     pout->m[0][0] = 1.0f / (aspect * tan(fovy/2.0f));
 135     pout->m[1][1] = 1.0f / tan(fovy/2.0f);
 136     pout->m[2][2] = zf / (zn - zf);
 137     pout->m[2][3] = -1.0f;
 138     pout->m[3][2] = (zf * zn) / (zn - zf);
 139     pout->m[3][3] = 0.0f;
 140     return pout;
 141 }
 142
 143 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveLH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
 144 {
 145     D3DXMatrixIdentity(pout);
 146     pout->m[0][0] = 2.0f * zn / w;
 147     pout->m[1][1] = 2.0f * zn / h;
 148     pout->m[2][2] = zf / (zf - zn);
 149     pout->m[3][2] = (zn * zf) / (zn - zf);
 150     pout->m[2][3] = 1.0f;
 151     pout->m[3][3] = 0.0f;
 152     return pout;
 153 }
 154
 155 D3DXMATRIX* WINAPI D3DXMatrixPerspectiveRH(D3DXMATRIX *pout, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf)
 156 {
 157     D3DXMatrixIdentity(pout);
 158     pout->m[0][0] = 2.0f * zn / w;
 159     pout->m[1][1] = 2.0f * zn / h;
 160     pout->m[2][2] = zf / (zn - zf);
 161     pout->m[3][2] = (zn * zf) / (zn - zf);
 162     pout->m[2][3] = -1.0f;
 163     pout->m[3][3] = 0.0f;
 164     return pout;
 165 }
 166
 167 D3DXMATRIX* WINAPI D3DXMatrixRotationAxis(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pv, FLOAT angle)
 168 {
 169     D3DXVECTOR3 v;
 170
 171     D3DXVec3Normalize(&v,pv);
 172     D3DXMatrixIdentity(pout);
 173     pout->m[0][0] = (1.0f - cos(angle)) * v.x * v.x + cos(angle);
 174     pout->m[1][0] = (1.0f - cos(angle)) * v.x * v.y - sin(angle) * v.z;
 175     pout->m[2][0] = (1.0f - cos(angle)) * v.x * v.z + sin(angle) * v.y;
 176     pout->m[0][1] = (1.0f - cos(angle)) * v.y * v.x + sin(angle) * v.z;
 177     pout->m[1][1] = (1.0f - cos(angle)) * v.y * v.y + cos(angle);
 178     pout->m[2][1] = (1.0f - cos(angle)) * v.y * v.z - sin(angle) * v.x;
 179     pout->m[0][2] = (1.0f - cos(angle)) * v.z * v.x - sin(angle) * v.y;
 180     pout->m[1][2] = (1.0f - cos(angle)) * v.z * v.y + sin(angle) * v.x;
 181     pout->m[2][2] = (1.0f - cos(angle)) * v.z * v.z + cos(angle);
 182     return pout;
 183 }
 184
 185 D3DXMATRIX* WINAPI D3DXMatrixRotationQuaternion(D3DXMATRIX *pout, CONST D3DXQUATERNION *pq)
 186 {
 187     D3DXMatrixIdentity(pout);
 188     pout->m[0][0] = 1.0f - 2.0f * (pq->y * pq->y + pq->z * pq->z);
 189     pout->m[0][1] = 2.0f * (pq->x *pq->y + pq->z * pq->w);
 190     pout->m[0][2] = 2.0f * (pq->x * pq->z - pq->y * pq->w);
 191     pout->m[1][0] = 2.0f * (pq->x * pq->y - pq->z * pq->w);
 192     pout->m[1][1] = 1.0f - 2.0f * (pq->x * pq->x + pq->z * pq->z);
 193     pout->m[1][2] = 2.0f * (pq->y *pq->z + pq->x *pq->w);
 194     pout->m[2][0] = 2.0f * (pq->x * pq->z + pq->y * pq->w);
 195     pout->m[2][1] = 2.0f * (pq->y *pq->z - pq->x *pq->w);
 196     pout->m[2][2] = 1.0f - 2.0f * (pq->x * pq->x + pq->y * pq->y);
 197     return pout;
 198 }
 199
 200 D3DXMATRIX* WINAPI D3DXMatrixRotationX(D3DXMATRIX *pout, FLOAT angle)
 201 {
 202     D3DXMatrixIdentity(pout);
 203     pout->m[1][1] = cos(angle);
 204     pout->m[2][2] = cos(angle);
 205     pout->m[1][2] = sin(angle);
 206     pout->m[2][1] = -sin(angle);
 207     return pout;
 208 }
 209
 210 D3DXMATRIX* WINAPI D3DXMatrixRotationY(D3DXMATRIX *pout, FLOAT angle)
 211 {
 212     D3DXMatrixIdentity(pout);
 213     pout->m[0][0] = cos(angle);
 214     pout->m[2][2] = cos(angle);
 215     pout->m[0][2] = -sin(angle);
 216     pout->m[2][0] = sin(angle);
 217     return pout;
 218 }
 219
 220 D3DXMATRIX* WINAPI D3DXMatrixRotationYawPitchRoll(D3DXMATRIX *pout, FLOAT yaw, FLOAT pitch, FLOAT roll)
 221 {
 222     D3DXMATRIX m, pout1, pout2, pout3;
 223
 224     D3DXMatrixIdentity(&pout3);
 225     D3DXMatrixRotationZ(&m,roll);
 226     D3DXMatrixMultiply(&pout2,&pout3,&m);
 227     D3DXMatrixRotationX(&m,pitch);
 228     D3DXMatrixMultiply(&pout1,&pout2,&m);
 229     D3DXMatrixRotationY(&m,yaw);
 230     D3DXMatrixMultiply(pout,&pout1,&m);
 231     return pout;
 232 }
 233 D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle)
 234 {
 235     D3DXMatrixIdentity(pout);
 236     pout->m[0][0] = cos(angle);
 237     pout->m[1][1] = cos(angle);
 238     pout->m[0][1] = sin(angle);
 239     pout->m[1][0] = -sin(angle);
 240     return pout;
 241 }
 242
 243 D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz)
 244 {
 245     D3DXMatrixIdentity(pout);
 246     pout->m[0][0] = sx;
 247     pout->m[1][1] = sy;
 248     pout->m[2][2] = sz;
 249     return pout;
 250 }
 251
 252 D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z)
 253 {
 254     D3DXMatrixIdentity(pout);
 255     pout->m[3][0] = x;
 256     pout->m[3][1] = y;
 257     pout->m[3][2] = z;
 258     return pout;
 259 }
 260
 261 D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm)
 262 {
 263     int i,j;
 264
 265     for (i=0; i<4; i++)
 266     {
 267      for (j=0; j<4; j++)
 268      {
 269       pout->m[i][j] = pm->m[j][i];
 270      }
 271     }
 272     return pout;
 273 }
 274
 275 /*_________________D3DXQUATERNION________________*/
 276
 277 D3DXQUATERNION* WINAPI D3DXQuaternionNormalize(D3DXQUATERNION *pout, CONST D3DXQUATERNION *pq)
 278 {
 279     FLOAT norm;
 280
 281     norm = D3DXQuaternionLength(pq);
 282     if ( !norm )
 283     {
 284      pout->x = 0.0f;
 285      pout->y = 0.0f;
 286      pout->z = 0.0f;
 287      pout->w = 0.0f;
 288     }
 289     else
 290     {
 291      pout->x = pq->x / norm;
 292      pout->y = pq->y / norm;
 293      pout->z = pq->z / norm;
 294      pout->w = pq->w / norm;
 295     }
 296     return pout;
 297 }
 298 /*_________________D3DXVec2_____________________*/
 299
 300 D3DXVECTOR2* WINAPI D3DXVec2BaryCentric(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT f, FLOAT g)
 301 {
 302     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 303     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 304     return pout;
 305 }
 306
 307 D3DXVECTOR2* WINAPI D3DXVec2CatmullRom(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv0, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pv3, FLOAT s)
 308 {
 309     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);
 310     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);
 311     return pout;
 312 }
 313
 314 D3DXVECTOR2* WINAPI D3DXVec2Hermite(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv1, CONST D3DXVECTOR2 *pt1, CONST D3DXVECTOR2 *pv2, CONST D3DXVECTOR2 *pt2, FLOAT s)
 315 {
 316     FLOAT h1, h2, h3, h4;
 317
 318     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 319     h2 = s * s * s - 2.0f * s * s + s;
 320     h3 = -2.0f * s * s * s + 3.0f * s * s;
 321     h4 = s * s * s - s * s;
 322
 323     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 324     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 325     return pout;
 326 }
 327
 328 D3DXVECTOR2* WINAPI D3DXVec2Normalize(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv)
 329 {
 330     FLOAT norm;
 331
 332     norm = D3DXVec2Length(pv);
 333     if ( !norm )
 334     {
 335      pout->x = 0.0f;
 336      pout->y = 0.0f;
 337     }
 338     else
 339     {
 340      pout->x = pv->x / norm;
 341      pout->y = pv->y / norm;
 342     }
 343     return pout;
 344 }
 345
 346 D3DXVECTOR4* WINAPI D3DXVec2Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 347 {
 348     pout->x = pm->m[0][0] * pv->x + pm->m[1][0] * pv->y  + pm->m[3][0];
 349     pout->y = pm->m[0][1] * pv->x + pm->m[1][1] * pv->y  + pm->m[3][1];
 350     pout->z = pm->m[0][2] * pv->x + pm->m[1][2] * pv->y  + pm->m[3][2];
 351     pout->w = pm->m[0][3] * pv->x + pm->m[1][3] * pv->y  + pm->m[3][3];
 352     return pout;
 353 }
 354
 355 D3DXVECTOR2* WINAPI D3DXVec2TransformCoord(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 356 {
 357     FLOAT norm;
 358
 359     norm = pm->m[0][3] * pv->x + pm->m[1][3] * pv->y + pm->m[3][3];
 360     if ( norm )
 361     {
 362      pout->x = (pm->m[0][0] * pv->x + pm->m[1][0] * pv->y + pm->m[3][0]) / norm;
 363      pout->y = (pm->m[0][1] * pv->x + pm->m[1][1] * pv->y + pm->m[3][1]) / norm;
 364     }
 365     else
 366     {
 367      pout->x = 0.0f;
 368      pout->y = 0.0f;
 369     }
 370     return pout;
 371 }
 372
 373 D3DXVECTOR2* WINAPI D3DXVec2TransformNormal(D3DXVECTOR2 *pout, CONST D3DXVECTOR2 *pv, CONST D3DXMATRIX *pm)
 374 {
 375     pout->x = pm->m[0][0] * pv->x + pm->m[1][0] * pv->y;
 376     pout->y = pm->m[0][1] * pv->x + pm->m[1][1] * pv->y;
 377     return pout;
 378 }
 379
 380 /*_________________D3DXVec3_____________________*/
 381
 382 D3DXVECTOR3* WINAPI D3DXVec3BaryCentric(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT f, FLOAT g)
 383 {
 384     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 385     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 386     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
 387     return pout;
 388 }
 389
 390 D3DXVECTOR3* WINAPI D3DXVec3CatmullRom( D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv0, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pv3, FLOAT s)
 391 {
 392     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);
 393     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);
 394     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);
 395     return pout;
 396 }
 397
 398 D3DXVECTOR3* WINAPI D3DXVec3Hermite(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv1, CONST D3DXVECTOR3 *pt1, CONST D3DXVECTOR3 *pv2, CONST D3DXVECTOR3 *pt2, FLOAT s)
 399 {
 400     FLOAT h1, h2, h3, h4;
 401
 402     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 403     h2 = s * s * s - 2.0f * s * s + s;
 404     h3 = -2.0f * s * s * s + 3.0f * s * s;
 405     h4 = s * s * s - s * s;
 406
 407     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 408     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 409     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
 410     return pout;
 411 }
 412
 413 D3DXVECTOR3* WINAPI D3DXVec3Normalize(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv)
 414 {
 415     FLOAT norm;
 416
 417     norm = D3DXVec3Length(pv);
 418     if ( !norm )
 419     {
 420      pout->x = 0.0f;
 421      pout->y = 0.0f;
 422      pout->z = 0.0f;
 423     }
 424     else
 425     {
 426      pout->x = pv->x / norm;
 427      pout->y = pv->y / norm;
 428      pout->z = pv->z / norm;
 429     }
 430     return pout;
 431 }
 432
 433 D3DXVECTOR4* WINAPI D3DXVec3Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
 434 {
 435     pout->x = pm->m[0][0] * pv->x + pm->m[1][0] * pv->y + pm->m[2][0] * pv->z + pm->m[3][0];
 436     pout->y = pm->m[0][1] * pv->x + pm->m[1][1] * pv->y + pm->m[2][1] * pv->z + pm->m[3][1];
 437     pout->z = pm->m[0][2] * pv->x + pm->m[1][2] * pv->y + pm->m[2][2] * pv->z + pm->m[3][2];
 438     pout->w = pm->m[0][3] * pv->x + pm->m[1][3] * pv->y + pm->m[2][3] * pv->z + pm->m[3][3];
 439     return pout;
 440 }
 441
 442 D3DXVECTOR3* WINAPI D3DXVec3TransformCoord(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
 443 {
 444     FLOAT norm;
 445
 446     norm = pm->m[0][3] * pv->x + pm->m[1][3] * pv->y + pm->m[2][3] *pv->z + pm->m[3][3];
 447
 448     if ( norm )
 449     {
 450      pout->x = (pm->m[0][0] * pv->x + pm->m[1][0] * pv->y + pm->m[2][0] * pv->z + pm->m[3][0]) / norm;
 451      pout->y = (pm->m[0][1] * pv->x + pm->m[1][1] * pv->y + pm->m[2][1] * pv->z + pm->m[3][1]) / norm;
 452      pout->z = (pm->m[0][2] * pv->x + pm->m[1][2] * pv->y + pm->m[2][2] * pv->z + pm->m[3][2]) / norm;
 453     }
 454     else
 455     {
 456      pout->x = 0.0f;
 457      pout->y = 0.0f;
 458      pout->z = 0.0f;
 459     }
 460     return pout;
 461 }
 462
 463 D3DXVECTOR3* WINAPI D3DXVec3TransformNormal(D3DXVECTOR3 *pout, CONST D3DXVECTOR3 *pv, CONST D3DXMATRIX *pm)
 464 {
 465     pout->x = pm->m[0][0] * pv->x + pm->m[1][0] * pv->y + pm->m[2][0] * pv->z;
 466     pout->y = pm->m[0][1] * pv->x + pm->m[1][1] * pv->y + pm->m[2][1] * pv->z;
 467     pout->z = pm->m[0][2] * pv->x + pm->m[1][2] * pv->y + pm->m[2][2] * pv->z;
 468     return pout;
 469
 470 }
 471
 472 /*_________________D3DXVec4_____________________*/
 473
 474 D3DXVECTOR4* WINAPI D3DXVec4BaryCentric(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT f, FLOAT g)
 475 {
 476     pout->x = (1.0f-f-g) * (pv1->x) + f * (pv2->x) + g * (pv3->x);
 477     pout->y = (1.0f-f-g) * (pv1->y) + f * (pv2->y) + g * (pv3->y);
 478     pout->z = (1.0f-f-g) * (pv1->z) + f * (pv2->z) + g * (pv3->z);
 479     pout->w = (1.0f-f-g) * (pv1->w) + f * (pv2->w) + g * (pv3->w);
 480     return pout;
 481 }
 482
 483 D3DXVECTOR4* WINAPI D3DXVec4CatmullRom(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv0, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3, FLOAT s)
 484 {
 485     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);
 486     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);
 487     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);
 488     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);
 489     return pout;
 490 }
 491
 492 D3DXVECTOR4* WINAPI D3DXVec4Cross(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pv3)
 493 {
 494     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);
 495     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));
 496     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);
 497     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));
 498     return pout;
 499 }
 500
 501 D3DXVECTOR4* WINAPI D3DXVec4Hermite(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv1, CONST D3DXVECTOR4 *pt1, CONST D3DXVECTOR4 *pv2, CONST D3DXVECTOR4 *pt2, FLOAT s)
 502 {
 503     FLOAT h1, h2, h3, h4;
 504
 505     h1 = 2.0f * s * s * s - 3.0f * s * s + 1.0f;
 506     h2 = s * s * s - 2.0f * s * s + s;
 507     h3 = -2.0f * s * s * s + 3.0f * s * s;
 508     h4 = s * s * s - s * s;
 509
 510     pout->x = h1 * (pv1->x) + h2 * (pt1->x) + h3 * (pv2->x) + h4 * (pt2->x);
 511     pout->y = h1 * (pv1->y) + h2 * (pt1->y) + h3 * (pv2->y) + h4 * (pt2->y);
 512     pout->z = h1 * (pv1->z) + h2 * (pt1->z) + h3 * (pv2->z) + h4 * (pt2->z);
 513     pout->w = h1 * (pv1->w) + h2 * (pt1->w) + h3 * (pv2->w) + h4 * (pt2->w);
 514     return pout;
 515 }
 516
 517 D3DXVECTOR4* WINAPI D3DXVec4Normalize(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv)
 518 {
 519     FLOAT norm;
 520
 521     norm = D3DXVec4Length(pv);
 522     if ( !norm )
 523     {
 524      pout->x = 0.0f;
 525      pout->y = 0.0f;
 526      pout->z = 0.0f;
 527      pout->w = 0.0f;
 528     }
 529     else
 530     {
 531      pout->x = pv->x / norm;
 532      pout->y = pv->y / norm;
 533      pout->z = pv->z / norm;
 534      pout->w = pv->w / norm;
 535     }
 536     return pout;
 537 }
 538
 539 D3DXVECTOR4* WINAPI D3DXVec4Transform(D3DXVECTOR4 *pout, CONST D3DXVECTOR4 *pv, CONST D3DXMATRIX *pm)
 540 {
 541     pout->x = pm->m[0][0] * pv->x + pm->m[1][0] * pv->y + pm->m[2][0] * pv->z + pm->m[3][0] * pv->w;
 542     pout->y = pm->m[0][1] * pv->x + pm->m[1][1] * pv->y + pm->m[2][1] * pv->z + pm->m[3][1] * pv->w;
 543     pout->z = pm->m[0][2] * pv->x + pm->m[1][2] * pv->y + pm->m[2][2] * pv->z + pm->m[3][2] * pv->w;
 544     pout->w = pm->m[0][3] * pv->x + pm->m[1][3] * pv->y + pm->m[2][3] * pv->z + pm->m[3][3] * pv->w;
 545     return pout;
 546 }