16 #if GDISP_NEED_STARTUP_LOGO
17 #define GDISP_STARTUP_LOGO_TIMEOUT 1000
18 #define GDISP_STARTUP_LOGO_COLOR GFX_WHITE
20 #define GDISP_STARTUP_LOGO_TIMEOUT 0
27 #if GDISP_NEED_TIMERFLUSH
33 #if GDISP_NEED_MULTITHREAD
34 #define MUTEX_INIT(g) gfxMutexInit(&(g)->mutex)
35 #define MUTEX_ENTER(g) gfxMutexEnter(&(g)->mutex)
36 #define MUTEX_EXIT(g) gfxMutexExit(&(g)->mutex)
37 #define MUTEX_DEINIT(g) gfxMutexDestroy(&(g)->mutex)
40 #define MUTEX_ENTER(g)
42 #define MUTEX_DEINIT(g)
45 #define NEED_CLIPPING (GDISP_HARDWARE_CLIP != GFXON && (GDISP_NEED_VALIDATION || GDISP_NEED_CLIP))
48 #define TEST_CLIP_AREA(g)
49 #elif GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
50 #define TEST_CLIP_AREA(g) \
51 if (!gvmt(g)->setclip) { \
52 if ((g)->p.x < (g)->clipx0) { (g)->p.cx -= (g)->clipx0 - (g)->p.x; (g)->p.x = (g)->clipx0; } \
53 if ((g)->p.y < (g)->clipy0) { (g)->p.cy -= (g)->clipy0 - (g)->p.y; (g)->p.y = (g)->clipy0; } \
54 if ((g)->p.x + (g)->p.cx > (g)->clipx1) (g)->p.cx = (g)->clipx1 - (g)->p.x; \
55 if ((g)->p.y + (g)->p.cy > (g)->clipy1) (g)->p.cy = (g)->clipy1 - (g)->p.y; \
57 if ((g)->p.cx > 0 && (g)->p.cy > 0)
59 #define TEST_CLIP_AREA(g) \
60 if ((g)->p.x < (g)->clipx0) { (g)->p.cx -= (g)->clipx0 - (g)->p.x; (g)->p.x = (g)->clipx0; } \
61 if ((g)->p.y < (g)->clipy0) { (g)->p.cy -= (g)->clipy0 - (g)->p.y; (g)->p.y = (g)->clipy0; } \
62 if ((g)->p.x + (g)->p.cx > (g)->clipx1) (g)->p.cx = (g)->clipx1 - (g)->p.x; \
63 if ((g)->p.y + (g)->p.cy > (g)->clipy1) (g)->p.cy = (g)->clipy1 - (g)->p.y; \
64 if ((g)->p.cx > 0 && (g)->p.cy > 0)
71 #if GDISP_HARDWARE_STREAM_POS && GDISP_HARDWARE_STREAM_WRITE
72 static GFXINLINE void setglobalwindow(GDisplay *g) {
74 x = g->p.x; y = g->p.y;
76 g->p.cx = g->g.Width; g->p.cy = g->g.Height;
77 gdisp_lld_write_start(g);
78 g->p.x = x; g->p.y = y;
79 g->flags |= GDISP_FLG_SCRSTREAM;
83 #if GDISP_NEED_AUTOFLUSH && GDISP_HARDWARE_FLUSH == HARDWARE_AUTODETECT
84 #define autoflush_stopdone(g) if (gvmt(g)->flush) gdisp_lld_flush(g)
85 #elif GDISP_NEED_AUTOFLUSH && GDISP_HARDWARE_FLUSH
86 #define autoflush_stopdone(g) gdisp_lld_flush(g)
88 #define autoflush_stopdone(g)
91 #if GDISP_HARDWARE_STREAM_POS && GDISP_HARDWARE_STREAM_WRITE
92 #define autoflush(g) \
94 if ((g->flags & GDISP_FLG_SCRSTREAM)) { \
95 gdisp_lld_write_stop(g); \
96 g->flags &= ~GDISP_FLG_SCRSTREAM; \
98 autoflush_stopdone(g); \
101 #define autoflush(g) autoflush_stopdone(g)
108 static GFXINLINE void drawpixel(GDisplay *g) {
111 #if GDISP_HARDWARE_DRAWPIXEL
112 #if GDISP_HARDWARE_DRAWPIXEL == HARDWARE_AUTODETECT
116 gdisp_lld_draw_pixel(g);
122 #if GDISP_HARDWARE_DRAWPIXEL != GFXON && GDISP_HARDWARE_STREAM_POS && GDISP_HARDWARE_STREAM_WRITE
123 #if GDISP_HARDWARE_STREAM_POS == HARDWARE_AUTODETECT
124 if (gvmt(g)->writepos)
127 if (!(g->flags & GDISP_FLG_SCRSTREAM))
129 gdisp_lld_write_pos(g);
130 gdisp_lld_write_color(g);
136 #if GDISP_HARDWARE_DRAWPIXEL != GFXON && GDISP_HARDWARE_STREAM_POS != GFXON && GDISP_HARDWARE_STREAM_WRITE
142 g->p.cx = g->p.cy = 1;
143 gdisp_lld_write_start(g);
144 gdisp_lld_write_color(g);
145 gdisp_lld_write_stop(g);
155 static GFXINLINE void drawpixel_clip(GDisplay *g) {
156 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
157 if (!gvmt(g)->setclip)
160 if (g->p.x < g->clipx0 || g->p.x >= g->clipx1 || g->p.y < g->clipy0 || g->p.y >= g->clipy1)
166 #define drawpixel_clip(g) drawpixel(g)
174 static GFXINLINE void fillarea(GDisplay *g) {
177 #if GDISP_HARDWARE_FILLS
178 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
182 #if GDISP_HARDWARE_STREAM_POS && GDISP_HARDWARE_STREAM_WRITE
183 if ((g->flags & GDISP_FLG_SCRSTREAM)) {
184 gdisp_lld_write_stop(g);
185 g->flags &= ~GDISP_FLG_SCRSTREAM;
188 gdisp_lld_fill_area(g);
194 #if GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE
195 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
196 if (gvmt(g)->writestart)
201 #if GDISP_HARDWARE_STREAM_POS
202 if ((g->flags & GDISP_FLG_SCRSTREAM)) {
203 gdisp_lld_write_stop(g);
204 g->flags &= ~GDISP_FLG_SCRSTREAM;
208 area = (gU32)g->p.cx * g->p.cy;
209 gdisp_lld_write_start(g);
210 #if GDISP_HARDWARE_STREAM_POS
211 #if GDISP_HARDWARE_STREAM_POS == HARDWARE_AUTODETECT
212 if (gvmt(g)->writepos)
214 gdisp_lld_write_pos(g);
217 gdisp_lld_write_color(g);
218 gdisp_lld_write_stop(g);
224 #if GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_DRAWPIXEL
234 x1 = g->p.x + g->p.cx;
235 y1 = g->p.y + g->p.cy;
236 for(; g->p.y < y1; g->p.y++, g->p.x = x0)
237 for(; g->p.x < x1; g->p.x++)
238 gdisp_lld_draw_pixel(g);
249 static void hline_clip(GDisplay *g) {
251 if (g->p.x1 < g->p.x) {
252 g->p.cx = g->p.x; g->p.x = g->p.x1; g->p.x1 = g->p.cx;
257 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
258 if (!gvmt(g)->setclip)
261 if (g->p.y < g->clipy0 || g->p.y >= g->clipy1)
return;
262 if (g->p.x < g->clipx0) g->p.x = g->clipx0;
263 if (g->p.x1 >= g->clipx1) g->p.x1 = g->clipx1 - 1;
264 if (g->p.x1 < g->p.x)
return;
270 #if GDISP_HARDWARE_FILLS || (GDISP_HARDWARE_DRAWPIXEL && GDISP_HARDWARE_STREAM_WRITE)
272 if (g->p.x == g->p.x1) {
279 #if GDISP_HARDWARE_FILLS
280 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
284 g->p.cx = g->p.x1 - g->p.x + 1;
286 gdisp_lld_fill_area(g);
292 #if GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_POS && GDISP_HARDWARE_STREAM_WRITE
293 #if GDISP_HARDWARE_STREAM_POS == HARDWARE_AUTODETECT
294 if (gvmt(g)->writepos)
297 if (!(g->flags & GDISP_FLG_SCRSTREAM))
299 g->p.cx = g->p.x1 - g->p.x + 1;
300 gdisp_lld_write_pos(g);
301 do { gdisp_lld_write_color(g); }
while(--g->p.cx);
307 #if GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_POS != GFXON && GDISP_HARDWARE_STREAM_WRITE
308 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
309 if (gvmt(g)->writestart)
312 g->p.cx = g->p.x1 - g->p.x + 1;
314 gdisp_lld_write_start(g);
315 do { gdisp_lld_write_color(g); }
while(--g->p.cx);
316 gdisp_lld_write_stop(g);
322 #if GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_DRAWPIXEL
328 for(; g->p.x <= g->p.x1; g->p.x++)
329 gdisp_lld_draw_pixel(g);
337 static void vline_clip(GDisplay *g) {
339 if (g->p.y1 < g->p.y) {
340 g->p.cy = g->p.y; g->p.y = g->p.y1; g->p.y1 = g->p.cy;
345 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
346 if (!gvmt(g)->setclip)
349 if (g->p.x < g->clipx0 || g->p.x >= g->clipx1)
return;
350 if (g->p.y < g->clipy0) g->p.y = g->clipy0;
351 if (g->p.y1 >= g->clipy1) g->p.y1 = g->clipy1 - 1;
352 if (g->p.y1 < g->p.y)
return;
358 #if GDISP_HARDWARE_FILLS || (GDISP_HARDWARE_DRAWPIXEL && GDISP_HARDWARE_STREAM_WRITE) || (GDISP_HARDWARE_STREAM_POS && GDISP_HARDWARE_STREAM_WRITE)
360 if (g->p.y == g->p.y1) {
367 #if GDISP_HARDWARE_FILLS
368 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
372 #if GDISP_HARDWARE_STREAM_POS && GDISP_HARDWARE_STREAM_WRITE
373 if ((g->flags & GDISP_FLG_SCRSTREAM)) {
374 gdisp_lld_write_stop(g);
375 g->flags &= ~GDISP_FLG_SCRSTREAM;
378 g->p.cy = g->p.y1 - g->p.y + 1;
380 gdisp_lld_fill_area(g);
386 #if GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE
387 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
388 if (gvmt(g)->writestart)
391 #if GDISP_HARDWARE_STREAM_POS
392 if ((g->flags & GDISP_FLG_SCRSTREAM)) {
393 gdisp_lld_write_stop(g);
394 g->flags &= ~GDISP_FLG_SCRSTREAM;
397 g->p.cy = g->p.y1 - g->p.y + 1;
399 gdisp_lld_write_start(g);
400 #if GDISP_HARDWARE_STREAM_POS
401 #if GDISP_HARDWARE_STREAM_POS == HARDWARE_AUTODETECT
402 if (gvmt(g)->writepos)
404 gdisp_lld_write_pos(g);
406 do { gdisp_lld_write_color(g); }
while(--g->p.cy);
407 gdisp_lld_write_stop(g);
413 #if GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_DRAWPIXEL
419 for(; g->p.y <= g->p.y1; g->p.y++)
420 gdisp_lld_draw_pixel(g);
428 static void line_clip(GDisplay *g) {
434 if (g->p.y == g->p.y1) {
440 if (g->p.x == g->p.x1) {
453 if (g->p.x1 >= g->p.x) {
454 dx = g->p.x1 - g->p.x;
457 dx = g->p.x - g->p.x1;
460 if (g->p.y1 >= g->p.y) {
461 dy = g->p.y1 - g->p.y;
464 dy = g->p.y - g->p.y1;
473 for(i=0; i<=dx; ++i) {
489 for(i=0; i<=dy; ++i) {
503 #if GDISP_STARTUP_LOGO_TIMEOUT > 0
504 static gBool gdispInitDone;
505 static void StartupLogoDisplay(GDisplay *g) {
508 static const gCoord blks[] = {
533 w = g->g.Width/(8*4*2);
535 x = (g->g.Width - (8*4)*w)/2;
536 y = (g->g.Height - (16*1)*w)/2;
539 for(p = blks; p < blks+
sizeof(blks)/
sizeof(blks[0]); p+=4)
540 gdispGFillArea(g, x+p[0]*w, y+p[1]*w, p[2]*w, p[3]*w, GDISP_STARTUP_LOGO_COLOR);
544 #if GDISP_NEED_TIMERFLUSH
545 static void FlushTimerFn(
void *param) {
560 #if defined(GDISP_DRIVER_LIST)
563 extern const GDISPVMT GDISPVMT_OnlyOne[1];
566 void _gdispInit(
void)
569 #if defined(GDISP_DRIVER_LIST)
572 typedef const GDISPVMT
const GDISPVMTLIST[1];
576 for(i = 0; i <
sizeof(dclist)/
sizeof(dclist[0]); i++) {
577 if (!(dclist[i]->d.flags & GDISP_VFLG_DYNAMICONLY))
581 #elif GDISP_TOTAL_DISPLAYS > 1
585 if (!(GDISPVMT_OnlyOne->d.flags & GDISP_VFLG_DYNAMICONLY)) {
592 if (!(GDISPVMT_OnlyOne->d.flags & GDISP_VFLG_DYNAMICONLY))
598 #if GDISP_STARTUP_LOGO_TIMEOUT > 0
606 #if GDISP_HARDWARE_FLUSH
611 gdispInitDone = gTrue;
616 #if GDISP_NEED_TIMERFLUSH
622 void _gdispDeinit(
void)
627 gBool _gdispInitDriver(
GDriver *g,
void *param,
unsigned driverinstance,
unsigned systeminstance) {
628 #define gd ((GDisplay *)g)
632 gd->systemdisplay = systeminstance;
633 gd->controllerdisplay = driverinstance;
640 ret = gdisp_lld_init(gd);
647 void _gdispPostInitDriver(
GDriver *g) {
648 #define gd ((GDisplay *)g)
651 #if defined(GDISP_DEFAULT_ORIENTATION) && GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
652 #if GDISP_NEED_PIXMAP
654 if (!(gvmt(gd)->d.flags & GDISP_VFLG_PIXMAP))
656 gdispGControl(gd, GDISP_CONTROL_ORIENTATION, (
void *)GDISP_DEFAULT_ORIENTATION);
658 #if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
666 #if GDISP_STARTUP_LOGO_TIMEOUT > 0
668 StartupLogoDisplay(gd);
672 #if GDISP_HARDWARE_FLUSH
683 void _gdispDeInitDriver(
GDriver *g) {
684 #define gd ((GDisplay *)g)
689 #if GDISP_HARDWARE_DEINIT
690 #if GDISP_HARDWARE_DEINIT == HARDWARE_AUTODETECT
691 if (gvmt(gd)->deinit)
695 gdisp_lld_deinit(gd);
724 #if GDISP_HARDWARE_FLUSH
725 #if GDISP_HARDWARE_FLUSH == HARDWARE_AUTODETECT
738 #if GDISP_NEED_STREAMING
743 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
744 if (!gvmt(g)->setclip)
747 if (x < g->clipx0 || x+cx > g->clipx1 || y < g->clipy0 || y+cy > g->clipy1) {
753 g->flags |= GDISP_FLG_INSTREAM;
756 #if GDISP_HARDWARE_STREAM_WRITE
757 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
758 if (gvmt(g)->writestart)
765 gdisp_lld_write_start(g);
766 #if GDISP_HARDWARE_STREAM_POS
767 #if GDISP_HARDWARE_STREAM_POS == HARDWARE_AUTODETECT
768 if (gvmt(g)->writepos)
770 gdisp_lld_write_pos(g);
777 #if GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_DRAWPIXEL
784 g->p.x1 = g->p.x = x;
785 g->p.y1 = g->p.y = y;
788 #if (GDISP_LINEBUF_SIZE != 0 && GDISP_HARDWARE_BITFILLS) || GDISP_HARDWARE_FILLS
800 #if !GDISP_HARDWARE_STREAM_WRITE && GDISP_LINEBUF_SIZE != 0 && GDISP_HARDWARE_BITFILLS
807 if (!(g->flags & GDISP_FLG_INSTREAM))
811 #if GDISP_HARDWARE_STREAM_WRITE
812 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
813 if (gvmt(g)->writestart)
817 gdisp_lld_write_color(g);
823 #if GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_LINEBUF_SIZE != 0 && GDISP_HARDWARE_BITFILLS
824 #if GDISP_HARDWARE_BITFILLS == HARDWARE_AUTODETECT
828 g->linebuf[g->p.cx++] = color;
834 g->p.ptr = (
void *)g->linebuf;
835 gdisp_lld_blit_area(g);
843 if (g->p.x+g->p.cx >= g->p.x2) {
849 g->p.ptr = (
void *)g->linebuf;
850 gdisp_lld_blit_area(g);
856 if (++g->p.y >= g->p.y2)
863 #if GDISP_HARDWARE_STREAM_WRITE != GFXON && (GDISP_LINEBUF_SIZE == 0 || GDISP_HARDWARE_BITFILLS != GFXON) && GDISP_HARDWARE_FILLS
865 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
869 if (!g->p.cx || g->p.color == color) {
874 gdisp_lld_draw_pixel(g);
876 gdisp_lld_fill_area(g);
882 if (g->p.x+g->p.cx >= g->p.x2) {
885 gdisp_lld_draw_pixel(g);
887 gdisp_lld_fill_area(g);
891 if (++g->p.y >= g->p.y2)
899 #if GDISP_HARDWARE_STREAM_WRITE != GFXON && (GDISP_LINEBUF_SIZE == 0 || GDISP_HARDWARE_BITFILLS != GFXON) && GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_DRAWPIXEL
906 gdisp_lld_draw_pixel(g);
909 if (++g->p.x >= g->p.x2) {
911 if (++g->p.y >= g->p.y2)
921 if (!(g->flags & GDISP_FLG_INSTREAM))
925 g->flags &= ~GDISP_FLG_INSTREAM;
929 #if GDISP_HARDWARE_STREAM_WRITE
930 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
931 if (gvmt(g)->writestart)
934 gdisp_lld_write_stop(g);
935 autoflush_stopdone(g);
941 #if GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_LINEBUF_SIZE != 0 && GDISP_HARDWARE_BITFILLS
942 #if GDISP_HARDWARE_BITFILLS == HARDWARE_AUTODETECT
949 g->p.ptr = (
void *)g->linebuf;
950 gdisp_lld_blit_area(g);
952 autoflush_stopdone(g);
958 #if GDISP_HARDWARE_STREAM_WRITE != GFXON && (GDISP_LINEBUF_SIZE == 0 || GDISP_HARDWARE_BITFILLS != GFXON) && GDISP_HARDWARE_FILLS
960 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
966 gdisp_lld_draw_pixel(g);
968 gdisp_lld_fill_area(g);
970 autoflush_stopdone(g);
976 #if GDISP_HARDWARE_STREAM_WRITE != GFXON && (GDISP_LINEBUF_SIZE == 0 || GDISP_HARDWARE_BITFILLS != GFXON) && GDISP_HARDWARE_FILLS != GFXON
978 autoflush_stopdone(g);
1012 #if GDISP_HARDWARE_CLEARS
1013 #if GDISP_HARDWARE_CLEARS == HARDWARE_AUTODETECT
1019 autoflush_stopdone(g);
1026 #if GDISP_HARDWARE_CLEARS != GFXON && GDISP_HARDWARE_FILLS
1027 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
1031 g->p.x = g->p.y = 0;
1032 g->p.cx = g->g.Width;
1033 g->p.cy = g->g.Height;
1035 gdisp_lld_fill_area(g);
1036 autoflush_stopdone(g);
1043 #if GDISP_HARDWARE_CLEARS != GFXON && GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE
1044 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
1045 if (gvmt(g)->writestart)
1050 g->p.x = g->p.y = 0;
1051 g->p.cx = g->g.Width;
1052 g->p.cy = g->g.Height;
1054 area = (gU32)g->p.cx * g->p.cy;
1056 gdisp_lld_write_start(g);
1057 #if GDISP_HARDWARE_STREAM_POS
1058 #if GDISP_HARDWARE_STREAM_POS == HARDWARE_AUTODETECT
1059 if (gvmt(g)->writepos)
1061 gdisp_lld_write_pos(g);
1064 gdisp_lld_write_color(g);
1065 gdisp_lld_write_stop(g);
1066 autoflush_stopdone(g);
1073 #if GDISP_HARDWARE_CLEARS != GFXON && GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_DRAWPIXEL
1080 for(g->p.y = 0; g->p.y < g->g.Height; g->p.y++)
1081 for(g->p.x = 0; g->p.x < g->g.Width; g->p.x++)
1082 gdisp_lld_draw_pixel(g);
1083 autoflush_stopdone(g);
1100 autoflush_stopdone(g);
1108 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
1109 if (!gvmt(g)->setclip)
1113 if (x < g->clipx0) { cx -= g->clipx0 - x; srcx += g->clipx0 - x; x = g->clipx0; }
1114 if (y < g->clipy0) { cy -= g->clipy0 - y; srcy += g->clipy0 - x; y = g->clipy0; }
1115 if (x+cx > g->clipx1) cx = g->clipx1 - x;
1116 if (y+cy > g->clipy1) cy = g->clipy1 - y;
1117 if (srcx+cx > srccx) cx = srccx - srcx;
1118 if (cx <= 0 || cy <= 0) { MUTEX_EXIT(g);
return; }
1123 #if GDISP_HARDWARE_BITFILLS
1124 #if GDISP_HARDWARE_BITFILLS == HARDWARE_AUTODETECT
1135 g->p.ptr = (
void *)buffer;
1136 gdisp_lld_blit_area(g);
1137 autoflush_stopdone(g);
1144 #if GDISP_HARDWARE_BITFILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE
1145 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
1146 if (gvmt(g)->writestart)
1150 buffer += srcy*srccx+srcx;
1159 gdisp_lld_write_start(g);
1160 #if GDISP_HARDWARE_STREAM_POS
1161 #if GDISP_HARDWARE_STREAM_POS == HARDWARE_AUTODETECT
1162 if (gvmt(g)->writepos)
1164 gdisp_lld_write_pos(g);
1166 for(g->p.y = y; g->p.y < srcy; g->p.y++, buffer += srccx) {
1167 for(g->p.x = x; g->p.x < srcx; g->p.x++) {
1168 g->p.color = *buffer++;
1169 gdisp_lld_write_color(g);
1172 gdisp_lld_write_stop(g);
1173 autoflush_stopdone(g);
1180 #if GDISP_HARDWARE_BITFILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_FILLS
1182 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
1187 buffer += srcy*srccx+srcx;
1193 for(g->p.y = y; g->p.y < srcy; g->p.y++, buffer += srccx) {
1194 for(g->p.x=x; g->p.x < srcx; g->p.x += g->p.cx) {
1196 g->p.color = *buffer++;
1197 while(g->p.x+g->p.cx < srcx && *buffer == g->p.color) {
1202 gdisp_lld_draw_pixel(g);
1204 gdisp_lld_fill_area(g);
1208 autoflush_stopdone(g);
1215 #if GDISP_HARDWARE_BITFILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_DRAWPIXEL
1222 buffer += srcy*srccx+srcx;
1227 for(g->p.y = y; g->p.y < srcy; g->p.y++, buffer += srccx) {
1228 for(g->p.x=x; g->p.x < srcx; g->p.x++) {
1229 g->p.color = *buffer++;
1230 gdisp_lld_draw_pixel(g);
1233 autoflush_stopdone(g);
1240 #if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION
1245 #if GDISP_HARDWARE_CLIP
1246 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
1247 if (gvmt(g)->setclip)
1254 gdisp_lld_set_clip(g);
1256 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
1262 #if GDISP_HARDWARE_CLIP != GFXON
1264 if (x < 0) { cx += x; x = 0; }
1265 if (y < 0) { cy += y; y = 0; }
1266 if (cx <= 0 || cy <= 0 || x >= g->g.Width || y >= g->g.Height) { x = y = cx = cy = 0; }
1269 g->clipx1 = x+cx;
if (g->clipx1 > g->g.Width) g->clipx1 = g->g.Width;
1270 g->clipy1 = y+cy;
if (g->clipy1 > g->g.Height) g->clipy1 = g->g.Height;
1277 #if GDISP_NEED_CIRCLE
1291 g->p.x = x; g->p.y = y + b; drawpixel_clip(g);
1292 g->p.x = x; g->p.y = y - b; drawpixel_clip(g);
1293 g->p.x = x + b; g->p.y = y; drawpixel_clip(g);
1294 g->p.x = x - b; g->p.y = y; drawpixel_clip(g);
1296 g->p.x = x + a; g->p.y = y + b; drawpixel_clip(g);
1297 g->p.x = x + a; g->p.y = y - b; drawpixel_clip(g);
1298 g->p.x = x + b; g->p.y = y + a; drawpixel_clip(g);
1299 g->p.x = x - b; g->p.y = y + a; drawpixel_clip(g);
1300 g->p.x = x - a; g->p.y = y + b; drawpixel_clip(g);
1301 g->p.x = x - a; g->p.y = y - b; drawpixel_clip(g);
1302 g->p.x = x + b; g->p.y = y - a; drawpixel_clip(g);
1303 g->p.x = x - b; g->p.y = y - a; drawpixel_clip(g);
1307 P += 5 + 2*(a++ - b--);
1309 g->p.x = x + a; g->p.y = y + b; drawpixel_clip(g);
1310 g->p.x = x + a; g->p.y = y - b; drawpixel_clip(g);
1311 g->p.x = x - a; g->p.y = y + b; drawpixel_clip(g);
1312 g->p.x = x - a; g->p.y = y - b; drawpixel_clip(g);
1319 #if GDISP_NEED_CIRCLE
1333 g->p.y = y; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
1334 g->p.y = y+b; g->p.x = x; drawpixel_clip(g);
1335 g->p.y = y-b; g->p.x = x; drawpixel_clip(g);
1337 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
1338 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
1342 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
1343 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
1344 P += 5 + 2*(a++ - b--);
1347 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
1348 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
1355 #if GDISP_NEED_DUALCIRCLE
1357 #define DRAW_DUALLINE(yval, r1, r2) \
1359 g->p.x = x-r1; g->p.x1 = x-r2+1; hline_clip(g); \
1360 g->p.x = x-r2; g->p.x1 = x+r2; g->p.color = color2; hline_clip(g); \
1361 g->p.x = x+r2+1; g->p.x1 = x+r1; g->p.color = color1; hline_clip(g)
1362 #define DRAW_SINGLELINE(yval, r) g->p.y = yval; g->p.x = x-r; g->p.x1 = x+r; hline_clip(g)
1365 gCoord a, b1, b2, p1, p2;
1370 g->p.color = color1;
1371 a = 0; b1 = radius1; b2 = radius2; p1 = p2 = 1;
1373 DRAW_DUALLINE(y+a, b1, b2);
1374 DRAW_DUALLINE(y-a, b1, b2);
1375 if (p1 >= 0) p1 -= b1--;
1377 if (p2 >= 0) p2 -= b2--;
1383 DRAW_DUALLINE(y+a, b1, b2);
1384 DRAW_DUALLINE(y-a, b1, b2);
1385 if (p1 >= 0) p1 -= b1--;
1387 do { p2 -= --b2; }
while (p2+a >= b2);
1389 }
while(++a <= radius2 && a < b1);
1394 DRAW_DUALLINE(y+a, b1, b2);
1395 DRAW_DUALLINE(y-a, b1, b2);
1396 do { p1 -= --b1; }
while (p1+a >= b1);
1398 do { p2 -= --b2; }
while (p2+a >= b2);
1405 DRAW_SINGLELINE(y+a, b1);
1406 DRAW_SINGLELINE(y-a, b1);
1407 if (p1 >= 0) p1 -= b1--;
1410 DRAW_SINGLELINE(y+a, b1);
1411 DRAW_SINGLELINE(y-a, b1);
1415 a = 0; b1 = radius1; p1 = 1;
1418 DRAW_SINGLELINE(y+b1, a);
1419 DRAW_SINGLELINE(y-b1, a);
1423 }
while(b1 > radius2 && a < b1);
1428 #undef DRAW_DUALLINE
1429 #undef DRAW_SINGLELINE
1432 #if GDISP_NEED_ELLIPSE
1445 err = b2-(2*b-1)*a2;
1450 g->p.x = x + dx; g->p.y = y + dy; drawpixel_clip(g);
1451 g->p.x = x - dx; g->p.y = y + dy; drawpixel_clip(g);
1452 g->p.x = x - dx; g->p.y = y - dy; drawpixel_clip(g);
1453 g->p.x = x + dx; g->p.y = y - dy; drawpixel_clip(g);
1456 if(e2 < (2*dx+1)*b2) {
1460 if(e2 > -(2*dy-1)*a2) {
1471 #if GDISP_NEED_ELLIPSE
1484 err = b2-(2*b-1)*a2;
1491 if(e2 < (2*dx+1)*b2) {
1495 if(e2 > -(2*dy-1)*a2) {
1496 g->p.y = y + dy; g->p.x = x - dx; g->p.x1 = x + dx; hline_clip(g);
1497 if (y) { g->p.y = y - dy; g->p.x = x - dx; g->p.x1 = x + dx; hline_clip(g); }
1508 #if GDISP_NEED_ARCSECTORS
1522 if (sectors & 0x06) { g->p.x = x; g->p.y = y - b; drawpixel_clip(g); }
1523 if (sectors & 0x60) { g->p.x = x; g->p.y = y + b; drawpixel_clip(g); }
1524 if (sectors & 0x81) { g->p.x = x + b; g->p.y = y; drawpixel_clip(g); }
1525 if (sectors & 0x18) { g->p.x = x - b; g->p.y = y; drawpixel_clip(g); }
1528 if (sectors & 0x01) { g->p.x = x + b; g->p.y = y - a; drawpixel_clip(g); }
1529 if (sectors & 0x02) { g->p.x = x + a; g->p.y = y - b; drawpixel_clip(g); }
1530 if (sectors & 0x04) { g->p.x = x - a; g->p.y = y - b; drawpixel_clip(g); }
1531 if (sectors & 0x08) { g->p.x = x - b; g->p.y = y - a; drawpixel_clip(g); }
1532 if (sectors & 0x10) { g->p.x = x - b; g->p.y = y + a; drawpixel_clip(g); }
1533 if (sectors & 0x20) { g->p.x = x - a; g->p.y = y + b; drawpixel_clip(g); }
1534 if (sectors & 0x40) { g->p.x = x + a; g->p.y = y + b; drawpixel_clip(g); }
1535 if (sectors & 0x80) { g->p.x = x + b; g->p.y = y + a; drawpixel_clip(g); }
1539 P += 5 + 2*(a++ - b--);
1542 if (sectors & 0xC0) { g->p.x = x + a; g->p.y = y + b; drawpixel_clip(g); }
1543 if (sectors & 0x03) { g->p.x = x + a; g->p.y = y - b; drawpixel_clip(g); }
1544 if (sectors & 0x30) { g->p.x = x - a; g->p.y = y + b; drawpixel_clip(g); }
1545 if (sectors & 0x0C) { g->p.x = x - a; g->p.y = y - b; drawpixel_clip(g); }
1552 #if GDISP_NEED_ARCSECTORS
1566 if (sectors & 0x06) { g->p.x = x; g->p.y = y - b; drawpixel_clip(g); }
1567 if (sectors & 0x60) { g->p.x = x; g->p.y = y + b; drawpixel_clip(g); }
1568 if (sectors & 0x81) {
1569 g->p.y = y; g->p.x = x; g->p.x1 = x + b;
1570 if (sectors & 0x18) g->p.x -= b;
1572 }
else if (sectors & 0x18) {
1573 g->p.x = x - b; g->p.x1 = x; g->p.y = y;
1579 switch(sectors & 0x0F) {
1581 g->p.y = y - a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1584 g->p.y = y - b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1585 g->p.y = y - a; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1588 g->p.y = y - b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1589 g->p.y = y - a; g->p.x = x; g->p.x1 = x + b; hline_clip(g);
1592 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1593 g->p.y = y - a; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1596 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1597 g->p.y = y - a; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1598 g->p.y = y - a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1601 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1602 g->p.y = y - a; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1605 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1606 g->p.y = y - a; g->p.x = x - a; g->p.x1 = x + b; hline_clip(g);
1609 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1612 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1613 g->p.y = y - a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1616 g->p.y = y - b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1617 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1618 g->p.y = y - a; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1621 g->p.y = y - b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1622 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1623 g->p.y = y - a; g->p.x = x; g->p.x1 = x + b; hline_clip(g);
1626 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1627 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x; hline_clip(g);
1630 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1631 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x; hline_clip(g);
1632 g->p.y = y - a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1635 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1636 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x + a; hline_clip(g);
1639 g->p.y = y - b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1640 g->p.y = y - a; g->p.x = x - b; g->p.x1 = x + b; hline_clip(g);
1645 switch((sectors & 0xF0)>>4) {
1647 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1650 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1651 g->p.y = y + a; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1654 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1655 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x; hline_clip(g);
1658 g->p.y = y + b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1659 g->p.y = y + a; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1662 g->p.y = y + b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1663 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1664 g->p.y = y + a; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1667 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1668 g->p.y = y + a; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1671 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1672 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x + a; hline_clip(g);
1675 g->p.y = y + a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1678 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1679 g->p.y = y + a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1682 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1683 g->p.y = y + a; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1684 g->p.y = y + a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1687 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x; hline_clip(g);
1688 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x; hline_clip(g);
1689 g->p.y = y + a; g->p.x = x + a; g->p.x1 = x + b; hline_clip(g);
1692 g->p.y = y + b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1693 g->p.y = y + a; g->p.x = x; g->p.x1 = x + b; hline_clip(g);
1696 g->p.y = y + b; g->p.x = x; g->p.x1 = x + a; hline_clip(g);
1697 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x - a; hline_clip(g);
1698 g->p.y = y + a; g->p.x = x; g->p.x1 = x + b; hline_clip(g);
1701 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1702 g->p.y = y + a; g->p.x = x - a; g->p.x1 = x + b; hline_clip(g);
1705 g->p.y = y + b; g->p.x = x - a; g->p.x1 = x + a; hline_clip(g);
1706 g->p.y = y + a; g->p.x = x - b; g->p.x1 = x + b; hline_clip(g);
1713 P += 5 + 2*(a++ - b--);
1717 if (sectors & 0x02) { g->p.y = y - a; g->p.x = x; g->p.x1 = x + a; hline_clip(g); }
1718 else if (sectors & 0x01) { g->p.y = y - a; g->p.x = x + a; drawpixel_clip(g); }
1719 if (sectors & 0x04) { g->p.y = y - a; g->p.x = x - a; g->p.x1 = x; hline_clip(g); }
1720 else if (sectors & 0x08) { g->p.y = y - a; g->p.x = x - a; drawpixel_clip(g); }
1723 if (sectors & 0x40) { g->p.y = y + a; g->p.x = x; g->p.x1 = x + a; hline_clip(g); }
1724 else if (sectors & 0x80) { g->p.y = y + a; g->p.x = x + a; drawpixel_clip(g); }
1725 if (sectors & 0x20) { g->p.y = y + a; g->p.x = x - a; g->p.x1 = x; hline_clip(g); }
1726 else if (sectors & 0x10) { g->p.y = y + a; g->p.x = x - a; drawpixel_clip(g); }
1734 #if (!GMISC_NEED_FIXEDTRIG && !GMISC_NEED_FASTTRIG) || !GFX_USE_GMISC
1739 gCoord a, b, P, sedge, eedge;
1740 gU8 full, sbit, ebit, tbit;
1744 start -= (start/360-1)*360;
1745 else if (start >= 360)
1748 end -= (end/360-1)*360;
1749 else if (end >= 360)
1752 sbit = 1<<(start/45);
1757 }
else if (end < start) {
1758 for(tbit=sbit<<1; tbit; tbit<<=1) full |= tbit;
1759 for(tbit=ebit>>1; tbit; tbit>>=1) full |= tbit;
1760 }
else if (sbit < 0x80) {
1761 for(tbit=sbit<<1; tbit < ebit; tbit<<=1) full |= tbit;
1763 tbit = start%45 == 0 ? sbit : 0;
1774 if (full & 0x60) { g->p.y = y+b; g->p.x = x; drawpixel_clip(g); }
1775 if (full & 0x06) { g->p.y = y-b; g->p.x = x; drawpixel_clip(g); }
1776 if (full & 0x81) { g->p.y = y; g->p.x = x+b; drawpixel_clip(g); }
1777 if (full & 0x18) { g->p.y = y; g->p.x = x-b; drawpixel_clip(g); }
1779 if (full & 0x01) { g->p.x = x+b; g->p.y = y-a; drawpixel_clip(g); }
1780 if (full & 0x02) { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1781 if (full & 0x04) { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1782 if (full & 0x08) { g->p.x = x-b; g->p.y = y-a; drawpixel_clip(g); }
1783 if (full & 0x10) { g->p.x = x-b; g->p.y = y+a; drawpixel_clip(g); }
1784 if (full & 0x20) { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1785 if (full & 0x40) { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1786 if (full & 0x80) { g->p.x = x+b; g->p.y = y+a; drawpixel_clip(g); }
1790 P += 5 + 2*(a++ - b--);
1792 if (full & 0xC0) { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1793 if (full & 0x0C) { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1794 if (full & 0x03) { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1795 if (full & 0x30) { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1803 #if GFX_USE_GMISC && GMISC_NEED_FIXEDTRIG
1804 sedge = NONFIXED(radius * ((sbit & 0x99) ?
ffsin(start) : ffcos(start)) + FIXED0_5);
1805 eedge = NONFIXED(radius * ((ebit & 0x99) ?
ffsin(end) : ffcos(end)) + FIXED0_5);
1806 #elif GFX_USE_GMISC && GMISC_NEED_FASTTRIG
1807 sedge = floor(radius * ((sbit & 0x99) ?
fsin(start) : fcos(start)) + 0.5);
1808 eedge = floor(radius * ((ebit & 0x99) ?
fsin(end) : fcos(end)) + 0.5);
1810 sedge = floor(radius * ((sbit & 0x99) ? sin(start*GFX_PI/180) : cos(start*GFX_PI/180)) + 0.5);
1811 eedge = floor(radius * ((ebit & 0x99) ? sin(end*GFX_PI/180) : cos(end*GFX_PI/180)) + 0.5);
1813 if (sbit & 0xB4) sedge = -sedge;
1814 if (ebit & 0xB4) eedge = -eedge;
1822 if ((sbit & 0x20) || (tbit & 0x40) || (ebit & 0x40)) { g->p.x = x; g->p.y = y+b; drawpixel_clip(g); }
1823 if ((sbit & 0x02) || (tbit & 0x04) || (ebit & 0x04)) { g->p.x = x; g->p.y = y-b; drawpixel_clip(g); }
1824 if ((sbit & 0x80) || (tbit & 0x01) || (ebit & 0x01)) { g->p.x = x+b; g->p.y = y; drawpixel_clip(g); }
1825 if ((sbit & 0x08) || (tbit & 0x10) || (ebit & 0x10)) { g->p.x = x-b; g->p.y = y; drawpixel_clip(g); }
1827 if (((sbit & 0x01) && a >= sedge) || ((ebit & 0x01) && a <= eedge)) { g->p.x = x+b; g->p.y = y-a; drawpixel_clip(g); }
1828 if (((sbit & 0x02) && a <= sedge) || ((ebit & 0x02) && a >= eedge)) { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1829 if (((sbit & 0x04) && a >= sedge) || ((ebit & 0x04) && a <= eedge)) { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1830 if (((sbit & 0x08) && a <= sedge) || ((ebit & 0x08) && a >= eedge)) { g->p.x = x-b; g->p.y = y-a; drawpixel_clip(g); }
1831 if (((sbit & 0x10) && a >= sedge) || ((ebit & 0x10) && a <= eedge)) { g->p.x = x-b; g->p.y = y+a; drawpixel_clip(g); }
1832 if (((sbit & 0x20) && a <= sedge) || ((ebit & 0x20) && a >= eedge)) { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1833 if (((sbit & 0x40) && a >= sedge) || ((ebit & 0x40) && a <= eedge)) { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1834 if (((sbit & 0x80) && a <= sedge) || ((ebit & 0x80) && a >= eedge)) { g->p.x = x+b; g->p.y = y+a; drawpixel_clip(g); }
1838 P += 5 + 2*(a++ - b--);
1840 if (((sbit & 0x40) && a >= sedge) || ((ebit & 0x40) && a <= eedge) || ((sbit & 0x80) && a <= sedge) || ((ebit & 0x80) && a >= eedge))
1841 { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1842 if (((sbit & 0x04) && a >= sedge) || ((ebit & 0x04) && a <= eedge) || ((sbit & 0x08) && a <= sedge) || ((ebit & 0x08) && a >= eedge))
1843 { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1844 if (((sbit & 0x01) && a >= sedge) || ((ebit & 0x01) && a <= eedge) || ((sbit & 0x02) && a <= sedge) || ((ebit & 0x02) && a >= eedge))
1845 { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1846 if (((sbit & 0x10) && a >= sedge) || ((ebit & 0x10) && a <= eedge) || ((sbit & 0x20) && a <= sedge) || ((ebit & 0x20) && a >= eedge))
1847 { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1848 }
else if (end < start) {
1854 if ((sbit & 0x60) || (tbit & 0xC0)) { g->p.x = x; g->p.y = y+b; drawpixel_clip(g); }
1855 if ((sbit & 0x06) || (tbit & 0x0C)) { g->p.x = x; g->p.y = y-b; drawpixel_clip(g); }
1856 if ((sbit & 0x81) || (tbit & 0x03)) { g->p.x = x+b; g->p.y = y; drawpixel_clip(g); }
1857 if ((sbit & 0x18) || (tbit & 0x30)) { g->p.x = x-b; g->p.y = y; drawpixel_clip(g); }
1859 if ((sbit & 0x01) && (a >= sedge || a <= eedge)) { g->p.x = x+b; g->p.y = y-a; drawpixel_clip(g); }
1860 if ((sbit & 0x02) && (a <= sedge || a >= eedge)) { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1861 if ((sbit & 0x04) && (a >= sedge || a <= eedge)) { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1862 if ((sbit & 0x08) && (a <= sedge || a >= eedge)) { g->p.x = x-b; g->p.y = y-a; drawpixel_clip(g); }
1863 if ((sbit & 0x10) && (a >= sedge || a <= eedge)) { g->p.x = x-b; g->p.y = y+a; drawpixel_clip(g); }
1864 if ((sbit & 0x20) && (a <= sedge || a >= eedge)) { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1865 if ((sbit & 0x40) && (a >= sedge || a <= eedge)) { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1866 if ((sbit & 0x80) && (a <= sedge || a >= eedge)) { g->p.x = x+b; g->p.y = y+a; drawpixel_clip(g); }
1870 P += 5 + 2*(a++ - b--);
1872 if (((sbit & 0x04) && (a >= sedge || a <= eedge)) || ((sbit & 0x08) && (a <= sedge || a >= eedge)))
1873 { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1874 if (((sbit & 0x40) && (a >= sedge || a <= eedge)) || ((sbit & 0x80) && (a <= sedge || a >= eedge)))
1875 { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1876 if (((sbit & 0x01) && (a >= sedge || a <= eedge)) || ((sbit & 0x02) && (a <= sedge || a >= eedge)))
1877 { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1878 if (((sbit & 0x10) && (a >= sedge || a <= eedge)) || ((sbit & 0x20) && (a <= sedge || a >= eedge)))
1879 { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1886 if (((sbit & 0x20) && !eedge) || ((sbit & 0x40) && !sedge)) { g->p.x = x; g->p.y = y+b; drawpixel_clip(g); }
1887 if (((sbit & 0x02) && !eedge) || ((sbit & 0x04) && !sedge)) { g->p.x = x; g->p.y = y-b; drawpixel_clip(g); }
1888 if (((sbit & 0x80) && !eedge) || ((sbit & 0x01) && !sedge)) { g->p.x = x+b; g->p.y = y; drawpixel_clip(g); }
1889 if (((sbit & 0x08) && !eedge) || ((sbit & 0x10) && !sedge)) { g->p.x = x-b; g->p.y = y; drawpixel_clip(g); }
1891 if (((sbit & 0x01) && a >= sedge && a <= eedge)) { g->p.x = x+b; g->p.y = y-a; drawpixel_clip(g); }
1892 if (((sbit & 0x02) && a <= sedge && a >= eedge)) { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1893 if (((sbit & 0x04) && a >= sedge && a <= eedge)) { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1894 if (((sbit & 0x08) && a <= sedge && a >= eedge)) { g->p.x = x-b; g->p.y = y-a; drawpixel_clip(g); }
1895 if (((sbit & 0x10) && a >= sedge && a <= eedge)) { g->p.x = x-b; g->p.y = y+a; drawpixel_clip(g); }
1896 if (((sbit & 0x20) && a <= sedge && a >= eedge)) { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1897 if (((sbit & 0x40) && a >= sedge && a <= eedge)) { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1898 if (((sbit & 0x80) && a <= sedge && a >= eedge)) { g->p.x = x+b; g->p.y = y+a; drawpixel_clip(g); }
1902 P += 5 + 2*(a++ - b--);
1904 if (((sbit & 0x04) && a >= sedge && a <= eedge) || ((sbit & 0x08) && a <= sedge && a >= eedge))
1905 { g->p.x = x-a; g->p.y = y-b; drawpixel_clip(g); }
1906 if (((sbit & 0x40) && a >= sedge && a <= eedge) || ((sbit & 0x80) && a <= sedge && a >= eedge))
1907 { g->p.x = x+a; g->p.y = y+b; drawpixel_clip(g); }
1908 if (((sbit & 0x01) && a >= sedge && a <= eedge) || ((sbit & 0x02) && a <= sedge && a >= eedge))
1909 { g->p.x = x+a; g->p.y = y-b; drawpixel_clip(g); }
1910 if (((sbit & 0x10) && a >= sedge && a <= eedge) || ((sbit & 0x20) && a <= sedge && a >= eedge))
1911 { g->p.x = x-a; g->p.y = y+b; drawpixel_clip(g); }
1920 #if (!GMISC_NEED_FIXEDTRIG && !GMISC_NEED_FASTTRIG) || !GFX_USE_GMISC
1926 gCoord startTan, endTan, curangle;
1931 start -= (start/360-1)*360;
1932 else if (start >= 360)
1935 end -= (end/360-1)*360;
1936 else if (end >= 360)
1939 #if GFX_USE_GMISC && GMISC_NEED_FIXEDTRIG
1940 if((start / 45) % 2 == 0){
1941 startTan =
ffsin(start % 45) * precision / ffcos(start % 45) + start / 45 * precision;}
1943 startTan =
ffsin(start % 45 - 45) * precision / ffcos(start % 45 - 45) + start / 45 * precision + precision;}
1945 if((end / 45) % 2 == 0){
1946 endTan =
ffsin(end % 45) * precision / ffcos(end % 45) + end / 45 * precision;}
1948 endTan =
ffsin(end % 45 - 45) * precision / ffcos(end % 45 - 45) + end / 45 * precision + precision;}
1949 #elif GFX_USE_GMISC && GMISC_NEED_FASTTRIG
1950 if((start / 45) % 2 == 0){
1951 startTan =
fsin(start % 45) * precision / fcos(start % 45) + start / 45 * precision;}
1953 startTan =
fsin(start % 45 - 45) * precision / fcos(start % 45 - 45) + start / 45 * precision + precision;}
1955 if((end / 45) % 2 == 0){
1956 endTan =
fsin(end % 45) * precision / fcos(end % 45) + end / 45 * precision;}
1958 endTan =
fsin(end % 45 - 45) * precision / fcos(end % 45 - 45) + end / 45 * precision + precision;}
1960 if((start / 45) % 2 == 0){
1961 startTan = (tan((start % 45)*GFX_PI/180) + start / 45)* precision;}
1963 startTan = (1+tan((start % 45 - 45)*GFX_PI/180) + start / 45)* precision;}
1965 if((end / 45) % 2 == 0){
1966 endTan = (tan((end % 45) *GFX_PI/180) + end / 45) * precision;}
1968 endTan = (1+tan((end % 45 - 45) *GFX_PI/180) + end / 45) * precision;}
1975 for(r = radiusStart; r <= radiusEnd; r++)
1983 curangle = x*precision/y;
1988 if(curangle > startTan && curangle < endTan){g->p.y = yc - x; g->p.x = xc + y; drawpixel_clip(g);}
1989 if(curangle + 2*precision > startTan && curangle + 2*precision < endTan){g->p.y = yc - y; g->p.x = xc - x; drawpixel_clip(g);}
1990 if(curangle + 4*precision > startTan && curangle + 4*precision < endTan){g->p.y = yc + x; g->p.x = xc - y; drawpixel_clip(g);}
1991 if(curangle + 6*precision > startTan && curangle + 6*precision < endTan){g->p.y = yc + y; g->p.x = xc + x; drawpixel_clip(g);}
1993 curangle = precision - curangle;
1995 if(curangle + precision > startTan && curangle + precision < endTan){g->p.y = yc - y; g->p.x = xc + x; drawpixel_clip(g);}
1996 if(curangle + 3*precision > startTan && curangle + 3*precision < endTan){g->p.y = yc - x; g->p.x = xc - y; drawpixel_clip(g);}
1997 if(curangle + 5*precision > startTan && curangle + 5*precision < endTan){g->p.y = yc + y; g->p.x = xc - x; drawpixel_clip(g);}
1998 if(curangle + 7*precision > startTan && curangle + 7*precision < endTan){g->p.y = yc + x; g->p.x = xc + y; drawpixel_clip(g);}
2003 if(curangle > startTan || curangle < endTan){g->p.y = yc - x; g->p.x = xc + y; drawpixel_clip(g);}
2004 if(curangle + 2*precision > startTan || curangle + 2*precision < endTan){g->p.y = yc - y; g->p.x = xc - x; drawpixel_clip(g);}
2005 if(curangle + 4*precision > startTan || curangle + 4*precision < endTan){g->p.y = yc + x; g->p.x = xc - y; drawpixel_clip(g);}
2006 if(curangle + 6*precision > startTan || curangle + 6*precision < endTan){g->p.y = yc + y; g->p.x = xc + x; drawpixel_clip(g);}
2008 curangle = precision - curangle;
2010 if(curangle + precision > startTan || curangle + precision < endTan){g->p.y = yc - y; g->p.x = xc + x; drawpixel_clip(g);}
2011 if(curangle + 3*precision > startTan || curangle + 3*precision < endTan){g->p.y = yc - x; g->p.x = xc - y; drawpixel_clip(g);}
2012 if(curangle + 5*precision > startTan || curangle + 5*precision < endTan){g->p.y = yc + y; g->p.x = xc - x; drawpixel_clip(g);}
2013 if(curangle + 7*precision > startTan || curangle + 7*precision < endTan){g->p.y = yc + x; g->p.x = xc + y; drawpixel_clip(g);}
2021 else if (d < 2 * (r - y)){
2026 d += 2 * (y - x - 1);
2042 fixed sxa, sxb, sxd, exa, exb, exd;
2050 sxa = exa =
FIXED(x) + FIXED0_5;
2053 #if GFX_USE_GMISC && GMISC_NEED_FIXEDTRIG
2054 sxb = radius*ffcos(start); sy = NONFIXED(FIXED0_5 - radius*
ffsin(start));
2055 exb = radius*ffcos(end); ey = NONFIXED(FIXED0_5 - radius*
ffsin(end));
2056 #elif GFX_USE_GMISC && GMISC_NEED_FASTTRIG
2057 sxb = FP2FIXED(radius*fcos(start)); sy = floor(0.5-radius*
fsin(start));
2058 exb = FP2FIXED(radius*fcos(end)); ey = floor(0.5-radius*
fsin(end));
2060 sxb = FP2FIXED(radius*cos(start*GFX_PI/180)); sy = floor(0.5-radius*sin(start*GFX_PI/180));
2061 exb = FP2FIXED(radius*cos(end*GFX_PI/180)); ey = floor(0.5-radius*sin(end*GFX_PI/180));
2063 sxd = sy ? sxb/sy : sxb;
2064 exd = ey ? exb/ey : exb;
2068 if (sxb > 0) qtr |= 0x01;
2069 if (sy > 0) qtr |= 0x02;
2070 if (exb > 0) qtr |= 0x04;
2071 if (ey > 0) qtr |= 0x08;
2072 if (sy > ey || (sy == ey && sxb > 0)) qtr |= 0x10;
2089 g->p.x = x; g->p.x1 = x;
2090 sxa -= sxd; exa -= exd;
2092 g->p.x = x-b; g->p.x1 = x;
2095 g->p.x = x; g->p.x1 = x+b;
2098 g->p.x = x-b; g->p.x1 = x+b;
2104 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = NONFIXED(sxa); hline_clip(g);
2105 sxa -= sxd; exa -= exd;
2106 }
else if (-a >= sy) {
2107 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2109 }
else if (qtr & 1) {
2110 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2116 g->p.y = y-b; g->p.x = NONFIXED(exb); g->p.x1 = NONFIXED(sxb); hline_clip(g);
2117 sxb += sxd; exb += exd;
2118 }
else if (-b >= sy) {
2119 g->p.y = y-b; g->p.x = x-a; g->p.x1 = NONFIXED(sxb); hline_clip(g);
2121 }
else if (qtr & 1) {
2122 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2124 P += 5 + 2*(a++ - b--);
2128 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = NONFIXED(sxa); hline_clip(g);
2129 }
else if (-a >= sy) {
2130 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2131 }
else if (qtr & 1) {
2132 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2144 g->p.y = y; g->p.x = x; g->p.x1 = x+b; hline_clip(g);
2145 sxa += sxd; exa -= exd;
2148 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2150 }
else if (!(qtr & 4)) {
2151 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2154 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2156 }
else if (!(qtr & 1)) {
2157 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2163 g->p.y = y-b; g->p.x = NONFIXED(exb); g->p.x1 = x+a; hline_clip(g);
2165 }
else if (!(qtr & 4)) {
2166 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2169 g->p.y = y+b; g->p.x = NONFIXED(sxb); g->p.x1 = x+a; hline_clip(g);
2171 }
else if (!(qtr & 1)) {
2172 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2174 P += 5 + 2*(a++ - b--);
2178 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2179 }
else if (!(qtr & 4)) {
2180 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2183 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+a; hline_clip(g);
2184 }
else if (!(qtr & 1)) {
2185 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+a; hline_clip(g);
2191 g->p.y = y; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2194 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2195 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2196 sxa -= sxd; exa -= exd;
2197 }
else if (-a >= sy) {
2198 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2200 }
else if (qtr & 1) {
2201 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2203 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2208 g->p.y = y-b; g->p.x = x-a; g->p.x1 = NONFIXED(sxb); hline_clip(g);
2209 g->p.y = y-b; g->p.x = NONFIXED(exb); g->p.x1 = x+a; hline_clip(g);
2210 sxb += sxd; exb += exd;
2211 }
else if (-b >= sy) {
2212 g->p.y = y-b; g->p.x = x-a; g->p.x1 = NONFIXED(sxb); hline_clip(g);
2214 }
else if (qtr & 1) {
2215 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2217 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2218 P += 5 + 2*(a++ - b--);
2222 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2223 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2224 }
else if (-a >= sy) {
2225 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2226 }
else if (qtr & 1) {
2227 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2229 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2240 g->p.y = y; g->p.x = x-b; g->p.x1 = x; hline_clip(g);
2241 sxa -= sxd; exa += exd;
2244 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2246 }
else if (qtr & 1) {
2247 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2250 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2252 }
else if (qtr & 4) {
2253 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2259 g->p.y = y-b; g->p.x = x-a; g->p.x1 = NONFIXED(sxb); hline_clip(g);
2261 }
else if (qtr & 1) {
2262 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2265 g->p.y = y+b; g->p.x = x-a; g->p.x1 = NONFIXED(exb); hline_clip(g);
2267 }
else if (qtr & 4) {
2268 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2270 P += 5 + 2*(a++ - b--);
2274 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2275 }
else if (qtr & 1) {
2276 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2279 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2280 }
else if (qtr & 4) {
2281 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+a; hline_clip(g);
2287 g->p.y = y; g->p.x = x; drawpixel_clip(g);
2288 sxa += sxd; exa += exd;
2291 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = NONFIXED(exa); hline_clip(g);
2292 sxa += sxd; exa += exd;
2293 }
else if (a <= ey) {
2294 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2296 }
else if (qtr & 4) {
2297 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2303 g->p.y = y+b; g->p.x = NONFIXED(sxb); g->p.x1 = NONFIXED(exb); hline_clip(g);
2304 sxb -= sxd; exb -= exd;
2305 }
else if (b <= ey) {
2306 g->p.y = y+b; g->p.x = x-a; g->p.x1 = NONFIXED(exb); hline_clip(g);
2308 }
else if (qtr & 4) {
2309 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2311 P += 5 + 2*(a++ - b--);
2315 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = NONFIXED(exa); hline_clip(g);
2316 }
else if (a <= ey) {
2317 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2318 }
else if (qtr & 4) {
2319 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2325 g->p.y = y; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2327 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2329 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2330 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2331 sxa += sxd; exa += exd;
2332 }
else if (a <= ey) {
2333 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2335 }
else if (qtr & 4) {
2336 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2341 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2343 g->p.y = y+b; g->p.x = x-a; g->p.x1 = NONFIXED(exb); hline_clip(g);
2344 g->p.y = y+b; g->p.x = NONFIXED(sxb); g->p.x1 = x+a; hline_clip(g);
2345 sxb -= sxd; exb -= exd;
2346 }
else if (b <= ey) {
2347 g->p.y = y+b; g->p.x = x-a; g->p.x1 = NONFIXED(exb); hline_clip(g);
2349 }
else if (qtr & 4) {
2350 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2352 P += 5 + 2*(a++ - b--);
2355 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2357 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2358 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2359 }
else if (a <= ey) {
2360 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2361 }
else if (qtr & 4) {
2362 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2368 g->p.y = y; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2369 sxa -= sxd; exa -= exd;
2372 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2373 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2374 sxa -= sxd; exa -= exd;
2375 }
else if (-a >= ey) {
2376 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2378 }
else if (!(qtr & 4)){
2379 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2381 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2386 g->p.y = y-b; g->p.x = x-a; g->p.x1 = NONFIXED(sxb); hline_clip(g);
2387 g->p.y = y-b; g->p.x = NONFIXED(exb); g->p.x1 = x+a; hline_clip(g);
2388 sxb += sxd; exb += exd;
2389 }
else if (-b >= ey) {
2390 g->p.y = y-b; g->p.x = NONFIXED(exb); g->p.x1 = x+a; hline_clip(g);
2392 }
else if (!(qtr & 4)){
2393 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2395 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2396 P += 5 + 2*(a++ - b--);
2400 g->p.y = y-a; g->p.x = x-b; g->p.x1 = NONFIXED(sxa); hline_clip(g);
2401 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2402 }
else if (-a >= ey) {
2403 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2404 }
else if (!(qtr & 4)){
2405 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2407 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2413 g->p.x = x; g->p.x1 = x;
2414 sxa -= sxd; exa -= exd;
2416 g->p.x = x; g->p.x1 = x+b;
2423 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = NONFIXED(sxa); hline_clip(g);
2424 sxa -= sxd; exa -= exd;
2425 }
else if (-a >= ey) {
2426 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2428 }
else if (!(qtr & 4)) {
2429 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2435 g->p.y = y-b; g->p.x = NONFIXED(exb); g->p.x1 = NONFIXED(sxb); hline_clip(g);
2436 sxb += sxd; exb += exd;
2437 }
else if (-b >= ey) {
2438 g->p.y = y-b; g->p.x = NONFIXED(exb); g->p.x1 = x+a; hline_clip(g);
2440 }
else if (!(qtr & 4)) {
2441 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2443 P += 5 + 2*(a++ - b--);
2447 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = NONFIXED(sxa); hline_clip(g);
2448 }
else if (-a >= ey) {
2449 g->p.y = y-a; g->p.x = NONFIXED(exa); g->p.x1 = x+b; hline_clip(g);
2450 }
else if (!(qtr & 4)) {
2451 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2457 g->p.y = y; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2459 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2461 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2462 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2463 sxa += sxd; exa += exd;
2464 }
else if (a <= sy) {
2465 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2467 }
else if (!(qtr & 1)) {
2468 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2473 g->p.y = y-b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2475 g->p.y = y+b; g->p.x = x-a; g->p.x1 = NONFIXED(exb); hline_clip(g);
2476 g->p.y = y+b; g->p.x = NONFIXED(sxb); g->p.x1 = x+a; hline_clip(g);
2477 sxb -= sxd; exb -= exd;
2478 }
else if (b <= sy) {
2479 g->p.y = y+b; g->p.x = NONFIXED(sxb); g->p.x1 = x+a; hline_clip(g);
2481 }
else if (!(qtr & 1)) {
2482 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2484 P += 5 + 2*(a++ - b--);
2487 g->p.y = y-a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2489 g->p.y = y+a; g->p.x = x-b; g->p.x1 = NONFIXED(exa); hline_clip(g);
2490 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2491 }
else if (a <= sy) {
2492 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2493 }
else if (!(qtr & 4)) {
2494 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2502 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = NONFIXED(exa); hline_clip(g);
2503 sxa += sxd; exa += exd;
2504 }
else if (a <= sy) {
2505 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2507 }
else if (!(qtr & 1)) {
2508 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2514 g->p.y = y+b; g->p.x = NONFIXED(sxb); g->p.x1 = NONFIXED(exb); hline_clip(g);
2515 sxb -= sxd; exb -= exd;
2516 }
else if (b <= sy) {
2517 g->p.y = y+b; g->p.x = NONFIXED(sxb); g->p.x1 = x+a; hline_clip(g);
2519 }
else if (!(qtr & 1)) {
2520 g->p.y = y+b; g->p.x = x-a; g->p.x1 = x+a; hline_clip(g);
2522 P += 5 + 2*(a++ - b--);
2526 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = NONFIXED(exa); hline_clip(g);
2527 }
else if (a <= sy) {
2528 g->p.y = y+a; g->p.x = NONFIXED(sxa); g->p.x1 = x+b; hline_clip(g);
2529 }
else if (!(qtr & 4)) {
2530 g->p.y = y+a; g->p.x = x-b; g->p.x1 = x+b; hline_clip(g);
2540 #if GDISP_NEED_ARC || GDISP_NEED_ARCSECTORS
2542 if (2*radius > cx || 2*radius > cy) {
2547 #if GDISP_NEED_ARCSECTORS
2553 gdispGDrawArc(g, x+radius, y+radius, radius, 90, 180, color);
2554 gdispGDrawArc(g, x+cx-1-radius, y+radius, radius, 0, 90, color);
2555 gdispGDrawArc(g, x+cx-1-radius, y+cy-1-radius, radius, 270, 360, color);
2556 gdispGDrawArc(g, x+radius, y+cy-1-radius, radius, 180, 270, color);
2559 gdispGDrawLine(g, x+cx-1, y+radius+1, x+cx-1, y+cy-2-radius, color);
2560 gdispGDrawLine(g, x+radius+1, y+cy-1, x+cx-2-radius, y+cy-1, color);
2565 #if GDISP_NEED_ARC || GDISP_NEED_ARCSECTORS
2570 if (radius2 > cx || radius2 > cy) {
2574 #if GDISP_NEED_ARCSECTORS
2580 gdispGFillArc(g, x+radius, y+radius, radius, 90, 180, color);
2581 gdispGFillArc(g, x+cx-1-radius, y+radius, radius, 0, 90, color);
2582 gdispGFillArc(g, x+cx-1-radius, y+cy-1-radius, radius, 270, 360, color);
2583 gdispGFillArc(g, x+radius, y+cy-1-radius, radius, 180, 270, color);
2586 gdispGFillArea(g, x+radius+1, y+cy-radius, cx-radius2, radius, color);
2591 #if GDISP_NEED_PIXELREAD
2597 #if GDISP_HARDWARE_PIXELREAD
2598 #if GDISP_HARDWARE_PIXELREAD == HARDWARE_AUTODETECT
2605 c = gdisp_lld_get_pixel_color(g);
2610 #if GDISP_HARDWARE_PIXELREAD != GFXON && GDISP_HARDWARE_STREAM_READ
2611 #if GDISP_HARDWARE_STREAM_READ == HARDWARE_AUTODETECT
2612 if (gvmt(g)->readcolor)
2620 gdisp_lld_read_start(g);
2621 c = gdisp_lld_read_color(g);
2622 gdisp_lld_read_stop(g);
2627 #if GDISP_HARDWARE_PIXELREAD != GFXON && GDISP_HARDWARE_STREAM_READ != GFXON
2628 #if !GDISP_HARDWARE_PIXELREAD && !GDISP_HARDWARE_STREAM_READ
2630 #error "GDISP: GDISP_NEED_PIXELREAD has been set but there is no hardware support for reading the display"
2638 #if GDISP_NEED_SCROLL
2641 #if GDISP_HARDWARE_SCROLL != GFXON
2642 gCoord fy, dy, ix, fx, i, j;
2649 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
2650 if (!gvmt(g)->setclip)
2653 if (x < g->clipx0) { cx -= g->clipx0 - x; x = g->clipx0; }
2654 if (y < g->clipy0) { cy -= g->clipy0 - y; y = g->clipy0; }
2655 if (cx <= 0 || cy <= 0 || x >= g->clipx1 || y >= g->clipy1) { MUTEX_EXIT(g);
return; }
2656 if (x+cx > g->clipx1) cx = g->clipx1 - x;
2657 if (y+cy > g->clipy1) cy = g->clipy1 - y;
2661 abslines = lines < 0 ? -lines : lines;
2662 if (abslines >= cy) {
2667 #if GDISP_HARDWARE_SCROLL
2668 #if GDISP_HARDWARE_SCROLL == HARDWARE_AUTODETECT
2669 if (gvmt(g)->vscroll)
2677 g->p.color = bgcolor;
2678 gdisp_lld_vertical_scroll(g);
2681 #if GDISP_HARDWARE_SCROLL == HARDWARE_AUTODETECT
2684 #elif GDISP_LINEBUF_SIZE == 0
2685 #error "GDISP: GDISP_NEED_SCROLL is set but there is no hardware support and GDISP_LINEBUF_SIZE is zero."
2689 #if GDISP_HARDWARE_SCROLL != GFXON
2700 for(i = 0; i < cy; i++, fy += dy) {
2713 #if GDISP_HARDWARE_STREAM_READ
2714 #if GDISP_HARDWARE_STREAM_READ == HARDWARE_AUTODETECT
2715 if (gvmt(g)->readstart)
2722 gdisp_lld_read_start(g);
2723 for(j=0; j < fx; j++)
2724 g->linebuf[j] = gdisp_lld_read_color(g);
2725 gdisp_lld_read_stop(g);
2727 #if GDISP_HARDWARE_STREAM_READ == HARDWARE_AUTODETECT
2733 #if GDISP_HARDWARE_STREAM_READ != GFXON && GDISP_HARDWARE_PIXELREAD
2734 #if GDISP_HARDWARE_PIXELREAD == HARDWARE_AUTODETECT
2738 for(j=0; j < fx; j++) {
2741 g->linebuf[j] = gdisp_lld_get_pixel_color(g);
2744 #if GDISP_HARDWARE_PIXELREAD == HARDWARE_AUTODETECT
2754 #if !GDISP_HARDWARE_STREAM_READ && !GDISP_HARDWARE_PIXELREAD
2755 #error "GDISP: GDISP_NEED_SCROLL is set but there is no hardware support for scrolling or reading pixels."
2761 #if GDISP_HARDWARE_BITFILLS
2762 #if GDISP_HARDWARE_BITFILLS == HARDWARE_AUTODETECT
2773 g->p.ptr = (
void *)g->linebuf;
2774 gdisp_lld_blit_area(g);
2776 #if GDISP_HARDWARE_BITFILLS == HARDWARE_AUTODETECT
2782 #if GDISP_HARDWARE_BITFILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE
2783 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
2784 if (gvmt(g)->writestart)
2791 gdisp_lld_write_start(g);
2792 #if GDISP_HARDWARE_STREAM_POS
2793 gdisp_lld_write_pos(g);
2795 for(j = 0; j < fx; j++) {
2796 g->p.color = g->linebuf[j];
2797 gdisp_lld_write_color(g);
2799 gdisp_lld_write_stop(g);
2801 #if GDISP_HARDWARE_STREAM_WRITE == HARDWARE_AUTODETECT
2807 #if GDISP_HARDWARE_BITFILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_FILLS && GDISP_HARDWARE_DRAWPIXEL
2809 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
2817 for(j = 0; j < fx; ) {
2818 g->p.color = g->linebuf[j];
2819 if (j + g->p.cx < fx && g->linebuf[j] == g->linebuf[j + g->p.cx])
2821 else if (g->p.cx == 1) {
2822 gdisp_lld_draw_pixel(g);
2826 gdisp_lld_fill_area(g);
2833 #if GDISP_HARDWARE_FILLS == HARDWARE_AUTODETECT
2839 #if GDISP_HARDWARE_BITFILLS != GFXON && GDISP_HARDWARE_STREAM_WRITE != GFXON && GDISP_HARDWARE_FILLS != GFXON && GDISP_HARDWARE_DRAWPIXEL
2846 for(g->p.x = x+ix, j = 0; j < fx; g->p.x++, j++) {
2847 g->p.color = g->linebuf[j];
2848 gdisp_lld_draw_pixel(g);
2860 g->p.y = lines > 0 ? (y+cy) : y;
2863 g->p.color = bgcolor;
2865 autoflush_stopdone(g);
2870 #if GDISP_NEED_CONTROL
2871 #if GDISP_HARDWARE_CONTROL
2872 void gdispGControl(GDisplay *g,
unsigned what,
void *value) {
2873 #if GDISP_HARDWARE_CONTROL == HARDWARE_AUTODETECT
2874 if (!gvmt(g)->control)
2880 if (what == GDISP_CONTROL_ORIENTATION) {
2892 gdisp_lld_control(g);
2893 #if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION
2894 if (what == GDISP_CONTROL_ORIENTATION) {
2896 #if GDISP_HARDWARE_CLIP
2897 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
2898 if (gvmt(g)->setclip)
2903 g->p.cx = g->g.Width;
2904 g->p.cy = g->g.Height;
2905 gdisp_lld_set_clip(g);
2907 #if GDISP_HARDWARE_CLIP == HARDWARE_AUTODETECT
2913 #if GDISP_HARDWARE_CLIP != GFXON
2917 g->clipx1 = g->g.Width;
2918 g->clipy1 = g->g.Height;
2926 void gdispGControl(GDisplay *g,
unsigned what,
void *value) {
2935 #if GDISP_NEED_QUERY
2936 #if GDISP_HARDWARE_QUERY
2940 #if GDISP_HARDWARE_QUERY == HARDWARE_AUTODETECT
2941 if (!gvmt(g)->query)
2946 res = gdisp_lld_query(g);
2963 if (cx <= 0 || cy <= 0)
return;
2964 cx = x+cx-1; cy = y+cy-1;
2971 g->p.x = x; g->p.y = y; g->p.x1 = cx; hline_clip(g);
2973 g->p.x = x; g->p.y = cy; g->p.x1 = cx; hline_clip(g);
2976 g->p.x = x; g->p.y = y; g->p.y1 = cy; vline_clip(g);
2977 g->p.x = cx; g->p.y = y; g->p.y1 = cy; vline_clip(g);
2981 g->p.x = x; g->p.y = y; g->p.y1 = cy; vline_clip(g);
2983 g->p.x = cx; g->p.y = y; g->p.y1 = cy; vline_clip(g);
2991 #if GDISP_NEED_CONVEX_POLYGON
2995 epnt = &pntarray[cnt-1];
2999 for(p = pntarray; p < epnt; p++) {
3000 g->p.x=tx+p->
x; g->p.y=ty+p->
y; g->p.x1=tx+p[1].
x; g->p.y1=ty+p[1].
y; line_clip(g);
3002 g->p.x=tx+p->
x; g->p.y=ty+p->
y; g->p.x1=tx+pntarray->
x; g->p.y1=ty+pntarray->
y; line_clip(g);
3009 const gPoint *lpnt, *rpnt, *epnts;
3010 fixed lx, rx, lk, rk;
3011 gCoord y, ymax, lxc, rxc;
3013 epnts = &pntarray[cnt-1];
3017 for(lpnt=pntarray+1; lpnt <= epnts; lpnt++) {
3018 if (lpnt->
y < rpnt->
y)
3021 lx = rx =
FIXED(rpnt->
x);
3025 for (lpnt = rpnt <= pntarray ? epnts : rpnt-1; lpnt->y == y; cnt--) {
3028 lpnt = lpnt <= pntarray ? epnts : lpnt-1;
3030 for (rpnt = rpnt >= epnts ? pntarray : rpnt+1; rpnt->
y == y; cnt--) {
3033 rpnt = rpnt >= epnts ? pntarray : rpnt+1;
3035 lk = (
FIXED(lpnt->
x) - lx) / (lpnt->
y - y);
3036 rk = (
FIXED(rpnt->
x) - rx) / (rpnt->
y - y);
3047 ymax = rpnt->
y < lpnt->
y ? rpnt->
y : lpnt->
y;
3050 for(; y < ymax; y++) {
3059 g->p.x=tx+lxc; g->p.y=ty+y; g->p.x1=tx+rxc-1; hline_clip(g);
3060 }
else if (lxc > rxc) {
3061 g->p.x=tx+rxc; g->p.y=ty+y; g->p.x1=tx+lxc-1; hline_clip(g);
3076 if (ymax == lpnt->
y) {
3078 for (lpnt = lpnt <= pntarray ? epnts : lpnt-1; lpnt->y == y; cnt--) {
3085 lpnt = lpnt <= pntarray ? epnts : lpnt-1;
3087 lk = (
FIXED(lpnt->
x) - lx) / (lpnt->
y - y);
3091 for (rpnt = rpnt >= epnts ? pntarray : rpnt+1; rpnt->
y == y; cnt--) {
3098 rpnt = rpnt >= epnts ? pntarray : rpnt+1;
3100 rk = (
FIXED(rpnt->
x) - rx) / (rpnt->
y - y);
3106 static gI32 rounding_div(
const gI32 n,
const gI32 d)
3108 if ((n < 0) != (d < 0))
3109 return (n - d/2) / d;
3111 return (n + d/2) / d;
3119 gI32 len_n, len, len2;
3123 absDx = (dx >= 0 ? dx : -dx) * 2;
3124 absDy = (dy >= 0 ? dy : -dy) * 2;
3127 len2 = absDx * absDx + absDy * absDy;
3130 len = absDx + absDy;
3133 for(maxSteps = 8; maxSteps > 0; maxSteps--)
3139 len_n = (len + len2 / len) / 2;
3152 *nx = rounding_div(dy * norm * 2, len);
3153 *ny = rounding_div(-dx * norm * 2, len);
3158 gCoord dx, dy, nx = 0, ny = 0;
3165 if (dx == 0 && dy == 0)
3169 get_normal_vector(dx, dy, width, &nx, &ny);
3172 if (nx == 0 && ny == 0)
3180 x0 -= rounding_div(nx, 2);
3181 y0 -= rounding_div(ny, 2);
3200 pntarray[2].
x = dx + nx;
3201 pntarray[2].
y = dy + ny;
3229 nx2 = rounding_div((nx * 75 + ny * 75), 256);
3230 ny2 = rounding_div((-nx * 75 + ny * 75), 256);
3234 x0 += ny * 53 / 256;
3235 y0 -= nx * 53 / 256;
3236 dx -= ny * 106 / 256;
3237 dy += nx * 106 / 256;
3242 pntarray[1].
x = nx2;
3243 pntarray[1].
y = ny2;
3244 pntarray[2].
x = nx2 + nx * 106/256;
3245 pntarray[2].
y = ny2 + ny * 106/256;
3248 pntarray[4].
x = dx + nx;
3249 pntarray[4].
y = dy + ny;
3250 pntarray[5].
x = dx + nx - nx2;
3251 pntarray[5].
y = dy + ny - ny2;
3252 pntarray[6].
x = dx + nx * 150/256 - nx2;
3253 pntarray[6].
y = dy + ny * 150/256 - ny2;
3263 #include "mcufont/mcufont.h"
3265 #if GDISP_NEED_ANTIALIAS && GDISP_HARDWARE_PIXELREAD
3266 static void drawcharline(gI16 x, gI16 y, gU8 count, gU8 alpha,
void *state) {
3267 #define GD ((GDisplay *)state)
3268 if (y < GD->t.clipy0 || y >= GD->t.clipy1 || x+count <= GD->t.clipx0 || x >= GD->t.clipx1)
3270 if (x < GD->t.clipx0) {
3271 count -= GD->t.clipx0 - x;
3274 if (x+count > GD->t.clipx1)
3275 count = GD->t.clipx1 - x;
3277 GD->p.x = x; GD->p.y = y; GD->p.x1 = x+count-1; GD->p.color = GD->t.color;
3280 for (; count; count--, x++) {
3281 GD->p.x = x; GD->p.y = y;
3282 GD->p.color =
gdispBlendColor(GD->t.color, gdisp_lld_get_pixel_color(GD), alpha);
3289 static void drawcharline(gI16 x, gI16 y, gU8 count, gU8 alpha,
void *state) {
3290 #define GD ((GDisplay *)state)
3291 if (y < GD->t.clipy0 || y >= GD->t.clipy1 || x+count <= GD->t.clipx0 || x >= GD->t.clipx1)
3293 if (x < GD->t.clipx0) {
3294 count -= GD->t.clipx0 - x;
3297 if (x+count > GD->t.clipx1)
3298 count = GD->t.clipx1 - x;
3300 GD->p.x = x; GD->p.y = y; GD->p.x1 = x+count-1; GD->p.color = GD->t.color;
3307 #if GDISP_NEED_ANTIALIAS
3308 static void fillcharline(gI16 x, gI16 y, gU8 count, gU8 alpha,
void *state) {
3309 #define GD ((GDisplay *)state)
3310 if (y < GD->t.clipy0 || y >= GD->t.clipy1 || x+count <= GD->t.clipx0 || x >= GD->t.clipx1)
3312 if (x < GD->t.clipx0) {
3313 count -= GD->t.clipx0 - x;
3316 if (x+count > GD->t.clipx1)
3317 count = GD->t.clipx1 - x;
3319 GD->p.color = GD->t.color;
3323 GD->p.x = x; GD->p.y = y; GD->p.x1 = x+count-1;
3328 #define fillcharline drawcharline
3332 static gU8 drawcharglyph(gI16 x, gI16 y, mf_char ch,
void *state) {
3333 #define GD ((GDisplay *)state)
3334 return mf_render_character(GD->t.font, x, y, ch, drawcharline, state);
3339 static gU8 fillcharglyph(gI16 x, gI16 y, mf_char ch,
void *state) {
3340 #define GD ((GDisplay *)state)
3341 return mf_render_character(GD->t.font, x, y, ch, fillcharline, state);
3346 #if GDISP_NEED_TEXT_WORDWRAP
3347 static gBool mf_countline_callback(mf_str line, gU16 count,
void *state) {
3354 static gBool mf_drawline_callback(mf_str line, gU16 count,
void *state) {
3355 #define GD ((GDisplay *)state)
3356 mf_render_aligned(GD->t.font, GD->t.wrapx, GD->t.wrapy, GD->t.lrj, line, count, drawcharglyph, state);
3357 GD->t.wrapy += GD->t.font->line_height;
3361 static gBool mf_fillline_callback(mf_str line, gU16 count,
void *state) {
3362 #define GD ((GDisplay *)state)
3363 mf_render_aligned(GD->t.font, GD->t.wrapx, GD->t.wrapy, GD->t.lrj, line, count, fillcharglyph, state);
3364 GD->t.wrapy += GD->t.font->line_height;
3377 g->t.clipx1 = x + mf_character_width(font, c) + font->baseline_x;
3378 g->t.clipy1 = y + font->height;
3380 mf_render_character(font, x, y, c, drawcharline, g);
3389 g->p.cx = mf_character_width(font, c) + font->baseline_x;
3390 g->p.cy = font->height;
3392 g->t.clipx0 = g->p.x = x;
3393 g->t.clipy0 = g->p.y = y;
3394 g->t.clipx1 = g->p.x+g->p.cx;
3395 g->t.clipy1 = g->p.y+g->p.cy;
3397 g->t.bgcolor = g->p.color = bgcolor;
3401 mf_render_character(font, x, y, c, fillcharline, g);
3414 g->t.clipx1 = 32767;
3415 g->t.clipy1 = y + font->height;
3418 mf_render_aligned(font, x+font->baseline_x, y, MF_ALIGN_LEFT, str, 0, drawcharglyph, g);
3427 g->p.cx = mf_get_string_width(font, str, 0, 0) + font->baseline_x;
3428 g->p.cy = font->height;
3430 g->t.clipx0 = g->p.x = x;
3431 g->t.clipy0 = g->p.y = y;
3432 g->t.clipx1 = g->p.x+g->p.cx;
3433 g->t.clipy1 = g->p.y+g->p.cy;
3435 g->t.bgcolor = g->p.color = bgcolor;
3439 mf_render_aligned(font, x+font->baseline_x, y, MF_ALIGN_LEFT, str, 0, fillcharglyph, g);
3454 #if GDISP_NEED_TEXT_BOXPADLR != 0 || GDISP_NEED_TEXT_BOXPADTB != 0
3456 #if GDISP_NEED_TEXT_BOXPADLR != 0
3460 #if GDISP_NEED_TEXT_BOXPADTB != 0
3474 #if GDISP_NEED_TEXT_WORDWRAP
3478 mf_wordwrap(font, cx, str, mf_countline_callback, &totalHeight);
3479 totalHeight *= font->height;
3482 totalHeight = font->height;
3485 switch((justify & JUSTIFYMASK_VERTICAL)) {
3489 y += cy - totalHeight;
3492 y += (cy+1 - totalHeight)/2;
3495 switch((justify & JUSTIFYMASK_HORIZONTAL)) {
3509 #if GDISP_NEED_TEXT_WORDWRAP
3511 g->t.lrj = (justify & JUSTIFYMASK_HORIZONTAL);
3515 mf_wordwrap(font, cx, str, mf_drawline_callback, g);
3518 mf_render_aligned(font, x, y, (justify & JUSTIFYMASK_HORIZONTAL), str, 0, drawcharglyph, g);
3539 g->p.color = bgcolor;
3543 #if GDISP_NEED_TEXT_BOXPADLR != 0 || GDISP_NEED_TEXT_BOXPADTB != 0
3545 #if GDISP_NEED_TEXT_BOXPADLR != 0
3549 #if GDISP_NEED_TEXT_BOXPADTB != 0
3563 #if GDISP_NEED_TEXT_WORDWRAP
3567 mf_wordwrap(font, cx, str, mf_countline_callback, &totalHeight);
3568 totalHeight *= font->height;
3571 totalHeight = font->height;
3574 switch((justify & JUSTIFYMASK_VERTICAL)) {
3578 y += cy - totalHeight;
3581 y += (cy+1 - totalHeight)/2;
3584 switch((justify & JUSTIFYMASK_HORIZONTAL)) {
3598 g->t.bgcolor = bgcolor;
3599 #if GDISP_NEED_TEXT_WORDWRAP
3601 g->t.lrj = (justify & JUSTIFYMASK_HORIZONTAL);
3605 mf_wordwrap(font, cx, str, mf_fillline_callback, g);
3608 mf_render_aligned(font, x, y, (justify & JUSTIFYMASK_HORIZONTAL), str, 0, fillcharglyph, g);
3636 return mf_character_width(font, c);
3644 #if GDISP_NEED_TEXT_KERNING
3645 return mf_get_string_width(font, str, count, gTrue);
3647 return mf_get_string_width(font, str, count, gFalse);
3656 #if GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
3662 gU32 a1, r1, g1, b1;
3663 gU32 a2, r2, g2, b2;
3666 ratio = (gU32)alpha + 1;
3670 r1 = RED_OF(fg) * a1;
3671 g1 = GREEN_OF(fg) * a1;
3672 b1 = BLUE_OF(fg) * a1;
3676 r2 = RED_OF(bg) * a2;
3677 g2 = GREEN_OF(bg) * a2;
3678 b2 = BLUE_OF(bg) * a2;
3681 a1 = ratio * (a1 - a2) + (a2<<8);
3682 if (!a1)
return GFXTRANSPARENT;
3683 r1 = ((ratio * (r1 - r2))>>8) + r2;
3684 g1 = ((ratio * (g1 - g2))>>8) + g2;
3685 b1 = ((ratio * (b1 - b2))>>8) + b2;
3690 ratio = 0x80000000 / a1;
3692 r1 = (r1 * ratio) >> 23;
3693 g1 = (g1 * ratio) >> 23;
3694 b1 = (b1 * ratio) >> 23;
3703 return ARGB2COLOR(a1, r1, g1, b1);
3708 gU16 fg_ratio = alpha + 1;
3709 gU16 bg_ratio = 256 - alpha;
3712 r = RED_OF(fg) * fg_ratio;
3713 g = GREEN_OF(fg) * fg_ratio;
3714 b = BLUE_OF(fg) * fg_ratio;
3716 r += RED_OF(bg) * bg_ratio;
3717 g += GREEN_OF(bg) * bg_ratio;
3718 b += BLUE_OF(bg) * bg_ratio;
3731 r = RED_OF(color) > 128 ? 0 : 255;
3732 g = GREEN_OF(color) > 128 ? 0 : 255;
3733 b = BLUE_OF(color) > 128 ? 0 : 255;
3738 #if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM))
3741 #if defined(GDISP_PIXELFORMAT_RGB888)
3742 #error "GDISP: Packed pixels not supported yet"
3743 #elif defined(GDISP_PIXELFORMAT_RGB444)
3744 #error "GDISP: Packed pixels not supported yet"
3745 #elif defined(GDISP_PIXELFORMAT_RGB666)
3746 #error "GDISP: Packed pixels not supported yet"
3748 #error "GDISP: Unsupported packed pixel format"
GDISP Graphic Driver subsystem low level driver header.
#define RGB2COLOR(r, g, b)
Convert red, green, blue (each 0 to 255) into a color value.
COLOR_TYPE gColor
The color type definition.
GDisplay * gdispGetDisplay(unsigned display)
Get the specified display.
void gdispGDrawArcSectors(GDisplay *g, gCoord x, gCoord y, gCoord radius, gU8 sectors, gColor color)
Draw a selection of 45 degree arcs of a circle.
gU8 gdispGGetBacklight(GDisplay *g)
Get the current display backlight brightness.
gColor gdispBlendColor(gColor fg, gColor bg, gU8 alpha)
Blend 2 colors according to the alpha.
#define GDISP_TOTAL_DISPLAYS
The total number of displays using the default driver.
void gdispGVerticalScroll(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, int lines, gColor bgcolor)
Scroll vertically a section of the screen.
gCoord gdispGetCharWidth(char c, gFont font)
Get the pixel width of a character.
void gdispGDrawPixel(GDisplay *g, gCoord x, gCoord y, gColor color)
Set a pixel in the specified color.
void gdispGFillChar(GDisplay *g, gCoord x, gCoord y, gU16 c, gFont font, gColor color, gColor bgcolor)
Draw a text character with a filled background.
#define GDISP_NEED_TEXT_BOXPADLR
Adding pixels to the left and right side of the box to pad text.
gCoord gdispGetFontMetric(gFont font, gFontmetric metric)
Get a metric of a font.
void gdispGClear(GDisplay *g, gColor color)
Clear the display to the specified color.
void gdispGSetClip(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy)
Clip all drawing to the defined area.
GDisplay * GDISP
The default screen to use for the gdispXXXX calls.
void gdispGFillCircle(GDisplay *g, gCoord x, gCoord y, gCoord radius, gColor color)
Draw a filled circle.
void gdispGDrawPoly(GDisplay *g, gCoord tx, gCoord ty, const gPoint *pntarray, unsigned cnt, gColor color)
Draw an enclosed polygon (convex, non-convex or complex).
void gdispGDrawStringBox(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, const char *str, gFont font, gColor color, gJustify justify)
Draw a text string vertically centered within the specified box.
void gdispGDrawRoundedBox(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord radius, gColor color)
Draw a rectangular box with rounded corners.
void gdispGDrawEllipse(GDisplay *g, gCoord x, gCoord y, gCoord a, gCoord b, gColor color)
Draw an ellipse.
const struct mf_font_s * gFont
The type of a font.
void gdispGFlush(GDisplay *g)
Flush current drawing operations to the display.
void * gdispGQuery(GDisplay *g, unsigned what)
Query a property of the display.
void gdispGBlitArea(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord srcx, gCoord srcy, gCoord srccx, const gPixel *buffer)
Fill an area using the supplied bitmap.
gColor gPixel
The pixel format.
gU8 gdispGGetContrast(GDisplay *g)
Get the current display contrast.
void gdispGStreamStart(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy)
Start a streaming operation.
gJustify
Type for the text justification.
void gdispGFillArcSectors(GDisplay *g, gCoord x, gCoord y, gCoord radius, gU8 sectors, gColor color)
Fill a selection of 45 degree arcs of a circle.
void gdispGControl(GDisplay *g, unsigned what, void *value)
Control hardware specific parts of the display. eg powermodes, backlight etc.
void gdispGDrawThickArc(GDisplay *g, gCoord xc, gCoord yc, gCoord startradius, gCoord endradius, gCoord startangle, gCoord endangle, gColor color)
Draw a thick arc.
gOrientation
Type for the screen orientation.
gOrientation gdispGGetOrientation(GDisplay *g)
Get the current display orientation.
void gdispGFillEllipse(GDisplay *g, gCoord x, gCoord y, gCoord a, gCoord b, gColor color)
Draw a filled ellipse.
void gdispGDrawCircle(GDisplay *g, gCoord x, gCoord y, gCoord radius, gColor color)
Draw a circle.
gCoord gdispGGetWidth(GDisplay *g)
Get the display width in pixels.
gColor gdispContrastColor(gColor color)
Find a contrasting color.
void gdispGFillArc(GDisplay *g, gCoord x, gCoord y, gCoord radius, gCoord startangle, gCoord endangle, gColor color)
Draw a filled arc.
#define GDISP_DRIVER_LIST
The list of display drivers.
gPowermode
Type for the available power modes for the screen.
void gdispGFillArea(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, gColor color)
Fill an area with a color.
void gdispGDrawChar(GDisplay *g, gCoord x, gCoord y, gU16 c, gFont font, gColor color)
Draw a text character.
void gdispSetDisplay(GDisplay *g)
Set the current default display to the specified display.
void gdispGDrawLine(GDisplay *g, gCoord x0, gCoord y0, gCoord x1, gCoord y1, gColor color)
Draw a line.
#define GDISP_NEED_TEXT_BOXPADTB
Adding pixels to the top and bottom side of the box to pad text.
void gdispGStreamStop(GDisplay *g)
Finish the current streaming operation.
void gdispGFillRoundedBox(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord radius, gColor color)
Draw a filled rectangular box with rounded corners.
void gdispGDrawArc(GDisplay *g, gCoord x, gCoord y, gCoord radius, gCoord startangle, gCoord endangle, gColor color)
Draw an arc.
unsigned gdispGetDisplayCount(void)
Get the count of currently active displays.
void gdispGFillStringBox(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, const char *str, gFont font, gColor color, gColor bgColor, gJustify justify)
Draw a text string vertically centered within the specified box. The box background is filled with th...
gColor gdispGGetPixelColor(GDisplay *g, gCoord x, gCoord y)
Get the color of a pixel.
#define GDISP_NEED_TIMERFLUSH
Should drawing operations be automatically flushed on a timer.
#define GDISP_STARTUP_COLOR
Define the initial background color for all displays in the system.
gCoord gdispGetStringWidthCount(const char *str, gFont font, gU16 count)
Get the pixel width of a string of a given character length.
void gdispGDrawString(GDisplay *g, gCoord x, gCoord y, const char *str, gFont font, gColor color)
Draw a text string.
gPowermode gdispGGetPowerMode(GDisplay *g)
Get the current display power mode.
void gdispGDrawThickLine(GDisplay *g, gCoord x0, gCoord y0, gCoord x1, gCoord y1, gColor color, gCoord width, gBool round)
Draw a line with a specified thickness.
gCoord gdispGGetHeight(GDisplay *g)
Get the display height in pixels.
void gdispGFillDualCircle(GDisplay *g, gCoord x, gCoord y, gCoord radius1, gColor color1, gCoord radius2, gColor color2)
Draw two filled circles with the same centre.
void gdispGFillString(GDisplay *g, gCoord x, gCoord y, const char *str, gFont font, gColor color, gColor bgcolor)
Draw a text string.
gI16 gCoord
The type for a coordinate or length on the screen.
gCoord gdispGetStringWidth(const char *str, gFont font)
Get the pixel width of an entire string.
void gdispGStreamColor(GDisplay *g, gColor color)
Send pixel data to the stream.
void gdispGFillConvexPoly(GDisplay *g, gCoord tx, gCoord ty, const gPoint *pntarray, unsigned cnt, gColor color)
Fill a convex polygon.
void gdispGDrawBox(GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, gColor color)
Draw a rectangular box.
#define GDISP_LINEBUF_SIZE
Define the default orientation for all displays in the system.
gFontmetric
Type for the font metric.
GDriver * gdriverRegister(const GDriverVMT *vmt, void *param)
Register a new driver instance.
GDriver * gdriverGetInstance(gU16 type, unsigned instance)
Get the driver for a particular instance of a type of device.
GDriver * gdriverGetNext(gU16 type, GDriver *driver)
Get the next driver for a type of device.
unsigned gdriverInstanceCount(gU16 type)
Get the count of instances of a type of device.
#define GFXINLINE
Mark a function as inline.
gI32 fixed
The type for a fixed point type.
fixed ffsin(int degrees)
Fast Table Based Trig functions.
double fsin(int degrees)
Fast Table Based Trig functions.
#define FIXED(x)
Macros to convert to and from a fixed point.
void gfxSleepMilliseconds(gDelay ms)
Put the current thread to sleep for the specified period in milliseconds.
void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, gBool periodic, gDelay millisec)
Set a timer going or alter its properties if it is already going.
void gtimerInit(GTimer *pt)
Initialise a timer.
All runtime driver structures start with this structure.
Type for a 2D point on the screen.