2 * Copyright 2007 David Adam
3 * Copyright 2007 Vijay Kiran Kamuju
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.
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.
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
20 #include "d3drm_private.h"
24 /* Create a RGB color from its components */
25 D3DCOLOR WINAPI
D3DRMCreateColorRGB(D3DVALUE red
, D3DVALUE green
, D3DVALUE blue
)
27 return D3DRMCreateColorRGBA(red
, green
, blue
, 1.0f
);
29 /* Create a RGBA color from its components */
30 D3DCOLOR WINAPI
D3DRMCreateColorRGBA(D3DVALUE red
, D3DVALUE green
, D3DVALUE blue
, D3DVALUE alpha
)
34 d3drm_set_color(&color
, red
, green
, blue
, alpha
);
39 /* Determine the alpha part of a color */
40 D3DVALUE WINAPI
D3DRMColorGetAlpha(D3DCOLOR color
)
42 return (RGBA_GETALPHA(color
)/255.0);
45 /* Determine the blue part of a color */
46 D3DVALUE WINAPI
D3DRMColorGetBlue(D3DCOLOR color
)
48 return (RGBA_GETBLUE(color
)/255.0);
51 /* Determine the green part of a color */
52 D3DVALUE WINAPI
D3DRMColorGetGreen(D3DCOLOR color
)
54 return (RGBA_GETGREEN(color
)/255.0);
57 /* Determine the red part of a color */
58 D3DVALUE WINAPI
D3DRMColorGetRed(D3DCOLOR color
)
60 return (RGBA_GETRED(color
)/255.0);
63 /* Product of 2 quaternions */
64 D3DRMQUATERNION
* WINAPI
D3DRMQuaternionMultiply(D3DRMQUATERNION
*q
, D3DRMQUATERNION
*a
, D3DRMQUATERNION
*b
)
67 D3DVECTOR cross_product
;
69 D3DRMVectorCrossProduct(&cross_product
, &a
->v
, &b
->v
);
70 temp
.s
= a
->s
* b
->s
- D3DRMVectorDotProduct(&a
->v
, &b
->v
);
71 temp
.v
.u1
.x
= a
->s
* b
->v
.u1
.x
+ b
->s
* a
->v
.u1
.x
+ cross_product
.u1
.x
;
72 temp
.v
.u2
.y
= a
->s
* b
->v
.u2
.y
+ b
->s
* a
->v
.u2
.y
+ cross_product
.u2
.y
;
73 temp
.v
.u3
.z
= a
->s
* b
->v
.u3
.z
+ b
->s
* a
->v
.u3
.z
+ cross_product
.u3
.z
;
79 /* Matrix for the Rotation that a unit quaternion represents */
80 void WINAPI
D3DRMMatrixFromQuaternion(D3DRMMATRIX4D m
, D3DRMQUATERNION
*q
)
87 m
[0][0] = 1.0-2.0*(y
*y
+z
*z
);
88 m
[1][1] = 1.0-2.0*(x
*x
+z
*z
);
89 m
[2][2] = 1.0-2.0*(x
*x
+y
*y
);
90 m
[1][0] = 2.0*(x
*y
+z
*w
);
91 m
[0][1] = 2.0*(x
*y
-z
*w
);
92 m
[2][0] = 2.0*(x
*z
-y
*w
);
93 m
[0][2] = 2.0*(x
*z
+y
*w
);
94 m
[2][1] = 2.0*(y
*z
+x
*w
);
95 m
[1][2] = 2.0*(y
*z
-x
*w
);
105 /* Return a unit quaternion that represents a rotation of an angle around an axis */
106 D3DRMQUATERNION
* WINAPI
D3DRMQuaternionFromRotation(D3DRMQUATERNION
*q
, D3DVECTOR
*v
, D3DVALUE theta
)
108 q
->s
= cos(theta
/2.0);
109 D3DRMVectorScale(&q
->v
, D3DRMVectorNormalize(v
), sin(theta
/2.0));
113 /* Interpolation between two quaternions */
114 D3DRMQUATERNION
* WINAPI
D3DRMQuaternionSlerp(D3DRMQUATERNION
*q
,
115 D3DRMQUATERNION
*a
, D3DRMQUATERNION
*b
, D3DVALUE alpha
)
117 D3DVALUE dot
, epsilon
, temp
, theta
, u
;
120 dot
= a
->s
* b
->s
+ D3DRMVectorDotProduct(&a
->v
, &b
->v
);
129 if( 1.0f
- dot
> 0.001f
)
132 temp
= sin(theta
* temp
) / sin(theta
);
133 u
= sin(theta
* alpha
) / sin(theta
);
135 q
->s
= temp
* a
->s
+ epsilon
* u
* b
->s
;
136 D3DRMVectorScale(&v1
, &a
->v
, temp
);
137 D3DRMVectorScale(&v2
, &b
->v
, epsilon
* u
);
138 D3DRMVectorAdd(&q
->v
, &v1
, &v2
);
142 /* Add Two Vectors */
143 D3DVECTOR
* WINAPI
D3DRMVectorAdd(D3DVECTOR
*d
, D3DVECTOR
*s1
, D3DVECTOR
*s2
)
147 temp
.u1
.x
=s1
->u1
.x
+ s2
->u1
.x
;
148 temp
.u2
.y
=s1
->u2
.y
+ s2
->u2
.y
;
149 temp
.u3
.z
=s1
->u3
.z
+ s2
->u3
.z
;
155 /* Subtract Two Vectors */
156 D3DVECTOR
* WINAPI
D3DRMVectorSubtract(D3DVECTOR
*d
, D3DVECTOR
*s1
, D3DVECTOR
*s2
)
160 temp
.u1
.x
=s1
->u1
.x
- s2
->u1
.x
;
161 temp
.u2
.y
=s1
->u2
.y
- s2
->u2
.y
;
162 temp
.u3
.z
=s1
->u3
.z
- s2
->u3
.z
;
168 /* Cross Product of Two Vectors */
169 D3DVECTOR
* WINAPI
D3DRMVectorCrossProduct(D3DVECTOR
*d
, D3DVECTOR
*s1
, D3DVECTOR
*s2
)
173 temp
.u1
.x
=s1
->u2
.y
* s2
->u3
.z
- s1
->u3
.z
* s2
->u2
.y
;
174 temp
.u2
.y
=s1
->u3
.z
* s2
->u1
.x
- s1
->u1
.x
* s2
->u3
.z
;
175 temp
.u3
.z
=s1
->u1
.x
* s2
->u2
.y
- s1
->u2
.y
* s2
->u1
.x
;
181 /* Dot Product of Two vectors */
182 D3DVALUE WINAPI
D3DRMVectorDotProduct(D3DVECTOR
*s1
, D3DVECTOR
*s2
)
184 D3DVALUE dot_product
;
185 dot_product
=s1
->u1
.x
* s2
->u1
.x
+ s1
->u2
.y
* s2
->u2
.y
+ s1
->u3
.z
* s2
->u3
.z
;
189 /* Norm of a vector */
190 D3DVALUE WINAPI
D3DRMVectorModulus(D3DVECTOR
*v
)
193 result
=sqrt(v
->u1
.x
* v
->u1
.x
+ v
->u2
.y
* v
->u2
.y
+ v
->u3
.z
* v
->u3
.z
);
197 /* Normalize a vector. Returns (1,0,0) if INPUT is the NULL vector. */
198 D3DVECTOR
* WINAPI
D3DRMVectorNormalize(D3DVECTOR
*u
)
200 D3DVALUE modulus
= D3DRMVectorModulus(u
);
203 D3DRMVectorScale(u
,u
,1.0/modulus
);
214 /* Returns a random unit vector */
215 D3DVECTOR
* WINAPI
D3DRMVectorRandom(D3DVECTOR
*d
)
220 D3DRMVectorNormalize(d
);
224 /* Reflection of a vector on a surface */
225 D3DVECTOR
* WINAPI
D3DRMVectorReflect(D3DVECTOR
*r
, D3DVECTOR
*ray
, D3DVECTOR
*norm
)
228 D3DRMVectorSubtract(&temp
, D3DRMVectorScale(&sca
, norm
, 2.0*D3DRMVectorDotProduct(ray
,norm
)), ray
);
234 /* Rotation of a vector */
235 D3DVECTOR
* WINAPI
D3DRMVectorRotate(D3DVECTOR
*r
, D3DVECTOR
*v
, D3DVECTOR
*axis
, D3DVALUE theta
)
237 D3DRMQUATERNION quaternion1
, quaternion2
, quaternion3
;
240 quaternion1
.s
= cos(theta
* 0.5f
);
241 quaternion2
.s
= cos(theta
* 0.5f
);
242 norm
= *D3DRMVectorNormalize(axis
);
243 D3DRMVectorScale(&quaternion1
.v
, &norm
, sin(theta
* 0.5f
));
244 D3DRMVectorScale(&quaternion2
.v
, &norm
, -sin(theta
* 0.5f
));
247 D3DRMQuaternionMultiply(&quaternion1
, &quaternion1
, &quaternion3
);
248 D3DRMQuaternionMultiply(&quaternion1
, &quaternion1
, &quaternion2
);
250 *r
= *D3DRMVectorNormalize(&quaternion1
.v
);
255 D3DVECTOR
* WINAPI
D3DRMVectorScale(D3DVECTOR
*d
, D3DVECTOR
*s
, D3DVALUE factor
)
259 temp
.u1
.x
=factor
* s
->u1
.x
;
260 temp
.u2
.y
=factor
* s
->u2
.y
;
261 temp
.u3
.z
=factor
* s
->u3
.z
;