[NTOSKRNL] Drop the useless Timestamp field
[reactos.git] / dll / win32 / gdiplus / matrix.c
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
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 <stdarg.h>
20 #include <math.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25
26 #include "objbase.h"
27
28 #include "gdiplus.h"
29 #include "gdiplus_private.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
33
34 /* Multiplies two matrices of the form
35 *
36 * idx:0 idx:1 0
37 * idx:2 idx:3 0
38 * idx:4 idx:5 1
39 *
40 * and puts the output in out.
41 * */
42 static void matrix_multiply(GDIPCONST REAL * left, GDIPCONST REAL * right, REAL * out)
43 {
44 REAL temp[6];
45 int i, odd;
46
47 for(i = 0; i < 6; i++){
48 odd = i % 2;
49 temp[i] = left[i - odd] * right[odd] + left[i - odd + 1] * right[odd + 2] +
50 (i >= 4 ? right[odd + 4] : 0.0);
51 }
52
53 memcpy(out, temp, 6 * sizeof(REAL));
54 }
55
56 static REAL matrix_det(GDIPCONST GpMatrix *matrix)
57 {
58 return matrix->matrix[0]*matrix->matrix[3] - matrix->matrix[1]*matrix->matrix[2];
59 }
60
61 GpStatus WINGDIPAPI GdipCreateMatrix2(REAL m11, REAL m12, REAL m21, REAL m22,
62 REAL dx, REAL dy, GpMatrix **matrix)
63 {
64 TRACE("(%.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p)\n", m11, m12, m21, m22, dx, dy, matrix);
65
66 if(!matrix)
67 return InvalidParameter;
68
69 *matrix = heap_alloc_zero(sizeof(GpMatrix));
70 if(!*matrix) return OutOfMemory;
71
72 /* first row */
73 (*matrix)->matrix[0] = m11;
74 (*matrix)->matrix[1] = m12;
75 /* second row */
76 (*matrix)->matrix[2] = m21;
77 (*matrix)->matrix[3] = m22;
78 /* third row */
79 (*matrix)->matrix[4] = dx;
80 (*matrix)->matrix[5] = dy;
81
82 return Ok;
83 }
84
85 GpStatus WINGDIPAPI GdipCreateMatrix3(GDIPCONST GpRectF *rect,
86 GDIPCONST GpPointF *pt, GpMatrix **matrix)
87 {
88 REAL m11, m12, m21, m22, dx, dy;
89 TRACE("(%p, %p, %p)\n", rect, pt, matrix);
90
91 if(!matrix || !pt)
92 return InvalidParameter;
93
94 m11 = (pt[1].X - pt[0].X) / rect->Width;
95 m21 = (pt[2].X - pt[0].X) / rect->Height;
96 dx = pt[0].X - m11 * rect->X - m21 * rect->Y;
97 m12 = (pt[1].Y - pt[0].Y) / rect->Width;
98 m22 = (pt[2].Y - pt[0].Y) / rect->Height;
99 dy = pt[0].Y - m12 * rect->X - m22 * rect->Y;
100
101 return GdipCreateMatrix2(m11, m12, m21, m22, dx, dy, matrix);
102 }
103
104 GpStatus WINGDIPAPI GdipCreateMatrix3I(GDIPCONST GpRect *rect, GDIPCONST GpPoint *pt,
105 GpMatrix **matrix)
106 {
107 GpRectF rectF;
108 GpPointF ptF[3];
109 int i;
110
111 TRACE("(%p, %p, %p)\n", rect, pt, matrix);
112
113 rectF.X = (REAL)rect->X;
114 rectF.Y = (REAL)rect->Y;
115 rectF.Width = (REAL)rect->Width;
116 rectF.Height = (REAL)rect->Height;
117
118 for (i = 0; i < 3; i++) {
119 ptF[i].X = (REAL)pt[i].X;
120 ptF[i].Y = (REAL)pt[i].Y;
121 }
122 return GdipCreateMatrix3(&rectF, ptF, matrix);
123 }
124
125 GpStatus WINGDIPAPI GdipCloneMatrix(GpMatrix *matrix, GpMatrix **clone)
126 {
127 TRACE("(%p, %p)\n", matrix, clone);
128
129 if(!matrix || !clone)
130 return InvalidParameter;
131
132 *clone = heap_alloc_zero(sizeof(GpMatrix));
133 if(!*clone) return OutOfMemory;
134
135 **clone = *matrix;
136
137 return Ok;
138 }
139
140 GpStatus WINGDIPAPI GdipCreateMatrix(GpMatrix **matrix)
141 {
142 TRACE("(%p)\n", matrix);
143
144 if(!matrix)
145 return InvalidParameter;
146
147 *matrix = heap_alloc_zero(sizeof(GpMatrix));
148 if(!*matrix) return OutOfMemory;
149
150 (*matrix)->matrix[0] = 1.0;
151 (*matrix)->matrix[1] = 0.0;
152 (*matrix)->matrix[2] = 0.0;
153 (*matrix)->matrix[3] = 1.0;
154 (*matrix)->matrix[4] = 0.0;
155 (*matrix)->matrix[5] = 0.0;
156
157 return Ok;
158 }
159
160 GpStatus WINGDIPAPI GdipDeleteMatrix(GpMatrix *matrix)
161 {
162 TRACE("(%p)\n", matrix);
163
164 if(!matrix)
165 return InvalidParameter;
166
167 heap_free(matrix);
168
169 return Ok;
170 }
171
172 GpStatus WINGDIPAPI GdipGetMatrixElements(GDIPCONST GpMatrix *matrix,
173 REAL *out)
174 {
175 TRACE("(%p, %p)\n", matrix, out);
176
177 if(!matrix || !out)
178 return InvalidParameter;
179
180 memcpy(out, matrix->matrix, sizeof(matrix->matrix));
181
182 return Ok;
183 }
184
185 GpStatus WINGDIPAPI GdipInvertMatrix(GpMatrix *matrix)
186 {
187 GpMatrix copy;
188 REAL det;
189 BOOL invertible;
190
191 TRACE("(%p)\n", matrix);
192
193 if(!matrix)
194 return InvalidParameter;
195
196 GdipIsMatrixInvertible(matrix, &invertible);
197 if(!invertible)
198 return InvalidParameter;
199
200 /* optimize inverting simple scaling and translation matrices */
201 if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
202 {
203 matrix->matrix[4] = -matrix->matrix[4] / matrix->matrix[0];
204 matrix->matrix[5] = -matrix->matrix[5] / matrix->matrix[3];
205 matrix->matrix[0] = 1 / matrix->matrix[0];
206 matrix->matrix[3] = 1 / matrix->matrix[3];
207
208 return Ok;
209 }
210
211 det = matrix_det(matrix);
212
213 copy = *matrix;
214 /* store result */
215 matrix->matrix[0] = copy.matrix[3] / det;
216 matrix->matrix[1] = -copy.matrix[1] / det;
217 matrix->matrix[2] = -copy.matrix[2] / det;
218 matrix->matrix[3] = copy.matrix[0] / det;
219 matrix->matrix[4] = (copy.matrix[2]*copy.matrix[5]-copy.matrix[3]*copy.matrix[4]) / det;
220 matrix->matrix[5] = -(copy.matrix[0]*copy.matrix[5]-copy.matrix[1]*copy.matrix[4]) / det;
221
222 return Ok;
223 }
224
225 GpStatus WINGDIPAPI GdipIsMatrixInvertible(GDIPCONST GpMatrix *matrix, BOOL *result)
226 {
227 TRACE("(%p, %p)\n", matrix, result);
228
229 if(!matrix || !result)
230 return InvalidParameter;
231
232 if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
233 *result = matrix->matrix[0] != 0 && matrix->matrix[3] != 0;
234 else
235 *result = (fabs(matrix_det(matrix)) >= 1e-5);
236
237 return Ok;
238 }
239
240 GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix *matrix, GDIPCONST GpMatrix* matrix2,
241 GpMatrixOrder order)
242 {
243 TRACE("(%p, %p, %d)\n", matrix, matrix2, order);
244
245 if(!matrix || !matrix2)
246 return InvalidParameter;
247
248 if(order == MatrixOrderAppend)
249 matrix_multiply(matrix->matrix, matrix2->matrix, matrix->matrix);
250 else if (order == MatrixOrderPrepend)
251 matrix_multiply(matrix2->matrix, matrix->matrix, matrix->matrix);
252 else
253 return InvalidParameter;
254
255 return Ok;
256 }
257
258 GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix *matrix, REAL angle,
259 GpMatrixOrder order)
260 {
261 REAL cos_theta, sin_theta, rotate[6];
262
263 TRACE("(%p, %.2f, %d)\n", matrix, angle, order);
264
265 if(!matrix)
266 return InvalidParameter;
267
268 angle = deg2rad(angle);
269 cos_theta = cos(angle);
270 sin_theta = sin(angle);
271
272 rotate[0] = cos_theta;
273 rotate[1] = sin_theta;
274 rotate[2] = -sin_theta;
275 rotate[3] = cos_theta;
276 rotate[4] = 0.0;
277 rotate[5] = 0.0;
278
279 if(order == MatrixOrderAppend)
280 matrix_multiply(matrix->matrix, rotate, matrix->matrix);
281 else if (order == MatrixOrderPrepend)
282 matrix_multiply(rotate, matrix->matrix, matrix->matrix);
283 else
284 return InvalidParameter;
285
286 return Ok;
287 }
288
289 GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix *matrix, REAL scaleX, REAL scaleY,
290 GpMatrixOrder order)
291 {
292 REAL scale[6];
293
294 TRACE("(%p, %.2f, %.2f, %d)\n", matrix, scaleX, scaleY, order);
295
296 if(!matrix)
297 return InvalidParameter;
298
299 scale[0] = scaleX;
300 scale[1] = 0.0;
301 scale[2] = 0.0;
302 scale[3] = scaleY;
303 scale[4] = 0.0;
304 scale[5] = 0.0;
305
306 if(order == MatrixOrderAppend)
307 matrix_multiply(matrix->matrix, scale, matrix->matrix);
308 else if (order == MatrixOrderPrepend)
309 matrix_multiply(scale, matrix->matrix, matrix->matrix);
310 else
311 return InvalidParameter;
312
313 return Ok;
314 }
315
316 GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12,
317 REAL m21, REAL m22, REAL dx, REAL dy)
318 {
319 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", matrix, m11, m12,
320 m21, m22, dx, dy);
321
322 if(!matrix)
323 return InvalidParameter;
324
325 matrix->matrix[0] = m11;
326 matrix->matrix[1] = m12;
327 matrix->matrix[2] = m21;
328 matrix->matrix[3] = m22;
329 matrix->matrix[4] = dx;
330 matrix->matrix[5] = dy;
331
332 return Ok;
333 }
334
335 GpStatus WINGDIPAPI GdipShearMatrix(GpMatrix *matrix, REAL shearX, REAL shearY,
336 GpMatrixOrder order)
337 {
338 REAL shear[6];
339
340 TRACE("(%p, %.2f, %.2f, %d)\n", matrix, shearX, shearY, order);
341
342 if(!matrix)
343 return InvalidParameter;
344
345 /* prepare transformation matrix */
346 shear[0] = 1.0;
347 shear[1] = shearY;
348 shear[2] = shearX;
349 shear[3] = 1.0;
350 shear[4] = 0.0;
351 shear[5] = 0.0;
352
353 if(order == MatrixOrderAppend)
354 matrix_multiply(matrix->matrix, shear, matrix->matrix);
355 else if (order == MatrixOrderPrepend)
356 matrix_multiply(shear, matrix->matrix, matrix->matrix);
357 else
358 return InvalidParameter;
359
360 return Ok;
361 }
362
363 GpStatus WINGDIPAPI GdipTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts,
364 INT count)
365 {
366 REAL x, y;
367 INT i;
368
369 TRACE("(%p, %p, %d)\n", matrix, pts, count);
370
371 if(!matrix || !pts || count <= 0)
372 return InvalidParameter;
373
374 for(i = 0; i < count; i++)
375 {
376 x = pts[i].X;
377 y = pts[i].Y;
378
379 pts[i].X = x * matrix->matrix[0] + y * matrix->matrix[2] + matrix->matrix[4];
380 pts[i].Y = x * matrix->matrix[1] + y * matrix->matrix[3] + matrix->matrix[5];
381 }
382
383 return Ok;
384 }
385
386 GpStatus WINGDIPAPI GdipTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count)
387 {
388 GpPointF *ptsF;
389 GpStatus ret;
390 INT i;
391
392 TRACE("(%p, %p, %d)\n", matrix, pts, count);
393
394 if(count <= 0)
395 return InvalidParameter;
396
397 ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
398 if(!ptsF)
399 return OutOfMemory;
400
401 for(i = 0; i < count; i++){
402 ptsF[i].X = (REAL)pts[i].X;
403 ptsF[i].Y = (REAL)pts[i].Y;
404 }
405
406 ret = GdipTransformMatrixPoints(matrix, ptsF, count);
407
408 if(ret == Ok)
409 for(i = 0; i < count; i++){
410 pts[i].X = gdip_round(ptsF[i].X);
411 pts[i].Y = gdip_round(ptsF[i].Y);
412 }
413 heap_free(ptsF);
414
415 return ret;
416 }
417
418 GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix *matrix, REAL offsetX,
419 REAL offsetY, GpMatrixOrder order)
420 {
421 REAL translate[6];
422
423 TRACE("(%p, %.2f, %.2f, %d)\n", matrix, offsetX, offsetY, order);
424
425 if(!matrix)
426 return InvalidParameter;
427
428 translate[0] = 1.0;
429 translate[1] = 0.0;
430 translate[2] = 0.0;
431 translate[3] = 1.0;
432 translate[4] = offsetX;
433 translate[5] = offsetY;
434
435 if(order == MatrixOrderAppend)
436 matrix_multiply(matrix->matrix, translate, matrix->matrix);
437 else if (order == MatrixOrderPrepend)
438 matrix_multiply(translate, matrix->matrix, matrix->matrix);
439 else
440 return InvalidParameter;
441
442 return Ok;
443 }
444
445 GpStatus WINGDIPAPI GdipVectorTransformMatrixPoints(GpMatrix *matrix, GpPointF *pts, INT count)
446 {
447 REAL x, y;
448 INT i;
449
450 TRACE("(%p, %p, %d)\n", matrix, pts, count);
451
452 if(!matrix || !pts || count <= 0)
453 return InvalidParameter;
454
455 for(i = 0; i < count; i++)
456 {
457 x = pts[i].X;
458 y = pts[i].Y;
459
460 pts[i].X = x * matrix->matrix[0] + y * matrix->matrix[2];
461 pts[i].Y = x * matrix->matrix[1] + y * matrix->matrix[3];
462 }
463
464 return Ok;
465 }
466
467 GpStatus WINGDIPAPI GdipVectorTransformMatrixPointsI(GpMatrix *matrix, GpPoint *pts, INT count)
468 {
469 GpPointF *ptsF;
470 GpStatus ret;
471 INT i;
472
473 TRACE("(%p, %p, %d)\n", matrix, pts, count);
474
475 if(count <= 0)
476 return InvalidParameter;
477
478 ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
479 if(!ptsF)
480 return OutOfMemory;
481
482 for(i = 0; i < count; i++){
483 ptsF[i].X = (REAL)pts[i].X;
484 ptsF[i].Y = (REAL)pts[i].Y;
485 }
486
487 ret = GdipVectorTransformMatrixPoints(matrix, ptsF, count);
488 /* store back */
489 if(ret == Ok)
490 for(i = 0; i < count; i++){
491 pts[i].X = gdip_round(ptsF[i].X);
492 pts[i].Y = gdip_round(ptsF[i].Y);
493 }
494 heap_free(ptsF);
495
496 return ret;
497 }
498
499 GpStatus WINGDIPAPI GdipIsMatrixEqual(GDIPCONST GpMatrix *matrix, GDIPCONST GpMatrix *matrix2,
500 BOOL *result)
501 {
502 TRACE("(%p, %p, %p)\n", matrix, matrix2, result);
503
504 if(!matrix || !matrix2 || !result)
505 return InvalidParameter;
506 /* based on single array member of GpMatrix */
507 *result = (memcmp(matrix->matrix, matrix2->matrix, sizeof(GpMatrix)) == 0);
508
509 return Ok;
510 }
511
512 GpStatus WINGDIPAPI GdipIsMatrixIdentity(GDIPCONST GpMatrix *matrix, BOOL *result)
513 {
514 static const GpMatrix identity =
515 {
516 { 1.0, 0.0,
517 0.0, 1.0,
518 0.0, 0.0 }
519 };
520
521 TRACE("(%p, %p)\n", matrix, result);
522
523 if(!matrix || !result)
524 return InvalidParameter;
525
526 return GdipIsMatrixEqual(matrix, &identity, result);
527 }