d3drm: Fix compilation on systems that don't support nameless unions.

dlls/d3drm/math.c

@@ -17,6 +17,8 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
+#define NONAMELESSUNION
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -38,9 +40,9 @@ LPD3DRMQUATERNION WINAPI D3DRMQuaternionMultiply(LPD3DRMQUATERNION q, LPD3DRMQUA
     D3DVECTOR cross_product;
     D3DRMVectorCrossProduct(&cross_product, &a->v, &b->v);
     q->s = a->s * b->s - D3DRMVectorDotProduct(&a->v, &b->v);
-    q->v.x = a->s * b->v.x + b->s * a->v.x + cross_product.x;
-    q->v.y = a->s * b->v.y + b->s * a->v.y + cross_product.y;
-    q->v.z = a->s * b->v.z + b->s * a->v.z + cross_product.z;
+    q->v.u1.x = a->s * b->v.u1.x + b->s * a->v.u1.x + cross_product.u1.x;
+    q->v.u2.y = a->s * b->v.u2.y + b->s * a->v.u2.y + cross_product.u2.y;
+    q->v.u3.z = a->s * b->v.u3.z + b->s * a->v.u3.z + cross_product.u3.z;
     return q;
 }
 
@@ -49,9 +51,9 @@ void WINAPI D3DRMMatrixFromQuaternion(D3DRMMATRIX4D m, LPD3DRMQUATERNION q)
 {
     D3DVALUE w,x,y,z;
     w = q->s;
-    x = q->v.x;
-    y = q->v.y;
-    z = q->v.z;
+    x = q->v.u1.x;
+    y = q->v.u2.y;
+    z = q->v.u3.z;
     m[0][0] = 1.0-2.0*(y*y+z*z);
     m[1][1] = 1.0-2.0*(x*x+z*z);
     m[2][2] = 1.0-2.0*(x*x+y*y);
@@ -93,27 +95,27 @@ LPD3DRMQUATERNION WINAPI D3DRMQuaternionSlerp(LPD3DRMQUATERNION q, LPD3DRMQUATER
 /* Add Two Vectors */
 LPD3DVECTOR WINAPI D3DRMVectorAdd(LPD3DVECTOR d, LPD3DVECTOR s1, LPD3DVECTOR s2)
 {
-    d->x=s1->x + s2->x;
-    d->y=s1->y + s2->y;
-    d->z=s1->z + s2->z;
+    d->u1.x=s1->u1.x + s2->u1.x;
+    d->u2.y=s1->u2.y + s2->u2.y;
+    d->u3.z=s1->u3.z + s2->u3.z;
     return d;
 }
 
 /* Subtract Two Vectors */
 LPD3DVECTOR WINAPI D3DRMVectorSubtract(LPD3DVECTOR d, LPD3DVECTOR s1, LPD3DVECTOR s2)
 {
-    d->x=s1->x - s2->x;
-    d->y=s1->y - s2->y;
-    d->z=s1->z - s2->z;
+    d->u1.x=s1->u1.x - s2->u1.x;
+    d->u2.y=s1->u2.y - s2->u2.y;
+    d->u3.z=s1->u3.z - s2->u3.z;
     return d;
 }
 
 /* Cross Product of Two Vectors */
 LPD3DVECTOR WINAPI D3DRMVectorCrossProduct(LPD3DVECTOR d, LPD3DVECTOR s1, LPD3DVECTOR s2)
 {
-    d->x=s1->y * s2->z - s1->z * s2->y;
-    d->y=s1->z * s2->x - s1->x * s2->z;
-    d->z=s1->x * s2->y - s1->y * s2->x;
+    d->u1.x=s1->u2.y * s2->u3.z - s1->u3.z * s2->u2.y;
+    d->u2.y=s1->u3.z * s2->u1.x - s1->u1.x * s2->u3.z;
+    d->u3.z=s1->u1.x * s2->u2.y - s1->u2.y * s2->u1.x;
     return d;
 }
 
@@ -121,7 +123,7 @@ LPD3DVECTOR WINAPI D3DRMVectorCrossProduct(LPD3DVECTOR d, LPD3DVECTOR s1, LPD3DV
 D3DVALUE WINAPI D3DRMVectorDotProduct(LPD3DVECTOR s1, LPD3DVECTOR s2)
 {
     D3DVALUE dot_product;
-    dot_product=s1->x * s2->x + s1->y * s2->y + s1->z * s2->z;
+    dot_product=s1->u1.x * s2->u1.x + s1->u2.y * s2->u2.y + s1->u3.z * s2->u3.z;
     return dot_product;
 }
 
@@ -129,7 +131,7 @@ D3DVALUE WINAPI D3DRMVectorDotProduct(LPD3DVECTOR s1, LPD3DVECTOR s2)
 D3DVALUE WINAPI D3DRMVectorModulus(LPD3DVECTOR v)
 {
     D3DVALUE result;
-    result=sqrt(v->x * v->x + v->y * v->y + v->z * v->z);
+    result=sqrt(v->u1.x * v->u1.x + v->u2.y * v->u2.y + v->u3.z * v->u3.z);
     return result;
 }
 
@@ -143,9 +145,9 @@ LPD3DVECTOR WINAPI D3DRMVectorNormalize(LPD3DVECTOR u)
     }
     else
     {
-        u->x=1.0;
-        u->y=0.0;
-        u->z=0.0;
+        u->u1.x=1.0;
+        u->u2.y=0.0;
+        u->u3.z=0.0;
     }
     return u;
 }
@@ -153,9 +155,9 @@ LPD3DVECTOR WINAPI D3DRMVectorNormalize(LPD3DVECTOR u)
 /* Returns a random unit vector */
 LPD3DVECTOR WINAPI D3DRMVectorRandom(LPD3DVECTOR d)
 {
-    d->x = rand();
-    d->y = rand();
-    d->z = rand();
+    d->u1.x = rand();
+    d->u2.y = rand();
+    d->u3.z = rand();
     D3DRMVectorNormalize(d);
     return d;
 }
@@ -190,8 +192,8 @@ LPD3DVECTOR WINAPI D3DRMVectorRotate(LPD3DVECTOR r, LPD3DVECTOR v, LPD3DVECTOR a
 /* Scale a vector */
 LPD3DVECTOR WINAPI D3DRMVectorScale(LPD3DVECTOR d, LPD3DVECTOR s, D3DVALUE factor)
 {
-    d->x=factor * s->x;
-    d->y=factor * s->y;
-    d->z=factor * s->z;
+    d->u1.x=factor * s->u1.x;
+    d->u2.y=factor * s->u2.y;
+    d->u3.z=factor * s->u3.z;
     return d;
 }

dlls/d3drm/tests/vector.c

@@ -18,10 +18,11 @@
  */
 
 #include <assert.h>
-#include "wine/test.h"
 #include "d3drmdef.h"
 #include <math.h>
 
+#include "wine/test.h"
+
 #define PI (4*atan(1.0))
 #define admit_error 0.000001
 
@@ -51,40 +52,40 @@
 }
 
 #define expect_quat(expectedquat,gotquat) \
-  ok( (fabs(expectedquat.v.x-gotquat.v.x)<admit_error) && \
-      (fabs(expectedquat.v.y-gotquat.v.y)<admit_error) && \
-      (fabs(expectedquat.v.z-gotquat.v.z)<admit_error) && \
+  ok( (fabs(U1(expectedquat.v).x-U1(gotquat.v).x)<admit_error) &&     \
+      (fabs(U2(expectedquat.v).y-U2(gotquat.v).y)<admit_error) &&     \
+      (fabs(U3(expectedquat.v).z-U3(gotquat.v).z)<admit_error) &&     \
       (fabs(expectedquat.s-gotquat.s)<admit_error), \
   "Expected Quaternion %f %f %f %f , Got Quaternion %f %f %f %f\n", \
-  expectedquat.s,expectedquat.v.x,expectedquat.v.y,expectedquat.v.z, \
-  gotquat.s,gotquat.v.x,gotquat.v.y,gotquat.v.z);
+      expectedquat.s,U1(expectedquat.v).x,U2(expectedquat.v).y,U3(expectedquat.v).z, \
+      gotquat.s,U1(gotquat.v).x,U2(gotquat.v).y,U3(gotquat.v).z);
 
 #define expect_vec(expectedvec,gotvec) \
-  ok( ((fabs(expectedvec.x-gotvec.x)<admit_error)&&(fabs(expectedvec.y-gotvec.y)<admit_error)&&(fabs(expectedvec.z-gotvec.z)<admit_error)), \
+  ok( ((fabs(U1(expectedvec).x-U1(gotvec).x)<admit_error)&&(fabs(U2(expectedvec).y-U2(gotvec).y)<admit_error)&&(fabs(U3(expectedvec).z-U3(gotvec).z)<admit_error)), \
   "Expected Vector= (%f, %f, %f)\n , Got Vector= (%f, %f, %f)\n", \
-  expectedvec.x,expectedvec.y,expectedvec.z, gotvec.x, gotvec.y, gotvec.z);
+  U1(expectedvec).x,U2(expectedvec).y,U3(expectedvec).z, U1(gotvec).x, U2(gotvec).y, U3(gotvec).z);
 
 static void VectorTest(void)
 {
     D3DVALUE mod,par,theta;
     D3DVECTOR e,r,u,v,w,axis,casnul,norm,ray;
 
-    u.x=2.0;u.y=2.0;u.z=1.0;
-    v.x=4.0;v.y=4.0;v.z=0.0;
+    U1(u).x=2.0;U2(u).y=2.0;U3(u).z=1.0;
+    U1(v).x=4.0;U2(v).y=4.0;U3(v).z=0.0;
 
 /*______________________VectorAdd_________________________________*/
     D3DRMVectorAdd(&r,&u,&v);
-    e.x=6.0;e.y=6.0;e.z=1.0;
+    U1(e).x=6.0;U2(e).y=6.0;U3(e).z=1.0;
     expect_vec(e,r);
 
 /*_______________________VectorSubtract__________________________*/
     D3DRMVectorSubtract(&r,&u,&v);
-    e.x=-2.0;e.y=-2.0;e.z=1.0;
+    U1(e).x=-2.0;U2(e).y=-2.0;U3(e).z=1.0;
     expect_vec(e,r);
 
 /*_______________________VectorCrossProduct_______________________*/
     D3DRMVectorCrossProduct(&r,&u,&v);
-    e.x=-4.0;e.y=4.0;e.z=0.0;
+    U1(e).x=-4.0;U2(e).y=4.0;U3(e).z=0.0;
     expect_vec(e,r);
 
 /*_______________________VectorDotProduct__________________________*/
@@ -97,41 +98,41 @@ static void VectorTest(void)
 
 /*_______________________VectorNormalize___________________________*/
     D3DRMVectorNormalize(&u);
-    e.x=2.0/3.0;e.y=2.0/3.0;e.z=1.0/3.0;
+    U1(e).x=2.0/3.0;U2(e).y=2.0/3.0;U3(e).z=1.0/3.0;
     expect_vec(e,u);
 
 /* If u is the NULL vector, MSDN says that the return vector is NULL. In fact, the returned vector is (1,0,0). The following test case prove it. */
 
-    casnul.x=0.0; casnul.y=0.0; casnul.z=0.0;
+    U1(casnul).x=0.0; U2(casnul).y=0.0; U3(casnul).z=0.0;
     D3DRMVectorNormalize(&casnul);
-    e.x=1.0; e.y=0.0; e.z=0.0;
+    U1(e).x=1.0; U2(e).y=0.0; U3(e).z=0.0;
     expect_vec(e,casnul);
 
 /*____________________VectorReflect_________________________________*/
-    ray.x=3.0; ray.y=-4.0; ray.z=5.0;
-    norm.x=1.0; norm.y=-2.0; norm.z=6.0;
-    e.x=79.0; e.y=-160.0; e.z=487.0;
+    U1(ray).x=3.0; U2(ray).y=-4.0; U3(ray).z=5.0;
+    U1(norm).x=1.0; U2(norm).y=-2.0; U3(norm).z=6.0;
+    U1(e).x=79.0; U2(e).y=-160.0; U3(e).z=487.0;
     D3DRMVectorReflect(&r,&ray,&norm);
     expect_vec(e,r);
 
 /*_______________________VectorRotate_______________________________*/
-    w.x=3.0;w.y=4.0;w.z=0.0;
-    axis.x=0.0;axis.y=0.0;axis.z=1.0;
+    U1(w).x=3.0; U2(w).y=4.0; U3(w).z=0.0;
+    U1(axis).x=0.0; U2(axis).y=0.0; U3(axis).z=1.0;
     theta=2.0*PI/3.0;
     D3DRMVectorRotate(&r,&w,&axis,theta);
-    e.x=-0.3-0.4*sqrt(3.0); e.y=0.3*sqrt(3.0)-0.4; e.z=0.0;
+    U1(e).x=-0.3-0.4*sqrt(3.0); U2(e).y=0.3*sqrt(3.0)-0.4; U3(e).z=0.0;
     expect_vec(e,r);
 
 /* The same formula gives D3DRMVectorRotate, for theta in [-PI/2;+PI/2] or not. The following test proves this fact.*/
     theta=-PI/4.0;
     D3DRMVectorRotate(&r,&w,&axis,-PI/4);
-    e.x=1.4/sqrt(2.0); e.y=0.2/sqrt(2.0); e.z=0.0;
+    U1(e).x=1.4/sqrt(2.0); U2(e).y=0.2/sqrt(2.0); U3(e).z=0.0;
     expect_vec(e,r);
 
 /*_______________________VectorScale__________________________*/
     par=2.5;
     D3DRMVectorScale(&r,&v,par);
-    e.x=10.0; e.y=10.0; e.z=0.0;
+    U1(e).x=10.0; U2(e).y=10.0; U3(e).z=0.0;
     expect_vec(e,r);
 }
 
@@ -144,7 +145,7 @@ static void MatrixTest(void)
     exp[1][0]=20.0;  exp[1][1]=-39.0; exp[1][2]=20.0;  exp[1][3]=0.0;
     exp[2][0]=10.0;  exp[2][1]=28.0;  exp[2][2]=-25.0; exp[2][3]=0.0;
     exp[3][0]=0.0;   exp[3][1]=0.0;   exp[3][2]=0.0;   exp[3][3]=1.0;
-    q.s=1.0; q.v.x=2.0; q.v.y=3.0; q.v.z=4.0;
+    q.s=1.0; U1(q.v).x=2.0; U2(q.v).y=3.0; U3(q.v).z=4.0;
 
    D3DRMMatrixFromQuaternion(mat,&q);
    expect_mat(exp,mat);
@@ -157,10 +158,10 @@ static void QuaternionTest(void)
     D3DRMQUATERNION q,q1,q2,r;
 
 /*_________________QuaternionFromRotation___________________*/
-    axis.x=1.0;axis.y=1.0;axis.z=1.0;
+    U1(axis).x=1.0; U2(axis).y=1.0; U3(axis).z=1.0;
     theta=2.0*PI/3.0;
     D3DRMQuaternionFromRotation(&r,&axis,theta);
-    q.s=0.5;q.v.x=0.5;q.v.y=0.5;q.v.z=0.5;
+    q.s=0.5; U1(q.v).x=0.5; U2(q.v).y=0.5; U3(q.v).z=0.5;
     expect_quat(q,r);
 
 /*_________________QuaternionSlerp_________________________*/
@@ -169,28 +170,28 @@ static void QuaternionTest(void)
  * interpolates between the first quaternion and the opposite of the second one. The test proves
  * these two facts. */
     par=0.31;
-    q1.s=1.0; q1.v.x=2.0; q1.v.y=3.0; q1.v.z=50.0;
-    q2.s=-4.0; q2.v.x=6.0; q2.v.y=7.0; q2.v.z=8.0;
+    q1.s=1.0; U1(q1.v).x=2.0; U2(q1.v).y=3.0; U3(q1.v).z=50.0;
+    q2.s=-4.0; U1(q2.v).x=6.0; U2(q2.v).y=7.0; U3(q2.v).z=8.0;
 /* The angle between q1 and q2 is in [-PI/2,PI/2]. So, one interpolates between q1 and q2. */
     epsilon=1.0;
     g=1.0-par; h=epsilon*par;
 /* Part of the test proving that the interpolation is linear. */
     q.s=g*q1.s+h*q2.s;
-    q.v.x=g*q1.v.x+h*q2.v.x;
-    q.v.y=g*q1.v.y+h*q2.v.y;
-    q.v.z=g*q1.v.z+h*q2.v.z;
+    U1(q.v).x=g*U1(q1.v).x+h*U1(q2.v).x;
+    U2(q.v).y=g*U2(q1.v).y+h*U2(q2.v).y;
+    U3(q.v).z=g*U3(q1.v).z+h*U3(q2.v).z;
     D3DRMQuaternionSlerp(&r,&q1,&q2,par);
     expect_quat(q,r);
 
-    q1.s=1.0; q1.v.x=2.0; q1.v.y=3.0; q1.v.z=50.0;
-    q2.s=-94.0; q2.v.x=6.0; q2.v.y=7.0; q2.v.z=-8.0;
+    q1.s=1.0; U1(q1.v).x=2.0; U2(q1.v).y=3.0; U3(q1.v).z=50.0;
+    q2.s=-94.0; U1(q2.v).x=6.0; U2(q2.v).y=7.0; U3(q2.v).z=-8.0;
 /* The angle between q1 and q2 is not in [-PI/2,PI/2]. So, one interpolates between q1 and -q2. */
     epsilon=-1.0;
     g=1.0-par; h=epsilon*par;
     q.s=g*q1.s+h*q2.s;
-    q.v.x=g*q1.v.x+h*q2.v.x;
-    q.v.y=g*q1.v.y+h*q2.v.y;
-    q.v.z=g*q1.v.z+h*q2.v.z;
+    U1(q.v).x=g*U1(q1.v).x+h*U1(q2.v).x;
+    U2(q.v).y=g*U2(q1.v).y+h*U2(q2.v).y;
+    U3(q.v).z=g*U3(q1.v).z+h*U3(q2.v).z;
     D3DRMQuaternionSlerp(&r,&q1,&q2,par);
     expect_quat(q,r);
 }