git.oblomov.eu Git - wine/blob - dlls/d3drm/math.c

   1 /*
   2  * Copyright 2007 David Adam
   3  * Copyright 2007 Vijay Kiran Kamuju
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define NONAMELESSUNION
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25 #include <assert.h>
  26 #include <math.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "d3drmdef.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  36
  37 /* Determine the red part of a color */
  38 D3DVALUE WINAPI D3DRMColorGetRed(D3DCOLOR color)
  39 {
  40     return (RGBA_GETRED(color)/255.0);
  41 }
  42
  43 /* Product of 2 quaternions */
  44 LPD3DRMQUATERNION WINAPI D3DRMQuaternionMultiply(LPD3DRMQUATERNION q, LPD3DRMQUATERNION a, LPD3DRMQUATERNION b)
  45 {
  46     D3DVECTOR cross_product;
  47     D3DRMVectorCrossProduct(&cross_product, &a->v, &b->v);
  48     q->s = a->s * b->s - D3DRMVectorDotProduct(&a->v, &b->v);
  49     q->v.u1.x = a->s * b->v.u1.x + b->s * a->v.u1.x + cross_product.u1.x;
  50     q->v.u2.y = a->s * b->v.u2.y + b->s * a->v.u2.y + cross_product.u2.y;
  51     q->v.u3.z = a->s * b->v.u3.z + b->s * a->v.u3.z + cross_product.u3.z;
  52     return q;
  53 }
  54
  55 /* Matrix for the Rotation that a unit quaternion represents */
  56 void WINAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D m, LPD3DRMQUATERNION q)
  57 {
  58     D3DVALUE w,x,y,z;
  59     w = q->s;
  60     x = q->v.u1.x;
  61     y = q->v.u2.y;
  62     z = q->v.u3.z;
  63     m[0][0] = 1.0-2.0*(y*y+z*z);
  64     m[1][1] = 1.0-2.0*(x*x+z*z);
  65     m[2][2] = 1.0-2.0*(x*x+y*y);
  66     m[1][0] = 2.0*(x*y+z*w);
  67     m[0][1] = 2.0*(x*y-z*w);
  68     m[2][0] = 2.0*(x*z-y*w);
  69     m[0][2] = 2.0*(x*z+y*w);
  70     m[2][1] = 2.0*(y*z+x*w);
  71     m[1][2] = 2.0*(y*z-x*w);
  72     m[3][0] = 0.0;
  73     m[3][1] = 0.0;
  74     m[3][2] = 0.0;
  75     m[0][3] = 0.0;
  76     m[1][3] = 0.0;
  77     m[2][3] = 0.0;
  78     m[3][3] = 1.0;
  79 }
  80
  81 /* Return a unit quaternion that represents a rotation of an angle around an axis */
  82 LPD3DRMQUATERNION WINAPI D3DRMQuaternionFromRotation(LPD3DRMQUATERNION q, LPD3DVECTOR v, D3DVALUE theta)
  83 {
  84     q->s = cos(theta/2.0);
  85     D3DRMVectorScale(&q->v, D3DRMVectorNormalize(v), sin(theta/2.0));
  86     return q;
  87 }
  88
  89 /* Interpolation between two quaternions */
  90 LPD3DRMQUATERNION WINAPI D3DRMQuaternionSlerp(LPD3DRMQUATERNION q, LPD3DRMQUATERNION a, LPD3DRMQUATERNION b, D3DVALUE alpha)
  91 {
  92     D3DVALUE epsilon=1.0;
  93     D3DVECTOR sca1,sca2;
  94     if (a->s * b->s + D3DRMVectorDotProduct(&a->v, &b->v) < 0.0) epsilon = -1.0;
  95     q->s = (1.0 - alpha) * a->s + epsilon * alpha * b->s;
  96     D3DRMVectorAdd(&q->v, D3DRMVectorScale(&sca1, &a->v, 1.0 - alpha),
  97                    D3DRMVectorScale(&sca2, &b->v, epsilon * alpha));
  98     return q;
  99 }
 100
 101 /* Add Two Vectors */
 102 LPD3DVECTOR WINAPI D3DRMVectorAdd(LPD3DVECTOR d, LPD3DVECTOR s1, LPD3DVECTOR s2)
 103 {
 104     d->u1.x=s1->u1.x + s2->u1.x;
 105     d->u2.y=s1->u2.y + s2->u2.y;
 106     d->u3.z=s1->u3.z + s2->u3.z;
 107     return d;
 108 }
 109
 110 /* Subtract Two Vectors */
 111 LPD3DVECTOR WINAPI D3DRMVectorSubtract(LPD3DVECTOR d, LPD3DVECTOR s1, LPD3DVECTOR s2)
 112 {
 113     d->u1.x=s1->u1.x - s2->u1.x;
 114     d->u2.y=s1->u2.y - s2->u2.y;
 115     d->u3.z=s1->u3.z - s2->u3.z;
 116     return d;
 117 }
 118
 119 /* Cross Product of Two Vectors */
 120 LPD3DVECTOR WINAPI D3DRMVectorCrossProduct(LPD3DVECTOR d, LPD3DVECTOR s1, LPD3DVECTOR s2)
 121 {
 122     d->u1.x=s1->u2.y * s2->u3.z - s1->u3.z * s2->u2.y;
 123     d->u2.y=s1->u3.z * s2->u1.x - s1->u1.x * s2->u3.z;
 124     d->u3.z=s1->u1.x * s2->u2.y - s1->u2.y * s2->u1.x;
 125     return d;
 126 }
 127
 128 /* Dot Product of Two vectors */
 129 D3DVALUE WINAPI D3DRMVectorDotProduct(LPD3DVECTOR s1, LPD3DVECTOR s2)
 130 {
 131     D3DVALUE dot_product;
 132     dot_product=s1->u1.x * s2->u1.x + s1->u2.y * s2->u2.y + s1->u3.z * s2->u3.z;
 133     return dot_product;
 134 }
 135
 136 /* Norm of a vector */
 137 D3DVALUE WINAPI D3DRMVectorModulus(LPD3DVECTOR v)
 138 {
 139     D3DVALUE result;
 140     result=sqrt(v->u1.x * v->u1.x + v->u2.y * v->u2.y + v->u3.z * v->u3.z);
 141     return result;
 142 }
 143
 144 /* Normalize a vector.  Returns (1,0,0) if INPUT is the NULL vector. */
 145 LPD3DVECTOR WINAPI D3DRMVectorNormalize(LPD3DVECTOR u)
 146 {
 147     D3DVALUE modulus = D3DRMVectorModulus(u);
 148     if(modulus)
 149     {
 150         D3DRMVectorScale(u,u,1.0/modulus);
 151     }
 152     else
 153     {
 154         u->u1.x=1.0;
 155         u->u2.y=0.0;
 156         u->u3.z=0.0;
 157     }
 158     return u;
 159 }
 160
 161 /* Returns a random unit vector */
 162 LPD3DVECTOR WINAPI D3DRMVectorRandom(LPD3DVECTOR d)
 163 {
 164     d->u1.x = rand();
 165     d->u2.y = rand();
 166     d->u3.z = rand();
 167     D3DRMVectorNormalize(d);
 168     return d;
 169 }
 170
 171 /* Reflection of a vector on a surface */
 172 LPD3DVECTOR WINAPI D3DRMVectorReflect(LPD3DVECTOR r, LPD3DVECTOR ray, LPD3DVECTOR norm)
 173 {
 174     D3DVECTOR sca;
 175     D3DRMVectorSubtract(r, D3DRMVectorScale(&sca, norm, 2.0*D3DRMVectorDotProduct(ray,norm)), ray);
 176     return r;
 177 }
 178
 179 /* Rotation of a vector */
 180 LPD3DVECTOR WINAPI D3DRMVectorRotate(LPD3DVECTOR r, LPD3DVECTOR v, LPD3DVECTOR axis, D3DVALUE theta)
 181 {
 182     D3DRMQUATERNION quaternion,quaternion1, quaternion2, quaternion3, resultq;
 183     D3DVECTOR NORM;
 184
 185     quaternion1.s = cos(theta*.5);
 186     quaternion2.s = cos(theta*.5);
 187     NORM = *D3DRMVectorNormalize(axis);
 188     D3DRMVectorScale(&quaternion1.v, &NORM, sin(theta * .5));
 189     D3DRMVectorScale(&quaternion2.v, &NORM, -sin(theta * .5));
 190     quaternion3.s = 0.0;
 191     quaternion3.v = *v;
 192     D3DRMQuaternionMultiply(&quaternion, &quaternion1, &quaternion3);
 193     D3DRMQuaternionMultiply(&resultq, &quaternion, &quaternion2);
 194     *r = *D3DRMVectorNormalize(&resultq.v);
 195     return r;
 196 }
 197
 198 /* Scale a vector */
 199 LPD3DVECTOR WINAPI D3DRMVectorScale(LPD3DVECTOR d, LPD3DVECTOR s, D3DVALUE factor)
 200 {
 201     d->u1.x=factor * s->u1.x;
 202     d->u2.y=factor * s->u2.y;
 203     d->u3.z=factor * s->u3.z;
 204     return d;
 205 }