diff options
Diffstat (limited to 'firmware/drivers')
-rw-r--r-- | firmware/drivers/lcd-16bit-common.c | 103 | ||||
-rw-r--r-- | firmware/drivers/lcd-16bit-vert.c | 80 | ||||
-rw-r--r-- | firmware/drivers/lcd-16bit.c | 80 | ||||
-rw-r--r-- | firmware/drivers/lcd-1bit-vert.c | 86 | ||||
-rw-r--r-- | firmware/drivers/lcd-24bit.c | 180 | ||||
-rw-r--r-- | firmware/drivers/lcd-2bit-horz.c | 112 | ||||
-rw-r--r-- | firmware/drivers/lcd-2bit-vert.c | 111 | ||||
-rw-r--r-- | firmware/drivers/lcd-2bit-vi.c | 113 | ||||
-rw-r--r-- | firmware/drivers/lcd-bitmap-common.c | 4 | ||||
-rw-r--r-- | firmware/drivers/lcd-color-common.c | 8 |
10 files changed, 0 insertions, 877 deletions
diff --git a/firmware/drivers/lcd-16bit-common.c b/firmware/drivers/lcd-16bit-common.c index 1b84847929..523354d5d2 100644 --- a/firmware/drivers/lcd-16bit-common.c +++ b/firmware/drivers/lcd-16bit-common.c | |||
@@ -40,30 +40,6 @@ void lcd_clear_viewport(void) | |||
40 | width = lcd_current_viewport->width; | 40 | width = lcd_current_viewport->width; |
41 | height = lcd_current_viewport->height; | 41 | height = lcd_current_viewport->height; |
42 | 42 | ||
43 | #if defined(HAVE_VIEWPORT_CLIP) | ||
44 | /********************* Viewport on screen clipping ********************/ | ||
45 | /* nothing to draw? */ | ||
46 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
47 | || (x + width <= 0) || (y + height <= 0)) | ||
48 | return; | ||
49 | |||
50 | /* clip image in viewport in screen */ | ||
51 | if (x < 0) | ||
52 | { | ||
53 | width += x; | ||
54 | x = 0; | ||
55 | } | ||
56 | if (y < 0) | ||
57 | { | ||
58 | height += y; | ||
59 | y = 0; | ||
60 | } | ||
61 | if (x + width > LCD_WIDTH) | ||
62 | width = LCD_WIDTH - x; | ||
63 | if (y + height > LCD_HEIGHT) | ||
64 | height = LCD_HEIGHT - y; | ||
65 | #endif | ||
66 | |||
67 | len = STRIDE_MAIN(width, height); | 43 | len = STRIDE_MAIN(width, height); |
68 | step = STRIDE_MAIN(ROW_INC, COL_INC); | 44 | step = STRIDE_MAIN(ROW_INC, COL_INC); |
69 | 45 | ||
@@ -182,30 +158,6 @@ void lcd_fillrect(int x, int y, int width, int height) | |||
182 | x += lcd_current_viewport->x; | 158 | x += lcd_current_viewport->x; |
183 | y += lcd_current_viewport->y; | 159 | y += lcd_current_viewport->y; |
184 | 160 | ||
185 | #if defined(HAVE_VIEWPORT_CLIP) | ||
186 | /********************* Viewport on screen clipping ********************/ | ||
187 | /* nothing to draw? */ | ||
188 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
189 | || (x + width <= 0) || (y + height <= 0)) | ||
190 | return; | ||
191 | |||
192 | /* clip image in viewport in screen */ | ||
193 | if (x < 0) | ||
194 | { | ||
195 | width += x; | ||
196 | x = 0; | ||
197 | } | ||
198 | if (y < 0) | ||
199 | { | ||
200 | height += y; | ||
201 | y = 0; | ||
202 | } | ||
203 | if (x + width > LCD_WIDTH) | ||
204 | width = LCD_WIDTH - x; | ||
205 | if (y + height > LCD_HEIGHT) | ||
206 | height = LCD_HEIGHT - y; | ||
207 | #endif | ||
208 | |||
209 | /* drawmode and optimisation */ | 161 | /* drawmode and optimisation */ |
210 | if (lcd_current_viewport->drawmode & DRMODE_INVERSEVID) | 162 | if (lcd_current_viewport->drawmode & DRMODE_INVERSEVID) |
211 | { | 163 | { |
@@ -310,32 +262,6 @@ void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x, | |||
310 | x += lcd_current_viewport->x; | 262 | x += lcd_current_viewport->x; |
311 | y += lcd_current_viewport->y; | 263 | y += lcd_current_viewport->y; |
312 | 264 | ||
313 | #if defined(HAVE_VIEWPORT_CLIP) | ||
314 | /********************* Viewport on screen clipping ********************/ | ||
315 | /* nothing to draw? */ | ||
316 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
317 | || (x + width <= 0) || (y + height <= 0)) | ||
318 | return; | ||
319 | |||
320 | /* clip image in viewport in screen */ | ||
321 | if (x < 0) | ||
322 | { | ||
323 | width += x; | ||
324 | src_x -= x; | ||
325 | x = 0; | ||
326 | } | ||
327 | if (y < 0) | ||
328 | { | ||
329 | height += y; | ||
330 | src_y -= y; | ||
331 | y = 0; | ||
332 | } | ||
333 | if (x + width > LCD_WIDTH) | ||
334 | width = LCD_WIDTH - x; | ||
335 | if (y + height > LCD_HEIGHT) | ||
336 | height = LCD_HEIGHT - y; | ||
337 | #endif | ||
338 | |||
339 | /* move starting point */ | 265 | /* move starting point */ |
340 | src += stride * (src_y >> 3) + src_x; | 266 | src += stride * (src_y >> 3) + src_x; |
341 | src_y &= 7; | 267 | src_y &= 7; |
@@ -568,35 +494,6 @@ static void ICODE_ATTR lcd_alpha_bitmap_part_mix(const fb_data* image, | |||
568 | x += lcd_current_viewport->x; | 494 | x += lcd_current_viewport->x; |
569 | y += lcd_current_viewport->y; | 495 | y += lcd_current_viewport->y; |
570 | 496 | ||
571 | #if defined(HAVE_VIEWPORT_CLIP) | ||
572 | /********************* Viewport on screen clipping ********************/ | ||
573 | /* nothing to draw? */ | ||
574 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
575 | || (x + width <= 0) || (y + height <= 0)) | ||
576 | { | ||
577 | BLEND_FINISH; | ||
578 | return; | ||
579 | } | ||
580 | |||
581 | /* clip image in viewport in screen */ | ||
582 | if (x < 0) | ||
583 | { | ||
584 | width += x; | ||
585 | src_x -= x; | ||
586 | x = 0; | ||
587 | } | ||
588 | if (y < 0) | ||
589 | { | ||
590 | height += y; | ||
591 | src_y -= y; | ||
592 | y = 0; | ||
593 | } | ||
594 | if (x + width > LCD_WIDTH) | ||
595 | width = LCD_WIDTH - x; | ||
596 | if (y + height > LCD_HEIGHT) | ||
597 | height = LCD_HEIGHT - y; | ||
598 | #endif | ||
599 | |||
600 | /* the following drawmode combinations are possible: | 497 | /* the following drawmode combinations are possible: |
601 | * 1) COMPLEMENT: just negates the framebuffer contents | 498 | * 1) COMPLEMENT: just negates the framebuffer contents |
602 | * 2) BG and BG+backdrop: draws _only_ background pixels with either | 499 | * 2) BG and BG+backdrop: draws _only_ background pixels with either |
diff --git a/firmware/drivers/lcd-16bit-vert.c b/firmware/drivers/lcd-16bit-vert.c index 4422fdea50..166af02791 100644 --- a/firmware/drivers/lcd-16bit-vert.c +++ b/firmware/drivers/lcd-16bit-vert.c | |||
@@ -93,20 +93,6 @@ void lcd_hline(int x1, int x2, int y) | |||
93 | x2 += lcd_current_viewport->x; | 93 | x2 += lcd_current_viewport->x; |
94 | y += lcd_current_viewport->y; | 94 | y += lcd_current_viewport->y; |
95 | 95 | ||
96 | #if defined(HAVE_VIEWPORT_CLIP) | ||
97 | /********************* Viewport on screen clipping ********************/ | ||
98 | /* nothing to draw? */ | ||
99 | if (((unsigned)y >= (unsigned) LCD_HEIGHT) || (x1 >= LCD_WIDTH) | ||
100 | || (x2 < 0)) | ||
101 | return; | ||
102 | |||
103 | /* clipping */ | ||
104 | if (x1 < 0) | ||
105 | x1 = 0; | ||
106 | if (x2 >= LCD_WIDTH) | ||
107 | x2 = LCD_WIDTH-1; | ||
108 | #endif | ||
109 | |||
110 | dst = FBADDR(x1 , y ); | 96 | dst = FBADDR(x1 , y ); |
111 | stride_dst = lcd_current_viewport->buffer->stride; | 97 | stride_dst = lcd_current_viewport->buffer->stride; |
112 | dst_end = dst + (x2 - x1) * stride_dst; | 98 | dst_end = dst + (x2 - x1) * stride_dst; |
@@ -152,20 +138,6 @@ void lcd_vline(int x, int y1, int y2) | |||
152 | y1 += lcd_current_viewport->y; | 138 | y1 += lcd_current_viewport->y; |
153 | y2 += lcd_current_viewport->y; | 139 | y2 += lcd_current_viewport->y; |
154 | 140 | ||
155 | #if defined(HAVE_VIEWPORT_CLIP) | ||
156 | /********************* Viewport on screen clipping ********************/ | ||
157 | /* nothing to draw? */ | ||
158 | if (( (unsigned) x >= (unsigned)LCD_WIDTH) || (y1 >= LCD_HEIGHT) | ||
159 | || (y2 < 0)) | ||
160 | return; | ||
161 | |||
162 | /* clipping */ | ||
163 | if (y1 < 0) | ||
164 | y1 = 0; | ||
165 | if (y2 >= LCD_HEIGHT) | ||
166 | y2 = LCD_HEIGHT-1; | ||
167 | #endif | ||
168 | |||
169 | height = y2 - y1 + 1; | 141 | height = y2 - y1 + 1; |
170 | 142 | ||
171 | /* drawmode and optimisation */ | 143 | /* drawmode and optimisation */ |
@@ -250,32 +222,6 @@ void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y, | |||
250 | x += lcd_current_viewport->x; | 222 | x += lcd_current_viewport->x; |
251 | y += lcd_current_viewport->y; | 223 | y += lcd_current_viewport->y; |
252 | 224 | ||
253 | #if defined(HAVE_VIEWPORT_CLIP) | ||
254 | /********************* Viewport on screen clipping ********************/ | ||
255 | /* nothing to draw? */ | ||
256 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
257 | || (x + width <= 0) || (y + height <= 0)) | ||
258 | return; | ||
259 | |||
260 | /* clip image in viewport in screen */ | ||
261 | if (x < 0) | ||
262 | { | ||
263 | width += x; | ||
264 | src_x -= x; | ||
265 | x = 0; | ||
266 | } | ||
267 | if (y < 0) | ||
268 | { | ||
269 | height += y; | ||
270 | src_y -= y; | ||
271 | y = 0; | ||
272 | } | ||
273 | if (x + width > LCD_WIDTH) | ||
274 | width = LCD_WIDTH - x; | ||
275 | if (y + height > LCD_HEIGHT) | ||
276 | height = LCD_HEIGHT - y; | ||
277 | #endif | ||
278 | |||
279 | src += stride * src_x + src_y; /* move starting point */ | 225 | src += stride * src_x + src_y; /* move starting point */ |
280 | dst = FBADDR(x, y); | 226 | dst = FBADDR(x, y); |
281 | stride_dst = lcd_current_viewport->buffer->stride; | 227 | stride_dst = lcd_current_viewport->buffer->stride; |
@@ -326,32 +272,6 @@ void ICODE_ATTR lcd_bitmap_transparent_part(const fb_data *src, int src_x, | |||
326 | x += lcd_current_viewport->x; | 272 | x += lcd_current_viewport->x; |
327 | y += lcd_current_viewport->y; | 273 | y += lcd_current_viewport->y; |
328 | 274 | ||
329 | #if defined(HAVE_VIEWPORT_CLIP) | ||
330 | /********************* Viewport on screen clipping ********************/ | ||
331 | /* nothing to draw? */ | ||
332 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
333 | || (x + width <= 0) || (y + height <= 0)) | ||
334 | return; | ||
335 | |||
336 | /* clip image in viewport in screen */ | ||
337 | if (x < 0) | ||
338 | { | ||
339 | width += x; | ||
340 | src_x -= x; | ||
341 | x = 0; | ||
342 | } | ||
343 | if (y < 0) | ||
344 | { | ||
345 | height += y; | ||
346 | src_y -= y; | ||
347 | y = 0; | ||
348 | } | ||
349 | if (x + width > LCD_WIDTH) | ||
350 | width = LCD_WIDTH - x; | ||
351 | if (y + height > LCD_HEIGHT) | ||
352 | height = LCD_HEIGHT - y; | ||
353 | #endif | ||
354 | |||
355 | src += stride * src_x + src_y; /* move starting point */ | 275 | src += stride * src_x + src_y; /* move starting point */ |
356 | dst = FBADDR(x, y); | 276 | dst = FBADDR(x, y); |
357 | stride_dst = lcd_current_viewport->buffer->stride; | 277 | stride_dst = lcd_current_viewport->buffer->stride; |
diff --git a/firmware/drivers/lcd-16bit.c b/firmware/drivers/lcd-16bit.c index d6bf5a500d..6dff6f3b50 100644 --- a/firmware/drivers/lcd-16bit.c +++ b/firmware/drivers/lcd-16bit.c | |||
@@ -92,20 +92,6 @@ void lcd_hline(int x1, int x2, int y) | |||
92 | x2 += lcd_current_viewport->x; | 92 | x2 += lcd_current_viewport->x; |
93 | y += lcd_current_viewport->y; | 93 | y += lcd_current_viewport->y; |
94 | 94 | ||
95 | #if defined(HAVE_VIEWPORT_CLIP) | ||
96 | /********************* Viewport on screen clipping ********************/ | ||
97 | /* nothing to draw? */ | ||
98 | if (((unsigned)y >= (unsigned) LCD_HEIGHT) || (x1 >= LCD_WIDTH) | ||
99 | || (x2 < 0)) | ||
100 | return; | ||
101 | |||
102 | /* clipping */ | ||
103 | if (x1 < 0) | ||
104 | x1 = 0; | ||
105 | if (x2 >= LCD_WIDTH) | ||
106 | x2 = LCD_WIDTH-1; | ||
107 | #endif | ||
108 | |||
109 | width = x2 - x1 + 1; | 95 | width = x2 - x1 + 1; |
110 | 96 | ||
111 | /* drawmode and optimisation */ | 97 | /* drawmode and optimisation */ |
@@ -188,20 +174,6 @@ void lcd_vline(int x, int y1, int y2) | |||
188 | y1 += lcd_current_viewport->y; | 174 | y1 += lcd_current_viewport->y; |
189 | y2 += lcd_current_viewport->y; | 175 | y2 += lcd_current_viewport->y; |
190 | 176 | ||
191 | #if defined(HAVE_VIEWPORT_CLIP) | ||
192 | /********************* Viewport on screen clipping ********************/ | ||
193 | /* nothing to draw? */ | ||
194 | if (( (unsigned) x >= (unsigned)LCD_WIDTH) || (y1 >= LCD_HEIGHT) | ||
195 | || (y2 < 0)) | ||
196 | return; | ||
197 | |||
198 | /* clipping */ | ||
199 | if (y1 < 0) | ||
200 | y1 = 0; | ||
201 | if (y2 >= LCD_HEIGHT) | ||
202 | y2 = LCD_HEIGHT-1; | ||
203 | #endif | ||
204 | |||
205 | dst = FBADDR(x , y1); | 177 | dst = FBADDR(x , y1); |
206 | stride_dst = lcd_current_viewport->buffer->stride; | 178 | stride_dst = lcd_current_viewport->buffer->stride; |
207 | dst_end = dst + (y2 - y1) * stride_dst; | 179 | dst_end = dst + (y2 - y1) * stride_dst; |
@@ -250,32 +222,6 @@ void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y, | |||
250 | x += lcd_current_viewport->x; | 222 | x += lcd_current_viewport->x; |
251 | y += lcd_current_viewport->y; | 223 | y += lcd_current_viewport->y; |
252 | 224 | ||
253 | #if defined(HAVE_VIEWPORT_CLIP) | ||
254 | /********************* Viewport on screen clipping ********************/ | ||
255 | /* nothing to draw? */ | ||
256 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
257 | || (x + width <= 0) || (y + height <= 0)) | ||
258 | return; | ||
259 | |||
260 | /* clip image in viewport in screen */ | ||
261 | if (x < 0) | ||
262 | { | ||
263 | width += x; | ||
264 | src_x -= x; | ||
265 | x = 0; | ||
266 | } | ||
267 | if (y < 0) | ||
268 | { | ||
269 | height += y; | ||
270 | src_y -= y; | ||
271 | y = 0; | ||
272 | } | ||
273 | if (x + width > LCD_WIDTH) | ||
274 | width = LCD_WIDTH - x; | ||
275 | if (y + height > LCD_HEIGHT) | ||
276 | height = LCD_HEIGHT - y; | ||
277 | #endif | ||
278 | |||
279 | src += stride * src_y + src_x; /* move starting point */ | 225 | src += stride * src_y + src_x; /* move starting point */ |
280 | dst = FBADDR(x, y); | 226 | dst = FBADDR(x, y); |
281 | stride_dst = lcd_current_viewport->buffer->stride; | 227 | stride_dst = lcd_current_viewport->buffer->stride; |
@@ -326,32 +272,6 @@ void ICODE_ATTR lcd_bitmap_transparent_part(const fb_data *src, int src_x, | |||
326 | x += lcd_current_viewport->x; | 272 | x += lcd_current_viewport->x; |
327 | y += lcd_current_viewport->y; | 273 | y += lcd_current_viewport->y; |
328 | 274 | ||
329 | #if defined(HAVE_VIEWPORT_CLIP) | ||
330 | /********************* Viewport on screen clipping ********************/ | ||
331 | /* nothing to draw? */ | ||
332 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
333 | || (x + width <= 0) || (y + height <= 0)) | ||
334 | return; | ||
335 | |||
336 | /* clip image in viewport in screen */ | ||
337 | if (x < 0) | ||
338 | { | ||
339 | width += x; | ||
340 | src_x -= x; | ||
341 | x = 0; | ||
342 | } | ||
343 | if (y < 0) | ||
344 | { | ||
345 | height += y; | ||
346 | src_y -= y; | ||
347 | y = 0; | ||
348 | } | ||
349 | if (x + width > LCD_WIDTH) | ||
350 | width = LCD_WIDTH - x; | ||
351 | if (y + height > LCD_HEIGHT) | ||
352 | height = LCD_HEIGHT - y; | ||
353 | #endif | ||
354 | |||
355 | src += stride * src_y + src_x; /* move starting point */ | 275 | src += stride * src_y + src_x; /* move starting point */ |
356 | dst = FBADDR(x, y); | 276 | dst = FBADDR(x, y); |
357 | 277 | ||
diff --git a/firmware/drivers/lcd-1bit-vert.c b/firmware/drivers/lcd-1bit-vert.c index dcf5e49504..ff95eacdbc 100644 --- a/firmware/drivers/lcd-1bit-vert.c +++ b/firmware/drivers/lcd-1bit-vert.c | |||
@@ -274,10 +274,6 @@ void LCDFN(drawpixel)(int x, int y) | |||
274 | { | 274 | { |
275 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) | 275 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) |
276 | && ((unsigned)y < (unsigned)CURRENT_VP->height) | 276 | && ((unsigned)y < (unsigned)CURRENT_VP->height) |
277 | #if defined(HAVE_VIEWPORT_CLIP) | ||
278 | && ((unsigned)x < (unsigned)LCDM(WIDTH)) | ||
279 | && ((unsigned)y < (unsigned)LCDM(HEIGHT)) | ||
280 | #endif | ||
281 | ) | 277 | ) |
282 | LCDFN(pixelfuncs)[CURRENT_VP->drawmode](CURRENT_VP->x + x, CURRENT_VP->y + y); | 278 | LCDFN(pixelfuncs)[CURRENT_VP->drawmode](CURRENT_VP->x + x, CURRENT_VP->y + y); |
283 | } | 279 | } |
@@ -349,10 +345,6 @@ void LCDFN(drawline)(int x1, int y1, int x2, int y2) | |||
349 | { | 345 | { |
350 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) | 346 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) |
351 | && ((unsigned)y < (unsigned)CURRENT_VP->height) | 347 | && ((unsigned)y < (unsigned)CURRENT_VP->height) |
352 | #if defined(HAVE_VIEWPORT_CLIP) | ||
353 | && ((unsigned)x < (unsigned)LCDM(WIDTH)) | ||
354 | && ((unsigned)y < (unsigned)LCDM(HEIGHT)) | ||
355 | #endif | ||
356 | ) | 348 | ) |
357 | pfunc(CURRENT_VP->x + x, CURRENT_VP->y + y); | 349 | pfunc(CURRENT_VP->x + x, CURRENT_VP->y + y); |
358 | 350 | ||
@@ -403,20 +395,6 @@ void LCDFN(hline)(int x1, int x2, int y) | |||
403 | x2 += CURRENT_VP->x; | 395 | x2 += CURRENT_VP->x; |
404 | y += CURRENT_VP->y; | 396 | y += CURRENT_VP->y; |
405 | 397 | ||
406 | #if defined(HAVE_VIEWPORT_CLIP) | ||
407 | /********************* Viewport on screen clipping ********************/ | ||
408 | /* nothing to draw? */ | ||
409 | if (((unsigned)y >= (unsigned) LCDM(HEIGHT)) || (x1 >= LCDM(WIDTH)) | ||
410 | || (x2 < 0)) | ||
411 | return; | ||
412 | |||
413 | /* clipping */ | ||
414 | if (x1 < 0) | ||
415 | x1 = 0; | ||
416 | if (x2 >= LCDM(WIDTH)) | ||
417 | x2 = LCDM(WIDTH)-1; | ||
418 | #endif | ||
419 | |||
420 | width = x2 - x1 + 1; | 398 | width = x2 - x1 + 1; |
421 | 399 | ||
422 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; | 400 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; |
@@ -462,20 +440,6 @@ void LCDFN(vline)(int x, int y1, int y2) | |||
462 | y2 += CURRENT_VP->y; | 440 | y2 += CURRENT_VP->y; |
463 | x += CURRENT_VP->x; | 441 | x += CURRENT_VP->x; |
464 | 442 | ||
465 | #if defined(HAVE_VIEWPORT_CLIP) | ||
466 | /********************* Viewport on screen clipping ********************/ | ||
467 | /* nothing to draw? */ | ||
468 | if (( (unsigned) x >= (unsigned)LCDM(WIDTH)) || (y1 >= LCDM(HEIGHT)) | ||
469 | || (y2 < 0)) | ||
470 | return; | ||
471 | |||
472 | /* clipping */ | ||
473 | if (y1 < 0) | ||
474 | y1 = 0; | ||
475 | if (y2 >= LCDM(HEIGHT)) | ||
476 | y2 = LCDM(HEIGHT)-1; | ||
477 | #endif | ||
478 | |||
479 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; | 443 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; |
480 | dst = LCDFB(x,y1>>3); | 444 | dst = LCDFB(x,y1>>3); |
481 | ny = y2 - (y1 & ~7); | 445 | ny = y2 - (y1 & ~7); |
@@ -544,30 +508,6 @@ void LCDFN(fillrect)(int x, int y, int width, int height) | |||
544 | x += CURRENT_VP->x; | 508 | x += CURRENT_VP->x; |
545 | y += CURRENT_VP->y; | 509 | y += CURRENT_VP->y; |
546 | 510 | ||
547 | #if defined(HAVE_VIEWPORT_CLIP) | ||
548 | /********************* Viewport on screen clipping ********************/ | ||
549 | /* nothing to draw? */ | ||
550 | if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT)) | ||
551 | || (x + width <= 0) || (y + height <= 0)) | ||
552 | return; | ||
553 | |||
554 | /* clip image in viewport in screen */ | ||
555 | if (x < 0) | ||
556 | { | ||
557 | width += x; | ||
558 | x = 0; | ||
559 | } | ||
560 | if (y < 0) | ||
561 | { | ||
562 | height += y; | ||
563 | y = 0; | ||
564 | } | ||
565 | if (x + width > LCDM(WIDTH)) | ||
566 | width = LCDM(WIDTH) - x; | ||
567 | if (y + height > LCDM(HEIGHT)) | ||
568 | height = LCDM(HEIGHT) - y; | ||
569 | #endif | ||
570 | |||
571 | if (CURRENT_VP->drawmode & DRMODE_INVERSEVID) | 511 | if (CURRENT_VP->drawmode & DRMODE_INVERSEVID) |
572 | { | 512 | { |
573 | if (CURRENT_VP->drawmode & DRMODE_BG) | 513 | if (CURRENT_VP->drawmode & DRMODE_BG) |
@@ -670,32 +610,6 @@ void ICODE_ATTR LCDFN(bitmap_part)(const unsigned char *src, int src_x, | |||
670 | x += CURRENT_VP->x; | 610 | x += CURRENT_VP->x; |
671 | y += CURRENT_VP->y; | 611 | y += CURRENT_VP->y; |
672 | 612 | ||
673 | #if defined(HAVE_VIEWPORT_CLIP) | ||
674 | /********************* Viewport on screen clipping ********************/ | ||
675 | /* nothing to draw? */ | ||
676 | if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT)) | ||
677 | || (x + width <= 0) || (y + height <= 0)) | ||
678 | return; | ||
679 | |||
680 | /* clip image in viewport in screen */ | ||
681 | if (x < 0) | ||
682 | { | ||
683 | width += x; | ||
684 | src_x -= x; | ||
685 | x = 0; | ||
686 | } | ||
687 | if (y < 0) | ||
688 | { | ||
689 | height += y; | ||
690 | src_y -= y; | ||
691 | y = 0; | ||
692 | } | ||
693 | if (x + width > LCDM(WIDTH)) | ||
694 | width = LCDM(WIDTH) - x; | ||
695 | if (y + height > LCDM(HEIGHT)) | ||
696 | height = LCDM(HEIGHT) - y; | ||
697 | #endif | ||
698 | |||
699 | src += stride * (src_y >> 3) + src_x; /* move starting point */ | 613 | src += stride * (src_y >> 3) + src_x; /* move starting point */ |
700 | src_y &= 7; | 614 | src_y &= 7; |
701 | y -= src_y; | 615 | y -= src_y; |
diff --git a/firmware/drivers/lcd-24bit.c b/firmware/drivers/lcd-24bit.c index c3aa27f7ce..279ed5924a 100644 --- a/firmware/drivers/lcd-24bit.c +++ b/firmware/drivers/lcd-24bit.c | |||
@@ -70,30 +70,6 @@ void lcd_clear_viewport(void) | |||
70 | width = lcd_current_viewport->width; | 70 | width = lcd_current_viewport->width; |
71 | height = lcd_current_viewport->height; | 71 | height = lcd_current_viewport->height; |
72 | 72 | ||
73 | #if defined(HAVE_VIEWPORT_CLIP) | ||
74 | /********************* Viewport on screen clipping ********************/ | ||
75 | /* nothing to draw? */ | ||
76 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
77 | || (x + width <= 0) || (y + height <= 0)) | ||
78 | return; | ||
79 | |||
80 | /* clip image in viewport in screen */ | ||
81 | if (x < 0) | ||
82 | { | ||
83 | width += x; | ||
84 | x = 0; | ||
85 | } | ||
86 | if (y < 0) | ||
87 | { | ||
88 | height += y; | ||
89 | y = 0; | ||
90 | } | ||
91 | if (x + width > LCD_WIDTH) | ||
92 | width = LCD_WIDTH - x; | ||
93 | if (y + height > LCD_HEIGHT) | ||
94 | height = LCD_HEIGHT - y; | ||
95 | #endif | ||
96 | |||
97 | len = STRIDE_MAIN(width, height); | 73 | len = STRIDE_MAIN(width, height); |
98 | step = STRIDE_MAIN(ROW_INC, COL_INC); | 74 | step = STRIDE_MAIN(ROW_INC, COL_INC); |
99 | 75 | ||
@@ -222,30 +198,6 @@ void lcd_fillrect(int x, int y, int width, int height) | |||
222 | x += lcd_current_viewport->x; | 198 | x += lcd_current_viewport->x; |
223 | y += lcd_current_viewport->y; | 199 | y += lcd_current_viewport->y; |
224 | 200 | ||
225 | #if defined(HAVE_VIEWPORT_CLIP) | ||
226 | /********************* Viewport on screen clipping ********************/ | ||
227 | /* nothing to draw? */ | ||
228 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
229 | || (x + width <= 0) || (y + height <= 0)) | ||
230 | return; | ||
231 | |||
232 | /* clip image in viewport in screen */ | ||
233 | if (x < 0) | ||
234 | { | ||
235 | width += x; | ||
236 | x = 0; | ||
237 | } | ||
238 | if (y < 0) | ||
239 | { | ||
240 | height += y; | ||
241 | y = 0; | ||
242 | } | ||
243 | if (x + width > LCD_WIDTH) | ||
244 | width = LCD_WIDTH - x; | ||
245 | if (y + height > LCD_HEIGHT) | ||
246 | height = LCD_HEIGHT - y; | ||
247 | #endif | ||
248 | |||
249 | /* drawmode and optimisation */ | 201 | /* drawmode and optimisation */ |
250 | if (lcd_current_viewport->drawmode & DRMODE_INVERSEVID) | 202 | if (lcd_current_viewport->drawmode & DRMODE_INVERSEVID) |
251 | { | 203 | { |
@@ -362,32 +314,6 @@ void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x, | |||
362 | x += lcd_current_viewport->x; | 314 | x += lcd_current_viewport->x; |
363 | y += lcd_current_viewport->y; | 315 | y += lcd_current_viewport->y; |
364 | 316 | ||
365 | #if defined(HAVE_VIEWPORT_CLIP) | ||
366 | /********************* Viewport on screen clipping ********************/ | ||
367 | /* nothing to draw? */ | ||
368 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
369 | || (x + width <= 0) || (y + height <= 0)) | ||
370 | return; | ||
371 | |||
372 | /* clip image in viewport in screen */ | ||
373 | if (x < 0) | ||
374 | { | ||
375 | width += x; | ||
376 | src_x -= x; | ||
377 | x = 0; | ||
378 | } | ||
379 | if (y < 0) | ||
380 | { | ||
381 | height += y; | ||
382 | src_y -= y; | ||
383 | y = 0; | ||
384 | } | ||
385 | if (x + width > LCD_WIDTH) | ||
386 | width = LCD_WIDTH - x; | ||
387 | if (y + height > LCD_HEIGHT) | ||
388 | height = LCD_HEIGHT - y; | ||
389 | #endif | ||
390 | |||
391 | src += stride * (src_y >> 3) + src_x; /* move starting point */ | 317 | src += stride * (src_y >> 3) + src_x; /* move starting point */ |
392 | src_y &= 7; | 318 | src_y &= 7; |
393 | src_end = src + width; | 319 | src_end = src + width; |
@@ -592,32 +518,6 @@ static void ICODE_ATTR lcd_alpha_bitmap_part_mix(const fb_data* image, | |||
592 | x += lcd_current_viewport->x; | 518 | x += lcd_current_viewport->x; |
593 | y += lcd_current_viewport->y; | 519 | y += lcd_current_viewport->y; |
594 | 520 | ||
595 | #if defined(HAVE_VIEWPORT_CLIP) | ||
596 | /********************* Viewport on screen clipping ********************/ | ||
597 | /* nothing to draw? */ | ||
598 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
599 | || (x + width <= 0) || (y + height <= 0)) | ||
600 | return; | ||
601 | |||
602 | /* clip image in viewport in screen */ | ||
603 | if (x < 0) | ||
604 | { | ||
605 | width += x; | ||
606 | src_x -= x; | ||
607 | x = 0; | ||
608 | } | ||
609 | if (y < 0) | ||
610 | { | ||
611 | height += y; | ||
612 | src_y -= y; | ||
613 | y = 0; | ||
614 | } | ||
615 | if (x + width > LCD_WIDTH) | ||
616 | width = LCD_WIDTH - x; | ||
617 | if (y + height > LCD_HEIGHT) | ||
618 | height = LCD_HEIGHT - y; | ||
619 | #endif | ||
620 | |||
621 | /* the following drawmode combinations are possible: | 521 | /* the following drawmode combinations are possible: |
622 | * 1) COMPLEMENT: just negates the framebuffer contents | 522 | * 1) COMPLEMENT: just negates the framebuffer contents |
623 | * 2) BG and BG+backdrop: draws _only_ background pixels with either | 523 | * 2) BG and BG+backdrop: draws _only_ background pixels with either |
@@ -887,20 +787,6 @@ void lcd_hline(int x1, int x2, int y) | |||
887 | x2 += lcd_current_viewport->x; | 787 | x2 += lcd_current_viewport->x; |
888 | y += lcd_current_viewport->y; | 788 | y += lcd_current_viewport->y; |
889 | 789 | ||
890 | #if defined(HAVE_VIEWPORT_CLIP) | ||
891 | /********************* Viewport on screen clipping ********************/ | ||
892 | /* nothing to draw? */ | ||
893 | if (((unsigned)y >= (unsigned) LCD_HEIGHT) || (x1 >= LCD_WIDTH) | ||
894 | || (x2 < 0)) | ||
895 | return; | ||
896 | |||
897 | /* clipping */ | ||
898 | if (x1 < 0) | ||
899 | x1 = 0; | ||
900 | if (x2 >= LCD_WIDTH) | ||
901 | x2 = LCD_WIDTH-1; | ||
902 | #endif | ||
903 | |||
904 | width = x2 - x1 + 1; | 790 | width = x2 - x1 + 1; |
905 | 791 | ||
906 | dst = FBADDR(x1 , y); | 792 | dst = FBADDR(x1 , y); |
@@ -944,20 +830,6 @@ void lcd_vline(int x, int y1, int y2) | |||
944 | y1 += lcd_current_viewport->y; | 830 | y1 += lcd_current_viewport->y; |
945 | y2 += lcd_current_viewport->y; | 831 | y2 += lcd_current_viewport->y; |
946 | 832 | ||
947 | #if defined(HAVE_VIEWPORT_CLIP) | ||
948 | /********************* Viewport on screen clipping ********************/ | ||
949 | /* nothing to draw? */ | ||
950 | if (( (unsigned) x >= (unsigned)LCD_WIDTH) || (y1 >= LCD_HEIGHT) | ||
951 | || (y2 < 0)) | ||
952 | return; | ||
953 | |||
954 | /* clipping */ | ||
955 | if (y1 < 0) | ||
956 | y1 = 0; | ||
957 | if (y2 >= LCD_HEIGHT) | ||
958 | y2 = LCD_HEIGHT-1; | ||
959 | #endif | ||
960 | |||
961 | dst = FBADDR(x , y1); | 833 | dst = FBADDR(x , y1); |
962 | dst_end = dst + (y2 - y1) * LCD_WIDTH; | 834 | dst_end = dst + (y2 - y1) * LCD_WIDTH; |
963 | 835 | ||
@@ -1004,32 +876,6 @@ void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y, | |||
1004 | x += lcd_current_viewport->x; | 876 | x += lcd_current_viewport->x; |
1005 | y += lcd_current_viewport->y; | 877 | y += lcd_current_viewport->y; |
1006 | 878 | ||
1007 | #if defined(HAVE_VIEWPORT_CLIP) | ||
1008 | /********************* Viewport on screen clipping ********************/ | ||
1009 | /* nothing to draw? */ | ||
1010 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
1011 | || (x + width <= 0) || (y + height <= 0)) | ||
1012 | return; | ||
1013 | |||
1014 | /* clip image in viewport in screen */ | ||
1015 | if (x < 0) | ||
1016 | { | ||
1017 | width += x; | ||
1018 | src_x -= x; | ||
1019 | x = 0; | ||
1020 | } | ||
1021 | if (y < 0) | ||
1022 | { | ||
1023 | height += y; | ||
1024 | src_y -= y; | ||
1025 | y = 0; | ||
1026 | } | ||
1027 | if (x + width > LCD_WIDTH) | ||
1028 | width = LCD_WIDTH - x; | ||
1029 | if (y + height > LCD_HEIGHT) | ||
1030 | height = LCD_HEIGHT - y; | ||
1031 | #endif | ||
1032 | |||
1033 | src += stride * src_y + src_x; /* move starting point */ | 879 | src += stride * src_y + src_x; /* move starting point */ |
1034 | dst = FBADDR(x, y); | 880 | dst = FBADDR(x, y); |
1035 | 881 | ||
@@ -1078,32 +924,6 @@ void ICODE_ATTR lcd_bitmap_transparent_part(const fb_data *src, int src_x, | |||
1078 | x += lcd_current_viewport->x; | 924 | x += lcd_current_viewport->x; |
1079 | y += lcd_current_viewport->y; | 925 | y += lcd_current_viewport->y; |
1080 | 926 | ||
1081 | #if defined(HAVE_VIEWPORT_CLIP) | ||
1082 | /********************* Viewport on screen clipping ********************/ | ||
1083 | /* nothing to draw? */ | ||
1084 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
1085 | || (x + width <= 0) || (y + height <= 0)) | ||
1086 | return; | ||
1087 | |||
1088 | /* clip image in viewport in screen */ | ||
1089 | if (x < 0) | ||
1090 | { | ||
1091 | width += x; | ||
1092 | src_x -= x; | ||
1093 | x = 0; | ||
1094 | } | ||
1095 | if (y < 0) | ||
1096 | { | ||
1097 | height += y; | ||
1098 | src_y -= y; | ||
1099 | y = 0; | ||
1100 | } | ||
1101 | if (x + width > LCD_WIDTH) | ||
1102 | width = LCD_WIDTH - x; | ||
1103 | if (y + height > LCD_HEIGHT) | ||
1104 | height = LCD_HEIGHT - y; | ||
1105 | #endif | ||
1106 | |||
1107 | src += stride * src_y + src_x; /* move starting point */ | 927 | src += stride * src_y + src_x; /* move starting point */ |
1108 | dst = FBADDR(x, y); | 928 | dst = FBADDR(x, y); |
1109 | 929 | ||
diff --git a/firmware/drivers/lcd-2bit-horz.c b/firmware/drivers/lcd-2bit-horz.c index 85918a735c..66313d624b 100644 --- a/firmware/drivers/lcd-2bit-horz.c +++ b/firmware/drivers/lcd-2bit-horz.c | |||
@@ -420,10 +420,6 @@ void lcd_drawpixel(int x, int y) | |||
420 | { | 420 | { |
421 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) | 421 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) |
422 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) | 422 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) |
423 | #if defined(HAVE_VIEWPORT_CLIP) | ||
424 | && ((unsigned)x < (unsigned)LCD_WIDTH) | ||
425 | && ((unsigned)y < (unsigned)LCD_HEIGHT) | ||
426 | #endif | ||
427 | ) | 423 | ) |
428 | lcd_pixelfuncs[lcd_current_viewport->drawmode](lcd_current_viewport->x + x, lcd_current_viewport->y + y); | 424 | lcd_pixelfuncs[lcd_current_viewport->drawmode](lcd_current_viewport->x + x, lcd_current_viewport->y + y); |
429 | } | 425 | } |
@@ -495,10 +491,6 @@ void lcd_drawline(int x1, int y1, int x2, int y2) | |||
495 | { | 491 | { |
496 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) | 492 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) |
497 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) | 493 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) |
498 | #if defined(HAVE_VIEWPORT_CLIP) | ||
499 | && ((unsigned)x < (unsigned)LCD_WIDTH) | ||
500 | && ((unsigned)y < (unsigned)LCD_HEIGHT) | ||
501 | #endif | ||
502 | ) | 494 | ) |
503 | pfunc(lcd_current_viewport->x + x, lcd_current_viewport->y + y); | 495 | pfunc(lcd_current_viewport->x + x, lcd_current_viewport->y + y); |
504 | 496 | ||
@@ -549,20 +541,6 @@ void lcd_hline(int x1, int x2, int y) | |||
549 | x2 += lcd_current_viewport->x; | 541 | x2 += lcd_current_viewport->x; |
550 | y += lcd_current_viewport->y; | 542 | y += lcd_current_viewport->y; |
551 | 543 | ||
552 | #if defined(HAVE_VIEWPORT_CLIP) | ||
553 | /********************* Viewport on screen clipping ********************/ | ||
554 | /* nothing to draw? */ | ||
555 | if (((unsigned)y >= (unsigned) LCD_HEIGHT) || (x1 >= LCD_WIDTH) | ||
556 | || (x2 < 0)) | ||
557 | return; | ||
558 | |||
559 | /* clipping */ | ||
560 | if (x1 < 0) | ||
561 | x1 = 0; | ||
562 | if (x2 >= LCD_WIDTH) | ||
563 | x2 = LCD_WIDTH-1; | ||
564 | #endif | ||
565 | |||
566 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; | 544 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; |
567 | dst = FBADDR(x1>>2,y); | 545 | dst = FBADDR(x1>>2,y); |
568 | nx = x2 - (x1 & ~3); | 546 | nx = x2 - (x1 & ~3); |
@@ -611,20 +589,6 @@ void lcd_vline(int x, int y1, int y2) | |||
611 | y2 += lcd_current_viewport->y; | 589 | y2 += lcd_current_viewport->y; |
612 | x += lcd_current_viewport->x; | 590 | x += lcd_current_viewport->x; |
613 | 591 | ||
614 | #if defined(HAVE_VIEWPORT_CLIP) | ||
615 | /********************* Viewport on screen clipping ********************/ | ||
616 | /* nothing to draw? */ | ||
617 | if (( (unsigned) x >= (unsigned)LCD_WIDTH) || (y1 >= LCD_HEIGHT) | ||
618 | || (y2 < 0)) | ||
619 | return; | ||
620 | |||
621 | /* clipping */ | ||
622 | if (y1 < 0) | ||
623 | y1 = 0; | ||
624 | if (y2 >= LCD_HEIGHT) | ||
625 | y2 = LCD_HEIGHT-1; | ||
626 | #endif | ||
627 | |||
628 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; | 592 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; |
629 | dst = FBADDR(x>>2,y1); | 593 | dst = FBADDR(x>>2,y1); |
630 | stride_dst = LCD_FBSTRIDE(lcd_current_viewport->buffer->stride, 0); | 594 | stride_dst = LCD_FBSTRIDE(lcd_current_viewport->buffer->stride, 0); |
@@ -688,30 +652,6 @@ void lcd_fillrect(int x, int y, int width, int height) | |||
688 | x += lcd_current_viewport->x; | 652 | x += lcd_current_viewport->x; |
689 | y += lcd_current_viewport->y; | 653 | y += lcd_current_viewport->y; |
690 | 654 | ||
691 | #if defined(HAVE_VIEWPORT_CLIP) | ||
692 | /********************* Viewport on screen clipping ********************/ | ||
693 | /* nothing to draw? */ | ||
694 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
695 | || (x + width <= 0) || (y + height <= 0)) | ||
696 | return; | ||
697 | |||
698 | /* clip image in viewport in screen */ | ||
699 | if (x < 0) | ||
700 | { | ||
701 | width += x; | ||
702 | x = 0; | ||
703 | } | ||
704 | if (y < 0) | ||
705 | { | ||
706 | height += y; | ||
707 | y = 0; | ||
708 | } | ||
709 | if (x + width > LCD_WIDTH) | ||
710 | width = LCD_WIDTH - x; | ||
711 | if (y + height > LCD_HEIGHT) | ||
712 | height = LCD_HEIGHT - y; | ||
713 | #endif | ||
714 | |||
715 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; | 655 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; |
716 | dst = FBADDR(x>>2,y); | 656 | dst = FBADDR(x>>2,y); |
717 | stride_dst = LCD_FBSTRIDE(lcd_current_viewport->buffer->stride, 0); | 657 | stride_dst = LCD_FBSTRIDE(lcd_current_viewport->buffer->stride, 0); |
@@ -792,32 +732,6 @@ void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x, | |||
792 | x += lcd_current_viewport->x; /* adjust for viewport */ | 732 | x += lcd_current_viewport->x; /* adjust for viewport */ |
793 | y += lcd_current_viewport->y; /* adjust for viewport */ | 733 | y += lcd_current_viewport->y; /* adjust for viewport */ |
794 | 734 | ||
795 | #if defined(HAVE_VIEWPORT_CLIP) | ||
796 | /********************* Viewport on screen clipping ********************/ | ||
797 | /* nothing to draw? */ | ||
798 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
799 | || (x + width <= 0) || (y + height <= 0)) | ||
800 | return; | ||
801 | |||
802 | /* clip image in viewport in screen */ | ||
803 | if (x < 0) | ||
804 | { | ||
805 | width += x; | ||
806 | src_x -= x; | ||
807 | x = 0; | ||
808 | } | ||
809 | if (y < 0) | ||
810 | { | ||
811 | height += y; | ||
812 | src_y -= y; | ||
813 | y = 0; | ||
814 | } | ||
815 | if (x + width > LCD_WIDTH) | ||
816 | width = LCD_WIDTH - x; | ||
817 | if (y + height > LCD_HEIGHT) | ||
818 | height = LCD_HEIGHT - y; | ||
819 | #endif | ||
820 | |||
821 | src += stride * (src_y >> 3) + src_x; /* move starting point */ | 735 | src += stride * (src_y >> 3) + src_x; /* move starting point */ |
822 | src_y &= 7; | 736 | src_y &= 7; |
823 | src_end = src + width; | 737 | src_end = src + width; |
@@ -1007,32 +921,6 @@ void ICODE_ATTR lcd_bitmap_part(const unsigned char *src, int src_x, | |||
1007 | x += lcd_current_viewport->x; | 921 | x += lcd_current_viewport->x; |
1008 | y += lcd_current_viewport->y; | 922 | y += lcd_current_viewport->y; |
1009 | 923 | ||
1010 | #if defined(HAVE_VIEWPORT_CLIP) | ||
1011 | /********************* Viewport on screen clipping ********************/ | ||
1012 | /* nothing to draw? */ | ||
1013 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
1014 | || (x + width <= 0) || (y + height <= 0)) | ||
1015 | return; | ||
1016 | |||
1017 | /* clip image in viewport in screen */ | ||
1018 | if (x < 0) | ||
1019 | { | ||
1020 | width += x; | ||
1021 | src_x -= x; | ||
1022 | x = 0; | ||
1023 | } | ||
1024 | if (y < 0) | ||
1025 | { | ||
1026 | height += y; | ||
1027 | src_y -= y; | ||
1028 | y = 0; | ||
1029 | } | ||
1030 | if (x + width > LCD_WIDTH) | ||
1031 | width = LCD_WIDTH - x; | ||
1032 | if (y + height > LCD_HEIGHT) | ||
1033 | height = LCD_HEIGHT - y; | ||
1034 | #endif | ||
1035 | |||
1036 | stride = LCD_FBSTRIDE(stride, 0); /* convert to no. of bytes */ | 924 | stride = LCD_FBSTRIDE(stride, 0); /* convert to no. of bytes */ |
1037 | 925 | ||
1038 | src += stride * src_y + (src_x >> 2); /* move starting point */ | 926 | src += stride * src_y + (src_x >> 2); /* move starting point */ |
diff --git a/firmware/drivers/lcd-2bit-vert.c b/firmware/drivers/lcd-2bit-vert.c index a059e3b512..4ce9960419 100644 --- a/firmware/drivers/lcd-2bit-vert.c +++ b/firmware/drivers/lcd-2bit-vert.c | |||
@@ -422,10 +422,6 @@ void lcd_drawpixel(int x, int y) | |||
422 | { | 422 | { |
423 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) | 423 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) |
424 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) | 424 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) |
425 | #if defined(HAVE_VIEWPORT_CLIP) | ||
426 | && ((unsigned)x < (unsigned)LCD_WIDTH) | ||
427 | && ((unsigned)y < (unsigned)LCD_HEIGHT) | ||
428 | #endif | ||
429 | ) | 425 | ) |
430 | lcd_pixelfuncs[lcd_current_viewport->drawmode](lcd_current_viewport->x + x, lcd_current_viewport->y + y); | 426 | lcd_pixelfuncs[lcd_current_viewport->drawmode](lcd_current_viewport->x + x, lcd_current_viewport->y + y); |
431 | } | 427 | } |
@@ -497,10 +493,6 @@ void lcd_drawline(int x1, int y1, int x2, int y2) | |||
497 | { | 493 | { |
498 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) | 494 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) |
499 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) | 495 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) |
500 | #if defined(HAVE_VIEWPORT_CLIP) | ||
501 | && ((unsigned)x < (unsigned)LCD_WIDTH) | ||
502 | && ((unsigned)y < (unsigned)LCD_HEIGHT) | ||
503 | #endif | ||
504 | ) | 496 | ) |
505 | pfunc(lcd_current_viewport->x + x, lcd_current_viewport->y + y); | 497 | pfunc(lcd_current_viewport->x + x, lcd_current_viewport->y + y); |
506 | 498 | ||
@@ -552,20 +544,6 @@ void lcd_hline(int x1, int x2, int y) | |||
552 | x2 += lcd_current_viewport->x; | 544 | x2 += lcd_current_viewport->x; |
553 | y += lcd_current_viewport->y; | 545 | y += lcd_current_viewport->y; |
554 | 546 | ||
555 | #if defined(HAVE_VIEWPORT_CLIP) | ||
556 | /********************* Viewport on screen clipping ********************/ | ||
557 | /* nothing to draw? */ | ||
558 | if (((unsigned)y >= (unsigned) LCD_HEIGHT) || (x1 >= LCD_WIDTH) | ||
559 | || (x2 < 0)) | ||
560 | return; | ||
561 | |||
562 | /* clipping */ | ||
563 | if (x1 < 0) | ||
564 | x1 = 0; | ||
565 | if (x2 >= LCD_WIDTH) | ||
566 | x2 = LCD_WIDTH-1; | ||
567 | #endif | ||
568 | |||
569 | width = x2 - x1 + 1; | 547 | width = x2 - x1 + 1; |
570 | 548 | ||
571 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; | 549 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; |
@@ -611,20 +589,6 @@ void lcd_vline(int x, int y1, int y2) | |||
611 | y2 += lcd_current_viewport->y; | 589 | y2 += lcd_current_viewport->y; |
612 | x += lcd_current_viewport->x; | 590 | x += lcd_current_viewport->x; |
613 | 591 | ||
614 | #if defined(HAVE_VIEWPORT_CLIP) | ||
615 | /********************* Viewport on screen clipping ********************/ | ||
616 | /* nothing to draw? */ | ||
617 | if (( (unsigned) x >= (unsigned)LCD_WIDTH) || (y1 >= LCD_HEIGHT) | ||
618 | || (y2 < 0)) | ||
619 | return; | ||
620 | |||
621 | /* clipping */ | ||
622 | if (y1 < 0) | ||
623 | y1 = 0; | ||
624 | if (y2 >= LCD_HEIGHT) | ||
625 | y2 = LCD_HEIGHT-1; | ||
626 | #endif | ||
627 | |||
628 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; | 592 | bfunc = lcd_blockfuncs[lcd_current_viewport->drawmode]; |
629 | dst = FBADDR(x,y1>>2); | 593 | dst = FBADDR(x,y1>>2); |
630 | stride_dst = lcd_current_viewport->buffer->stride; | 594 | stride_dst = lcd_current_viewport->buffer->stride; |
@@ -693,30 +657,6 @@ void lcd_fillrect(int x, int y, int width, int height) | |||
693 | x += lcd_current_viewport->x; | 657 | x += lcd_current_viewport->x; |
694 | y += lcd_current_viewport->y; | 658 | y += lcd_current_viewport->y; |
695 | 659 | ||
696 | #if defined(HAVE_VIEWPORT_CLIP) | ||
697 | /********************* Viewport on screen clipping ********************/ | ||
698 | /* nothing to draw? */ | ||
699 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
700 | || (x + width <= 0) || (y + height <= 0)) | ||
701 | return; | ||
702 | |||
703 | /* clip image in viewport in screen */ | ||
704 | if (x < 0) | ||
705 | { | ||
706 | width += x; | ||
707 | x = 0; | ||
708 | } | ||
709 | if (y < 0) | ||
710 | { | ||
711 | height += y; | ||
712 | y = 0; | ||
713 | } | ||
714 | if (x + width > LCD_WIDTH) | ||
715 | width = LCD_WIDTH - x; | ||
716 | if (y + height > LCD_HEIGHT) | ||
717 | height = LCD_HEIGHT - y; | ||
718 | #endif | ||
719 | |||
720 | if (lcd_current_viewport->drawmode & DRMODE_INVERSEVID) | 660 | if (lcd_current_viewport->drawmode & DRMODE_INVERSEVID) |
721 | { | 661 | { |
722 | if ((lcd_current_viewport->drawmode & DRMODE_BG) && !lcd_backdrop) | 662 | if ((lcd_current_viewport->drawmode & DRMODE_BG) && !lcd_backdrop) |
@@ -819,32 +759,6 @@ void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x, | |||
819 | x += lcd_current_viewport->x; | 759 | x += lcd_current_viewport->x; |
820 | y += lcd_current_viewport->y; | 760 | y += lcd_current_viewport->y; |
821 | 761 | ||
822 | #if defined(HAVE_VIEWPORT_CLIP) | ||
823 | /********************* Viewport on screen clipping ********************/ | ||
824 | /* nothing to draw? */ | ||
825 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
826 | || (x + width <= 0) || (y + height <= 0)) | ||
827 | return; | ||
828 | |||
829 | /* clip image in viewport in screen */ | ||
830 | if (x < 0) | ||
831 | { | ||
832 | width += x; | ||
833 | src_x -= x; | ||
834 | x = 0; | ||
835 | } | ||
836 | if (y < 0) | ||
837 | { | ||
838 | height += y; | ||
839 | src_y -= y; | ||
840 | y = 0; | ||
841 | } | ||
842 | if (x + width > LCD_WIDTH) | ||
843 | width = LCD_WIDTH - x; | ||
844 | if (y + height > LCD_HEIGHT) | ||
845 | height = LCD_HEIGHT - y; | ||
846 | #endif | ||
847 | |||
848 | src += stride * (src_y >> 3) + src_x; /* move starting point */ | 762 | src += stride * (src_y >> 3) + src_x; /* move starting point */ |
849 | src_y &= 7; | 763 | src_y &= 7; |
850 | y -= src_y; | 764 | y -= src_y; |
@@ -1018,31 +932,6 @@ void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y, | |||
1018 | x += lcd_current_viewport->x; | 932 | x += lcd_current_viewport->x; |
1019 | y += lcd_current_viewport->y; | 933 | y += lcd_current_viewport->y; |
1020 | 934 | ||
1021 | #if defined(HAVE_VIEWPORT_CLIP) | ||
1022 | /********************* Viewport on screen clipping ********************/ | ||
1023 | /* nothing to draw? */ | ||
1024 | if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT) | ||
1025 | || (x + width <= 0) || (y + height <= 0)) | ||
1026 | return; | ||
1027 | |||
1028 | /* clip image in viewport in screen */ | ||
1029 | if (x < 0) | ||
1030 | { | ||
1031 | width += x; | ||
1032 | src_x -= x; | ||
1033 | x = 0; | ||
1034 | } | ||
1035 | if (y < 0) | ||
1036 | { | ||
1037 | height += y; | ||
1038 | src_y -= y; | ||
1039 | y = 0; | ||
1040 | } | ||
1041 | if (x + width > LCD_WIDTH) | ||
1042 | width = LCD_WIDTH - x; | ||
1043 | if (y + height > LCD_HEIGHT) | ||
1044 | height = LCD_HEIGHT - y; | ||
1045 | #endif | ||
1046 | src += stride * (src_y >> 2) + src_x; /* move starting point */ | 935 | src += stride * (src_y >> 2) + src_x; /* move starting point */ |
1047 | src_y &= 3; | 936 | src_y &= 3; |
1048 | y -= src_y; | 937 | y -= src_y; |
diff --git a/firmware/drivers/lcd-2bit-vi.c b/firmware/drivers/lcd-2bit-vi.c index 423f4536d4..b969c93216 100644 --- a/firmware/drivers/lcd-2bit-vi.c +++ b/firmware/drivers/lcd-2bit-vi.c | |||
@@ -455,10 +455,6 @@ void LCDFN(drawpixel)(int x, int y) | |||
455 | { | 455 | { |
456 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) | 456 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) |
457 | && ((unsigned)y < (unsigned)CURRENT_VP->height) | 457 | && ((unsigned)y < (unsigned)CURRENT_VP->height) |
458 | #if defined(HAVE_VIEWPORT_CLIP) | ||
459 | && ((unsigned)x < (unsigned)LCDM(WIDTH)) | ||
460 | && ((unsigned)y < (unsigned)LCDM(HEIGHT)) | ||
461 | #endif | ||
462 | ) | 458 | ) |
463 | LCDFN(pixelfuncs)[CURRENT_VP->drawmode](CURRENT_VP->x+x, CURRENT_VP->y+y); | 459 | LCDFN(pixelfuncs)[CURRENT_VP->drawmode](CURRENT_VP->x+x, CURRENT_VP->y+y); |
464 | } | 460 | } |
@@ -530,10 +526,6 @@ void LCDFN(drawline)(int x1, int y1, int x2, int y2) | |||
530 | { | 526 | { |
531 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) | 527 | if ( ((unsigned)x < (unsigned)CURRENT_VP->width) |
532 | && ((unsigned)y < (unsigned)CURRENT_VP->height) | 528 | && ((unsigned)y < (unsigned)CURRENT_VP->height) |
533 | #if defined(HAVE_VIEWPORT_CLIP) | ||
534 | && ((unsigned)x < (unsigned)LCDM(WIDTH)) | ||
535 | && ((unsigned)y < (unsigned)LCDM(HEIGHT)) | ||
536 | #endif | ||
537 | ) | 529 | ) |
538 | pfunc(CURRENT_VP->x + x, CURRENT_VP->y + y); | 530 | pfunc(CURRENT_VP->x + x, CURRENT_VP->y + y); |
539 | 531 | ||
@@ -585,20 +577,6 @@ void LCDFN(hline)(int x1, int x2, int y) | |||
585 | x2 += CURRENT_VP->x; | 577 | x2 += CURRENT_VP->x; |
586 | y += CURRENT_VP->y; | 578 | y += CURRENT_VP->y; |
587 | 579 | ||
588 | #if defined(HAVE_VIEWPORT_CLIP) | ||
589 | /********************* Viewport on screen clipping ********************/ | ||
590 | /* nothing to draw? */ | ||
591 | if (((unsigned)y >= (unsigned) LCDM(HEIGHT)) || (x1 >= LCDM(WIDTH)) | ||
592 | || (x2 < 0)) | ||
593 | return; | ||
594 | |||
595 | /* clipping */ | ||
596 | if (x1 < 0) | ||
597 | x1 = 0; | ||
598 | if (x2 >= LCDM(WIDTH)) | ||
599 | x2 = LCDM(WIDTH)-1; | ||
600 | #endif | ||
601 | |||
602 | width = x2 - x1 + 1; | 580 | width = x2 - x1 + 1; |
603 | 581 | ||
604 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; | 582 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; |
@@ -644,20 +622,6 @@ void LCDFN(vline)(int x, int y1, int y2) | |||
644 | y2 += CURRENT_VP->y; | 622 | y2 += CURRENT_VP->y; |
645 | x += CURRENT_VP->x; | 623 | x += CURRENT_VP->x; |
646 | 624 | ||
647 | #if defined(HAVE_VIEWPORT_CLIP) | ||
648 | /********************* Viewport on screen clipping ********************/ | ||
649 | /* nothing to draw? */ | ||
650 | if (( (unsigned) x >= (unsigned)LCDM(WIDTH)) || (y1 >= LCDM(HEIGHT)) | ||
651 | || (y2 < 0)) | ||
652 | return; | ||
653 | |||
654 | /* clipping */ | ||
655 | if (y1 < 0) | ||
656 | y1 = 0; | ||
657 | if (y2 >= LCDM(HEIGHT)) | ||
658 | y2 = LCDM(HEIGHT)-1; | ||
659 | #endif | ||
660 | |||
661 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; | 625 | bfunc = LCDFN(blockfuncs)[CURRENT_VP->drawmode]; |
662 | dst = LCDFB(x,y1>>3); | 626 | dst = LCDFB(x,y1>>3); |
663 | stride_dst = CURRENT_VP->buffer->stride; | 627 | stride_dst = CURRENT_VP->buffer->stride; |
@@ -728,31 +692,6 @@ void LCDFN(fillrect)(int x, int y, int width, int height) | |||
728 | x += CURRENT_VP->x; | 692 | x += CURRENT_VP->x; |
729 | y += CURRENT_VP->y; | 693 | y += CURRENT_VP->y; |
730 | 694 | ||
731 | #if defined(HAVE_VIEWPORT_CLIP) | ||
732 | /********************* Viewport on screen clipping ********************/ | ||
733 | /* nothing to draw? */ | ||
734 | if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT)) | ||
735 | || (x + width <= 0) || (y + height <= 0)) | ||
736 | return; | ||
737 | |||
738 | /* clip image in viewport in screen */ | ||
739 | if (x < 0) | ||
740 | { | ||
741 | width += x; | ||
742 | x = 0; | ||
743 | } | ||
744 | if (y < 0) | ||
745 | { | ||
746 | height += y; | ||
747 | y = 0; | ||
748 | } | ||
749 | if (x + width > LCDM(WIDTH)) | ||
750 | width = LCDM(WIDTH) - x; | ||
751 | if (y + height > LCDM(HEIGHT)) | ||
752 | height = LCDM(HEIGHT) - y; | ||
753 | #endif | ||
754 | |||
755 | |||
756 | if (CURRENT_VP->drawmode & DRMODE_INVERSEVID) | 695 | if (CURRENT_VP->drawmode & DRMODE_INVERSEVID) |
757 | { | 696 | { |
758 | if ((CURRENT_VP->drawmode & DRMODE_BG) && !backdrop) | 697 | if ((CURRENT_VP->drawmode & DRMODE_BG) && !backdrop) |
@@ -857,32 +796,6 @@ void ICODE_ATTR LCDFN(mono_bitmap_part)(const unsigned char *src, int src_x, | |||
857 | x += CURRENT_VP->x; | 796 | x += CURRENT_VP->x; |
858 | y += CURRENT_VP->y; | 797 | y += CURRENT_VP->y; |
859 | 798 | ||
860 | #if defined(HAVE_VIEWPORT_CLIP) | ||
861 | /********************* Viewport on screen clipping ********************/ | ||
862 | /* nothing to draw? */ | ||
863 | if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT)) | ||
864 | || (x + width <= 0) || (y + height <= 0)) | ||
865 | return; | ||
866 | |||
867 | /* clip image in viewport in screen */ | ||
868 | if (x < 0) | ||
869 | { | ||
870 | width += x; | ||
871 | src_x -= x; | ||
872 | x = 0; | ||
873 | } | ||
874 | if (y < 0) | ||
875 | { | ||
876 | height += y; | ||
877 | src_y -= y; | ||
878 | y = 0; | ||
879 | } | ||
880 | if (x + width > LCDM(WIDTH)) | ||
881 | width = LCDM(WIDTH) - x; | ||
882 | if (y + height > LCDM(HEIGHT)) | ||
883 | height = LCDM(HEIGHT) - y; | ||
884 | #endif | ||
885 | |||
886 | src += stride * (src_y >> 3) + src_x; /* move starting point */ | 799 | src += stride * (src_y >> 3) + src_x; /* move starting point */ |
887 | src_y &= 7; | 800 | src_y &= 7; |
888 | y -= src_y; | 801 | y -= src_y; |
@@ -1027,32 +940,6 @@ void ICODE_ATTR LCDFN(bitmap_part)(const FBFN(data) *src, int src_x, | |||
1027 | x += CURRENT_VP->x; | 940 | x += CURRENT_VP->x; |
1028 | y += CURRENT_VP->y; | 941 | y += CURRENT_VP->y; |
1029 | 942 | ||
1030 | #if defined(HAVE_VIEWPORT_CLIP) | ||
1031 | /********************* Viewport on screen clipping ********************/ | ||
1032 | /* nothing to draw? */ | ||
1033 | if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT)) | ||
1034 | || (x + width <= 0) || (y + height <= 0)) | ||
1035 | return; | ||
1036 | |||
1037 | /* clip image in viewport in screen */ | ||
1038 | if (x < 0) | ||
1039 | { | ||
1040 | width += x; | ||
1041 | src_x -= x; | ||
1042 | x = 0; | ||
1043 | } | ||
1044 | if (y < 0) | ||
1045 | { | ||
1046 | height += y; | ||
1047 | src_y -= y; | ||
1048 | y = 0; | ||
1049 | } | ||
1050 | if (x + width > LCDM(WIDTH)) | ||
1051 | width = LCDM(WIDTH) - x; | ||
1052 | if (y + height > LCDM(HEIGHT)) | ||
1053 | height = LCDM(HEIGHT) - y; | ||
1054 | #endif | ||
1055 | |||
1056 | src += stride * (src_y >> 3) + src_x; /* move starting point */ | 943 | src += stride * (src_y >> 3) + src_x; /* move starting point */ |
1057 | src_y &= 7; | 944 | src_y &= 7; |
1058 | y -= src_y; | 945 | y -= src_y; |
diff --git a/firmware/drivers/lcd-bitmap-common.c b/firmware/drivers/lcd-bitmap-common.c index c85d16cb70..24b302b6d4 100644 --- a/firmware/drivers/lcd-bitmap-common.c +++ b/firmware/drivers/lcd-bitmap-common.c | |||
@@ -139,11 +139,7 @@ struct viewport* LCDFN(set_viewport_ex)(struct viewport* vp, int flags) | |||
139 | || vp->x + vp->width > LCDM(WIDTH) | 139 | || vp->x + vp->width > LCDM(WIDTH) |
140 | || vp->y + vp->height > LCDM(HEIGHT)) | 140 | || vp->y + vp->height > LCDM(HEIGHT)) |
141 | { | 141 | { |
142 | #if !defined(HAVE_VIEWPORT_CLIP) | ||
143 | DEBUGF("ERROR: " | 142 | DEBUGF("ERROR: " |
144 | #else | ||
145 | DEBUGF("NOTE: " | ||
146 | #endif | ||
147 | "set_viewport out of bounds: x: %d y: %d width: %d height:%d\n", | 143 | "set_viewport out of bounds: x: %d y: %d width: %d height:%d\n", |
148 | vp->x, vp->y, vp->width, vp->height); | 144 | vp->x, vp->y, vp->width, vp->height); |
149 | } | 145 | } |
diff --git a/firmware/drivers/lcd-color-common.c b/firmware/drivers/lcd-color-common.c index a867583d36..36144b574c 100644 --- a/firmware/drivers/lcd-color-common.c +++ b/firmware/drivers/lcd-color-common.c | |||
@@ -198,10 +198,6 @@ void lcd_drawpixel(int x, int y) | |||
198 | { | 198 | { |
199 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) | 199 | if ( ((unsigned)x < (unsigned)lcd_current_viewport->width) |
200 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) | 200 | && ((unsigned)y < (unsigned)lcd_current_viewport->height) |
201 | #if defined(HAVE_VIEWPORT_CLIP) | ||
202 | && ((unsigned)x < (unsigned)LCD_WIDTH) | ||
203 | && ((unsigned)y < (unsigned)LCD_HEIGHT) | ||
204 | #endif | ||
205 | ) | 201 | ) |
206 | lcd_fastpixelfuncs[lcd_current_viewport->drawmode](FBADDR(lcd_current_viewport->x+x, lcd_current_viewport->y+y)); | 202 | lcd_fastpixelfuncs[lcd_current_viewport->drawmode](FBADDR(lcd_current_viewport->x+x, lcd_current_viewport->y+y)); |
207 | } | 203 | } |
@@ -281,10 +277,6 @@ void lcd_drawline(int x1, int y1, int x2, int y2) | |||
281 | if ((x >= 0 && y >= 0) | 277 | if ((x >= 0 && y >= 0) |
282 | && (x < w_vp) | 278 | && (x < w_vp) |
283 | && (y < h_vp) | 279 | && (y < h_vp) |
284 | #if defined(HAVE_VIEWPORT_CLIP) | ||
285 | && (x < LCD_WIDTH) | ||
286 | && (y < LCD_HEIGHT) | ||
287 | #endif | ||
288 | ) | 280 | ) |
289 | pfunc(fbaddr( x + x_vp, y + y_vp)); | 281 | pfunc(fbaddr( x + x_vp, y + y_vp)); |
290 | 282 | ||