AllegroGL: glvtable.c Source File

AllegroGL 0.4.4

- Main Page
- Related Pages
- Modules
- Files

- File List
- Globals

glvtable.c
Go to the documentation of this file.
1 /* This code is (C) AllegroGL contributors, and double licensed under
2 * the GPL and zlib licenses. See gpl.txt or zlib.txt for details.
3 */
8 #include <string.h>
9
10 #include <allegro.h>
11
12 #ifdef ALLEGRO_WINDOWS
13 #include <winalleg.h>
14 #endif
15
16 #include "alleggl.h"
17 #include "allglint.h"
18 #include "glvtable.h"
19 #include <allegro/internal/aintern.h>
20 #ifdef ALLEGRO_MACOSX
21 #include <OpenGL/glu.h>
22 #else
23 #include <GL/glu.h>
24 #endif
25
26
27 static GFX_VTABLE allegro_gl_screen_vtable;
28 static GLuint __allegro_gl_pool_texture = 0;
29
30 static GLuint __allegro_gl_dummy_texture = 0; /* For ATI Rage Pro */
31
32 static int __agl_owning_drawing_pattern_tex = FALSE;
33 GLuint __agl_drawing_pattern_tex = 0;
34 BITMAP *__agl_drawing_pattern_bmp = 0;
35 static int __agl_drawing_mode = DRAW_MODE_SOLID;
36
37
58 /* Computes the next power of two if the number wasn't a power of two to start
59 * with. Ref: http://bob.allegronetwork.com/prog/tricks.html#roundtonextpowerof2
60 */
61 int __allegro_gl_make_power_of_2(int x) {
62 x--;
63 x |= (x >> 1);
64 x |= (x >> 2);
65 x |= (x >> 4);
66 x |= (x >> 8);
67 x |= (x >> 16);
68 x++;
69 return x;
70 }
71
72
73
74 /* allegro_gl_drawing_mode (GFX_DRIVER vtable entry):
75 * Sets the drawing mode. Same implementation to all GFX vtables.
76 */
77 void allegro_gl_drawing_mode(void) {
78 if (__agl_drawing_mode == _drawing_mode)
79 return;
80
81 switch (__agl_drawing_mode) {
82 case DRAW_MODE_TRANS:
83 glDisable(GL_BLEND);
84 break;
85 case DRAW_MODE_XOR:
86 glDisable(GL_COLOR_LOGIC_OP);
87 break;
88 case DRAW_MODE_COPY_PATTERN:
89 glDisable(GL_TEXTURE_2D);
90 glBindTexture(GL_TEXTURE_2D, 0);
91 if (__agl_owning_drawing_pattern_tex && __agl_drawing_pattern_tex)
92 glDeleteTextures(1, &__agl_drawing_pattern_tex);
93 __agl_drawing_pattern_tex = 0;
94 __agl_drawing_pattern_bmp = 0;
95 break;
96 }
97
98 __agl_drawing_mode = _drawing_mode;
99
100 switch (_drawing_mode) {
101 case DRAW_MODE_TRANS:
102 glEnable(GL_BLEND);
103 break;
104
105 case DRAW_MODE_XOR:
106 glEnable(GL_COLOR_LOGIC_OP);
107 glLogicOp(GL_XOR);
108 break;
109
110 case DRAW_MODE_COPY_PATTERN:
111 if (is_memory_bitmap(_drawing_pattern)) {
112 __agl_drawing_pattern_tex =
113 allegro_gl_make_texture(_drawing_pattern);
114 __agl_drawing_pattern_bmp = _drawing_pattern;
115 __agl_owning_drawing_pattern_tex = TRUE;
116 }
117 else if (is_video_bitmap(_drawing_pattern)) {
118 AGL_VIDEO_BITMAP *bmp = _drawing_pattern->extra;
119 __agl_drawing_pattern_tex = bmp->tex;
120 __agl_drawing_pattern_bmp = bmp->memory_copy;
121 __agl_owning_drawing_pattern_tex = FALSE;
122 }
123
124 glEnable(GL_TEXTURE_2D);
125 glBindTexture(GL_TEXTURE_2D, __agl_drawing_pattern_tex);
126
127 break;
128 }
129 }
130
131
132 void split_color(int color, GLubyte *r, GLubyte *g, GLubyte *b, GLubyte *a,
133 int color_depth)
134 {
135 AGL_LOG(2, "glvtable.c:split_color\n");
136 *r = getr_depth(color_depth, color);
137 *g = getg_depth(color_depth, color);
138 *b = getb_depth(color_depth, color);
139 if (color_depth == 32)
140 *a = geta_depth(color_depth, color);
141 else
142 *a = 255;
143 }
144
145
146 /* allegro_gl_created_sub_bitmap:
147 */
148 void allegro_gl_created_sub_bitmap(BITMAP *bmp, BITMAP *parent)
149 {
150 bmp->extra = parent;
151 }
152
153
154 /* static void allegro_gl_screen_acquire(struct BITMAP *bmp) */
160 static void allegro_gl_screen_acquire(struct BITMAP *bmp) {}
161
162
163
164 /* static void allegro_gl_screen_release(struct BITMAP *bmp) */
170 static void allegro_gl_screen_release(struct BITMAP *bmp) {}
171
172
173
174 static int allegro_gl_screen_getpixel(struct BITMAP *bmp, int x, int y)
175 {
176 GLubyte pixel[3];
177 AGL_LOG(2, "glvtable.c:allegro_gl_screen_getpixel\n");
178 if (bmp->clip && (x < bmp->cl || x >= bmp->cr
179 || y < bmp->ct || y >= bmp->cb)) {
180 return -1;
181 }
182 if (is_sub_bitmap(bmp)) {
183 x += bmp->x_ofs;
184 y += bmp->y_ofs;
185 }
186 glReadPixels(x, bmp->h - y - 1, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixel);
187
188 return makecol_depth(bitmap_color_depth(screen),
189 pixel[0], pixel[1], pixel[2]);
190 }
191
192
193
194 static void allegro_gl_screen_putpixel(struct BITMAP *bmp, int x, int y,
195 int color)
196 {
197 GLubyte r, g, b, a;
198 AGL_LOG(2, "glvtable.c:allegro_gl_screen_putpixel\n");
199 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
200 if (bmp->clip && (x < bmp->cl || x >= bmp->cr
201 || y < bmp->ct || y >= bmp->cb)) {
202 return;
203 }
204
205 if (is_sub_bitmap(bmp)) {
206 x += bmp->x_ofs;
207 y += bmp->y_ofs;
208 }
209
210 glColor4ub(r, g, b, a);
211 glBegin(GL_POINTS);
212 glVertex2f(x, y);
213 glEnd();
214 }
215
216
217
218 static void allegro_gl_screen_vline(struct BITMAP *bmp, int x, int y1, int y2,
219 int color)
220 {
221 GLubyte r, g, b, a;
222 AGL_LOG(2, "glvtable.c:allegro_gl_screen_vline\n");
223
224 if (y1 > y2) {
225 int temp = y1;
226 y1 = y2;
227 y2 = temp;
228 }
229
230 if (bmp->clip) {
231 if ((x < bmp->cl) || (x >= bmp->cr)) {
232 return;
233 }
234 if ((y1 >= bmp->cb) || (y2 < bmp->ct)) {
235 return;
236 }
237 if (y1 < bmp->ct) {
238 y1 = bmp->ct;
239 }
240 if (y2 >= bmp->cb) {
241 y2 = bmp->cb - 1;
242 }
243 }
244
245 if (is_sub_bitmap(bmp)) {
246 x += bmp->x_ofs;
247 y1 += bmp->y_ofs;
248 y2 += bmp->y_ofs;
249 }
250
251 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
252
253 glColor4ub(r, g, b, a);
254 glBegin(GL_LINES);
255 glVertex2f(x, y1);
256 glVertex2f(x, y2 + 0.325 * 3);
257 glEnd();
258
259 return;
260 }
261
262
263
264 static void allegro_gl_screen_hline(struct BITMAP *bmp, int x1, int y, int x2,
265 int color)
266 {
267 GLubyte r, g, b, a;
268 AGL_LOG(2, "glvtable.c:allegro_gl_hline\n");
269
270 if (x1 > x2) {
271 int temp = x1;
272 x1 = x2;
273 x2 = temp;
274 }
275 if (bmp->clip) {
276 if ((y < bmp->ct) || (y >= bmp->cb)) {
277 return;
278 }
279 if ((x1 >= bmp->cr) || (x2 < bmp->cl)) {
280 return;
281 }
282 if (x1 < bmp->cl) {
283 x1 = bmp->cl;
284 }
285 if (x2 >= bmp->cr) {
286 x2 = bmp->cr - 1;
287 }
288 }
289 if (is_sub_bitmap(bmp)) {
290 x1 += bmp->x_ofs;
291 x2 += bmp->x_ofs;
292 y += bmp->y_ofs;
293 }
294
295 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
296
297 glColor4ub(r, g, b, a);
298 glBegin(GL_LINES);
299 glVertex2f(x1 - 0.325, y);
300 glVertex2f(x2 + 0.325 * 2, y);
301 glEnd();
302
303 return;
304 }
305
306
307
308 static void allegro_gl_screen_line(struct BITMAP *bmp, int x1, int y1, int x2,
309 int y2, int color)
310 {
311 GLubyte r, g, b, a;
312 AGL_LOG(2, "glvtable.c:allegro_gl_screen_line\n");
313
314 if (bmp->clip) {
315 glPushAttrib(GL_SCISSOR_BIT);
316 glEnable(GL_SCISSOR_TEST);
317 glScissor(bmp->x_ofs + bmp->cl, bmp->h + bmp->y_ofs - bmp->cb,
318 bmp->cr - bmp->cl, bmp->cb - bmp->ct);
319 }
320 if (is_sub_bitmap(bmp)) {
321 x1 += bmp->x_ofs;
322 x2 += bmp->x_ofs;
323 y1 += bmp->y_ofs;
324 y2 += bmp->y_ofs;
325 }
326
327 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
328
329 glColor4ub(r, g, b, a);
330 glBegin(GL_LINES);
331 glVertex2f(x1 + 0.1625, y1 + 0.1625);
332 glVertex2f(x2 + 0.1625, y2 + 0.1625);
333 glEnd();
334
335 /* OpenGL skips the endpoint when drawing lines */
336 glBegin(GL_POINTS);
337 glVertex2f(x2 + 0.1625, y2 + 0.1625);
338 glEnd();
339
340 if (bmp->clip) {
341 glPopAttrib();
342 }
343
344 return;
345 }
346
347
348 #define SET_TEX_COORDS(x, y) \
349 do { \
350 if (__agl_drawing_pattern_tex) { \
351 glTexCoord2f ( \
352 (x - _drawing_x_anchor) / (float)__agl_drawing_pattern_bmp->w,\
353 (y - _drawing_y_anchor) / (float)__agl_drawing_pattern_bmp->h \
354 ); \
355 } \
356 } while(0)
357
358
359 void allegro_gl_screen_rectfill(struct BITMAP *bmp, int x1, int y1,
360 int x2, int y2, int color)
361 {
362 GLubyte r, g, b, a;
363 GLfloat old_col[4];
364 AGL_LOG(2, "glvtable.c:allegro_gl_screen_rectfill\n");
365
366 if (x1 > x2) {
367 int temp = x1;
368 x1 = x2;
369 x2 = temp;
370 }
371
372 if (y1 > y2) {
373 int temp = y1;
374 y1 = y2;
375 y2 = temp;
376 }
377
378 if (bmp->clip) {
379 if ((x1 > bmp->cr) || (x2 < bmp->cl)) {
380 return;
381 }
382 if (x1 < bmp->cl) {
383 x1 = bmp->cl;
384 }
385 if (x2 > bmp->cr) {
386 x2 = bmp->cr;
387 }
388 if ((y1 > bmp->cb) || (y2 < bmp->ct)) {
389 return;
390 }
391 if (y1 < bmp->ct) {
392 y1 = bmp->ct;
393 }
394 if (y2 > bmp->cb) {
395 y2 = bmp->cb;
396 }
397 }
398 if (is_sub_bitmap(bmp)) {
399 x1 += bmp->x_ofs;
400 x2 += bmp->x_ofs;
401 y1 += bmp->y_ofs;
402 y2 += bmp->y_ofs;
403 }
404
405 glGetFloatv(GL_CURRENT_COLOR, old_col);
406 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
407 glColor4ub(r, g, b, a);
408
409 glBegin(GL_QUADS);
410 SET_TEX_COORDS(x1, y1);
411 glVertex2f(x1, y1);
412 SET_TEX_COORDS(x2, y1);
413 glVertex2f(x2, y1);
414 SET_TEX_COORDS(x2, y2);
415 glVertex2f(x2, y2);
416 SET_TEX_COORDS(x1, y2);
417 glVertex2f(x1, y2);
418 glEnd();
419
420 glColor4fv(old_col);
421
422 return;
423 }
424
425
426
427 static void allegro_gl_screen_triangle(struct BITMAP *bmp, int x1, int y1,
428 int x2, int y2, int x3, int y3, int color)
429 {
430 GLubyte r, g, b, a;
431 AGL_LOG(2, "glvtable.c:allegro_gl_screen_triangle\n");
432
433 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
434
435 if (bmp->clip) {
436 glPushAttrib(GL_SCISSOR_BIT);
437 glEnable(GL_SCISSOR_TEST);
438 glScissor(bmp->x_ofs + bmp->cl, bmp->h + bmp->y_ofs - bmp->cb,
439 bmp->cr - bmp->cl, bmp->cb - bmp->ct);
440 }
441 if (is_sub_bitmap(bmp)) {
442 x1 += bmp->x_ofs;
443 y1 += bmp->y_ofs;
444 x2 += bmp->x_ofs;
445 y2 += bmp->y_ofs;
446 x3 += bmp->x_ofs;
447 y3 += bmp->y_ofs;
448 }
449
450 glColor4ub(r, g, b, a);
451 glBegin(GL_TRIANGLES);
452 SET_TEX_COORDS(x1, y1);
453 glVertex2f(x1, y1);
454 SET_TEX_COORDS(x2, y2);
455 glVertex2f(x2, y2);
456 SET_TEX_COORDS(x3, y3);
457 glVertex2f(x3, y3);
458 glEnd();
459
460 if (bmp->clip) {
461 glPopAttrib();
462 }
463 }
464
465
466
467 #define BITMAP_BLIT_CLIP(source, dest, source_x, source_y, dest_x, dest_y, \
468 width, height) { \
469 if (dest->clip) { \
470 if ((dest_x >= dest->cr) || (dest_y >= dest->cb) \
471 || (dest_x + width < dest->cl) || (dest_y + height < dest->ct)) { \
472 width = 0; \
473 } \
474 if (dest_x < dest->cl) { \
475 width += dest_x - dest->cl; \
476 source_x -= dest_x - dest->cl; \
477 dest_x = dest->cl; \
478 } \
479 if (dest_y < dest->ct) { \
480 height += dest_y - dest->ct; \
481 source_y -= dest_y - dest->ct; \
482 dest_y = dest->ct; \
483 } \
484 if (dest_x + width > dest->cr) { \
485 width = dest->cr - dest_x; \
486 } \
487 if (dest_y + height > dest->cb) { \
488 height = dest->cb - dest_y; \
489 } \
490 } \
491 if (source->clip) { \
492 if ((source_x >= source->cr) || (source_y >= source->cb) \
493 || (source_x + width < source->cl) \
494 || (source_y + height < source->ct)) { \
495 width = 0; \
496 } \
497 if (source_x < source->cl) { \
498 width += source_x - source->cl; \
499 dest_x -= source_x - source->cl; \
500 source_x = source->cl; \
501 } \
502 if (source_y < source->ct) { \
503 height += source_y - source->ct; \
504 dest_y -= source_y - source->ct; \
505 source_y = source->ct; \
506 } \
507 if (source_x + width > source->cr) { \
508 width = source->cr - source_x; \
509 } \
510 if (source_y + height > source->cb) { \
511 height = source->cb - source_y; \
512 } \
513 } \
514 }
515
516
517
518
519 static void allegro_gl_screen_blit_from_memory(
520 struct BITMAP *source, struct BITMAP *dest,
521 int source_x, int source_y, int dest_x, int dest_y, int width, int height)
522 {
523 GLfloat saved_zoom_x, saved_zoom_y;
524 GLint saved_row_length;
525 BITMAP *temp = NULL;
526 void *data;
527 AGL_LOG(2, "glvtable.c:allegro_gl_screen_blit_from_memory\n");
528
529 BITMAP_BLIT_CLIP(source, dest, source_x, source_y, dest_x, dest_y,
530 width, height);
531
532 if (width <= 0 || height <= 0) {
533 return;
534 }
535
536
537 if (is_sub_bitmap(dest)) {
538 dest_x += dest->x_ofs;
539 dest_y += dest->y_ofs;
540 }
541
542 /* Note: We don't need to offset the source bitmap coordinates
543 * because we use source->line[] directly, which is already offsetted for
544 * us.
545 */
546 data = source->line[source_y]
547 + source_x * BYTES_PER_PIXEL(bitmap_color_depth(source));
548
549 /* If packed pixels (or GL 1.2) isn't supported, then we need to convert
550 * the bitmap into something GL can understand - 24-bpp should do it.
551 */
552 if (!allegro_gl_extensions_GL.EXT_packed_pixels
553 && bitmap_color_depth(source) < 24) {
554 temp = create_bitmap_ex(24, width, height);
555
556 if (temp) {
557 blit(source, temp, source_x, source_y, 0, 0, width, height);
558 source_x = 0;
559 source_y = 0;
560 data = temp->line[0];
561 }
562 else {
563 /* XXX <rohannessian> Report error? */
564 return;
565 }
566 source = temp;
567 }
568
569
570 /* Save state */
571 glGetFloatv(GL_ZOOM_X, &saved_zoom_x);
572 glGetFloatv(GL_ZOOM_Y, &saved_zoom_y);
573 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &saved_row_length);
574
575 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
576
577 glRasterPos2i(dest_x, dest_y);
578
579 /* XXX <rohannessian> I wonder if it would be faster to use glDrawPixels()
580 * one line at a time instead of playing with the Zoom factor.
581 */
582 glPixelZoom (1.0, -1.0);
583 glPixelStorei(GL_UNPACK_ROW_LENGTH,
584 (source->line[1] - source->line[0])
585 / BYTES_PER_PIXEL(source->vtable->color_depth));
586
587 glDrawPixels(width, height, __allegro_gl_get_bitmap_color_format(source, 0),
588 __allegro_gl_get_bitmap_type(source, 0), data);
589
590 /* Restore state */
591 glPixelZoom(saved_zoom_x, saved_zoom_y);
592 glPixelStorei(GL_UNPACK_ROW_LENGTH, saved_row_length);
593
594 if (temp) {
595 destroy_bitmap(temp);
596 }
597 return;
598 }
599
600
601
602 static void allegro_gl_screen_blit_to_memory(
603 struct BITMAP *source, struct BITMAP *dest,
604 int source_x, int source_y, int dest_x, int dest_y, int width, int height)
605 {
606 GLint saved_row_length;
607 GLint saved_alignment;
608 GLint saved_pack_invert;
609
610 BITMAP *bmp = NULL;
611
612 AGL_LOG(2, "glvtable.c:allegro_gl_screen_blit_to_memory\n");
613
614 BITMAP_BLIT_CLIP(source, dest, source_x, source_y, dest_x, dest_y,
615 width, height);
616
617 if (is_sub_bitmap(source)) {
618 source_x += source->x_ofs;
619 source_y += source->y_ofs;
620 }
621 if (is_sub_bitmap(dest)) {
622 dest_x += dest->x_ofs;
623 dest_y += dest->y_ofs;
624 }
625
626 if (width <= 0 || height <= 0) {
627 return;
628 }
629
630 /* Note that glPixelZoom doesn't affect reads -- so we have to do a flip.
631 * We can do this by reading into a temporary bitmap then flipping that to
632 * the destination, -OR- use the GL_MESA_pack_invert extension to do it
633 * for us.
634 *
635 * If GL_EXT_packed_pixels isn't supported, then we can't use
636 * MESA_pack_invert on 16-bpp bitmaps or less.
637 */
638
639 if ( !allegro_gl_extensions_GL.MESA_pack_invert
640 || (!allegro_gl_extensions_GL.EXT_packed_pixels
641 && bitmap_color_depth(dest) < 24)) {
642
643 /* XXX <rohannessian> Bitmap format should be the same as the source
644 * dest bitmap!
645 */
646 if ((!allegro_gl_extensions_GL.EXT_packed_pixels
647 && bitmap_color_depth(dest) < 24)) {
648 bmp = create_bitmap_ex(24, width, height);
649 }
650 else {
651 bmp = create_bitmap_ex(bitmap_color_depth(dest), width, height);
652 }
653 if (!bmp)
654 return;
655 }
656
657 glGetIntegerv(GL_PACK_ROW_LENGTH, &saved_row_length);
658 glGetIntegerv(GL_PACK_ALIGNMENT, &saved_alignment);
659 glPixelStorei(GL_PACK_ROW_LENGTH, 0);
660 glPixelStorei(GL_PACK_ALIGNMENT, 1);
661
662 if (!allegro_gl_extensions_GL.MESA_pack_invert) {
663
664 glReadPixels(source_x, source->h - source_y - height, width, height,
665 __allegro_gl_get_bitmap_color_format(bmp, 0),
666 __allegro_gl_get_bitmap_type(bmp, 0), bmp->dat);
667 }
668 else {
669 glGetIntegerv(GL_PACK_INVERT_MESA, &saved_pack_invert);
670 glPixelStorei(GL_PACK_INVERT_MESA, TRUE);
671 glPixelStorei(GL_PACK_ROW_LENGTH,
672 (dest->line[1] - dest->line[0])
673 / BYTES_PER_PIXEL(dest->vtable->color_depth));
674
675 glReadPixels(source_x, source->h - source_y - height, width, height,
676 __allegro_gl_get_bitmap_color_format(dest, 0),
677 __allegro_gl_get_bitmap_type(dest, 0), dest->line[0]);
678
679 glPixelStorei(GL_PACK_INVERT_MESA, saved_pack_invert);
680 }
681
682 glPixelStorei(GL_PACK_ROW_LENGTH, saved_row_length);
683 glPixelStorei(GL_PACK_ALIGNMENT, saved_alignment);
684
685 /* Flip image if needed (glPixelZoom doesn't affect reads) */
686 if (bmp) {
687
688 int y, dy;
689
690 for (y = 0, dy = dest_y + height - 1; y < height; y++, dy--) {
691 blit(bmp, dest, 0, y, dest_x, dy, width, 1);
692 }
693
694 destroy_bitmap(bmp);
695 }
696
697 return;
698 }
699
700
701
702
703 void allegro_gl_screen_blit_to_self (
704 struct BITMAP *source, struct BITMAP *dest,
705 int source_x, int source_y, int dest_x, int dest_y, int width, int height)
706 {
707 AGL_LOG(2, "glvtable.c:allegro_gl_screen_blit_to_self\n");
708
709 BITMAP_BLIT_CLIP(source, dest, source_x, source_y, dest_x, dest_y,
710 width, height);
711
712 if (is_sub_bitmap(source)) {
713 source_x += source->x_ofs;
714 source_y += source->y_ofs;
715 }
716 if (is_sub_bitmap(dest)) {
717 dest_x += dest->x_ofs;
718 dest_y += dest->y_ofs;
719 }
720
721 if (width <= 0 || height <= 0) {
722 return;
723 }
724
725 /* screen -> screen */
726 if (is_screen_bitmap(source) && is_screen_bitmap(dest)) {
727 glRasterPos2i(dest_x, dest_y + height - 1);
728 glCopyPixels(source_x, SCREEN_H - source_y - height, width, height,
729 GL_COLOR);
730 }
731 /* video -> screen */
732 else if (is_screen_bitmap(dest) && is_video_bitmap(source)) {
733 AGL_VIDEO_BITMAP *vid;
734 BITMAP *source_parent = source;
735 GLfloat current_color[4];
736
737 while (source_parent->id & BMP_ID_SUB) {
738 source_parent = (BITMAP *)source_parent->extra;
739 }
740 vid = source_parent->extra;
741
742 glGetFloatv(GL_CURRENT_COLOR, current_color);
743 glColor4ub(255, 255, 255, 255);
744
745 while (vid) {
746 int sx, sy; /* source coordinates */
747 int dx, dy; /* destination coordinates */
748 int w, h;
749
750 if (source_x >= vid->x_ofs + vid->memory_copy->w ||
751 source_y >= vid->y_ofs + vid->memory_copy->h ||
752 vid->x_ofs >= source_x + width ||
753 vid->y_ofs >= source_y + height) {
754 vid = vid->next;
755 continue;
756 }
757
758 sx = MAX(vid->x_ofs, source_x) - vid->x_ofs;
759 w = MIN(vid->x_ofs + vid->memory_copy->w, source_x + width)
760 - vid->x_ofs - sx;
761 sy = MAX(vid->y_ofs, source_y) - vid->y_ofs;
762 h = MIN(vid->y_ofs + vid->memory_copy->h, source_y + height)
763 - vid->y_ofs - sy;
764
765 dx = dest_x + vid->x_ofs + sx - source_x;
766 dy = dest_y + vid->y_ofs + sy - source_y;
767
768 glEnable(vid->target);
769 glBindTexture(vid->target, vid->tex);
770
771 if (vid->target == GL_TEXTURE_2D) {
772 float tx = sx / (float)vid->memory_copy->w;
773 float ty = sy / (float)vid->memory_copy->h;
774 float tw = w / (float)vid->memory_copy->w;
775 float th = h / (float)vid->memory_copy->h;
776
777 glBegin(GL_QUADS);
778 glTexCoord2f(tx, ty);
779 glVertex2f(dx, dy);
780 glTexCoord2f(tx, ty + th);
781 glVertex2f(dx, dy + h);
782 glTexCoord2f(tx + tw, ty + th);
783 glVertex2f(dx + w, dy + h);
784 glTexCoord2f(tx + tw, ty);
785 glVertex2f(dx + w, dy);
786 glEnd();
787 }
788 else {
789 glBegin(GL_QUADS);
790 glTexCoord2i(sx, sy);
791 glVertex2f(dx, dy);
792 glTexCoord2i(sx, sy + h);
793 glVertex2f(dx, dy + h);
794 glTexCoord2i(sx + w, sy + h);
795 glVertex2f(dx + w, dy + h);
796 glTexCoord2i(sx + w, sy);
797 glVertex2f(dx + w, dy);
798 glEnd();
799 }
800
801 glBindTexture(vid->target, 0);
802 glDisable(vid->target);
803
804 vid = vid->next;
805 }
806
807 glColor4fv(current_color);
808 }
809 /* screen -> video */
810 else if (is_screen_bitmap(source) && is_video_bitmap(dest)) {
811
812 AGL_VIDEO_BITMAP *vid;
813 BITMAP *source_parent = source;
814
815 while (source_parent->id & BMP_ID_SUB) {
816 source_parent = (BITMAP *)source_parent->extra;
817 }
818
819 vid = dest->extra;
820
821 while (vid) {
822 int sx, sy; /* source coordinates */
823 int dx, dy; /* destination coordinates */
824 int w, h;
825
826 if (dest_x >= vid->x_ofs + vid->memory_copy->w ||
827 dest_y >= vid->y_ofs + vid->memory_copy->h ||
828 vid->x_ofs >= dest_x + width ||
829 vid->y_ofs >= dest_y + height) {
830 vid = vid->next;
831 continue;
832 }
833
834 dx = MAX(vid->x_ofs, dest_x) - vid->x_ofs;
835 w = MIN(vid->x_ofs + vid->memory_copy->w, dest_x + width)
836 - vid->x_ofs - dx;
837 dy = MAX(vid->y_ofs, dest_y) - vid->y_ofs;
838 h = MIN(vid->y_ofs + vid->memory_copy->h, dest_y + height)
839 - vid->y_ofs - dy;
840
841 sx = source_x + vid->x_ofs + dx - dest_x;
842 sy = source_y + vid->y_ofs + dy - dest_y;
843
844 /* We cannot use glCopyTexSubImage2D() here because it will flip the image. */
845 allegro_gl_screen_blit_to_memory(source, vid->memory_copy,
846 sx, sy, dx, dy, w, h);
847
848 allegro_gl_video_blit_from_memory(vid->memory_copy, dest, 0, 0,
849 vid->x_ofs, vid->y_ofs, vid->memory_copy->w, vid->memory_copy->h);
850
851 vid = vid->next;
852 }
853 }
854 else if (is_video_bitmap(source) && is_video_bitmap(dest)) {
855 allegro_gl_video_blit_to_self(source, dest, source_x, source_y,
856 dest_x, dest_y, width, height);
857 }
858 }
859
860
861
862 void allegro_gl_upload_and_display_texture(struct BITMAP *source,
863 int source_x, int source_y, int dest_x, int dest_y, int width, int height,
864 int flip_dir, GLint format, GLint type)
865 {
866 float tx, ty;
867 GLint saved_row_length;
868 int bytes_per_pixel = BYTES_PER_PIXEL(bitmap_color_depth(source));
869 int i, j;
870
871 glEnable(GL_ALPHA_TEST);
872 glAlphaFunc(GL_GREATER, 0.0f);
873
874 glEnable(GL_TEXTURE_2D);
875 glBindTexture(GL_TEXTURE_2D, __allegro_gl_pool_texture);
876
877 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &saved_row_length);
878 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
879
880 glPixelStorei(GL_UNPACK_ROW_LENGTH,
881 (source->line[1] - source->line[0]) / bytes_per_pixel);
882
883 for (i = 0; i <= abs(width) / 256; i++) {
884 for (j = 0; j <= abs(height) / 256; j++) {
885
886 void *data = source->line[source_y + j * 256]
887 + (source_x + i * 256) * bytes_per_pixel;
888 int w = abs(width) - i * 256;
889 int h = abs(height) - j * 256;
890 int dx = dest_x + i * 256;
891 int dy = dest_y + j * 256;
892
893 w = (w & -256) ? 256 : w;
894 h = (h & -256) ? 256 : h;
895
896 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, format, type, data);
897
898 tx = (float)w / 256.;
899 ty = (float)h / 256.;
900
901 if (flip_dir & AGL_H_FLIP) {
902 dx = 2*dest_x + width - dx;
903 w = -w;
904 }
905
906 if (flip_dir & AGL_V_FLIP) {
907 dy = 2*dest_y + height - dy;
908 h = -h;
909 }
910
911 if (width < 0) w = -w;
912 if (height < 0) h = -h;
913
914 glBegin(GL_QUADS);
915 glTexCoord2f(0., 0.);
916 glVertex2i(dx, dy);
917 glTexCoord2f(0., ty);
918 glVertex2i(dx, dy + h);
919 glTexCoord2f(tx, ty);
920 glVertex2i(dx + w, dy + h);
921 glTexCoord2f(tx, 0.);
922 glVertex2i(dx + w, dy);
923 glEnd();
924 }
925 }
926
927 /* Restore state */
928 glPixelStorei(GL_UNPACK_ROW_LENGTH, saved_row_length);
929 glBindTexture(GL_TEXTURE_2D, 0);
930 glDisable(GL_TEXTURE_2D);
931 glDisable(GL_ALPHA_TEST);
932
933 return;
934 }
935
936
937
938 static void do_screen_masked_blit_standard(GLint format, GLint type, struct BITMAP *temp, int source_x, int source_y, int dest_x, int dest_y, int width, int height, int flip_dir, int blit_type)
939 {
940 glPushAttrib(GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
941
942 if (blit_type & AGL_NO_ROTATION) {
943 GLint saved_row_length;
944 float dx = dest_x, dy = dest_y;
945 GLfloat zoom_x, zoom_y, old_zoom_x, old_zoom_y;
946
947 glEnable(GL_ALPHA_TEST);
948 glAlphaFunc(GL_GREATER, 0.0f);
949
950 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &saved_row_length);
951 glGetFloatv(GL_ZOOM_X, &old_zoom_x);
952 glGetFloatv(GL_ZOOM_Y, &old_zoom_y);
953
954 if (flip_dir & AGL_H_FLIP) {
955 zoom_x = -1.0f;
956 /* Without the -0.5 below, we get an invalid position,
957 * and the operation is ignored by OpenGL. */
958 dx += abs(width) - 0.5;
959 }
960 else {
961 zoom_x = (float) width / abs(width);
962 }
963
964 if (flip_dir & AGL_V_FLIP) {
965 zoom_y = 1.0f;
966 dy += abs(height) - 0.5;
967 }
968 else {
969 zoom_y = -1.0f * width / abs(width);
970 }
971
972 glRasterPos2f(dx, dy);
973 glPixelZoom(zoom_x, zoom_y);
974 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
975 glPixelStorei(GL_UNPACK_ROW_LENGTH,
976 (temp->line[1] - temp->line[0])
977 / BYTES_PER_PIXEL(bitmap_color_depth(temp)));
978
979 glDrawPixels(abs(width), abs(height), format, type, temp->line[0]);
980
981 glPixelStorei(GL_UNPACK_ROW_LENGTH, saved_row_length);
982 glPixelZoom(old_zoom_x, old_zoom_y);
983 }
984 else {
985 allegro_gl_upload_and_display_texture(temp, 0, 0, dest_x, dest_y, width, height,
986 flip_dir, format, type);
987 }
988
989 glPopAttrib();
990 }
991
992
993
994 static void screen_masked_blit_standard(struct BITMAP *source,
995 int source_x, int source_y, int dest_x, int dest_y, int width, int height,
996 int flip_dir, int blit_type)
997 {
998 BITMAP *temp = NULL;
999
1000 GLint format, type;
1001
1002 format = __allegro_gl_get_bitmap_color_format(source, AGL_TEXTURE_MASKED);
1003 type = __allegro_gl_get_bitmap_type(source, AGL_TEXTURE_MASKED);
1004
1005 temp = __allegro_gl_munge_bitmap(AGL_TEXTURE_MASKED, source,
1006 source_x, source_y, abs(width), abs(height),
1007 &type, &format);
1008
1009 if (temp) {
1010 source = temp;
1011 }
1012
1013 do_screen_masked_blit_standard(format, type, source, source_x, source_y,
1014 dest_x, dest_y, width, height, flip_dir, blit_type);
1015
1016 if (temp) {
1017 destroy_bitmap(temp);
1018 }
1019
1020 return;
1021 }
1022
1023
1024
1025 static void __allegro_gl_init_nv_register_combiners(BITMAP *bmp)
1026 {
1027 GLfloat mask_color[4];
1028 int depth = bitmap_color_depth(bmp);
1029 int color = bitmap_mask_color(bmp);
1030
1031 mask_color[0] = getr_depth(depth, color) / 255.;
1032 mask_color[1] = getg_depth(depth, color) / 255.;
1033 mask_color[2] = getb_depth(depth, color) / 255.;
1034 mask_color[3] = 0.;
1035
1036 glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, mask_color);
1037 glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, 2);
1038 glEnable(GL_REGISTER_COMBINERS_NV);
1039
1040 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV,
1041 GL_TEXTURE0_ARB, GL_SIGNED_IDENTITY_NV, GL_RGB);
1042 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV,
1043 GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
1044 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV,
1045 GL_CONSTANT_COLOR0_NV, GL_SIGNED_IDENTITY_NV, GL_RGB);
1046 glCombinerInputNV(GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV,
1047 GL_ZERO, GL_EXPAND_NORMAL_NV, GL_RGB);
1048 glCombinerOutputNV(GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV,
1049 GL_DISCARD_NV, GL_SPARE0_NV, GL_NONE, GL_NONE,
1050 GL_FALSE, GL_FALSE, GL_FALSE);
1051
1052 glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV,
1053 GL_SPARE0_NV, GL_SIGNED_IDENTITY_NV, GL_RGB);
1054 glCombinerInputNV(GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV,
1055 GL_SPARE0_NV, GL_SIGNED_IDENTITY_NV, GL_RGB);
1056 glCombinerOutputNV(GL_COMBINER1_NV, GL_RGB, GL_SPARE1_NV,
1057 GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
1058 GL_TRUE, GL_FALSE, GL_FALSE);
1059
1060 glFinalCombinerInputNV(GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
1061 GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1062 glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_ZERO,
1063 GL_UNSIGNED_INVERT_NV, GL_RGB);
1064 glFinalCombinerInputNV(GL_VARIABLE_C_NV, GL_ZERO,
1065 GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1066 glFinalCombinerInputNV(GL_VARIABLE_D_NV, GL_ZERO,
1067 GL_UNSIGNED_IDENTITY_NV, GL_RGB);
1068 glFinalCombinerInputNV(GL_VARIABLE_G_NV, GL_SPARE1_NV,
1069 GL_UNSIGNED_IDENTITY_NV, GL_BLUE);
1070
1071 return;
1072 }
1073
1074
1075
1076 static void screen_masked_blit_nv_register(struct BITMAP *source,
1077 int source_x, int source_y, int dest_x, int dest_y, int width, int height,
1078 int flip_dir, int blit_type)
1079 {
1080 BITMAP *temp = NULL;
1081 GLint type = __allegro_gl_get_bitmap_type(source, 0);
1082 GLint format = __allegro_gl_get_bitmap_color_format(source, 0);
1083
1084 if (type == -1) {
1085 temp = create_bitmap_ex(24, width, height);
1086 if (!temp) {
1087 return;
1088 }
1089 blit(source, temp, source_x, source_y, 0, 0, width, height);
1090 source = temp;
1091 source_x = 0;
1092 source_y = 0;
1093
1094 type = __allegro_gl_get_bitmap_type(source, 0);
1095 format = __allegro_gl_get_bitmap_color_format(source, 0);
1096 }
1097
1098 glPushAttrib(GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
1099 __allegro_gl_init_nv_register_combiners(source);
1100
1101 allegro_gl_upload_and_display_texture(source, source_x, source_y, dest_x, dest_y,
1102 width, height, flip_dir, format, type);
1103
1104 glPopAttrib();
1105
1106 if (temp) {
1107 destroy_bitmap(temp);
1108 }
1109 return;
1110 }
1111
1112
1113
1114 static void __allegro_gl_init_combine_textures(BITMAP *bmp)
1115 {
1116 GLubyte mask_color[4];
1117
1118 split_color(bitmap_mask_color(bmp), &mask_color[0], &mask_color[1],
1119 &mask_color[2], &mask_color[3], bitmap_color_depth(bmp));
1120 glColor4ubv(mask_color);
1121
1122 glActiveTexture(GL_TEXTURE0);
1123 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
1124 glEnable(GL_TEXTURE_2D);
1125 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD_SIGNED_ARB);
1126 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
1127 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR);
1128 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_ONE_MINUS_SRC_COLOR);
1129
1130 /* Dot the result of the subtract with itself. Store it in the alpha
1131 * component. The alpha should then be 0 if the color fragment was equal to
1132 * the mask color, or >0 otherwise.
1133 */
1134 glActiveTexture(GL_TEXTURE1);
1135 glEnable(GL_TEXTURE_2D);
1136 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
1137 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGBA_ARB);
1138 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
1139 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
1140
1141 /* Put the original RGB value in its place */
1142
1143 glActiveTexture(GL_TEXTURE2);
1144 glEnable(GL_TEXTURE_2D);
1145 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
1146 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
1147 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
1148 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
1149 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB);
1150
1151 glActiveTexture(GL_TEXTURE0);
1152
1153 return;
1154 }
1155
1156
1157
1158 static void screen_masked_blit_combine_tex(struct BITMAP *source,
1159 int source_x, int source_y, int dest_x, int dest_y, int width, int height,
1160 int flip_dir, int blit_type)
1161 {
1162 float tx, ty;
1163 BITMAP *temp = NULL;
1164 GLint saved_row_length;
1165 GLint type = __allegro_gl_get_bitmap_type(source, 0);
1166 GLint format = __allegro_gl_get_bitmap_color_format(source, 0);
1167 int bytes_per_pixel;
1168 int i, j;
1169 GLfloat current_color[4];
1170
1171 if (type == -1) {
1172 temp = create_bitmap_ex(24, width, height);
1173 if (!temp)
1174 return;
1175 blit(source, temp, source_x, source_y, 0, 0, width, height);
1176 source = temp;
1177 source_x = 0;
1178 source_y = 0;
1179
1180 type = __allegro_gl_get_bitmap_type(source, 0);
1181 format = __allegro_gl_get_bitmap_color_format(source, 0);
1182 }
1183
1184 glEnable(GL_TEXTURE_2D);
1185 glBindTexture(GL_TEXTURE_2D, __allegro_gl_pool_texture);
1186
1187 glPushAttrib(GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
1188 glGetFloatv(GL_CURRENT_COLOR, current_color);
1189 __allegro_gl_init_combine_textures(source);
1190
1191 glActiveTexture(GL_TEXTURE0);
1192 glBindTexture(GL_TEXTURE_2D, __allegro_gl_pool_texture);
1193 glActiveTexture(GL_TEXTURE1);
1194 glBindTexture(GL_TEXTURE_2D, __allegro_gl_pool_texture);
1195 glActiveTexture(GL_TEXTURE2);
1196 glBindTexture(GL_TEXTURE_2D, __allegro_gl_pool_texture);
1197 glActiveTexture(GL_TEXTURE0);
1198
1199 bytes_per_pixel = BYTES_PER_PIXEL(bitmap_color_depth(source));
1200
1201 glEnable(GL_ALPHA_TEST);
1202 glAlphaFunc(GL_GREATER, 0.0f);
1203
1204 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &saved_row_length);
1205 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1206
1207 glPixelStorei(GL_UNPACK_ROW_LENGTH,
1208 (source->line[1] - source->line[0]) / bytes_per_pixel);
1209
1210 for (i = 0; i <= width / 256; i++) {
1211 for (j = 0; j <= height / 256; j++) {
1212
1213 void *data = source->line[source_y + j * 256]
1214 + (source_x + i * 256) * bytes_per_pixel;
1215 int w = width - i * 256;
1216 int h = height - j * 256;
1217 int dx = dest_x + i * 256;
1218 int dy = dest_y + j * 256;
1219
1220 w = (w & -256) ? 256 : w;
1221 h = (h & -256) ? 256 : h;
1222
1223 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, format, type, data);
1224
1225 tx = (float)w / 256.;
1226 ty = (float)h / 256.;
1227
1228 if (flip_dir & AGL_H_FLIP) {
1229 dx = 2*dest_x + width - dx;
1230 w = -w;
1231 }
1232
1233 if (flip_dir & AGL_V_FLIP) {
1234 dy = 2*dest_y + height - dy;
1235 h = -h;
1236 }
1237
1238 glBegin(GL_QUADS);
1239 glMultiTexCoord2f(GL_TEXTURE0, 0., 0.);
1240 glMultiTexCoord2f(GL_TEXTURE1, 0., 0.);
1241 glMultiTexCoord2f(GL_TEXTURE2, 0., 0.);
1242 glVertex2f(dx, dy);
1243 glMultiTexCoord2f(GL_TEXTURE0, 0., ty);
1244 glMultiTexCoord2f(GL_TEXTURE1, 0., ty);
1245 glMultiTexCoord2f(GL_TEXTURE2, 0., ty);
1246 glVertex2f(dx, dy + h);
1247 glMultiTexCoord2f(GL_TEXTURE0, tx, ty);
1248 glMultiTexCoord2f(GL_TEXTURE1, tx, ty);
1249 glMultiTexCoord2f(GL_TEXTURE2, tx, ty);
1250 glVertex2f(dx + w, dy + h);
1251 glMultiTexCoord2f(GL_TEXTURE0, tx, 0.);
1252 glMultiTexCoord2f(GL_TEXTURE1, tx, 0.);
1253 glMultiTexCoord2f(GL_TEXTURE2, tx, 0.);
1254 glVertex2f(dx + w, dy);
1255 glEnd();
1256 }
1257 }
1258
1259 /* Restore state */
1260 glPixelStorei(GL_UNPACK_ROW_LENGTH, saved_row_length);
1261 glBindTexture(GL_TEXTURE_2D, 0);
1262 glDisable(GL_TEXTURE_2D);
1263 glPopAttrib();
1264 glColor4fv(current_color);
1265
1266 if (temp) {
1267 destroy_bitmap(temp);
1268 }
1269
1270 return;
1271 }
1272
1273
1274
1275 void do_masked_blit_screen(struct BITMAP *source, struct BITMAP *dest,
1276 int source_x, int source_y, int dest_x, int dest_y, int width, int height,
1277 int flip_dir, int blit_type)
1278 {
1279
1280 /* XXX <rohannessian> We should merge this clip code with the
1281 * BITMAP_BLIT_CLIP macro
1282 */
1283
1284 /* Clipping of destination bitmap */
1285 if (dest->clip && (blit_type & AGL_NO_ROTATION)) {
1286 if ((dest_x >= dest->cr) || (dest_y >= dest->cb)
1287 || (dest_x + width < dest->cl) || (dest_y + height < dest->ct)) {
1288 return;
1289 }
1290 if (flip_dir & AGL_H_FLIP) {
1291 if (dest_x < dest->cl) {
1292 width += dest_x - dest->cl;
1293 dest_x = dest->cl;
1294 }
1295 if (dest_x + width > dest->cr) {
1296 source_x += dest_x + width - dest->cr;
1297 width = dest->cr - dest_x;
1298 }
1299 }
1300 else {
1301 if (dest_x < dest->cl) {
1302 width += dest_x - dest->cl;
1303 source_x -= dest_x - dest->cl;
1304 dest_x = dest->cl;
1305 }
1306 if (dest_x + width > dest->cr) {
1307 width = dest->cr - dest_x;
1308 }
1309 }
1310 if (flip_dir & AGL_V_FLIP) {
1311 if (dest_y < dest->ct) {
1312 height += dest_y - dest->ct;
1313 dest_y = dest->ct;
1314 }
1315 if (dest_y + height > dest->cb) {
1316 source_y += dest_y + height - dest->cb;
1317 height = dest->cb - dest_y;
1318 }
1319 }
1320 else {
1321 if (dest_y < dest->ct) {
1322 height += dest_y - dest->ct;
1323 source_y -= dest_y - dest->ct;
1324 dest_y = dest->ct;
1325 }
1326 if (dest_y + height > dest->cb) {
1327 height = dest->cb - dest_y;
1328 }
1329 }
1330 }
1331
1332 /* Clipping of source bitmap */
1333 if (source->clip && (blit_type & AGL_REGULAR_BMP)) {
1334 if ((source_x >= source->cr) || (source_y >= source->cb)
1335 || (source_x + width < source->cl)
1336 || (source_y + height < source->ct)) {
1337 return;
1338 }
1339 if (source_x < source->cl) {
1340 width += source_x - source->cl;
1341 dest_x -= source_x - source->cl;
1342 source_x = source->cl;
1343 }
1344 if (source_y < source->ct) {
1345 height += source_y - source->ct;
1346 dest_y -= source_y - source->ct;
1347 source_y = source->ct;
1348 }
1349 if (source_x + width > source->cr) {
1350 width = source->cr - source_x;
1351 }
1352 if (source_y + height > source->cb) {
1353 height = source->cb - source_y;
1354 }
1355 }
1356 if (is_sub_bitmap(dest)) {
1357 dest_x += dest->x_ofs;
1358 dest_y += dest->y_ofs;
1359 }
1360 if (width <= 0 || height <= 0)
1361 return;
1362
1363 /* memory -> screen */
1364 if (!is_video_bitmap(source) && !is_screen_bitmap(source)) {
1365
1366 __allegro_gl_driver->screen_masked_blit(source, source_x, source_y,
1367 dest_x, dest_y, width, height, flip_dir, blit_type);
1368 }
1369 /* video -> screen */
1370 else if (is_video_bitmap(source)) {
1371 AGL_VIDEO_BITMAP *vid;
1372 BITMAP *source_parent = source;
1373
1374 int use_combiners = 0;
1375
1376 /* Special combiner paths */
1377 if (allegro_gl_extensions_GL.NV_register_combiners
1378 || allegro_gl_info.num_texture_units >= 3) {
1379
1380 use_combiners = 1;
1381
1382 glPushAttrib(GL_ENABLE_BIT | GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT);
1383
1384 if (allegro_gl_extensions_GL.NV_register_combiners) {
1385 __allegro_gl_init_nv_register_combiners(source);
1386 }
1387 else {
1388 __allegro_gl_init_combine_textures(source);
1389 }
1390
1391 glEnable(GL_ALPHA_TEST);
1392 glAlphaFunc(GL_GREATER, 0.0f);
1393 }
1394
1395 while (source_parent->id & BMP_ID_SUB) {
1396 source_parent = (BITMAP *)source_parent->extra;
1397 }
1398 vid = source_parent->extra;
1399
1400 while (vid) {
1401 int sx, sy; /* source coordinates */
1402 int dx, dy; /* destination coordinates */
1403 int w, h;
1404
1405 if (source_x >= vid->x_ofs + vid->memory_copy->w ||
1406 source_y >= vid->y_ofs + vid->memory_copy->h ||
1407 vid->x_ofs >= source_x + width ||
1408 vid->y_ofs >= source_y + height) {
1409 vid = vid->next;
1410 continue;
1411 }
1412
1413 sx = MAX (vid->x_ofs, source_x) - vid->x_ofs;
1414 w = MIN (vid->x_ofs + vid->memory_copy->w, source_x + width)
1415 - vid->x_ofs - sx;
1416 sy = MAX (vid->y_ofs, source_y) - vid->y_ofs;
1417 h = MIN (vid->y_ofs + vid->memory_copy->h, source_y + height)
1418 - vid->y_ofs - sy;
1419
1420 dx = dest_x + vid->x_ofs + sx - source_x;
1421 dy = dest_y + vid->y_ofs + sy - source_y;
1422
1423 if (flip_dir & AGL_H_FLIP) {
1424 dx = 2*dest_x + width - dx;
1425 w = -w;
1426 }
1427
1428 if (flip_dir & AGL_V_FLIP) {
1429 dy = 2*dest_y + height - dy;
1430 h = -h;
1431 }
1432
1433 if (use_combiners) {
1434 if (allegro_gl_extensions_GL.NV_register_combiners) {
1435 glEnable(vid->target);
1436 glBindTexture(vid->target, vid->tex);
1437 glTexParameteri(vid->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1438 glTexParameteri(vid->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1439
1440 if (vid->target == GL_TEXTURE_2D) {
1441 float tx = sx / (float)vid->memory_copy->w;
1442 float ty = sy / (float)vid->memory_copy->h;
1443 float tw = abs(w) / (float)vid->memory_copy->w;
1444 float th = abs(h) / (float)vid->memory_copy->h;
1445
1446 glBegin(GL_QUADS);
1447 glTexCoord2f(tx, ty);
1448 glVertex2f(dx, dy);
1449 glTexCoord2f(tx, ty + th);
1450 glVertex2f(dx, dy + h);
1451 glTexCoord2f(tx + tw, ty + th);
1452 glVertex2f(dx + w, dy + h);
1453 glTexCoord2f(tx + tw, ty);
1454 glVertex2f(dx + w, dy);
1455 glEnd();
1456 }
1457 else {
1458 glBegin(GL_QUADS);
1459 glTexCoord2i(sx, sy);
1460 glVertex2f(dx, dy);
1461 glTexCoord2i(sx, sy + h);
1462 glVertex2f(dx, dy + h);
1463 glTexCoord2i(sx + w, sy + h);
1464 glVertex2f(dx + w, dy + h);
1465 glTexCoord2i(sx + w, sy);
1466 glVertex2f(dx + w, dy);
1467 glEnd();
1468 }
1469
1470 glBindTexture(vid->target, 0);
1471 glDisable(vid->target);
1472 }
1473 else {
1474 glEnable(vid->target);
1475 glActiveTexture(GL_TEXTURE0);
1476 glBindTexture(vid->target, vid->tex);
1477 glActiveTexture(GL_TEXTURE1);
1478 glBindTexture(vid->target, vid->tex);
1479 glActiveTexture(GL_TEXTURE2);
1480 glBindTexture(vid->target, vid->tex);
1481 glActiveTexture(GL_TEXTURE0);
1482 glTexParameteri(vid->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1483 glTexParameteri(vid->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1484
1485 if (vid->target == GL_TEXTURE_2D) {
1486 float tx, ty, tw, th; /* texture coordinates */
1487 tx = sx / (float)vid->memory_copy->w;
1488 ty = sy / (float)vid->memory_copy->h;
1489 tw = abs(w) / (float)vid->memory_copy->w;
1490 th = abs(h) / (float)vid->memory_copy->h;
1491
1492 glBegin(GL_QUADS);
1493 glMultiTexCoord2f(GL_TEXTURE0, tx, ty);
1494 glMultiTexCoord2f(GL_TEXTURE1, tx, ty);
1495 glMultiTexCoord2f(GL_TEXTURE2, tx, ty);
1496 glVertex2f(dx, dy);
1497 glMultiTexCoord2f(GL_TEXTURE0, tx, ty + th);
1498 glMultiTexCoord2f(GL_TEXTURE1, tx, ty + th);
1499 glMultiTexCoord2f(GL_TEXTURE2, tx, ty + th);
1500 glVertex2f(dx, dy + h);
1501 glMultiTexCoord2f(GL_TEXTURE0, tx + tw, ty + th);
1502 glMultiTexCoord2f(GL_TEXTURE1, tx + tw, ty + th);
1503 glMultiTexCoord2f(GL_TEXTURE2, tx + tw, ty + th);
1504 glVertex2f(dx + w, dy + h);
1505 glMultiTexCoord2f(GL_TEXTURE0, tx + tw, ty);
1506 glMultiTexCoord2f(GL_TEXTURE1, tx + tw, ty);
1507 glMultiTexCoord2f(GL_TEXTURE2, tx + tw, ty);
1508 glVertex2f(dx + w, dy);
1509 glEnd();
1510 }
1511 else {
1512 glBegin(GL_QUADS);
1513 glMultiTexCoord2i(GL_TEXTURE0, dx, dy);
1514 glMultiTexCoord2i(GL_TEXTURE1, dx, dy);
1515 glMultiTexCoord2i(GL_TEXTURE2, dx, dy);
1516 glVertex2f(dx, dy);
1517 glMultiTexCoord2i(GL_TEXTURE0, dx, dy + h);
1518 glMultiTexCoord2i(GL_TEXTURE1, dx, dy + h);
1519 glMultiTexCoord2i(GL_TEXTURE2, dx, dy + h);
1520 glVertex2f(dx, dy + h);
1521 glMultiTexCoord2i(GL_TEXTURE0, dx + w, dy + h);
1522 glMultiTexCoord2i(GL_TEXTURE1, dx + w, dy + h);
1523 glMultiTexCoord2i(GL_TEXTURE2, dx + w, dy + h);
1524 glVertex2f(dx + w, dy + h);
1525 glMultiTexCoord2i(GL_TEXTURE0, dx + w, dy);
1526 glMultiTexCoord2i(GL_TEXTURE1, dx + w, dy);
1527 glMultiTexCoord2i(GL_TEXTURE2, dx + w, dy);
1528 glVertex2f(dx + w, dy);
1529 glEnd();
1530 }
1531
1532 glBindTexture(vid->target, 0);
1533 glDisable(vid->target);
1534 }
1535 }
1536 else {
1537 screen_masked_blit_standard(vid->memory_copy, sx, sy, dx, dy,
1538 w, h, FALSE, blit_type);
1539 }
1540
1541 vid = vid->next;
1542 }
1543
1544 if (use_combiners) {
1545 glPopAttrib();
1546 }
1547 }
1548 return;
1549 }
1550
1551
1552
1553 static BITMAP* __allegro_gl_convert_rle_sprite(AL_CONST struct RLE_SPRITE *sprite, int trans)
1554 {
1555 BITMAP *temp = NULL;
1556 int y, x, src_depth;
1557 signed long src_mask;
1558
1559 #define DRAW_RLE_8888(bits) \
1560 { \
1561 for (y = 0; y < sprite->h; y++) { \
1562 signed long c = *s++; \
1563 for (x = 0; x < sprite->w;) { \
1564 if (c == src_mask) \
1565 break; \
1566 if (c > 0) { \
1567 /* Run of solid pixels */ \
1568 for (c--; c>=0; c--) { \
1569 unsigned long col = *s++; \
1570 if (bits == 32 && trans) \
1571 _putpixel32(temp, x++, y, makeacol32(getr32(col), getg32(col), getb32(col), geta32(col))); \
1572 else \
1573 _putpixel32(temp, x++, y, makeacol32(getr##bits(col), getg##bits(col), getb##bits(col), 255)); \
1574 } \
1575 } \
1576 else { \
1577 /* Run of transparent pixels */ \
1578 hline(temp, x, y, x-c+1, 0); \
1579 x -= c; \
1580 } \
1581 c = *s++; \
1582 } \
1583 } \
1584 }
1585
1586 src_depth = sprite->color_depth;
1587 if (src_depth == 8)
1588 src_mask = 0;
1589 else
1590 src_mask = makecol_depth(src_depth, 255, 0, 255);
1591
1592 temp = create_bitmap_ex(32, sprite->w, sprite->h);
1593 if (!temp) return NULL;
1594
1595 /* RGBA 8888 */
1596 switch(src_depth) {
1597 case 8:
1598 {
1599 signed char *s = (signed char*)sprite->dat;
1600 DRAW_RLE_8888(8);
1601 break;
1602 }
1603 case 15:
1604 {
1605 int16_t *s = (int16_t*)sprite->dat;
1606 DRAW_RLE_8888(15);
1607 break;
1608 }
1609 case 16:
1610 {
1611 int16_t *s = (int16_t*)sprite->dat;
1612 DRAW_RLE_8888(16);
1613 break;
1614 }
1615 case 24:
1616 {
1617 int32_t *s = (int32_t*)sprite->dat;
1618 DRAW_RLE_8888(24);
1619 break;
1620 }
1621 case 32:
1622 {
1623 int32_t *s = (int32_t*)sprite->dat;
1624 DRAW_RLE_8888(32);
1625 break;
1626 }
1627 }
1628
1629 return temp;
1630 }
1631
1632
1633
1634 void allegro_gl_screen_draw_rle_sprite(struct BITMAP *bmp, AL_CONST struct RLE_SPRITE *sprite, int x, int y)
1635 {
1636 BITMAP *temp = NULL, *temp2 = NULL;
1637 int source_x = 0, source_y = 0;
1638 int width = sprite->w, height = sprite->h;
1639
1640 temp = __allegro_gl_convert_rle_sprite(sprite, FALSE);
1641 if (!temp)
1642 return;
1643
1644 BITMAP_BLIT_CLIP(temp, bmp, source_x, source_y, x, y, width, height);
1645
1646 if (is_sub_bitmap(bmp)) {
1647 x += bmp->x_ofs;
1648 y += bmp->y_ofs;
1649 }
1650
1651 if (width <= 0 || height <= 0) {
1652 destroy_bitmap(temp);
1653 return;
1654 }
1655
1656 temp2 = create_sub_bitmap(temp, source_x, source_y, width, height);
1657 if (!temp2) {
1658 destroy_bitmap(temp);
1659 return;
1660 }
1661
1662 do_screen_masked_blit_standard(GL_RGBA,
1663 __allegro_gl_get_bitmap_type(temp2, AGL_TEXTURE_MASKED), temp2,
1664 0, 0, x, y, width, height, FALSE, AGL_NO_ROTATION);
1665
1666 destroy_bitmap(temp2);
1667 destroy_bitmap(temp);
1668 }
1669
1670
1671 static void allegro_gl_screen_draw_trans_rgba_rle_sprite(struct BITMAP *bmp,
1672 AL_CONST struct RLE_SPRITE *sprite, int x, int y) {
1673 BITMAP *temp = NULL, *temp2 = NULL;
1674 int source_x = 0, source_y = 0;
1675 int width = sprite->w, height = sprite->h;
1676
1677 temp = __allegro_gl_convert_rle_sprite(sprite, TRUE);
1678 if (!temp)
1679 return;
1680
1681 BITMAP_BLIT_CLIP(temp, bmp, source_x, source_y, x, y, width, height);
1682
1683 if (is_sub_bitmap(bmp)) {
1684 x += bmp->x_ofs;
1685 y += bmp->y_ofs;
1686 }
1687
1688 if (width <= 0 || height <= 0) {
1689 destroy_bitmap(temp);
1690 return;
1691 }
1692
1693 temp2 = create_sub_bitmap(temp, source_x, source_y, width, height);
1694 if (!temp2) {
1695 destroy_bitmap(temp);
1696 return;
1697 }
1698
1699 if (__allegro_gl_blit_operation == AGL_OP_LOGIC_OP)
1700 glEnable(GL_COLOR_LOGIC_OP);
1701 else
1702 glEnable(GL_BLEND);
1703
1704 allegro_gl_upload_and_display_texture(temp2, 0, 0, x, y, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE);
1705
1706 if (__allegro_gl_blit_operation == AGL_OP_LOGIC_OP)
1707 glDisable(GL_COLOR_LOGIC_OP);
1708 else
1709 glDisable(GL_BLEND);
1710
1711 destroy_bitmap(temp2);
1712 destroy_bitmap(temp);
1713 }
1714
1715
1716
1717 static void allegro_gl_screen_masked_blit(struct BITMAP *source,
1718 struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y,
1719 int width, int height)
1720 {
1721 AGL_LOG(2, "glvtable.c:allegro_gl_screen_masked_blit\n");
1722 do_masked_blit_screen(source, dest, source_x, source_y, dest_x, dest_y,
1723 width, height, FALSE, AGL_REGULAR_BMP | AGL_NO_ROTATION);
1724 }
1725
1726
1727
1728 static void allegro_gl_screen_draw_sprite(struct BITMAP *bmp,
1729 struct BITMAP *sprite, int x, int y)
1730 {
1731 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_sprite\n");
1732 do_masked_blit_screen(sprite, bmp, 0, 0, x, y, sprite->w, sprite->h,
1733 FALSE, AGL_NO_ROTATION);
1734 }
1735
1736
1737
1738 static void allegro_gl_screen_draw_sprite_v_flip(struct BITMAP *bmp,
1739 struct BITMAP *sprite, int x, int y)
1740 {
1741 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_sprite_v_flip\n");
1742 do_masked_blit_screen(sprite, bmp, 0, 0, x, y, sprite->w, sprite->h,
1743 AGL_V_FLIP, AGL_NO_ROTATION);
1744 }
1745
1746
1747
1748 static void allegro_gl_screen_draw_sprite_h_flip(struct BITMAP *bmp,
1749 struct BITMAP *sprite, int x, int y)
1750 {
1751 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_sprite_h_flip\n");
1752 do_masked_blit_screen(sprite, bmp, 0, 0, x, y, sprite->w, sprite->h,
1753 AGL_H_FLIP, AGL_NO_ROTATION);
1754 }
1755
1756
1757
1758 static void allegro_gl_screen_draw_sprite_vh_flip(struct BITMAP *bmp,
1759 struct BITMAP *sprite, int x, int y)
1760 {
1761 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_sprite_vh_flip\n");
1762 do_masked_blit_screen(sprite, bmp, 0, 0, x, y, sprite->w, sprite->h,
1763 AGL_V_FLIP | AGL_H_FLIP, AGL_NO_ROTATION);
1764 }
1765
1766
1767
1768 static void allegro_gl_screen_pivot_scaled_sprite_flip(struct BITMAP *bmp,
1769 struct BITMAP *sprite, fixed x, fixed y, fixed cx, fixed cy, fixed angle,
1770 fixed scale, int v_flip)
1771 {
1772 double dscale = fixtof(scale);
1773 GLint matrix_mode;
1774 AGL_LOG(2, "glvtable.c:allegro_gl_screen_pivot_scaled_sprite_flip\n");
1775
1776 #define BIN_2_DEG(x) (-(x) * 180.0 / 128)
1777
1778 glGetIntegerv(GL_MATRIX_MODE, &matrix_mode);
1779 glMatrixMode(GL_MODELVIEW);
1780 glPushMatrix();
1781 glTranslated(fixtof(x), fixtof(y), 0.);
1782 glRotated(BIN_2_DEG(fixtof(angle)), 0., 0., -1.);
1783 glScaled(dscale, dscale, dscale);
1784 glTranslated(-fixtof(x+cx), -fixtof(y+cy), 0.);
1785
1786 do_masked_blit_screen(sprite, bmp, 0, 0, fixtoi(x), fixtoi(y),
1787 sprite->w, sprite->h, v_flip ? AGL_V_FLIP : FALSE, FALSE);
1788 glPopMatrix();
1789 glMatrixMode(matrix_mode);
1790
1791 #undef BIN_2_DEG
1792
1793 return;
1794 }
1795
1796
1797
1798 static void allegro_gl_screen_draw_trans_rgba_sprite(struct BITMAP *bmp,
1799 struct BITMAP *sprite, int x, int y) {
1800
1801 if (__allegro_gl_blit_operation == AGL_OP_LOGIC_OP)
1802 glEnable(GL_COLOR_LOGIC_OP);
1803 else
1804 glEnable(GL_BLEND);
1805
1806 /* video -> screen */
1807 if (is_video_bitmap(sprite)) {
1808 allegro_gl_screen_blit_to_self(sprite, bmp, 0, 0, x, y, sprite->w, sprite->h);
1809 }
1810 /* memory -> screen */
1811 else if (is_memory_bitmap(sprite)) {
1812 GLint format = __allegro_gl_get_bitmap_color_format(sprite, AGL_TEXTURE_HAS_ALPHA);
1813 GLint type = __allegro_gl_get_bitmap_type(sprite, 0);
1814 allegro_gl_upload_and_display_texture(sprite, 0, 0, x, y, sprite->w, sprite->h, 0, format, type);
1815 }
1816
1817 if (__allegro_gl_blit_operation == AGL_OP_LOGIC_OP)
1818 glDisable(GL_COLOR_LOGIC_OP);
1819 else
1820 glDisable(GL_BLEND);
1821
1822 return;
1823 }
1824
1825
1826
1827 static void allegro_gl_screen_draw_sprite_ex(struct BITMAP *bmp,
1828 struct BITMAP *sprite, int x, int y, int mode, int flip)
1829 {
1830 int lflip = 0;
1831 int matrix_mode;
1832 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_sprite_ex\n");
1833
1834 /* convert allegro's flipping flags to AGL's flags */
1835 switch (flip) {
1836 case DRAW_SPRITE_NO_FLIP:
1837 lflip = FALSE;
1838 break;
1839 case DRAW_SPRITE_V_FLIP:
1840 lflip = AGL_V_FLIP;
1841 break;
1842 case DRAW_SPRITE_H_FLIP:
1843 lflip = AGL_H_FLIP;
1844 break;
1845 case DRAW_SPRITE_VH_FLIP:
1846 lflip = AGL_V_FLIP | AGL_H_FLIP;
1847 break;
1848 }
1849
1850 switch (mode) {
1851 case DRAW_SPRITE_NORMAL:
1852 do_masked_blit_screen(sprite, bmp, 0, 0, x, y, sprite->w, sprite->h,
1853 lflip, AGL_NO_ROTATION);
1854 break;
1855 case DRAW_SPRITE_TRANS:
1856 if (lflip) {
1857 glGetIntegerv(GL_MATRIX_MODE, &matrix_mode);
1858 glMatrixMode(GL_MODELVIEW);
1859 glPushMatrix();
1860
1861 glTranslatef(x, y, 0.f);
1862 glScalef((lflip&AGL_H_FLIP) ? -1 : 1, (lflip&AGL_V_FLIP)? -1 : 1, 1);
1863 glTranslatef(-x, -y, 0);
1864 glTranslatef((lflip&AGL_H_FLIP) ? -sprite->w : 0,
1865 (lflip&AGL_V_FLIP) ? -sprite->h : 0, 0);
1866 }
1867
1868 allegro_gl_screen_draw_trans_rgba_sprite(bmp, sprite, x, y);
1869
1870 if (lflip) {
1871 glPopMatrix();
1872 glMatrixMode(matrix_mode);
1873 }
1874 break;
1875 case DRAW_SPRITE_LIT:
1876 /* unsupported */
1877 break;
1878 }
1879 }
1880
1881
1882
1883 void allegro_gl_screen_draw_glyph_ex(struct BITMAP *bmp,
1884 AL_CONST struct FONT_GLYPH *glyph, int x, int y,
1885 int color, int bg, int flip)
1886 {
1887 GLubyte r, g, b, a;
1888 int x_offs = 0;
1889 int i;
1890
1891 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_glyph_ex\n");
1892
1893 if (bmp->clip) {
1894 glPushAttrib(GL_SCISSOR_BIT);
1895 glEnable(GL_SCISSOR_TEST);
1896 glScissor(bmp->x_ofs + bmp->cl, bmp->h + bmp->y_ofs - bmp->cb,
1897 bmp->cr - bmp->cl, bmp->cb - bmp->ct);
1898
1899 if (x < bmp->cl) {
1900 x_offs -= x - bmp->cl;
1901 x = bmp->cl;
1902 }
1903 }
1904 if (is_sub_bitmap(bmp)) {
1905 x += bmp->x_ofs;
1906 y += bmp->y_ofs;
1907 }
1908
1909 if (bg != -1) {
1910 split_color(bg, &r, &g, &b, &a, bitmap_color_depth(bmp));
1911 glColor4ub(r, g, b, a);
1912 glRecti(x, y, x + glyph->w, y + glyph->h);
1913 }
1914
1915 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
1916 glColor4ub(r, g, b, a);
1917 glRasterPos2i(x, y);
1918 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1919 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
1920
1921 if (flip) {
1922 for (i = 0; i < glyph->h; i++) {
1923 glBitmap(glyph->w, 1, x_offs, i, 0, 2,
1924 glyph->dat + i * ((glyph->w + 7) / 8));
1925 }
1926 }
1927 else {
1928 for (i = 0; i < glyph->h; i++) {
1929 glBitmap(glyph->w, 1, x_offs, i, 0, 0,
1930 glyph->dat + i * ((glyph->w + 7) / 8));
1931 }
1932 }
1933
1934 if (bmp->clip) {
1935 glPopAttrib();
1936 }
1937
1938 return;
1939 }
1940
1941
1942
1943 static void allegro_gl_screen_draw_glyph(struct BITMAP *bmp,
1944 AL_CONST struct FONT_GLYPH *glyph, int x, int y,
1945 int color, int bg) {
1946 allegro_gl_screen_draw_glyph_ex(bmp, glyph, x, y, color, bg, 0);
1947 }
1948
1949
1950
1951 void allegro_gl_screen_draw_color_glyph_ex(struct BITMAP *bmp,
1952 struct BITMAP *sprite, int x, int y, int color, int bg, int flip)
1953 {
1954
1955 /* Implementation note: we should try building textures and see how well
1956 * those work instead of of DrawPixels with a weird I_TO_RGBA mapping.
1957 */
1958 static GLfloat red_map[256];
1959 static GLfloat green_map[256];
1960 static GLfloat blue_map[256];
1961 static GLfloat alpha_map[256];
1962 GLubyte r, g, b, a;
1963 int i;
1964 GLint saved_row_length;
1965 GLint width, height;
1966 int sprite_x = 0, sprite_y = 0;
1967 void *data;
1968 int *table;
1969
1970 width = sprite->w;
1971 height = sprite->h;
1972
1973 if (bmp->clip) {
1974 if ((x >= bmp->cr) || (y >= bmp->cb) || (x + width < bmp->cl)
1975 || (y + height < bmp->ct)) {
1976 return;
1977 }
1978 if (x < bmp->cl) {
1979 width += x - bmp->cl;
1980 sprite_x -= (x - bmp->cl);
1981 x = bmp->cl;
1982 }
1983 if (y < bmp->ct) {
1984 height += y - bmp->ct;
1985 sprite_y -= (y - bmp->ct);
1986 y = bmp->ct;
1987 }
1988 if (x + width > bmp->cr) {
1989 width = bmp->cr - x;
1990 }
1991 if (y + height > bmp->cb) {
1992 height = bmp->cb - y;
1993 }
1994 }
1995 if (is_sub_bitmap(bmp)) {
1996 x += bmp->x_ofs;
1997 y += bmp->y_ofs;
1998 }
1999
2000 data = sprite->line[sprite_y]
2001 + sprite_x * BYTES_PER_PIXEL(bitmap_color_depth(sprite));
2002
2003 if (bg < 0) {
2004 glAlphaFunc(GL_GREATER, 0.0f);
2005 glEnable(GL_ALPHA_TEST);
2006 alpha_map[0] = 0.;
2007 }
2008 else {
2009 split_color(bg, &r, &g, &b, &a, bitmap_color_depth(bmp));
2010 red_map[0] = r / 255.;
2011 green_map[0] = g / 255.;
2012 blue_map[0] = b / 255.;
2013 alpha_map[0] = 1.;
2014 }
2015
2016 if (color < 0) {
2017 table = _palette_expansion_table(bitmap_color_depth(bmp));
2018
2019 for(i = 1; i < 255; i++) {
2020 split_color(table[i], &r, &g, &b, &a, bitmap_color_depth(bmp));
2021 red_map[i] = r / 255.;
2022 green_map[i] = g / 255.;
2023 blue_map[i] = b / 255.;
2024 alpha_map[i] = 1.;
2025 }
2026 }
2027 else {
2028 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
2029
2030 for(i = 1; i < 255; i++) {
2031 red_map[i] = r / 255.;
2032 green_map[i] = g / 255.;
2033 blue_map[i] = b / 255.;
2034 alpha_map[i] = 1.;
2035 }
2036 }
2037
2038 glPixelMapfv(GL_PIXEL_MAP_I_TO_R, 256, red_map);
2039 glPixelMapfv(GL_PIXEL_MAP_I_TO_G, 256, green_map);
2040 glPixelMapfv(GL_PIXEL_MAP_I_TO_B, 256, blue_map);
2041 glPixelMapfv(GL_PIXEL_MAP_I_TO_A, 256, alpha_map);
2042
2043 glRasterPos2i(x, y);
2044 glPushAttrib(GL_PIXEL_MODE_BIT);
2045 glGetIntegerv(GL_UNPACK_ROW_LENGTH, &saved_row_length);
2046
2047 glPixelZoom(1.0, flip ? -1.0 : 1.0);
2048 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2049 glPixelStorei(GL_UNPACK_ROW_LENGTH, sprite->w);
2050 glPixelTransferi(GL_MAP_COLOR, GL_TRUE);
2051
2052 glDrawPixels(width, height, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, data);
2053 glPixelStorei(GL_UNPACK_ROW_LENGTH, saved_row_length);
2054 glPopAttrib();
2055 if (bg < 0) {
2056 glDisable(GL_ALPHA_TEST);
2057 }
2058
2059 return;
2060 }
2061
2062
2063
2064 static void allegro_gl_screen_draw_color_glyph(struct BITMAP *bmp,
2065 struct BITMAP *sprite, int x, int y, int color, int bg) {
2066 allegro_gl_screen_draw_color_glyph_ex(bmp, sprite, x, y, color, bg, 1);
2067 }
2068
2069
2070
2071 static void allegro_gl_screen_draw_character(struct BITMAP *bmp,
2072 struct BITMAP *sprite, int x, int y, int color, int bg)
2073 {
2074 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_character\n");
2075 allegro_gl_screen_draw_color_glyph(bmp, sprite, x, y, color, bg);
2076 }
2077
2078
2079
2080 static void allegro_gl_screen_draw_256_sprite(struct BITMAP *bmp,
2081 struct BITMAP *sprite, int x, int y)
2082 {
2083 AGL_LOG(2, "glvtable.c:allegro_gl_screen_draw_256_sprite\n");
2084 allegro_gl_screen_draw_color_glyph(bmp, sprite, x, y, -1, -1);
2085 }
2086
2087
2088
2089 void allegro_gl_screen_clear_to_color(struct BITMAP *bmp, int color)
2090 {
2091 if (__agl_drawing_pattern_tex || bmp->clip) {
2092 allegro_gl_screen_rectfill(bmp, 0, 0, bmp->w, bmp->h, color);
2093 }
2094 else {
2095 GLubyte r, g, b, a;
2096 GLfloat old_col[4];
2097
2098 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
2099
2100 glGetFloatv(GL_COLOR_CLEAR_VALUE, old_col);
2101 glClearColor(((float) r / 255), ((float) g / 255), ((float) b / 255),
2102 ((float) a / 255));
2103
2104 glClear(GL_COLOR_BUFFER_BIT);
2105 glClearColor(old_col[0], old_col[1], old_col[2], old_col[3]);
2106 }
2107
2108 return;
2109 }
2110
2111
2112
2113 /* TODO: Handle concave and self-intersecting. */
2114 static void allegro_gl_screen_polygon(struct BITMAP *bmp, int vertices,
2115 AL_CONST int *points, int color) {
2116 GLubyte r, g, b, a;
2117 int i;
2118
2119 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
2120 glColor4ub(r, g, b, a);
2121
2122 glPushAttrib(GL_SCISSOR_BIT);
2123
2124 if (bmp->clip) {
2125 glEnable(GL_SCISSOR_TEST);
2126 glScissor(bmp->x_ofs + bmp->cl, bmp->h + bmp->y_ofs - bmp->cb,
2127 bmp->cr - bmp->cl, bmp->cb - bmp->ct);
2128 }
2129 else {
2130 glScissor(0, 0, bmp->w, bmp->h);
2131 }
2132
2133 glBegin(GL_POLYGON);
2134 for (i = 0; i < vertices*2-1; i+=2) {
2135 SET_TEX_COORDS(points[i], points[i+1]);
2136 if (is_sub_bitmap(bmp)) {
2137 glVertex2f(points[i] + bmp->x_ofs, points[i+1] + bmp->y_ofs);
2138 }
2139 else {
2140 glVertex2f(points[i], points[i+1]);
2141 }
2142 }
2143 glEnd();
2144
2145 glPopAttrib();
2146 }
2147
2148
2149
2150 static void allegro_gl_screen_rect(struct BITMAP *bmp,
2151 int x1, int y1, int x2, int y2, int color) {
2152 GLubyte r, g, b, a;
2153
2154 split_color(color, &r, &g, &b, &a, bitmap_color_depth(bmp));
2155 glColor4ub(r, g, b, a);
2156
2157 glPushAttrib(GL_SCISSOR_BIT);
2158
2159 if (bmp->clip) {
2160 glEnable(GL_SCISSOR_TEST);
2161 glScissor(bmp->x_ofs + bmp->cl, bmp->h + bmp->y_ofs - bmp->cb,
2162 bmp->cr - bmp->cl, bmp->cb - bmp->ct);
2163 }
2164 else {
2165 glScissor(0, 0, bmp->w, bmp->h);
2166 }
2167 if (is_sub_bitmap(bmp)) {
2168 x1 += bmp->x_ofs;
2169 x2 += bmp->x_ofs;
2170 y1 += bmp->y_ofs;
2171 y2 += bmp->y_ofs;
2172 }
2173
2174 glBegin(GL_LINE_STRIP);
2175 glVertex2f(x1, y1);
2176 glVertex2f(x2, y1);
2177 glVertex2f(x2, y2);
2178 glVertex2f(x1, y2);
2179 glVertex2f(x1, y1);
2180 glEnd();
2181
2182 glPopAttrib();
2183 }
2184
2185
2186
2187 void allegro_gl_screen_polygon3d_f(struct BITMAP *bmp, int type,
2188 struct BITMAP *texture, int vc,
2189 V3D_f *vtx[]) {
2190 int i;
2191 int use_z = FALSE;
2192
2193 if (type & POLYTYPE_ZBUF) {
2194 use_z = TRUE;
2195 type &= ~POLYTYPE_ZBUF;
2196 }
2197
2198 if (type == POLYTYPE_PTEX || type == POLYTYPE_PTEX_TRANS)
2199 use_z = TRUE;
2200
2201 if (bmp->clip) {
2202 glPushAttrib(GL_SCISSOR_BIT);
2203 glEnable(GL_SCISSOR_TEST);
2204 glScissor(bmp->x_ofs + bmp->cl, bmp->h + bmp->y_ofs - bmp->cb,
2205 bmp->cr - bmp->cl, bmp->cb - bmp->ct);
2206 }
2207 if (is_sub_bitmap(bmp)) {
2208 for (i = 0; i < vc*2-1; i+=2) {
2209 vtx[i] += bmp->x_ofs;
2210 vtx[i+1] += bmp->y_ofs;
2211 }
2212 }
2213
2214 if (use_z) {
2215 glEnable(GL_DEPTH_TEST);
2216 glDepthFunc(GL_LESS);
2217 glDepthMask(GL_TRUE);
2218 }
2219
2220 glColor4ub(255, 255, 255, 255);
2221
2222 if (type == POLYTYPE_ATEX || type == POLYTYPE_PTEX
2223 || type == POLYTYPE_ATEX_TRANS || type == POLYTYPE_PTEX_TRANS) {
2224 drawing_mode(DRAW_MODE_COPY_PATTERN, texture, 0, 0);
2225 }
2226
2227 if (type == POLYTYPE_ATEX_TRANS || type == POLYTYPE_PTEX_TRANS) {
2228 glEnable(GL_BLEND);
2229 }
2230
2231 glBegin(GL_POLYGON);
2232 for (i = 0; i < vc; i++) {
2233 if (type == POLYTYPE_FLAT)
2234 glColor3ub(getr(vtx[0]->c), getg(vtx[0]->c), getb(vtx[0]->c));
2235 else if (type == POLYTYPE_GRGB)
2236 glColor3ub(getr24(vtx[i]->c), getg24(vtx[i]->c), getb24(vtx[i]->c));
2237 else if (type == POLYTYPE_GCOL)
2238 glColor3ub(getr(vtx[i]->c), getg(vtx[i]->c), getb(vtx[i]->c));
2239 else if (type == POLYTYPE_ATEX || type == POLYTYPE_PTEX
2240 || type == POLYTYPE_ATEX_TRANS || type == POLYTYPE_PTEX_TRANS) {
2241 SET_TEX_COORDS(vtx[i]->u, vtx[i]->v);
2242 }
2243
2244 if (use_z)
2245 glVertex3f(vtx[i]->x, vtx[i]->y, 1.f / vtx[i]->z);
2246 else
2247 glVertex2f(vtx[i]->x, vtx[i]->y);
2248 }
2249 glEnd();
2250
2251 if (bmp->clip)
2252 glPopAttrib();
2253
2254 if (use_z) {
2255 glDisable(GL_DEPTH_TEST);
2256 glDepthMask(GL_FALSE);
2257 }
2258
2259 if (type == POLYTYPE_ATEX || type == POLYTYPE_PTEX
2260 || type == POLYTYPE_ATEX_TRANS || type == POLYTYPE_PTEX_TRANS) {
2261 solid_mode();
2262 }
2263
2264 if (type == POLYTYPE_ATEX_TRANS || type == POLYTYPE_PTEX_TRANS)
2265 glDisable(GL_BLEND);
2266 }
2267
2268
2269
2270 static void allegro_gl_screen_polygon3d(struct BITMAP *bmp, int type,
2271 struct BITMAP *texture, int vc,
2272 V3D *vtx[]) {
2273 int i;
2274 V3D_f **vtx_f = malloc(vc * sizeof(struct V3D_f*));
2275 if (!vtx_f)
2276 return;
2277
2278 for (i = 0; i < vc; i++) {
2279 vtx_f[i] = malloc(sizeof(struct V3D_f));
2280 if (!vtx_f[i]) {
2281 int k;
2282 for (k = 0; k < i; k++)
2283 free(vtx_f[k]);
2284 free(vtx_f);
2285 return;
2286 }
2287 vtx_f[i]->c = vtx[i]->c;
2288 vtx_f[i]->u = fixtof(vtx[i]->u);
2289 vtx_f[i]->v = fixtof(vtx[i]->v);
2290 vtx_f[i]->x = fixtof(vtx[i]->x);
2291 vtx_f[i]->y = fixtof(vtx[i]->y);
2292 vtx_f[i]->z = fixtof(vtx[i]->z);
2293 }
2294
2295 allegro_gl_screen_polygon3d_f(bmp, type, texture, vc, vtx_f);
2296 for (i = 0; i < vc; i++)
2297 free(vtx_f[i]);
2298 free(vtx_f);
2299 }
2300
2301
2302 static void allegro_gl_screen_quad3d_f(struct BITMAP *bmp, int type,
2303 struct BITMAP *texture,
2304 V3D_f *v1, V3D_f *v2, V3D_f *v3, V3D_f *v4) {
2305
2306 V3D_f *vtx_f[4];
2307 vtx_f[0] = v1;
2308 vtx_f[1] = v2;
2309 vtx_f[2] = v3;
2310 vtx_f[3] = v4;
2311
2312 allegro_gl_screen_polygon3d_f(bmp, type, texture, 4, vtx_f);
2313 }
2314
2315
2316
2317 static void allegro_gl_screen_quad3d(struct BITMAP *bmp, int type,
2318 struct BITMAP *texture, V3D *v1, V3D *v2, V3D *v3, V3D *v4) {
2319
2320 V3D *vtx[4];
2321 vtx[0] = v1;
2322 vtx[1] = v2;
2323 vtx[2] = v3;
2324 vtx[3] = v4;
2325
2326 allegro_gl_screen_polygon3d(bmp, type, texture, 4, vtx);
2327 }
2328
2329
2330
2331 static void allegro_gl_screen_triangle3d(struct BITMAP *bmp, int type,
2332 struct BITMAP *texture,
2333 V3D *v1, V3D *v2, V3D *v3) {
2334 V3D *vtx[3];
2335 vtx[0] = v1;
2336 vtx[1] = v2;
2337 vtx[2] = v3;
2338
2339 allegro_gl_screen_polygon3d(bmp, type, texture, 3, vtx);
2340 }
2341
2342
2343
2344 static void allegro_gl_screen_triangle3d_f(struct BITMAP *bmp, int type,
2345 struct BITMAP *texture,
2346 V3D_f *v1, V3D_f *v2, V3D_f *v3) {
2347 V3D_f *vtx_f[3];
2348 vtx_f[0] = v1;
2349 vtx_f[1] = v2;
2350 vtx_f[2] = v3;
2351
2352 allegro_gl_screen_polygon3d_f(bmp, type, texture, 3, vtx_f);
2353 }
2354
2355
2356
2357 void __allegro_gl__glvtable_update_vtable(GFX_VTABLE ** vtable)
2358 {
2359 int maskcolor = (*vtable)->mask_color;
2360 int depth = (*vtable)->color_depth;
2361
2362 AGL_LOG(2, "glvtable.c:__allegro_gl__glvtable_update_vtable\n");
2363 allegro_gl_screen_vtable.color_depth = depth;
2364 /* makecol_depth is used below instead of the MASK_COLOR_x constants
2365 * because we may have changed the RGB shift values in order to
2366 * use the packed pixels extension
2367 */
2368 allegro_gl_screen_vtable.mask_color =
2369 makecol_depth(depth, getr(maskcolor), getg(maskcolor), getb(maskcolor));
2370
2371 *vtable = &allegro_gl_screen_vtable;
2372
2373 __allegro_gl_driver->screen_masked_blit = screen_masked_blit_standard;
2374 if (allegro_gl_extensions_GL.NV_register_combiners) {
2375 __allegro_gl_driver->screen_masked_blit
2376 = screen_masked_blit_nv_register;
2377 }
2378 else if (allegro_gl_info.num_texture_units >= 3) {
2379 __allegro_gl_driver->screen_masked_blit =
2380 screen_masked_blit_combine_tex;
2381 }
2382 }
2383
2384
2385
2386 /* Saved projection matrix */
2387 static double allegro_gl_projection_matrix[16];
2388 static double allegro_gl_modelview_matrix[16];
2389
2390
2391
2422 void allegro_gl_set_allegro_mode(void)
2423 {
2424 AGL_LOG(2, "glvtable.c:allegro_gl_set_allegro_mode\n");
2425
2426 /* Save the OpenGL state then set it up */
2427 glPushAttrib(GL_ENABLE_BIT | GL_TEXTURE_BIT | GL_TRANSFORM_BIT
2428 | GL_POINT_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
2429 glDisable(GL_DEPTH_TEST);
2430 glDisable(GL_CULL_FACE);
2431 glDisable(GL_FOG);
2432 glDisable(GL_LIGHTING);
2433 glDisable(GL_BLEND);
2434 glDisable(GL_ALPHA_TEST);
2435 glDepthMask(GL_FALSE);
2436 glEnable(GL_TEXTURE_2D);
2437 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2438 glPointSize(1.);
2439
2440 /* Create pool texture */
2441 if (!__allegro_gl_pool_texture) {
2442 glGenTextures(1, &__allegro_gl_pool_texture);
2443 }
2444
2445 glBindTexture(GL_TEXTURE_2D, __allegro_gl_pool_texture);
2446 /* Create a texture without defining the data */
2447 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0,
2448 GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2449 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2450 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2451
2452 glBindTexture(GL_TEXTURE_2D, 0);
2453 allegro_gl_set_projection();
2454
2455 /* For some reason, ATI Rage Pro isn't able to draw correctly without a
2456 * texture bound. So we bind a dummy 1x1 texture to work around the issue.
2457 */
2458 if (allegro_gl_info.is_ati_rage_pro) {
2459 if (!__allegro_gl_dummy_texture) {
2460 GLubyte tex[4] = {255, 255, 255, 255};
2461 glGenTextures(1, &__allegro_gl_dummy_texture);
2462 glBindTexture(GL_TEXTURE_2D, __allegro_gl_dummy_texture);
2463 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0,
2464 GL_RGBA, GL_UNSIGNED_BYTE, tex);
2465 }
2466 glBindTexture(GL_TEXTURE_2D, __allegro_gl_dummy_texture);
2467 }
2468 #ifdef ALLEGRO_MACOSX
2469 /* MacOSX 10.2.x has a bug: glRasterPos causes a crash (it is used in
2470 *'blit'). This stops it happening.
2471 */
2472 glBegin(GL_POINTS);
2473 glEnd();
2474 #endif
2475 }
2476
2477
2478
2491 void allegro_gl_unset_allegro_mode(void)
2492 {
2493 AGL_LOG(2, "glvtable.c:allegro_gl_unset_allegro_mode\n");
2494
2495 switch(allegro_gl_display_info.vidmem_policy) {
2496 case AGL_KEEP:
2497 break;
2498 case AGL_RELEASE:
2499 if (__allegro_gl_pool_texture) {
2500 glDeleteTextures(1, &__allegro_gl_pool_texture);
2501 __allegro_gl_pool_texture = 0;
2502 }
2503 break;
2504 }
2505 allegro_gl_unset_projection();
2506 glPopAttrib();
2507 }
2508
2509
2510
2540 void allegro_gl_set_projection(void)
2541 {
2542 GLint v[4];
2543 AGL_LOG(2, "glvtable.c:allegro_gl_set_projection\n");
2544
2545 /* Setup OpenGL matrices */
2546 glGetIntegerv(GL_VIEWPORT, &v[0]);
2547 glMatrixMode(GL_MODELVIEW);
2548 glGetDoublev(GL_MODELVIEW_MATRIX, allegro_gl_modelview_matrix);
2549 glLoadIdentity();
2550 glMatrixMode(GL_PROJECTION);
2551 glGetDoublev(GL_PROJECTION_MATRIX, allegro_gl_projection_matrix);
2552 glLoadIdentity();
2553 gluOrtho2D(v[0] - 0.325, v[0] + v[2] - 0.325, v[1] + v[3] - 0.325, v[1] - 0.325);
2554 }
2555
2556
2557
2567 void allegro_gl_unset_projection(void)
2568 {
2569 AGL_LOG(2, "glvtable.c:allegro_gl_unset_projection\n");
2570 glMatrixMode(GL_PROJECTION);
2571 glLoadMatrixd(allegro_gl_projection_matrix);
2572 glMatrixMode(GL_MODELVIEW);
2573 glLoadMatrixd(allegro_gl_modelview_matrix);
2574 }
2575
2576
2577
2578 void allegro_gl_memory_blit_between_formats(struct BITMAP *src,
2579 struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y,
2580 int width, int height)
2581 {
2582 AGL_LOG(2, "AGL::blit_between_formats\n");
2583
2584 /* screen -> memory */
2585 if (is_screen_bitmap(src)) {
2586 allegro_gl_screen_blit_to_memory(src, dest, source_x, source_y,
2587 dest_x, dest_y, width, height);
2588 return;
2589 }
2590
2591 /* video -> memory */
2592 if (is_video_bitmap(src)) {
2593 allegro_gl_video_blit_to_memory(src, dest, source_x, source_y,
2594 dest_x, dest_y, width, height);
2595 return;
2596 }
2597
2598 /* memory -> screen */
2599 if (is_screen_bitmap(dest)) {
2600 allegro_gl_screen_blit_from_memory(src, dest, source_x, source_y,
2601 dest_x, dest_y, width, height);
2602 return;
2603 }
2604
2605 /* memory -> video */
2606 if (is_video_bitmap(dest)) {
2607 allegro_gl_video_blit_from_memory(src, dest, source_x, source_y,
2608 dest_x, dest_y, width, height);
2609 return;
2610 }
2611
2612 switch(bitmap_color_depth(dest)) {
2613 #ifdef ALLEGRO_COLOR8
2614 case 8:
2615 __blit_between_formats8(src, dest, source_x, source_y,
2616 dest_x, dest_y, width, height);
2617 return;
2618 #endif
2619 #ifdef ALLEGRO_COLOR16
2620 case 15:
2621 __blit_between_formats15(src, dest, source_x, source_y,
2622 dest_x, dest_y, width, height);
2623 return;
2624 case 16:
2625 __blit_between_formats16(src, dest, source_x, source_y,
2626 dest_x, dest_y, width, height);
2627 return;
2628 #endif
2629 #ifdef ALLEGRO_COLOR24
2630 case 24:
2631 __blit_between_formats24(src, dest, source_x, source_y,
2632 dest_x, dest_y, width, height);
2633 return;
2634 #endif
2635 #ifdef ALLEGRO_COLOR32
2636 case 32:
2637 __blit_between_formats32(src, dest, source_x, source_y,
2638 dest_x, dest_y, width, height);
2639 return;
2640 #endif
2641 default:
2642 TRACE("--== ERROR ==-- AGL::blit_between_formats : %i -> %i bpp\n",
2643 bitmap_color_depth(src), bitmap_color_depth(dest));
2644 return;
2645 }
2646 }
2647
2648
2649
2650 static void dummy_unwrite_bank(void)
2651 {
2652 }
2653
2654
2655
2656 static GFX_VTABLE allegro_gl_screen_vtable = {
2657 0,
2658 0,
2659 dummy_unwrite_bank, //void *unwrite_bank;
2660 NULL, //AL_METHOD(void, set_clip, (struct BITMAP *bmp));
2661 allegro_gl_screen_acquire,
2662 allegro_gl_screen_release,
2663 NULL, //AL_METHOD(struct BITMAP *, create_sub_bitmap, (struct BITMAP *parent, int x, int y, int width, int height));
2664 NULL, //AL_METHOD(void, created_sub_bitmap, (struct BITMAP *bmp, struct BITMAP *parent));
2665 allegro_gl_screen_getpixel,
2666 allegro_gl_screen_putpixel,
2667 allegro_gl_screen_vline,
2668 allegro_gl_screen_hline,
2669 allegro_gl_screen_hline,
2670 allegro_gl_screen_line,
2671 allegro_gl_screen_line,
2672 allegro_gl_screen_rectfill,
2673 allegro_gl_screen_triangle,
2674 allegro_gl_screen_draw_sprite,
2675 allegro_gl_screen_draw_256_sprite,
2676 allegro_gl_screen_draw_sprite_v_flip,
2677 allegro_gl_screen_draw_sprite_h_flip,
2678 allegro_gl_screen_draw_sprite_vh_flip,
2679 allegro_gl_screen_draw_trans_rgba_sprite,
2680 allegro_gl_screen_draw_trans_rgba_sprite,
2681 NULL, //AL_METHOD(void, draw_lit_sprite, (struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int color));
2682 allegro_gl_screen_draw_rle_sprite,
2683 allegro_gl_screen_draw_trans_rgba_rle_sprite,
2684 allegro_gl_screen_draw_trans_rgba_rle_sprite,
2685 NULL, //AL_METHOD(void, draw_lit_rle_sprite, (struct BITMAP *bmp, struct RLE_SPRITE *sprite, int x, int y, int color));
2686 allegro_gl_screen_draw_character,
2687 allegro_gl_screen_draw_glyph,
2688 allegro_gl_screen_blit_from_memory,
2689 allegro_gl_screen_blit_to_memory,
2690 NULL, //AL_METHOD(void, blit_from_system, (struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height));
2691 NULL, //AL_METHOD(void, blit_to_system, (struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int dest_x, int dest_y, int width, int height));
2692 allegro_gl_screen_blit_to_self,
2693 allegro_gl_screen_blit_to_self, /* ..._forward */
2694 allegro_gl_screen_blit_to_self, /* ..._backward */
2695 allegro_gl_memory_blit_between_formats,
2696 allegro_gl_screen_masked_blit,
2697 allegro_gl_screen_clear_to_color,
2698 allegro_gl_screen_pivot_scaled_sprite_flip,
2699 NULL, //AL_METHOD(void, do_stretch_blit, (struct BITMAP *source, struct BITMAP *dest, int source_x, int source_y, int source_width, int source_height, int dest_x, int dest_y, int dest_width, int dest_height, int masked));
2700 NULL, //AL_METHOD(void, draw_gouraud_sprite, (struct BITMAP *bmp, struct BITMAP *sprite, int x, int y, int c1, int c2, int c3, int c4));
2701 NULL, //AL_METHOD(void, draw_sprite_end, (void));
2702 NULL, //AL_METHOD(void, blit_end, (void));
2703 allegro_gl_screen_polygon,
2704 allegro_gl_screen_rect,
2705 _soft_circle, //AL_METHOD(void, circle, (struct BITMAP *bmp, int x, int y, int radius, int color));
2706 _soft_circlefill, //AL_METHOD(void, circlefill, (struct BITMAP *bmp, int x, int y, int radius, int color));
2707 _soft_ellipse, //AL_METHOD(void, ellipse, (struct BITMAP *bmp, int x, int y, int rx, int ry, int color));
2708 _soft_ellipsefill, //AL_METHOD(void, ellipsefill, (struct BITMAP *bmp, int x, int y, int rx, int ry, int color));
2709 _soft_arc, //AL_METHOD(void, arc, (struct BITMAP *bmp, int x, int y, fixed ang1, fixed ang2, int r, int color));
2710 _soft_spline, //AL_METHOD(void, spline, (struct BITMAP *bmp, AL_CONST int points[8], int color));
2711 _soft_floodfill, //AL_METHOD(void, floodfill, (struct BITMAP *bmp, int x, int y, int color));
2712 allegro_gl_screen_polygon3d,
2713 allegro_gl_screen_polygon3d_f,
2714 allegro_gl_screen_triangle3d,
2715 allegro_gl_screen_triangle3d_f,
2716 allegro_gl_screen_quad3d,
2717 allegro_gl_screen_quad3d_f,
2718 allegro_gl_screen_draw_sprite_ex
2719 };
2720
AGL_KEEP
#define AGL_KEEP
Keep internal texture in video memory.
Definition: alleggl.h:399
allegro_gl_unset_projection
void allegro_gl_unset_projection(void)
Restores previously saved projection.
Definition: glvtable.c:2567
AGL_TEXTURE_MASKED
#define AGL_TEXTURE_MASKED
Generate an alpha channel for this texture, based on the Allegro mask color.
Definition: alleggl.h:537
allegro_gl_unset_allegro_mode
void allegro_gl_unset_allegro_mode(void)
Restores previous OpenGL settings.
Definition: glvtable.c:2491
allegro_gl_screen_acquire
static void allegro_gl_screen_acquire(struct BITMAP *bmp)
acquire_bitmap(screen) overload.
Definition: glvtable.c:160
allegro_gl_set_projection
void allegro_gl_set_projection(void)
Prepares for Allegro drawing to the screen.
Definition: glvtable.c:2540
allegro_gl_extensions_GL
struct AGL_EXTENSION_LIST_GL allegro_gl_extensions_GL
List of OpenGL extensions supported by AllegroGL.
Definition: glext.c:55
alleggl.h
Main header file for AllegroGL.
allegro_gl_set_allegro_mode
void allegro_gl_set_allegro_mode(void)
Prepares for Allegro drawing to the screen.
Definition: glvtable.c:2422
allegro_gl_make_texture
GLuint allegro_gl_make_texture(BITMAP *bmp)
Uploads an Allegro BITMAP to the GL driver as a texture.
Definition: texture.c:1383
AGL_TEXTURE_HAS_ALPHA
#define AGL_TEXTURE_HAS_ALPHA
Tell AllegroGL that the bitmap had an alpha channel, so it should be preserved when generating the te...
Definition: alleggl.h:526
AGL_RELEASE
#define AGL_RELEASE
Release video memory occupied by internal texture.
Definition: alleggl.h:400
allegro_gl_screen_release
static void allegro_gl_screen_release(struct BITMAP *bmp)
release_bitmap(screen) overload.
Definition: glvtable.c:170