1 /*
2 * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.java2d.marlin;
27
28 import sun.awt.geom.PathConsumer2D;
29 import java.awt.geom.AffineTransform;
30 import java.awt.geom.Path2D;
31
32 final class TransformingPathConsumer2D {
33
34 TransformingPathConsumer2D() {
35 // used by RendererContext
36 }
37
38 // recycled PathConsumer2D instance from transformConsumer()
39 private final Path2DWrapper wp_Path2DWrapper = new Path2DWrapper();
40
41 PathConsumer2D wrapPath2d(Path2D.Float p2d)
42 {
43 return wp_Path2DWrapper.init(p2d);
44 }
45
46 // recycled PathConsumer2D instances from transformConsumer()
47 private final TranslateFilter tx_TranslateFilter = new TranslateFilter();
48 private final DeltaScaleFilter tx_DeltaScaleFilter = new DeltaScaleFilter();
49 private final ScaleFilter tx_ScaleFilter = new ScaleFilter();
50 private final DeltaTransformFilter tx_DeltaTransformFilter = new DeltaTransformFilter();
51 private final TransformFilter tx_TransformFilter = new TransformFilter();
52
53 PathConsumer2D transformConsumer(PathConsumer2D out,
54 AffineTransform at)
55 {
56 if (at == null) {
57 return out;
58 }
59 float mxx = (float) at.getScaleX();
60 float mxy = (float) at.getShearX();
61 float mxt = (float) at.getTranslateX();
62 float myx = (float) at.getShearY();
63 float myy = (float) at.getScaleY();
64 float myt = (float) at.getTranslateY();
65 if (mxy == 0f && myx == 0f) {
66 if (mxx == 1f && myy == 1f) {
67 if (mxt == 0f && myt == 0f) {
68 return out;
69 } else {
70 return tx_TranslateFilter.init(out, mxt, myt);
71 }
72 } else {
73 if (mxt == 0f && myt == 0f) {
74 return tx_DeltaScaleFilter.init(out, mxx, myy);
75 } else {
76 return tx_ScaleFilter.init(out, mxx, myy, mxt, myt);
77 }
78 }
79 } else if (mxt == 0f && myt == 0f) {
80 return tx_DeltaTransformFilter.init(out, mxx, mxy, myx, myy);
81 } else {
82 return tx_TransformFilter.init(out, mxx, mxy, mxt, myx, myy, myt);
83 }
84 }
85
86 // recycled PathConsumer2D instances from deltaTransformConsumer()
87 private final DeltaScaleFilter dt_DeltaScaleFilter = new DeltaScaleFilter();
88 private final DeltaTransformFilter dt_DeltaTransformFilter = new DeltaTransformFilter();
89
90 PathConsumer2D deltaTransformConsumer(PathConsumer2D out,
91 AffineTransform at)
92 {
93 if (at == null) {
94 return out;
95 }
96 float mxx = (float) at.getScaleX();
97 float mxy = (float) at.getShearX();
98 float myx = (float) at.getShearY();
99 float myy = (float) at.getScaleY();
100 if (mxy == 0f && myx == 0f) {
101 if (mxx == 1f && myy == 1f) {
102 return out;
103 } else {
104 return dt_DeltaScaleFilter.init(out, mxx, myy);
105 }
106 } else {
107 return dt_DeltaTransformFilter.init(out, mxx, mxy, myx, myy);
108 }
109 }
110
111 // recycled PathConsumer2D instances from inverseDeltaTransformConsumer()
112 private final DeltaScaleFilter iv_DeltaScaleFilter = new DeltaScaleFilter();
113 private final DeltaTransformFilter iv_DeltaTransformFilter = new DeltaTransformFilter();
114
115 PathConsumer2D inverseDeltaTransformConsumer(PathConsumer2D out,
116 AffineTransform at)
117 {
118 if (at == null) {
119 return out;
120 }
121 float mxx = (float) at.getScaleX();
122 float mxy = (float) at.getShearX();
123 float myx = (float) at.getShearY();
124 float myy = (float) at.getScaleY();
125 if (mxy == 0f && myx == 0f) {
126 if (mxx == 1f && myy == 1f) {
127 return out;
128 } else {
129 return iv_DeltaScaleFilter.init(out, 1.0f/mxx, 1.0f/myy);
130 }
131 } else {
132 float det = mxx * myy - mxy * myx;
133 return iv_DeltaTransformFilter.init(out,
134 myy / det,
135 -mxy / det,
136 -myx / det,
137 mxx / det);
138 }
139 }
140
141 static final class TranslateFilter implements PathConsumer2D {
142 private PathConsumer2D out;
143 private float tx, ty;
144
145 TranslateFilter() {}
146
147 TranslateFilter init(PathConsumer2D out,
148 float tx, float ty)
149 {
150 this.out = out;
151 this.tx = tx;
152 this.ty = ty;
153 return this; // fluent API
154 }
155
156 @Override
157 public void moveTo(float x0, float y0) {
158 out.moveTo(x0 + tx, y0 + ty);
159 }
160
161 @Override
162 public void lineTo(float x1, float y1) {
163 out.lineTo(x1 + tx, y1 + ty);
164 }
165
166 @Override
167 public void quadTo(float x1, float y1,
168 float x2, float y2)
169 {
170 out.quadTo(x1 + tx, y1 + ty,
171 x2 + tx, y2 + ty);
172 }
173
174 @Override
175 public void curveTo(float x1, float y1,
176 float x2, float y2,
177 float x3, float y3)
178 {
179 out.curveTo(x1 + tx, y1 + ty,
180 x2 + tx, y2 + ty,
181 x3 + tx, y3 + ty);
182 }
183
184 @Override
185 public void closePath() {
186 out.closePath();
187 }
188
189 @Override
190 public void pathDone() {
191 out.pathDone();
192 }
193
194 @Override
195 public long getNativeConsumer() {
196 return 0;
197 }
198 }
199
200 static final class ScaleFilter implements PathConsumer2D {
201 private PathConsumer2D out;
202 private float sx, sy, tx, ty;
203
204 ScaleFilter() {}
205
206 ScaleFilter init(PathConsumer2D out,
207 float sx, float sy,
208 float tx, float ty)
209 {
210 this.out = out;
211 this.sx = sx;
212 this.sy = sy;
213 this.tx = tx;
214 this.ty = ty;
215 return this; // fluent API
216 }
217
218 @Override
219 public void moveTo(float x0, float y0) {
220 out.moveTo(x0 * sx + tx, y0 * sy + ty);
221 }
222
223 @Override
224 public void lineTo(float x1, float y1) {
225 out.lineTo(x1 * sx + tx, y1 * sy + ty);
226 }
227
228 @Override
229 public void quadTo(float x1, float y1,
230 float x2, float y2)
231 {
232 out.quadTo(x1 * sx + tx, y1 * sy + ty,
233 x2 * sx + tx, y2 * sy + ty);
234 }
235
236 @Override
237 public void curveTo(float x1, float y1,
238 float x2, float y2,
239 float x3, float y3)
240 {
241 out.curveTo(x1 * sx + tx, y1 * sy + ty,
242 x2 * sx + tx, y2 * sy + ty,
243 x3 * sx + tx, y3 * sy + ty);
244 }
245
246 @Override
247 public void closePath() {
248 out.closePath();
249 }
250
251 @Override
252 public void pathDone() {
253 out.pathDone();
254 }
255
256 @Override
257 public long getNativeConsumer() {
258 return 0;
259 }
260 }
261
262 static final class TransformFilter implements PathConsumer2D {
263 private PathConsumer2D out;
264 private float mxx, mxy, mxt, myx, myy, myt;
265
266 TransformFilter() {}
267
268 TransformFilter init(PathConsumer2D out,
269 float mxx, float mxy, float mxt,
270 float myx, float myy, float myt)
271 {
272 this.out = out;
273 this.mxx = mxx;
274 this.mxy = mxy;
275 this.mxt = mxt;
276 this.myx = myx;
277 this.myy = myy;
278 this.myt = myt;
279 return this; // fluent API
280 }
281
282 @Override
283 public void moveTo(float x0, float y0) {
284 out.moveTo(x0 * mxx + y0 * mxy + mxt,
285 x0 * myx + y0 * myy + myt);
286 }
287
288 @Override
289 public void lineTo(float x1, float y1) {
290 out.lineTo(x1 * mxx + y1 * mxy + mxt,
291 x1 * myx + y1 * myy + myt);
292 }
293
294 @Override
295 public void quadTo(float x1, float y1,
296 float x2, float y2)
297 {
298 out.quadTo(x1 * mxx + y1 * mxy + mxt,
299 x1 * myx + y1 * myy + myt,
300 x2 * mxx + y2 * mxy + mxt,
301 x2 * myx + y2 * myy + myt);
302 }
303
304 @Override
305 public void curveTo(float x1, float y1,
306 float x2, float y2,
307 float x3, float y3)
308 {
309 out.curveTo(x1 * mxx + y1 * mxy + mxt,
310 x1 * myx + y1 * myy + myt,
311 x2 * mxx + y2 * mxy + mxt,
312 x2 * myx + y2 * myy + myt,
313 x3 * mxx + y3 * mxy + mxt,
314 x3 * myx + y3 * myy + myt);
315 }
316
317 @Override
318 public void closePath() {
319 out.closePath();
320 }
321
322 @Override
323 public void pathDone() {
324 out.pathDone();
325 }
326
327 @Override
328 public long getNativeConsumer() {
329 return 0;
330 }
331 }
332
333 static final class DeltaScaleFilter implements PathConsumer2D {
334 private PathConsumer2D out;
335 private float sx, sy;
336
337 DeltaScaleFilter() {}
338
339 DeltaScaleFilter init(PathConsumer2D out,
340 float mxx, float myy)
341 {
342 this.out = out;
343 sx = mxx;
344 sy = myy;
345 return this; // fluent API
346 }
347
348 @Override
349 public void moveTo(float x0, float y0) {
350 out.moveTo(x0 * sx, y0 * sy);
351 }
352
353 @Override
354 public void lineTo(float x1, float y1) {
355 out.lineTo(x1 * sx, y1 * sy);
356 }
357
358 @Override
359 public void quadTo(float x1, float y1,
360 float x2, float y2)
361 {
362 out.quadTo(x1 * sx, y1 * sy,
363 x2 * sx, y2 * sy);
364 }
365
366 @Override
367 public void curveTo(float x1, float y1,
368 float x2, float y2,
369 float x3, float y3)
370 {
371 out.curveTo(x1 * sx, y1 * sy,
372 x2 * sx, y2 * sy,
373 x3 * sx, y3 * sy);
374 }
375
376 @Override
377 public void closePath() {
378 out.closePath();
379 }
380
381 @Override
382 public void pathDone() {
383 out.pathDone();
384 }
385
386 @Override
387 public long getNativeConsumer() {
388 return 0;
389 }
390 }
391
392 static final class DeltaTransformFilter implements PathConsumer2D {
393 private PathConsumer2D out;
394 private float mxx, mxy, myx, myy;
395
396 DeltaTransformFilter() {}
397
398 DeltaTransformFilter init(PathConsumer2D out,
399 float mxx, float mxy,
400 float myx, float myy)
401 {
402 this.out = out;
403 this.mxx = mxx;
404 this.mxy = mxy;
405 this.myx = myx;
406 this.myy = myy;
407 return this; // fluent API
408 }
409
410 @Override
411 public void moveTo(float x0, float y0) {
412 out.moveTo(x0 * mxx + y0 * mxy,
413 x0 * myx + y0 * myy);
414 }
415
416 @Override
417 public void lineTo(float x1, float y1) {
418 out.lineTo(x1 * mxx + y1 * mxy,
419 x1 * myx + y1 * myy);
420 }
421
422 @Override
423 public void quadTo(float x1, float y1,
424 float x2, float y2)
425 {
426 out.quadTo(x1 * mxx + y1 * mxy,
427 x1 * myx + y1 * myy,
428 x2 * mxx + y2 * mxy,
429 x2 * myx + y2 * myy);
430 }
431
432 @Override
433 public void curveTo(float x1, float y1,
434 float x2, float y2,
435 float x3, float y3)
436 {
437 out.curveTo(x1 * mxx + y1 * mxy,
438 x1 * myx + y1 * myy,
439 x2 * mxx + y2 * mxy,
440 x2 * myx + y2 * myy,
441 x3 * mxx + y3 * mxy,
442 x3 * myx + y3 * myy);
443 }
444
445 @Override
446 public void closePath() {
447 out.closePath();
448 }
449
450 @Override
451 public void pathDone() {
452 out.pathDone();
453 }
454
455 @Override
456 public long getNativeConsumer() {
457 return 0;
458 }
459 }
460
461 static final class Path2DWrapper implements PathConsumer2D {
462 private Path2D.Float p2d;
463
464 Path2DWrapper() {}
465
466 Path2DWrapper init(Path2D.Float p2d) {
467 this.p2d = p2d;
468 return this;
469 }
470
471 @Override
472 public void moveTo(float x0, float y0) {
473 p2d.moveTo(x0, y0);
474 }
475
476 @Override
477 public void lineTo(float x1, float y1) {
478 p2d.lineTo(x1, y1);
479 }
480
481 @Override
482 public void closePath() {
483 p2d.closePath();
484 }
485
486 @Override
487 public void pathDone() {}
488
489 @Override
490 public void curveTo(float x1, float y1,
491 float x2, float y2,
492 float x3, float y3)
493 {
494 p2d.curveTo(x1, y1, x2, y2, x3, y3);
495 }
496
497 @Override
498 public void quadTo(float x1, float y1, float x2, float y2) {
499 p2d.quadTo(x1, y1, x2, y2);
500 }
501
502 @Override
503 public long getNativeConsumer() {
504 throw new InternalError("Not using a native peer");
505 }
506 }
507 }