1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * Z-buffered polygon filler helpers (gouraud shading, tmapping, etc).
12 *
13 * Original routines by Michael Bukin.
14 * Modified to support z-buffered polygon drawing by Bertrand Coconnier
15 *
16 * See readme.txt for copyright information.
17 */
18
19 #define ZBUF_PTR float*
20
21 #ifndef __bma_czscan_h
22 #define __bma_czscan_h
23
24 /* _poly_zbuf_flat:
25 * Fills a single-color polygon scanline.
26 */
FUNC_POLY_ZBUF_FLAT(uintptr_t addr,int w,POLYGON_SEGMENT * info)27 void FUNC_POLY_ZBUF_FLAT(uintptr_t addr, int w, POLYGON_SEGMENT *info)
28 {
29 int x;
30 float z;
31 unsigned long c;
32 PIXEL_PTR d;
33 ZBUF_PTR zb;
34
35 ASSERT(addr);
36 ASSERT(info);
37
38 z = info->z;
39 c = info->c;
40 d = (PIXEL_PTR) addr;
41 zb = (ZBUF_PTR) info->zbuf_addr;
42
43 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
44 if (*zb < z) {
45 PUT_PIXEL(d, c);
46 *zb = z;
47 }
48 zb++;
49 z += info->dz;
50 }
51 }
52
53
54
55 #ifdef _bma_zbuf_gcol
56
57 /* _poly_zbuf_gcol:
58 * Fills a single-color gouraud shaded polygon scanline.
59 */
FUNC_POLY_ZBUF_GCOL(uintptr_t addr,int w,POLYGON_SEGMENT * info)60 void FUNC_POLY_ZBUF_GCOL(uintptr_t addr, int w, POLYGON_SEGMENT *info)
61 {
62 int x;
63 float z;
64 fixed c, dc;
65 PIXEL_PTR d;
66 ZBUF_PTR zb;
67
68 ASSERT(addr);
69 ASSERT(info);
70
71 z = info->z;
72 c = info->c;
73 dc = info->dc;
74 d = (PIXEL_PTR) addr;
75 zb = (ZBUF_PTR) info->zbuf_addr;
76
77 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
78 if (*zb < z) {
79 PUT_PIXEL(d, (c >> 16));
80 *zb = z;
81 }
82 c += dc;
83 zb++;
84 z += info->dz;
85 }
86 }
87
88 #endif /* _bma_zbuf_gcol */
89
90
91
92 /* _poly_zbuf_grgb:
93 * Fills an gouraud shaded polygon scanline.
94 */
FUNC_POLY_ZBUF_GRGB(uintptr_t addr,int w,POLYGON_SEGMENT * info)95 void FUNC_POLY_ZBUF_GRGB(uintptr_t addr, int w, POLYGON_SEGMENT *info)
96 {
97 int x;
98 fixed r, g, b, dr, dg, db;
99 PIXEL_PTR d;
100 float z;
101 ZBUF_PTR zb;
102
103 ASSERT(addr);
104 ASSERT(info);
105
106 r = info->r;
107 g = info->g;
108 b = info->b;
109 dr = info->dr;
110 dg = info->dg;
111 db = info->db;
112 d = (PIXEL_PTR) addr;
113 z = info->z;
114 zb = (ZBUF_PTR) info->zbuf_addr;
115
116 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
117 if (*zb < z) {
118 PUT_RGB(d, (r >> 16), (g >> 16), (b >> 16));
119 *zb = z;
120 }
121 r += dr;
122 g += dg;
123 b += db;
124 zb++;
125 z += info->dz;
126 }
127 }
128
129
130
131 /* _poly_zbuf_atex:
132 * Fills an affine texture mapped polygon scanline.
133 */
FUNC_POLY_ZBUF_ATEX(uintptr_t addr,int w,POLYGON_SEGMENT * info)134 void FUNC_POLY_ZBUF_ATEX(uintptr_t addr, int w, POLYGON_SEGMENT *info)
135 {
136 int x;
137 int vmask, vshift, umask;
138 fixed u, v, du, dv;
139 PIXEL_PTR texture;
140 PIXEL_PTR d;
141 float z;
142 ZBUF_PTR zb;
143
144 ASSERT(addr);
145 ASSERT(info);
146
147 vmask = info->vmask << info->vshift;
148 vshift = 16 - info->vshift;
149 umask = info->umask;
150 u = info->u;
151 v = info->v;
152 du = info->du;
153 dv = info->dv;
154 texture = (PIXEL_PTR) (info->texture);
155 d = (PIXEL_PTR) addr;
156 z = info->z;
157 zb = (ZBUF_PTR) info->zbuf_addr;
158
159 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
160 if (*zb < z) {
161 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
162 unsigned long color = GET_MEMORY_PIXEL(s);
163
164 PUT_PIXEL(d, color);
165 *zb = z;
166 }
167 u += du;
168 v += dv;
169 zb++;
170 z += info->dz;
171 }
172 }
173
174
175
176 /* _poly_zbuf_atex_mask:
177 * Fills a masked affine texture mapped polygon scanline.
178 */
FUNC_POLY_ZBUF_ATEX_MASK(uintptr_t addr,int w,POLYGON_SEGMENT * info)179 void FUNC_POLY_ZBUF_ATEX_MASK(uintptr_t addr, int w, POLYGON_SEGMENT *info)
180 {
181 int x;
182 int vmask, vshift, umask;
183 fixed u, v, du, dv;
184 PIXEL_PTR texture;
185 PIXEL_PTR d;
186 float z;
187 ZBUF_PTR zb;
188
189 ASSERT(addr);
190 ASSERT(info);
191
192 vmask = info->vmask << info->vshift;
193 vshift = 16 - info->vshift;
194 umask = info->umask;
195 u = info->u;
196 v = info->v;
197 du = info->du;
198 dv = info->dv;
199 texture = (PIXEL_PTR) (info->texture);
200 d = (PIXEL_PTR) addr;
201 z = info->z;
202 zb = (ZBUF_PTR) info->zbuf_addr;
203
204 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
205 if (*zb < z) {
206 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
207 unsigned long color = GET_MEMORY_PIXEL(s);
208
209 if (!IS_MASK(color)) {
210 PUT_PIXEL(d, color);
211 *zb = z;
212 }
213 }
214 u += du;
215 v += dv;
216 zb++;
217 z += info->dz;
218 }
219 }
220
221
222
223 /* _poly_zbuf_atex_lit:
224 * Fills a lit affine texture mapped polygon scanline.
225 */
FUNC_POLY_ZBUF_ATEX_LIT(uintptr_t addr,int w,POLYGON_SEGMENT * info)226 void FUNC_POLY_ZBUF_ATEX_LIT(uintptr_t addr, int w, POLYGON_SEGMENT *info)
227 {
228 int x;
229 int vmask, vshift, umask;
230 fixed u, v, c, du, dv, dc;
231 PIXEL_PTR texture;
232 PIXEL_PTR d;
233 PS_BLENDER blender;
234 float z;
235 ZBUF_PTR zb;
236
237 ASSERT(addr);
238 ASSERT(info);
239
240 vmask = info->vmask << info->vshift;
241 vshift = 16 - info->vshift;
242 umask = info->umask;
243 u = info->u;
244 v = info->v;
245 c = info->c;
246 du = info->du;
247 dv = info->dv;
248 dc = info->dc;
249 blender = MAKE_PS_BLENDER();
250 texture = (PIXEL_PTR) (info->texture);
251 d = (PIXEL_PTR) addr;
252 z = info->z;
253 zb = (ZBUF_PTR) info->zbuf_addr;
254
255 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
256 if (*zb < z) {
257 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
258 unsigned long color = GET_MEMORY_PIXEL(s);
259 color = PS_BLEND(blender, (c >> 16), color);
260
261 PUT_PIXEL(d, color);
262 *zb = z;
263 }
264 u += du;
265 v += dv;
266 c += dc;
267 zb++;
268 z += info->dz;
269 }
270 }
271
272
273
274 /* _poly_zbuf_atex_mask_lit:
275 * Fills a masked lit affine texture mapped polygon scanline.
276 */
FUNC_POLY_ZBUF_ATEX_MASK_LIT(uintptr_t addr,int w,POLYGON_SEGMENT * info)277 void FUNC_POLY_ZBUF_ATEX_MASK_LIT(uintptr_t addr, int w, POLYGON_SEGMENT *info)
278 {
279 int x;
280 int vmask, vshift, umask;
281 fixed u, v, c, du, dv, dc;
282 PIXEL_PTR texture;
283 PIXEL_PTR d;
284 PS_BLENDER blender;
285 float z;
286 ZBUF_PTR zb;
287
288 ASSERT(addr);
289 ASSERT(info);
290
291 vmask = info->vmask << info->vshift;
292 vshift = 16 - info->vshift;
293 umask = info->umask;
294 u = info->u;
295 v = info->v;
296 c = info->c;
297 du = info->du;
298 dv = info->dv;
299 dc = info->dc;
300 blender = MAKE_PS_BLENDER();
301 texture = (PIXEL_PTR) (info->texture);
302 d = (PIXEL_PTR) addr;
303 z = info->z;
304 zb = (ZBUF_PTR) info->zbuf_addr;
305
306 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
307 if (*zb < z) {
308 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
309 unsigned long color = GET_MEMORY_PIXEL(s);
310
311 if (!IS_MASK(color)) {
312 color = PS_BLEND(blender, (c >> 16), color);
313 PUT_PIXEL(d, color);
314 *zb = z;
315 }
316 }
317 u += du;
318 v += dv;
319 c += dc;
320 zb++;
321 z += info->dz;
322 }
323 }
324
325
326
327 /* _poly_zbuf_ptex:
328 * Fills a perspective correct texture mapped polygon scanline.
329 */
FUNC_POLY_ZBUF_PTEX(uintptr_t addr,int w,POLYGON_SEGMENT * info)330 void FUNC_POLY_ZBUF_PTEX(uintptr_t addr, int w, POLYGON_SEGMENT *info)
331 {
332 int x;
333 int vmask, vshift, umask;
334 double fu, fv, fz, dfu, dfv, dfz;
335 PIXEL_PTR texture;
336 PIXEL_PTR d;
337 ZBUF_PTR zb;
338
339 ASSERT(addr);
340 ASSERT(info);
341
342 vmask = info->vmask << info->vshift;
343 vshift = 16 - info->vshift;
344 umask = info->umask;
345 fu = info->fu;
346 fv = info->fv;
347 fz = info->z;
348 dfu = info->dfu;
349 dfv = info->dfv;
350 dfz = info->dz;
351 texture = (PIXEL_PTR) (info->texture);
352 d = (PIXEL_PTR) addr;
353 zb = (ZBUF_PTR) info->zbuf_addr;
354
355 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
356 if (*zb < fz) {
357 long u = fu / fz;
358 long v = fv / fz;
359 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
360 unsigned long color = GET_MEMORY_PIXEL(s);
361
362 PUT_PIXEL(d, color);
363 *zb = (float) fz;
364 }
365 fu += dfu;
366 fv += dfv;
367 fz += dfz;
368 zb++;
369 }
370 }
371
372
373
374 /* _poly_zbuf_ptex_mask:
375 * Fills a masked perspective correct texture mapped polygon scanline.
376 */
FUNC_POLY_ZBUF_PTEX_MASK(uintptr_t addr,int w,POLYGON_SEGMENT * info)377 void FUNC_POLY_ZBUF_PTEX_MASK(uintptr_t addr, int w, POLYGON_SEGMENT *info)
378 {
379 int x;
380 int vmask, vshift, umask;
381 double fu, fv, fz, dfu, dfv, dfz;
382 PIXEL_PTR texture;
383 PIXEL_PTR d;
384 ZBUF_PTR zb;
385
386 ASSERT(addr);
387 ASSERT(info);
388
389 vmask = info->vmask << info->vshift;
390 vshift = 16 - info->vshift;
391 umask = info->umask;
392 fu = info->fu;
393 fv = info->fv;
394 fz = info->z;
395 dfu = info->dfu;
396 dfv = info->dfv;
397 dfz = info->dz;
398 texture = (PIXEL_PTR) (info->texture);
399 d = (PIXEL_PTR) addr;
400 zb = (ZBUF_PTR) info->zbuf_addr;
401
402 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
403 if (*zb < fz) {
404 long u = fu / fz;
405 long v = fv / fz;
406 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
407 unsigned long color = GET_MEMORY_PIXEL(s);
408
409 if (!IS_MASK(color)) {
410 PUT_PIXEL(d, color);
411 *zb = (float) fz;
412 }
413 }
414 fu += dfu;
415 fv += dfv;
416 fz += dfz;
417 zb++;
418 }
419 }
420
421
422
423 /* _poly_zbuf_ptex_lit:
424 * Fills a lit perspective correct texture mapped polygon scanline.
425 */
FUNC_POLY_ZBUF_PTEX_LIT(uintptr_t addr,int w,POLYGON_SEGMENT * info)426 void FUNC_POLY_ZBUF_PTEX_LIT(uintptr_t addr, int w, POLYGON_SEGMENT *info)
427 {
428 int x;
429 int vmask, vshift, umask;
430 fixed c, dc;
431 double fu, fv, fz, dfu, dfv, dfz;
432 PS_BLENDER blender;
433 PIXEL_PTR texture;
434 PIXEL_PTR d;
435 ZBUF_PTR zb;
436
437 ASSERT(addr);
438 ASSERT(info);
439
440 vmask = info->vmask << info->vshift;
441 vshift = 16 - info->vshift;
442 umask = info->umask;
443 c = info->c;
444 dc = info->dc;
445 fu = info->fu;
446 fv = info->fv;
447 fz = info->z;
448 dfu = info->dfu;
449 dfv = info->dfv;
450 dfz = info->dz;
451 blender = MAKE_PS_BLENDER();
452 texture = (PIXEL_PTR) (info->texture);
453 d = (PIXEL_PTR) addr;
454 zb = (ZBUF_PTR) info->zbuf_addr;
455
456 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
457 if (*zb < fz) {
458 long u = fu / fz;
459 long v = fv / fz;
460 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
461 unsigned long color = GET_MEMORY_PIXEL(s);
462 color = PS_BLEND(blender, (c >> 16), color);
463
464 PUT_PIXEL(d, color);
465 *zb = (float) fz;
466 }
467 fu += dfu;
468 fv += dfv;
469 fz += dfz;
470 c += dc;
471 zb++;
472 }
473 }
474
475
476
477 /* _poly_zbuf_ptex_mask_lit:
478 * Fills a masked lit perspective correct texture mapped polygon scanline.
479 */
FUNC_POLY_ZBUF_PTEX_MASK_LIT(uintptr_t addr,int w,POLYGON_SEGMENT * info)480 void FUNC_POLY_ZBUF_PTEX_MASK_LIT(uintptr_t addr, int w, POLYGON_SEGMENT *info)
481 {
482 int x;
483 int vmask, vshift, umask;
484 fixed c, dc;
485 double fu, fv, fz, dfu, dfv, dfz;
486 PS_BLENDER blender;
487 PIXEL_PTR texture;
488 PIXEL_PTR d;
489 ZBUF_PTR zb;
490
491 ASSERT(addr);
492 ASSERT(info);
493
494 vmask = info->vmask << info->vshift;
495 vshift = 16 - info->vshift;
496 umask = info->umask;
497 c = info->c;
498 dc = info->dc;
499 fu = info->fu;
500 fv = info->fv;
501 fz = info->z;
502 dfu = info->dfu;
503 dfv = info->dfv;
504 dfz = info->dz;
505 blender = MAKE_PS_BLENDER();
506 texture = (PIXEL_PTR) (info->texture);
507 d = (PIXEL_PTR) addr;
508 zb = (ZBUF_PTR) info->zbuf_addr;
509
510 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), x--) {
511 if (*zb < fz) {
512 long u = fu / fz;
513 long v = fv / fz;
514 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
515 unsigned long color = GET_MEMORY_PIXEL(s);
516
517 if (!IS_MASK(color)) {
518 color = PS_BLEND(blender, (c >> 16), color);
519 PUT_PIXEL(d, color);
520 *zb = (float) fz;
521 }
522 }
523 fu += dfu;
524 fv += dfv;
525 fz += dfz;
526 c += dc;
527 zb++;
528 }
529 }
530
531
532
533 /* _poly_zbuf_atex_trans:
534 * Fills a trans affine texture mapped polygon scanline.
535 */
FUNC_POLY_ZBUF_ATEX_TRANS(uintptr_t addr,int w,POLYGON_SEGMENT * info)536 void FUNC_POLY_ZBUF_ATEX_TRANS(uintptr_t addr, int w, POLYGON_SEGMENT *info)
537 {
538 int x;
539 int vmask, vshift, umask;
540 fixed u, v, du, dv;
541 PS_BLENDER blender;
542 PIXEL_PTR texture;
543 PIXEL_PTR d;
544 PIXEL_PTR r;
545 float z;
546 ZBUF_PTR zb;
547
548 ASSERT(addr);
549 ASSERT(info);
550
551 vmask = info->vmask << info->vshift;
552 vshift = 16 - info->vshift;
553 umask = info->umask;
554 u = info->u;
555 v = info->v;
556 du = info->du;
557 dv = info->dv;
558 blender = MAKE_PS_BLENDER();
559 texture = (PIXEL_PTR) (info->texture);
560 d = (PIXEL_PTR) addr;
561 r = (PIXEL_PTR) info->read_addr;
562 z = info->z;
563 zb = (ZBUF_PTR) info->zbuf_addr;
564
565 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), INC_PIXEL_PTR(r), x--) {
566 if (*zb < z) {
567 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
568 unsigned long color = GET_MEMORY_PIXEL(s);
569 color = PS_ALPHA_BLEND(blender, color, GET_PIXEL(r));
570
571 PUT_PIXEL(d, color);
572 *zb = z;
573 }
574 u += du;
575 v += dv;
576 zb++;
577 z += info->dz;
578 }
579 }
580
581
582
583 /* _poly_zbuf_atex_mask_trans:
584 * Fills a trans masked affine texture mapped polygon scanline.
585 */
FUNC_POLY_ZBUF_ATEX_MASK_TRANS(uintptr_t addr,int w,POLYGON_SEGMENT * info)586 void FUNC_POLY_ZBUF_ATEX_MASK_TRANS(uintptr_t addr, int w, POLYGON_SEGMENT *info)
587 {
588 int x;
589 int vmask, vshift, umask;
590 fixed u, v, du, dv;
591 PS_BLENDER blender;
592 PIXEL_PTR texture;
593 PIXEL_PTR d;
594 PIXEL_PTR r;
595 float z;
596 ZBUF_PTR zb;
597
598 ASSERT(addr);
599 ASSERT(info);
600
601 vmask = info->vmask << info->vshift;
602 vshift = 16 - info->vshift;
603 umask = info->umask;
604 u = info->u;
605 v = info->v;
606 du = info->du;
607 dv = info->dv;
608 blender = MAKE_PS_BLENDER();
609 texture = (PIXEL_PTR) (info->texture);
610 d = (PIXEL_PTR) addr;
611 r = (PIXEL_PTR) info->read_addr;
612 z = info->z;
613 zb = (ZBUF_PTR) info->zbuf_addr;
614
615 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), INC_PIXEL_PTR(r), x--) {
616 if (*zb < z) {
617 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
618 unsigned long color = GET_MEMORY_PIXEL(s);
619 if (!IS_MASK(color)) {
620 color = PS_ALPHA_BLEND(blender, color, GET_PIXEL(r));
621 PUT_PIXEL(d, color);
622 *zb = z;
623 }
624 }
625 u += du;
626 v += dv;
627 zb++;
628 z += info->dz;
629 }
630 }
631
632
633
634 /* _poly_zbuf_ptex_trans:
635 * Fills a trans perspective correct texture mapped polygon scanline.
636 */
FUNC_POLY_ZBUF_PTEX_TRANS(uintptr_t addr,int w,POLYGON_SEGMENT * info)637 void FUNC_POLY_ZBUF_PTEX_TRANS(uintptr_t addr, int w, POLYGON_SEGMENT *info)
638 {
639 int x;
640 int vmask, vshift, umask;
641 double fu, fv, fz, dfu, dfv, dfz;
642 PS_BLENDER blender;
643 PIXEL_PTR texture;
644 PIXEL_PTR d;
645 PIXEL_PTR r;
646 ZBUF_PTR zb;
647
648 ASSERT(addr);
649 ASSERT(info);
650
651 vmask = info->vmask << info->vshift;
652 vshift = 16 - info->vshift;
653 umask = info->umask;
654 fu = info->fu;
655 fv = info->fv;
656 fz = info->z;
657 dfu = info->dfu;
658 dfv = info->dfv;
659 dfz = info->dz;
660 blender = MAKE_PS_BLENDER();
661 texture = (PIXEL_PTR) (info->texture);
662 d = (PIXEL_PTR) addr;
663 r = (PIXEL_PTR) info->read_addr;
664 zb = (ZBUF_PTR) info->zbuf_addr;
665
666 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), INC_PIXEL_PTR(r), x--) {
667 if (*zb < fz) {
668 long u = fu / fz;
669 long v = fv / fz;
670 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
671 unsigned long color = GET_MEMORY_PIXEL(s);
672 color = PS_ALPHA_BLEND(blender, color, GET_PIXEL(r));
673
674 PUT_PIXEL(d, color);
675 *zb = (float) fz;
676 }
677 fu += dfu;
678 fv += dfv;
679 fz += dfz;
680 zb++;
681 }
682 }
683
684
685
686 /* _poly_zbuf_ptex_mask_trans:
687 * Fills a trans masked perspective correct texture mapped polygon scanline.
688 */
FUNC_POLY_ZBUF_PTEX_MASK_TRANS(uintptr_t addr,int w,POLYGON_SEGMENT * info)689 void FUNC_POLY_ZBUF_PTEX_MASK_TRANS(uintptr_t addr, int w, POLYGON_SEGMENT *info)
690 {
691 int x;
692 int vmask, vshift, umask;
693 double fu, fv, fz, dfu, dfv, dfz;
694 PS_BLENDER blender;
695 PIXEL_PTR texture;
696 PIXEL_PTR d;
697 PIXEL_PTR r;
698 ZBUF_PTR zb;
699
700 ASSERT(addr);
701 ASSERT(info);
702
703 vmask = info->vmask << info->vshift;
704 vshift = 16 - info->vshift;
705 umask = info->umask;
706 fu = info->fu;
707 fv = info->fv;
708 fz = info->z;
709 dfu = info->dfu;
710 dfv = info->dfv;
711 dfz = info->dz;
712 blender = MAKE_PS_BLENDER();
713 texture = (PIXEL_PTR) (info->texture);
714 d = (PIXEL_PTR) addr;
715 r = (PIXEL_PTR) info->read_addr;
716 zb = (ZBUF_PTR) info->zbuf_addr;
717
718 for (x = w - 1; x >= 0; INC_PIXEL_PTR(d), INC_PIXEL_PTR(r), x--) {
719 if (*zb < fz) {
720 long u = fu / fz;
721 long v = fv / fz;
722 PIXEL_PTR s = OFFSET_PIXEL_PTR(texture, ((v >> vshift) & vmask) + ((u >> 16) & umask));
723 unsigned long color = GET_MEMORY_PIXEL(s);
724 if (!IS_MASK(color)) {
725 color = PS_ALPHA_BLEND(blender, color, GET_PIXEL(r));
726 PUT_PIXEL(d, color);
727 *zb = (float) fz;
728 }
729 }
730 fu += dfu;
731 fv += dfv;
732 fz += dfz;
733 zb++;
734 }
735 }
736
737 #endif /* !__bma_czscan_h */
738
739