?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs: [] on the end of a struct field is a variable length array.
[haiku.git] / headers / libs / agg / agg_renderer_outline_image.h
blobdd48450edbd4fb962c9535106f82bdb9385ffba9
1 //----------------------------------------------------------------------------
2 // Anti-Grain Geometry - Version 2.4
3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
4 //
5 // Permission to copy, use, modify, sell and distribute this software
6 // is granted provided this copyright notice appears in all copies.
7 // This software is provided "as is" without express or implied
8 // warranty, and with no claim as to its suitability for any purpose.
9 //
10 //----------------------------------------------------------------------------
11 // Contact: mcseem@antigrain.com
12 // mcseemagg@yahoo.com
13 // http://www.antigrain.com
14 //----------------------------------------------------------------------------
15 #ifndef AGG_RENDERER_OUTLINE_IMAGE_INCLUDED
16 #define AGG_RENDERER_OUTLINE_IMAGE_INCLUDED
17
18 #include "agg_array.h"
19 #include "agg_math.h"
20 #include "agg_line_aa_basics.h"
21 #include "agg_dda_line.h"
22 #include "agg_rendering_buffer.h"
23 #include "agg_clip_liang_barsky.h"
24
25
26 namespace agg
27 {
28 //========================================================line_image_scale
29 template<class Source> class line_image_scale
30 {
31 public:
32 typedef typename Source::color_type color_type;
33
34 line_image_scale(const Source& src, double height) :
35 m_source(src),
36 m_height(height),
37 m_scale(src.height() / height)
38 {
39 }
40
41 double width() const { return m_source.width(); }
42 double height() const { return m_height; }
43
44 color_type pixel(int x, int y) const
45 {
46 double src_y = (y + 0.5) * m_scale - 0.5;
47 int h = m_source.height() - 1;
48 int y1 = ufloor(src_y);
49 int y2 = y1 + 1;
50 color_type pix1 = (y1 < 0) ? color_type::no_color() : m_source.pixel(x, y1);
51 color_type pix2 = (y2 > h) ? color_type::no_color() : m_source.pixel(x, y2);
52 return pix1.gradient(pix2, src_y - y1);
53 }
54
55 private:
56 line_image_scale(const line_image_scale<Source>&);
57 const line_image_scale<Source>& operator = (const line_image_scale<Source>&);
58
59 const Source& m_source;
60 double m_height;
61 double m_scale;
62 };
63
64
65
66 //======================================================line_image_pattern
67 template<class Filter> class line_image_pattern
68 {
69 public:
70 typedef Filter filter_type;
71 typedef typename filter_type::color_type color_type;
72
73 //--------------------------------------------------------------------
74 line_image_pattern(const Filter& filter) :
75 m_filter(&filter),
76 m_dilation(filter.dilation() + 1),
77 m_dilation_hr(m_dilation << line_subpixel_shift),
78 m_data(),
79 m_width(0),
80 m_height(0),
81 m_width_hr(0),
82 m_half_height_hr(0),
83 m_offset_y_hr(0)
84 {
85 }
86
87 // Create
88 //--------------------------------------------------------------------
89 template<class Source>
90 line_image_pattern(const Filter& filter, const Source& src) :
91 m_filter(&filter),
92 m_dilation(filter.dilation() + 1),
93 m_dilation_hr(m_dilation << line_subpixel_shift),
94 m_data(),
95 m_width(0),
96 m_height(0),
97 m_width_hr(0),
98 m_half_height_hr(0),
99 m_offset_y_hr(0)
100 {
101 create(src);
102 }
103
104 // Create
105 //--------------------------------------------------------------------
106 template<class Source> void create(const Source& src)
107 {
108 m_height = uceil(src.height());
109 m_width = uceil(src.width());
110 m_width_hr = uround(src.width() * line_subpixel_scale);
111 m_half_height_hr = uround(src.height() * line_subpixel_scale/2);
112 m_offset_y_hr = m_dilation_hr + m_half_height_hr - line_subpixel_scale/2;
113 m_half_height_hr += line_subpixel_scale/2;
114
115 m_data.resize((m_width + m_dilation * 2) * (m_height + m_dilation * 2));
116
117 m_buf.attach(&m_data[0], m_width + m_dilation * 2,
118 m_height + m_dilation * 2,
119 m_width + m_dilation * 2);
120 unsigned x, y;
121 color_type* d1;
122 color_type* d2;
123 for(y = 0; y < m_height; y++)
124 {
125 d1 = m_buf.row_ptr(y + m_dilation) + m_dilation;
126 for(x = 0; x < m_width; x++)
127 {
128 *d1++ = src.pixel(x, y);
129 }
130 }
131
132 const color_type* s1;
133 const color_type* s2;
134 for(y = 0; y < m_dilation; y++)
135 {
136 //s1 = m_buf.row_ptr(m_height + m_dilation - 1) + m_dilation;
137 //s2 = m_buf.row_ptr(m_dilation) + m_dilation;
138 d1 = m_buf.row_ptr(m_dilation + m_height + y) + m_dilation;
139 d2 = m_buf.row_ptr(m_dilation - y - 1) + m_dilation;
140 for(x = 0; x < m_width; x++)
141 {
142 //*d1++ = color_type(*s1++, 0);
143 //*d2++ = color_type(*s2++, 0);
144 *d1++ = color_type::no_color();
145 *d2++ = color_type::no_color();
146 }
147 }
148
149 unsigned h = m_height + m_dilation * 2;
150 for(y = 0; y < h; y++)
151 {
152 s1 = m_buf.row_ptr(y) + m_dilation;
153 s2 = m_buf.row_ptr(y) + m_dilation + m_width;
154 d1 = m_buf.row_ptr(y) + m_dilation + m_width;
155 d2 = m_buf.row_ptr(y) + m_dilation;
156
157 for(x = 0; x < m_dilation; x++)
158 {
159 *d1++ = *s1++;
160 *--d2 = *--s2;
161 }
162 }
163 }
164
165 //--------------------------------------------------------------------
166 int pattern_width() const { return m_width_hr; }
167 int line_width() const { return m_half_height_hr; }
168 double width() const { return m_height; }
169
170 //--------------------------------------------------------------------
171 void pixel(color_type* p, int x, int y) const
172 {
173 m_filter->pixel_high_res(m_buf.rows(),
174 p,
175 x % m_width_hr + m_dilation_hr,
176 y + m_offset_y_hr);
177 }
178
179 //--------------------------------------------------------------------
180 const filter_type& filter() const { return *m_filter; }
181
182 private:
183 line_image_pattern(const line_image_pattern<filter_type>&);
184 const line_image_pattern<filter_type>&
185 operator = (const line_image_pattern<filter_type>&);
186
187 protected:
188 row_ptr_cache<color_type> m_buf;
189 const filter_type* m_filter;
190 unsigned m_dilation;
191 int m_dilation_hr;
192 pod_array<color_type> m_data;
193 unsigned m_width;
194 unsigned m_height;
195 int m_width_hr;
196 int m_half_height_hr;
197 int m_offset_y_hr;
198 };
199
200
201
202
203
204
205 //=================================================line_image_pattern_pow2
206 template<class Filter> class line_image_pattern_pow2 :
207 public line_image_pattern<Filter>
208 {
209 public:
210 typedef Filter filter_type;
211 typedef typename filter_type::color_type color_type;
212 typedef line_image_pattern<Filter> base_type;
213
214 //--------------------------------------------------------------------
215 line_image_pattern_pow2(const Filter& filter) :
216 line_image_pattern<Filter>(filter), m_mask(line_subpixel_mask) {}
217
218 //--------------------------------------------------------------------
219 template<class Source>
220 line_image_pattern_pow2(const Filter& filter, const Source& src) :
221 line_image_pattern<Filter>(filter), m_mask(line_subpixel_mask)
222 {
223 create(src);
224 }
225
226 //--------------------------------------------------------------------
227 template<class Source> void create(const Source& src)
228 {
229 line_image_pattern<Filter>::create(src);
230 m_mask = 1;
231 while(m_mask < base_type::m_width)
232 {
233 m_mask <<= 1;
234 m_mask |= 1;
235 }
236 m_mask <<= line_subpixel_shift - 1;
237 m_mask |= line_subpixel_mask;
238 base_type::m_width_hr = m_mask + 1;
239 }
240
241 //--------------------------------------------------------------------
242 void pixel(color_type* p, int x, int y) const
243 {
244 base_type::m_filter->pixel_high_res(
245 base_type::m_buf.rows(),
246 p,
247 (x & m_mask) + base_type::m_dilation_hr,
248 y + base_type::m_offset_y_hr);
249 }
250 private:
251 unsigned m_mask;
252 };
253
254
255
256
257
258
259
260 //===================================================distance_interpolator4
261 class distance_interpolator4
262 {
263 public:
264 //---------------------------------------------------------------------
265 distance_interpolator4() {}
266 distance_interpolator4(int x1, int y1, int x2, int y2,
267 int sx, int sy, int ex, int ey,
268 int len, double scale, int x, int y) :
269 m_dx(x2 - x1),
270 m_dy(y2 - y1),
271 m_dx_start(line_mr(sx) - line_mr(x1)),
272 m_dy_start(line_mr(sy) - line_mr(y1)),
273 m_dx_end(line_mr(ex) - line_mr(x2)),
274 m_dy_end(line_mr(ey) - line_mr(y2)),
275
276 m_dist(iround(double(x + line_subpixel_scale/2 - x2) * double(m_dy) -
277 double(y + line_subpixel_scale/2 - y2) * double(m_dx))),
278
279 m_dist_start((line_mr(x + line_subpixel_scale/2) - line_mr(sx)) * m_dy_start -
280 (line_mr(y + line_subpixel_scale/2) - line_mr(sy)) * m_dx_start),
281
282 m_dist_end((line_mr(x + line_subpixel_scale/2) - line_mr(ex)) * m_dy_end -
283 (line_mr(y + line_subpixel_scale/2) - line_mr(ey)) * m_dx_end),
284 m_len(uround(len / scale))
285 {
286 double d = len * scale;
287 int dx = iround(((x2 - x1) << line_subpixel_shift) / d);
288 int dy = iround(((y2 - y1) << line_subpixel_shift) / d);
289 m_dx_pict = -dy;
290 m_dy_pict = dx;
291 m_dist_pict = ((x + line_subpixel_scale/2 - (x1 - dy)) * m_dy_pict -
292 (y + line_subpixel_scale/2 - (y1 + dx)) * m_dx_pict) >>
293 line_subpixel_shift;
294
295 m_dx <<= line_subpixel_shift;
296 m_dy <<= line_subpixel_shift;
297 m_dx_start <<= line_mr_subpixel_shift;
298 m_dy_start <<= line_mr_subpixel_shift;
299 m_dx_end <<= line_mr_subpixel_shift;
300 m_dy_end <<= line_mr_subpixel_shift;
301 }
302
303 //---------------------------------------------------------------------
304 void inc_x()
305 {
306 m_dist += m_dy;
307 m_dist_start += m_dy_start;
308 m_dist_pict += m_dy_pict;
309 m_dist_end += m_dy_end;
310 }
311
312 //---------------------------------------------------------------------
313 void dec_x()
314 {
315 m_dist -= m_dy;
316 m_dist_start -= m_dy_start;
317 m_dist_pict -= m_dy_pict;
318 m_dist_end -= m_dy_end;
319 }
320
321 //---------------------------------------------------------------------
322 void inc_y()
323 {
324 m_dist -= m_dx;
325 m_dist_start -= m_dx_start;
326 m_dist_pict -= m_dx_pict;
327 m_dist_end -= m_dx_end;
328 }
329
330 //---------------------------------------------------------------------
331 void dec_y()
332 {
333 m_dist += m_dx;
334 m_dist_start += m_dx_start;
335 m_dist_pict += m_dx_pict;
336 m_dist_end += m_dx_end;
337 }
338
339 //---------------------------------------------------------------------
340 void inc_x(int dy)
341 {
342 m_dist += m_dy;
343 m_dist_start += m_dy_start;
344 m_dist_pict += m_dy_pict;
345 m_dist_end += m_dy_end;
346 if(dy > 0)
347 {
348 m_dist -= m_dx;
349 m_dist_start -= m_dx_start;
350 m_dist_pict -= m_dx_pict;
351 m_dist_end -= m_dx_end;
352 }
353 if(dy < 0)
354 {
355 m_dist += m_dx;
356 m_dist_start += m_dx_start;
357 m_dist_pict += m_dx_pict;
358 m_dist_end += m_dx_end;
359 }
360 }
361
362 //---------------------------------------------------------------------
363 void dec_x(int dy)
364 {
365 m_dist -= m_dy;
366 m_dist_start -= m_dy_start;
367 m_dist_pict -= m_dy_pict;
368 m_dist_end -= m_dy_end;
369 if(dy > 0)
370 {
371 m_dist -= m_dx;
372 m_dist_start -= m_dx_start;
373 m_dist_pict -= m_dx_pict;
374 m_dist_end -= m_dx_end;
375 }
376 if(dy < 0)
377 {
378 m_dist += m_dx;
379 m_dist_start += m_dx_start;
380 m_dist_pict += m_dx_pict;
381 m_dist_end += m_dx_end;
382 }
383 }
384
385 //---------------------------------------------------------------------
386 void inc_y(int dx)
387 {
388 m_dist -= m_dx;
389 m_dist_start -= m_dx_start;
390 m_dist_pict -= m_dx_pict;
391 m_dist_end -= m_dx_end;
392 if(dx > 0)
393 {
394 m_dist += m_dy;
395 m_dist_start += m_dy_start;
396 m_dist_pict += m_dy_pict;
397 m_dist_end += m_dy_end;
398 }
399 if(dx < 0)
400 {
401 m_dist -= m_dy;
402 m_dist_start -= m_dy_start;
403 m_dist_pict -= m_dy_pict;
404 m_dist_end -= m_dy_end;
405 }
406 }
407
408 //---------------------------------------------------------------------
409 void dec_y(int dx)
410 {
411 m_dist += m_dx;
412 m_dist_start += m_dx_start;
413 m_dist_pict += m_dx_pict;
414 m_dist_end += m_dx_end;
415 if(dx > 0)
416 {
417 m_dist += m_dy;
418 m_dist_start += m_dy_start;
419 m_dist_pict += m_dy_pict;
420 m_dist_end += m_dy_end;
421 }
422 if(dx < 0)
423 {
424 m_dist -= m_dy;
425 m_dist_start -= m_dy_start;
426 m_dist_pict -= m_dy_pict;
427 m_dist_end -= m_dy_end;
428 }
429 }
430
431 //---------------------------------------------------------------------
432 int dist() const { return m_dist; }
433 int dist_start() const { return m_dist_start; }
434 int dist_pict() const { return m_dist_pict; }
435 int dist_end() const { return m_dist_end; }
436
437 //---------------------------------------------------------------------
438 int dx() const { return m_dx; }
439 int dy() const { return m_dy; }
440 int dx_start() const { return m_dx_start; }
441 int dy_start() const { return m_dy_start; }
442 int dx_pict() const { return m_dx_pict; }
443 int dy_pict() const { return m_dy_pict; }
444 int dx_end() const { return m_dx_end; }
445 int dy_end() const { return m_dy_end; }
446 int len() const { return m_len; }
447
448 private:
449 //---------------------------------------------------------------------
450 int m_dx;
451 int m_dy;
452 int m_dx_start;
453 int m_dy_start;
454 int m_dx_pict;
455 int m_dy_pict;
456 int m_dx_end;
457 int m_dy_end;
458
459 int m_dist;
460 int m_dist_start;
461 int m_dist_pict;
462 int m_dist_end;
463 int m_len;
464 };
465
466
467
468
469
470 //==================================================line_interpolator_image
471 template<class Renderer> class line_interpolator_image
472 {
473 public:
474 typedef Renderer renderer_type;
475 typedef typename Renderer::color_type color_type;
476
477 //---------------------------------------------------------------------
478 enum max_half_width_e
479 {
480 max_half_width = 64
481 };
482
483 //---------------------------------------------------------------------
484 line_interpolator_image(renderer_type& ren, const line_parameters& lp,
485 int sx, int sy, int ex, int ey,
486 int pattern_start,
487 double scale_x) :
488 m_lp(lp),
489 m_li(lp.vertical ? line_dbl_hr(lp.x2 - lp.x1) :
490 line_dbl_hr(lp.y2 - lp.y1),
491 lp.vertical ? abs(lp.y2 - lp.y1) :
492 abs(lp.x2 - lp.x1) + 1),
493 m_di(lp.x1, lp.y1, lp.x2, lp.y2, sx, sy, ex, ey, lp.len, scale_x,
494 lp.x1 & ~line_subpixel_mask, lp.y1 & ~line_subpixel_mask),
495 m_ren(ren),
496 m_x(lp.x1 >> line_subpixel_shift),
497 m_y(lp.y1 >> line_subpixel_shift),
498 m_old_x(m_x),
499 m_old_y(m_y),
500 m_count((lp.vertical ? abs((lp.y2 >> line_subpixel_shift) - m_y) :
501 abs((lp.x2 >> line_subpixel_shift) - m_x))),
502 m_width(ren.subpixel_width()),
503 //m_max_extent(m_width >> (line_subpixel_shift - 2)),
504 m_max_extent((m_width + line_subpixel_scale) >> line_subpixel_shift),
505 m_start(pattern_start + (m_max_extent + 2) * ren.pattern_width()),
506 m_step(0)
507 {
508 agg::dda2_line_interpolator li(0, lp.vertical ?
509 (lp.dy << agg::line_subpixel_shift) :
510 (lp.dx << agg::line_subpixel_shift),
511 lp.len);
512
513 unsigned i;
514 int stop = m_width + line_subpixel_scale * 2;
515 for(i = 0; i < max_half_width; ++i)
516 {
517 m_dist_pos[i] = li.y();
518 if(m_dist_pos[i] >= stop) break;
519 ++li;
520 }
521 m_dist_pos[i] = 0x7FFF0000;
522
523 int dist1_start;
524 int dist2_start;
525 int npix = 1;
526
527 if(lp.vertical)
528 {
529 do
530 {
531 --m_li;
532 m_y -= lp.inc;
533 m_x = (m_lp.x1 + m_li.y()) >> line_subpixel_shift;
534
535 if(lp.inc > 0) m_di.dec_y(m_x - m_old_x);
536 else m_di.inc_y(m_x - m_old_x);
537
538 m_old_x = m_x;
539
540 dist1_start = dist2_start = m_di.dist_start();
541
542 int dx = 0;
543 if(dist1_start < 0) ++npix;
544 do
545 {
546 dist1_start += m_di.dy_start();
547 dist2_start -= m_di.dy_start();
548 if(dist1_start < 0) ++npix;
549 if(dist2_start < 0) ++npix;
550 ++dx;
551 }
552 while(m_dist_pos[dx] <= m_width);
553 if(npix == 0) break;
554
555 npix = 0;
556 }
557 while(--m_step >= -m_max_extent);
558 }
559 else
560 {
561 do
562 {
563 --m_li;
564
565 m_x -= lp.inc;
566 m_y = (m_lp.y1 + m_li.y()) >> line_subpixel_shift;
567
568 if(lp.inc > 0) m_di.dec_x(m_y - m_old_y);
569 else m_di.inc_x(m_y - m_old_y);
570
571 m_old_y = m_y;
572
573 dist1_start = dist2_start = m_di.dist_start();
574
575 int dy = 0;
576 if(dist1_start < 0) ++npix;
577 do
578 {
579 dist1_start -= m_di.dx_start();
580 dist2_start += m_di.dx_start();
581 if(dist1_start < 0) ++npix;
582 if(dist2_start < 0) ++npix;
583 ++dy;
584 }
585 while(m_dist_pos[dy] <= m_width);
586 if(npix == 0) break;
587
588 npix = 0;
589 }
590 while(--m_step >= -m_max_extent);
591 }
592 m_li.adjust_forward();
593 m_step -= m_max_extent;
594 }
595
596 //---------------------------------------------------------------------
597 bool step_hor()
598 {
599 ++m_li;
600 m_x += m_lp.inc;
601 m_y = (m_lp.y1 + m_li.y()) >> line_subpixel_shift;
602
603 if(m_lp.inc > 0) m_di.inc_x(m_y - m_old_y);
604 else m_di.dec_x(m_y - m_old_y);
605
606 m_old_y = m_y;
607
608 int s1 = m_di.dist() / m_lp.len;
609 int s2 = -s1;
610
611 if(m_lp.inc < 0) s1 = -s1;
612
613 int dist_start;
614 int dist_pict;
615 int dist_end;
616 int dy;
617 int dist;
618
619 dist_start = m_di.dist_start();
620 dist_pict = m_di.dist_pict() + m_start;
621 dist_end = m_di.dist_end();
622 color_type* p0 = m_colors + max_half_width + 2;
623 color_type* p1 = p0;
624
625 int npix = 0;
626 p1->clear();
627 if(dist_end > 0)
628 {
629 if(dist_start <= 0)
630 {
631 m_ren.pixel(p1, dist_pict, s2);
632 }
633 ++npix;
634 }
635 ++p1;
636
637 dy = 1;
638 while((dist = m_dist_pos[dy]) - s1 <= m_width)
639 {
640 dist_start -= m_di.dx_start();
641 dist_pict -= m_di.dx_pict();
642 dist_end -= m_di.dx_end();
643 p1->clear();
644 if(dist_end > 0 && dist_start <= 0)
645 {
646 if(m_lp.inc > 0) dist = -dist;
647 m_ren.pixel(p1, dist_pict, s2 - dist);
648 ++npix;
649 }
650 ++p1;
651 ++dy;
652 }
653
654 dy = 1;
655 dist_start = m_di.dist_start();
656 dist_pict = m_di.dist_pict() + m_start;
657 dist_end = m_di.dist_end();
658 while((dist = m_dist_pos[dy]) + s1 <= m_width)
659 {
660 dist_start += m_di.dx_start();
661 dist_pict += m_di.dx_pict();
662 dist_end += m_di.dx_end();
663 --p0;
664 p0->clear();
665 if(dist_end > 0 && dist_start <= 0)
666 {
667 if(m_lp.inc > 0) dist = -dist;
668 m_ren.pixel(p0, dist_pict, s2 + dist);
669 ++npix;
670 }
671 ++dy;
672 }
673 m_ren.blend_color_vspan(m_x,
674 m_y - dy + 1,
675 unsigned(p1 - p0),
676 p0);
677 return npix && ++m_step < m_count;
678 }
679
680
681
682 //---------------------------------------------------------------------
683 bool step_ver()
684 {
685 ++m_li;
686 m_y += m_lp.inc;
687 m_x = (m_lp.x1 + m_li.y()) >> line_subpixel_shift;
688
689 if(m_lp.inc > 0) m_di.inc_y(m_x - m_old_x);
690 else m_di.dec_y(m_x - m_old_x);
691
692 m_old_x = m_x;
693
694 int s1 = m_di.dist() / m_lp.len;
695 int s2 = -s1;
696
697 if(m_lp.inc > 0) s1 = -s1;
698
699 int dist_start;
700 int dist_pict;
701 int dist_end;
702 int dist;
703 int dx;
704
705 dist_start = m_di.dist_start();
706 dist_pict = m_di.dist_pict() + m_start;
707 dist_end = m_di.dist_end();
708 color_type* p0 = m_colors + max_half_width + 2;
709 color_type* p1 = p0;
710
711 int npix = 0;
712 p1->clear();
713 if(dist_end > 0)
714 {
715 if(dist_start <= 0)
716 {
717 m_ren.pixel(p1, dist_pict, s2);
718 }
719 ++npix;
720 }
721 ++p1;
722
723 dx = 1;
724 while((dist = m_dist_pos[dx]) - s1 <= m_width)
725 {
726 dist_start += m_di.dy_start();
727 dist_pict += m_di.dy_pict();
728 dist_end += m_di.dy_end();
729 p1->clear();
730 if(dist_end > 0 && dist_start <= 0)
731 {
732 if(m_lp.inc > 0) dist = -dist;
733 m_ren.pixel(p1, dist_pict, s2 + dist);
734 ++npix;
735 }
736 ++p1;
737 ++dx;
738 }
739
740 dx = 1;
741 dist_start = m_di.dist_start();
742 dist_pict = m_di.dist_pict() + m_start;
743 dist_end = m_di.dist_end();
744 while((dist = m_dist_pos[dx]) + s1 <= m_width)
745 {
746 dist_start -= m_di.dy_start();
747 dist_pict -= m_di.dy_pict();
748 dist_end -= m_di.dy_end();
749 --p0;
750 p0->clear();
751 if(dist_end > 0 && dist_start <= 0)
752 {
753 if(m_lp.inc > 0) dist = -dist;
754 m_ren.pixel(p0, dist_pict, s2 - dist);
755 ++npix;
756 }
757 ++dx;
758 }
759 m_ren.blend_color_hspan(m_x - dx + 1,
760 m_y,
761 unsigned(p1 - p0),
762 p0);
763 return npix && ++m_step < m_count;
764 }
765
766
767 //---------------------------------------------------------------------
768 int pattern_end() const { return m_start + m_di.len(); }
769
770 //---------------------------------------------------------------------
771 bool vertical() const { return m_lp.vertical; }
772 int width() const { return m_width; }
773 int count() const { return m_count; }
774
775 private:
776 line_interpolator_image(const line_interpolator_image<Renderer>&);
777 const line_interpolator_image<Renderer>&
778 operator = (const line_interpolator_image<Renderer>&);
779
780 protected:
781 const line_parameters& m_lp;
782 dda2_line_interpolator m_li;
783 distance_interpolator4 m_di;
784 renderer_type& m_ren;
785 int m_plen;
786 int m_x;
787 int m_y;
788 int m_old_x;
789 int m_old_y;
790 int m_count;
791 int m_width;
792 int m_max_extent;
793 int m_start;
794 int m_step;
795 int m_dist_pos[max_half_width + 1];
796 color_type m_colors[max_half_width * 2 + 4];
797 };
798
799
800
801
802
803
804
805
806 //===================================================renderer_outline_image
807 template<class BaseRenderer, class ImagePattern>
808 class renderer_outline_image
809 {
810 public:
811 //---------------------------------------------------------------------
812 typedef BaseRenderer base_ren_type;
813 typedef renderer_outline_image<BaseRenderer, ImagePattern> self_type;
814 typedef typename base_ren_type::color_type color_type;
815 typedef ImagePattern pattern_type;
816
817
818 //---------------------------------------------------------------------
819 renderer_outline_image(base_ren_type& ren, const pattern_type& patt) :
820 m_ren(&ren),
821 m_pattern(&patt),
822 m_start(0),
823 m_scale_x(1.0),
824 m_clip_box(0,0,0,0),
825 m_clipping(false)
826 {}
827 void attach(base_ren_type& ren) { m_ren = &ren; }
828
829 //---------------------------------------------------------------------
830 void pattern(const pattern_type& p) { m_pattern = &p; }
831 const pattern_type& pattern() const { return *m_pattern; }
832
833 //---------------------------------------------------------------------
834 void reset_clipping() { m_clipping = false; }
835 void clip_box(double x1, double y1, double x2, double y2)
836 {
837 m_clip_box.x1 = line_coord_sat::conv(x1);
838 m_clip_box.y1 = line_coord_sat::conv(y1);
839 m_clip_box.x2 = line_coord_sat::conv(x2);
840 m_clip_box.y2 = line_coord_sat::conv(y2);
841 m_clipping = true;
842 }
843
844 //---------------------------------------------------------------------
845 void scale_x(double s) { m_scale_x = s; }
846 double scale_x() const { return m_scale_x; }
847
848 //---------------------------------------------------------------------
849 void start_x(double s) { m_start = iround(s * line_subpixel_scale); }
850 double start_x() const { return double(m_start) / line_subpixel_scale; }
851
852 //---------------------------------------------------------------------
853 int subpixel_width() const { return m_pattern->line_width(); }
854 int pattern_width() const { return m_pattern->pattern_width(); }
855 double width() const { return double(subpixel_width()) / line_subpixel_scale; }
856
857 //-------------------------------------------------------------------------
858 void pixel(color_type* p, int x, int y) const
859 {
860 m_pattern->pixel(p, x, y);
861 }
862
863 //-------------------------------------------------------------------------
864 void blend_color_hspan(int x, int y, unsigned len, const color_type* colors)
865 {
866 m_ren->blend_color_hspan(x, y, len, colors, 0);
867 }
868
869 //-------------------------------------------------------------------------
870 void blend_color_vspan(int x, int y, unsigned len, const color_type* colors)
871 {
872 m_ren->blend_color_vspan(x, y, len, colors, 0);
873 }
874
875 //-------------------------------------------------------------------------
876 static bool accurate_join_only() { return true; }
877
878 //-------------------------------------------------------------------------
879 template<class Cmp>
880 void semidot(Cmp, int, int, int, int)
881 {
882 }
883
884 //-------------------------------------------------------------------------
885 void pie(int, int, int, int, int, int)
886 {
887 }
888
889 //-------------------------------------------------------------------------
890 void line0(const line_parameters&)
891 {
892 }
893
894 //-------------------------------------------------------------------------
895 void line1(const line_parameters&, int, int)
896 {
897 }
898
899 //-------------------------------------------------------------------------
900 void line2(const line_parameters&, int, int)
901 {
902 }
903
904 //-------------------------------------------------------------------------
905 void line3_no_clip(const line_parameters& lp,
906 int sx, int sy, int ex, int ey)
907 {
908 if(lp.len > line_max_length)
909 {
910 line_parameters lp1, lp2;
911 lp.divide(lp1, lp2);
912 int mx = lp1.x2 + (lp1.y2 - lp1.y1);
913 int my = lp1.y2 - (lp1.x2 - lp1.x1);
914 line3_no_clip(lp1, (lp.x1 + sx) >> 1, (lp.y1 + sy) >> 1, mx, my);
915 line3_no_clip(lp2, mx, my, (lp.x2 + ex) >> 1, (lp.y2 + ey) >> 1);
916 return;
917 }
918
919 fix_degenerate_bisectrix_start(lp, &sx, &sy);
920 fix_degenerate_bisectrix_end(lp, &ex, &ey);
921 line_interpolator_image<self_type> li(*this, lp,
922 sx, sy,
923 ex, ey,
924 m_start, m_scale_x);
925 if(li.vertical())
926 {
927 while(li.step_ver());
928 }
929 else
930 {
931 while(li.step_hor());
932 }
933 m_start += uround(lp.len / m_scale_x);
934 }
935
936 //-------------------------------------------------------------------------
937 void line3(const line_parameters& lp,
938 int sx, int sy, int ex, int ey)
939 {
940 if(m_clipping)
941 {
942 int x1 = lp.x1;
943 int y1 = lp.y1;
944 int x2 = lp.x2;
945 int y2 = lp.y2;
946 unsigned flags = clip_line_segment(&x1, &y1, &x2, &y2, m_clip_box);
947 int start = m_start;
948 if((flags & 4) == 0)
949 {
950 if(flags)
951 {
952 line_parameters lp2(x1, y1, x2, y2,
953 uround(calc_distance(x1, y1, x2, y2)));
954 if(flags & 1)
955 {
956 m_start += uround(calc_distance(lp.x1, lp.y1, x1, y1) / m_scale_x);
957 sx = x1 + (y2 - y1);
958 sy = y1 - (x2 - x1);
959 }
960 else
961 {
962 while(abs(sx - lp.x1) + abs(sy - lp.y1) > lp2.len)
963 {
964 sx = (lp.x1 + sx) >> 1;
965 sy = (lp.y1 + sy) >> 1;
966 }
967 }
968 if(flags & 2)
969 {
970 ex = x2 + (y2 - y1);
971 ey = y2 - (x2 - x1);
972 }
973 else
974 {
975 while(abs(ex - lp.x2) + abs(ey - lp.y2) > lp2.len)
976 {
977 ex = (lp.x2 + ex) >> 1;
978 ey = (lp.y2 + ey) >> 1;
979 }
980 }
981 line3_no_clip(lp2, sx, sy, ex, ey);
982 }
983 else
984 {
985 line3_no_clip(lp, sx, sy, ex, ey);
986 }
987 }
988 m_start = start + uround(lp.len / m_scale_x);
989 }
990 else
991 {
992 line3_no_clip(lp, sx, sy, ex, ey);
993 }
994 }
995
996 private:
997 base_ren_type* m_ren;
998 const pattern_type* m_pattern;
999 int m_start;
1000 double m_scale_x;
1001 rect_i m_clip_box;
1002 bool m_clipping;
1003 };
1004
1005
1006
1007
1008
1009 }
1010
1011
1012
1013 #endif
Clone of Haiku svn repository