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"
22 /* Create a RGB color from its components */
23 D3DCOLOR WINAPI
D3DRMCreateColorRGB(D3DVALUE red
, D3DVALUE green
, D3DVALUE blue
)
25 return D3DRMCreateColorRGBA(red
, green
, blue
, 1.0f
);
27 /* Create a RGBA color from its components */
28 D3DCOLOR WINAPI
D3DRMCreateColorRGBA(D3DVALUE red
, D3DVALUE green
, D3DVALUE blue
, D3DVALUE alpha
)
32 d3drm_set_color(&color
, red
, green
, blue
, alpha
);
37 /* Determine the alpha part of a color */
38 D3DVALUE WINAPI
D3DRMColorGetAlpha(D3DCOLOR color
)
40 return (RGBA_GETALPHA(color
)/255.0);
43 /* Determine the blue part of a color */
44 D3DVALUE WINAPI
D3DRMColorGetBlue(D3DCOLOR color
)
46 return (RGBA_GETBLUE(color
)/255.0);
49 /* Determine the green part of a color */
50 D3DVALUE WINAPI
D3DRMColorGetGreen(D3DCOLOR color
)
52 return (RGBA_GETGREEN(color
)/255.0);
55 /* Determine the red part of a color */
56 D3DVALUE WINAPI
D3DRMColorGetRed(D3DCOLOR color
)
58 return (RGBA_GETRED(color
)/255.0);
61 /* Product of 2 quaternions */
62 D3DRMQUATERNION
* WINAPI
D3DRMQuaternionMultiply(D3DRMQUATERNION
*q
, D3DRMQUATERNION
*a
, D3DRMQUATERNION
*b
)
65 D3DVECTOR cross_product
;
67 D3DRMVectorCrossProduct(&cross_product
, &a
->v
, &b
->v
);
68 temp
.s
= a
->s
* b
->s
- D3DRMVectorDotProduct(&a
->v
, &b
->v
);
69 temp
.v
.u1
.x
= a
->s
* b
->v
.u1
.x
+ b
->s
* a
->v
.u1
.x
+ cross_product
.u1
.x
;
70 temp
.v
.u2
.y
= a
->s
* b
->v
.u2
.y
+ b
->s
* a
->v
.u2
.y
+ cross_product
.u2
.y
;
71 temp
.v
.u3
.z
= a
->s
* b
->v
.u3
.z
+ b
->s
* a
->v
.u3
.z
+ cross_product
.u3
.z
;
77 /* Matrix for the Rotation that a unit quaternion represents */
78 void WINAPI
D3DRMMatrixFromQuaternion(D3DRMMATRIX4D m
, D3DRMQUATERNION
*q
)
85 m
[0][0] = 1.0-2.0*(y
*y
+z
*z
);
86 m
[1][1] = 1.0-2.0*(x
*x
+z
*z
);
87 m
[2][2] = 1.0-2.0*(x
*x
+y
*y
);
88 m
[1][0] = 2.0*(x
*y
+z
*w
);
89 m
[0][1] = 2.0*(x
*y
-z
*w
);
90 m
[2][0] = 2.0*(x
*z
-y
*w
);
91 m
[0][2] = 2.0*(x
*z
+y
*w
);
92 m
[2][1] = 2.0*(y
*z
+x
*w
);
93 m
[1][2] = 2.0*(y
*z
-x
*w
);
103 /* Return a unit quaternion that represents a rotation of an angle around an axis */
104 D3DRMQUATERNION
* WINAPI
D3DRMQuaternionFromRotation(D3DRMQUATERNION
*q
, D3DVECTOR
*v
, D3DVALUE theta
)
106 q
->s
= cos(theta
/2.0);
107 D3DRMVectorScale(&q
->v
, D3DRMVectorNormalize(v
), sin(theta
/2.0));
111 /* Interpolation between two quaternions */
112 D3DRMQUATERNION
* WINAPI
D3DRMQuaternionSlerp(D3DRMQUATERNION
*q
,
113 D3DRMQUATERNION
*a
, D3DRMQUATERNION
*b
, D3DVALUE alpha
)
115 D3DVALUE dot
, epsilon
, temp
, theta
, u
;
118 dot
= a
->s
* b
->s
+ D3DRMVectorDotProduct(&a
->v
, &b
->v
);
127 if( 1.0f
- dot
> 0.001f
)
130 temp
= sin(theta
* temp
) / sin(theta
);
131 u
= sin(theta
* alpha
) / sin(theta
);
133 q
->s
= temp
* a
->s
+ epsilon
* u
* b
->s
;
134 D3DRMVectorScale(&v1
, &a
->v
, temp
);
135 D3DRMVectorScale(&v2
, &b
->v
, epsilon
* u
);
136 D3DRMVectorAdd(&q
->v
, &v1
, &v2
);
140 /* Add Two Vectors */
141 D3DVECTOR
* WINAPI
D3DRMVectorAdd(D3DVECTOR
*d
, D3DVECTOR
*s1
, D3DVECTOR
*s2
)
145 temp
.u1
.x
=s1
->u1
.x
+ s2
->u1
.x
;
146 temp
.u2
.y
=s1
->u2
.y
+ s2
->u2
.y
;
147 temp
.u3
.z
=s1
->u3
.z
+ s2
->u3
.z
;
153 /* Subtract Two Vectors */
154 D3DVECTOR
* WINAPI
D3DRMVectorSubtract(D3DVECTOR
*d
, D3DVECTOR
*s1
, D3DVECTOR
*s2
)
158 temp
.u1
.x
=s1
->u1
.x
- s2
->u1
.x
;
159 temp
.u2
.y
=s1
->u2
.y
- s2
->u2
.y
;
160 temp
.u3
.z
=s1
->u3
.z
- s2
->u3
.z
;
166 /* Cross Product of Two Vectors */
167 D3DVECTOR
* WINAPI
D3DRMVectorCrossProduct(D3DVECTOR
*d
, D3DVECTOR
*s1
, D3DVECTOR
*s2
)
171 temp
.u1
.x
=s1
->u2
.y
* s2
->u3
.z
- s1
->u3
.z
* s2
->u2
.y
;
172 temp
.u2
.y
=s1
->u3
.z
* s2
->u1
.x
- s1
->u1
.x
* s2
->u3
.z
;
173 temp
.u3
.z
=s1
->u1
.x
* s2
->u2
.y
- s1
->u2
.y
* s2
->u1
.x
;
179 /* Dot Product of Two vectors */
180 D3DVALUE WINAPI
D3DRMVectorDotProduct(D3DVECTOR
*s1
, D3DVECTOR
*s2
)
182 D3DVALUE dot_product
;
183 dot_product
=s1
->u1
.x
* s2
->u1
.x
+ s1
->u2
.y
* s2
->u2
.y
+ s1
->u3
.z
* s2
->u3
.z
;
187 /* Norm of a vector */
188 D3DVALUE WINAPI
D3DRMVectorModulus(D3DVECTOR
*v
)
191 result
=sqrt(v
->u1
.x
* v
->u1
.x
+ v
->u2
.y
* v
->u2
.y
+ v
->u3
.z
* v
->u3
.z
);
195 /* Normalize a vector. Returns (1,0,0) if INPUT is the NULL vector. */
196 D3DVECTOR
* WINAPI
D3DRMVectorNormalize(D3DVECTOR
*u
)
198 D3DVALUE modulus
= D3DRMVectorModulus(u
);
201 D3DRMVectorScale(u
,u
,1.0/modulus
);
212 /* Returns a random unit vector */
213 D3DVECTOR
* WINAPI
D3DRMVectorRandom(D3DVECTOR
*d
)
218 D3DRMVectorNormalize(d
);
222 /* Reflection of a vector on a surface */
223 D3DVECTOR
* WINAPI
D3DRMVectorReflect(D3DVECTOR
*r
, D3DVECTOR
*ray
, D3DVECTOR
*norm
)
226 D3DRMVectorSubtract(&temp
, D3DRMVectorScale(&sca
, norm
, 2.0*D3DRMVectorDotProduct(ray
,norm
)), ray
);
232 /* Rotation of a vector */
233 D3DVECTOR
* WINAPI
D3DRMVectorRotate(D3DVECTOR
*r
, D3DVECTOR
*v
, D3DVECTOR
*axis
, D3DVALUE theta
)
235 D3DRMQUATERNION quaternion1
, quaternion2
, quaternion3
;
238 quaternion1
.s
= cos(theta
* 0.5f
);
239 quaternion2
.s
= cos(theta
* 0.5f
);
240 norm
= *D3DRMVectorNormalize(axis
);
241 D3DRMVectorScale(&quaternion1
.v
, &norm
, sin(theta
* 0.5f
));
242 D3DRMVectorScale(&quaternion2
.v
, &norm
, -sin(theta
* 0.5f
));
245 D3DRMQuaternionMultiply(&quaternion1
, &quaternion1
, &quaternion3
);
246 D3DRMQuaternionMultiply(&quaternion1
, &quaternion1
, &quaternion2
);
248 *r
= *D3DRMVectorNormalize(&quaternion1
.v
);
253 D3DVECTOR
* WINAPI
D3DRMVectorScale(D3DVECTOR
*d
, D3DVECTOR
*s
, D3DVALUE factor
)
257 temp
.u1
.x
=factor
* s
->u1
.x
;
258 temp
.u2
.y
=factor
* s
->u2
.y
;
259 temp
.u3
.z
=factor
* s
->u3
.z
;