notaz.gp2x.de / picodrive.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
pandora: fix readme and pxml version
[picodrive.git] / pico / mode4.c
... / ...
CommitLineData
1/*
2 * SMS renderer
3 * (C) notaz, 2009-2010
4 * (C) irixxxx, 2020-2024
5 *
6 * currently supports VDP mode 4 (SMS and GG) and mode 3-0 (TMS)
7 * modes numbered after the bit numbers used in Sega and TI documentation
8 *
9 * This work is licensed under the terms of MAME license.
10 * See COPYING file in the top-level directory.
11 */
12#include "pico_int.h"
13#include <platform/common/upscale.h>
14
15static void (*FinalizeLineSMS)(int line);
16static int skip_next_line;
17static int screen_offset, line_offset;
18static u8 mode;
19
20static unsigned int sprites_addr[32]; // bitmap address
21static unsigned char sprites_c[32]; // TMS sprites color
22static int sprites_x[32]; // x position
23static int sprites; // count
24static unsigned char sprites_map[2+256/8+2]; // collision detection map
25
26unsigned int sprites_status;
27
28int sprites_zoom; // latched sprite zoom flag
29int xscroll; // horizontal scroll
30
31/* sprite collision detection */
32static int CollisionDetect(u8 *mb, u16 sx, unsigned int pack, int zoomed)
33{
34 static u8 morton[16] = { 0x00,0x03,0x0c,0x0f,0x30,0x33,0x3c,0x3f,
35 0xc0,0xc3,0xcc,0xcf,0xf0,0xf3,0xfc,0xff };
36 u8 *mp = mb + (sx>>3);
37 unsigned col, m;
38
39 // check sprite map for collision and update map with current sprite
40 if (!zoomed) { // 8 sprite pixels
41 m = mp[0] | (mp[1]<<8);
42 col = m & (pack<<(sx&7)); // collision if current sprite overlaps sprite map
43 m |= pack<<(sx&7);
44 mp[0] = m, mp[1] = m>>8;
45 } else { // 16 sprite pixels in zoom mode
46 pack = morton[pack&0x0f] | (morton[(pack>>4)&0x0f] << 8);
47 m = mp[0] | (mp[1]<<8) | (mp[2]<<16);
48 col = m & (pack<<(sx&7));
49 m |= pack<<(sx&7);
50 mp[0] = m, mp[1] = m>>8, mp[2] = m>>16;
51 }
52
53 // invisible overscan area, not tested for collision
54 mb[0] = mb[33] = mb[34] = 0;
55 return col;
56}
57
58/* Mode 4 - SMS Graphics */
59/*=======================*/
60
61static void TileBGM4(u16 sx, int pal)
62{
63 if (sx & 3) {
64 u8 *pd = (u8 *)(Pico.est.HighCol + sx);
65 pd[0] = pd[1] = pd[2] = pd[3] = pal;
66 pd[4] = pd[5] = pd[6] = pd[7] = pal;
67 } else {
68 u32 *pd = (u32 *)(Pico.est.HighCol + sx);
69 pd[0] = pd[1] = pal * 0x01010101;
70 }
71}
72
73// 8 pixels are arranged in 4 bitplane bytes in a 32 bit word. To pull the
74// 4 bitplanes together multiply with each bit distance (multiples of 1<<7)
75#define PLANAR_PIXELBG(x,p) \
76 t = (pack>>(7-p)) & 0x01010101; \
77 t = (t*0x10204080) >> 28; \
78 pd[x] = pal|t;
79
80static void TileNormBGM4(u16 sx, unsigned int pack, int pal)
81{
82 u8 *pd = Pico.est.HighCol + sx;
83 u32 t;
84
85 PLANAR_PIXELBG(0, 0)
86 PLANAR_PIXELBG(1, 1)
87 PLANAR_PIXELBG(2, 2)
88 PLANAR_PIXELBG(3, 3)
89 PLANAR_PIXELBG(4, 4)
90 PLANAR_PIXELBG(5, 5)
91 PLANAR_PIXELBG(6, 6)
92 PLANAR_PIXELBG(7, 7)
93}
94
95static void TileFlipBGM4(u16 sx, unsigned int pack, int pal)
96{
97 u8 *pd = Pico.est.HighCol + sx;
98 u32 t;
99
100 PLANAR_PIXELBG(0, 7)
101 PLANAR_PIXELBG(1, 6)
102 PLANAR_PIXELBG(2, 5)
103 PLANAR_PIXELBG(3, 4)
104 PLANAR_PIXELBG(4, 3)
105 PLANAR_PIXELBG(5, 2)
106 PLANAR_PIXELBG(6, 1)
107 PLANAR_PIXELBG(7, 0)
108}
109
110// non-transparent sprite pixels apply if no higher prio pixel is already there
111#define PLANAR_PIXELSP(x,p) \
112 t = (pack>>(7-p)) & 0x01010101; \
113 if (t && (pd[x] & 0x2f) <= 0x20) { \
114 t = (t*0x10204080) >> 28; \
115 pd[x] = pal|t; \
116 }
117
118static void TileNormSprM4(u16 sx, unsigned int pack, int pal)
119{
120 u8 *pd = Pico.est.HighCol + sx;
121 u32 t;
122
123 PLANAR_PIXELSP(0, 0)
124 PLANAR_PIXELSP(1, 1)
125 PLANAR_PIXELSP(2, 2)
126 PLANAR_PIXELSP(3, 3)
127 PLANAR_PIXELSP(4, 4)
128 PLANAR_PIXELSP(5, 5)
129 PLANAR_PIXELSP(6, 6)
130 PLANAR_PIXELSP(7, 7)
131}
132
133static void TileDoubleSprM4(int sx, unsigned int pack, int pal)
134{
135 u8 *pd = Pico.est.HighCol + sx;
136 u32 t;
137
138 PLANAR_PIXELSP(0, 0)
139 PLANAR_PIXELSP(1, 0)
140 PLANAR_PIXELSP(2, 1)
141 PLANAR_PIXELSP(3, 1)
142 PLANAR_PIXELSP(4, 2)
143 PLANAR_PIXELSP(5, 2)
144 PLANAR_PIXELSP(6, 3)
145 PLANAR_PIXELSP(7, 3)
146 PLANAR_PIXELSP(8, 4)
147 PLANAR_PIXELSP(9, 4)
148 PLANAR_PIXELSP(10, 5)
149 PLANAR_PIXELSP(11, 5)
150 PLANAR_PIXELSP(12, 6)
151 PLANAR_PIXELSP(13, 6)
152 PLANAR_PIXELSP(14, 7)
153 PLANAR_PIXELSP(15, 7)
154}
155
156static void ParseSpritesM4(int scanline)
157{
158 struct PicoVideo *pv = &Pico.video;
159 u8 *sat;
160 int xoff = line_offset;
161 int sprite_base, addr_mask;
162 int zoomed = sprites_zoom & 0x1; // zoomed sprites, e.g. Earthworm Jim
163 unsigned int pack;
164 int i, s, h, m;
165
166 if (pv->reg[0] & 8)
167 xoff -= 8; // sprite shift
168 if (Pico.m.hardware & PMS_HW_LCD)
169 xoff -= 48; // GG LCD, adjust to center 160 px
170
171 sat = (u8 *)PicoMem.vram + ((pv->reg[5] & 0x7e) << 7);
172 if (sprites_zoom & 2) {
173 addr_mask = 0xfe; h = 16;
174 } else {
175 addr_mask = 0xff; h = 8;
176 }
177 if (zoomed) h *= 2;
178 sprite_base = (pv->reg[6] & 4) << (13-2-1);
179
180 m = pv->status & SR_C;
181 memset(sprites_map, 0, sizeof(sprites_map));
182 for (i = s = 0; i < 64; i++)
183 {
184 int y;
185 y = sat[MEM_LE2(i)];
186 if (y == 0xd0 && !((pv->reg[0] & 6) == 6 && (pv->reg[1] & 0x18)))
187 break;
188 if (y >= 0xe0)
189 y -= 256;
190 y &= ~zoomed; // zoomed sprites apparently only on even lines, see GG Tarzan
191 if (y + h <= scanline || scanline < y)
192 continue; // not on this line
193 if (s >= 8) {
194 if (scanline >= 0) sprites_status |= SR_SOVR;
195 if (!(PicoIn.opt & POPT_DIS_SPRITE_LIM) || s >= 32)
196 break;
197 }
198
199 if (xoff + sat[MEM_LE2(0x80 + i*2)] >= 0) {
200 sprites_x[s] = xoff + sat[MEM_LE2(0x80 + i*2)];
201 sprites_addr[s] = sprite_base + ((sat[MEM_LE2(0x80 + i*2 + 1)] & addr_mask) << (5-1)) +
202 ((scanline - y) >> zoomed << (2-1));
203 if (pv->reg[1] & 0x40) {
204 // collision detection. Do it here since off-screen lines aren't drawn
205 pack = CPU_LE2(*(u32 *)(PicoMem.vram + sprites_addr[s]));
206 // make sprite pixel map by merging the 4 bitplanes
207 pack = ((pack | (pack>>16)) | ((pack | (pack>>16))>>8)) & 0xff;
208 if (!m) m = CollisionDetect(sprites_map, sprites_x[s], pack, zoomed);
209 // no collision detection in 1st column if it's masked
210 if (pv->reg[0] & 0x20)
211 sprites_map[1] = 0;
212 }
213 s++;
214 }
215 }
216 if (m)
217 sprites_status |= SR_C;
218 sprites = s;
219}
220
221static void DrawSpritesM4(void)
222{
223 unsigned int pack;
224 int zoomed = sprites_zoom & 0x1; // zoomed sprites, e.g. Earthworm Jim
225 int s = sprites;
226
227 // now draw all sprites backwards
228 for (--s; s >= 0; s--) {
229 pack = CPU_LE2(*(u32 *)(PicoMem.vram + sprites_addr[s]));
230 if (zoomed) TileDoubleSprM4(sprites_x[s], pack, 0x10);
231 else TileNormSprM4(sprites_x[s], pack, 0x10);
232 }
233}
234
235// cells_dx, tilex_ty merged to reduce register pressure
236static void DrawStripM4(const u16 *nametab, int cells_dx, int tilex_ty)
237{
238 int oldcode = -1;
239 int addr = 0, pal = 0;
240
241 // Draw tiles across screen:
242 for (; cells_dx >= 0; cells_dx += 8, tilex_ty++, cells_dx -= 0x10000)
243 {
244 unsigned int pack;
245 unsigned code;
246
247 code = nametab[tilex_ty & 0x1f];
248
249 if (code != oldcode) {
250 oldcode = code;
251 // Get tile address/2:
252 addr = (code & 0x1ff) << 4;
253 addr += tilex_ty >> 16;
254 if (code & 0x0400)
255 addr ^= 0xe; // Y-flip
256
257 pal = (code>>7) & 0x30; // prio | palette select
258 }
259
260 pack = CPU_LE2(*(u32 *)(PicoMem.vram + addr)); // Get 4 bitplanes / 8 pixels
261 if (pack == 0) TileBGM4(cells_dx, pal);
262 else if (code & 0x0200) TileFlipBGM4(cells_dx, pack, pal);
263 else TileNormBGM4(cells_dx, pack, pal);
264 }
265}
266
267static void DrawDisplayM4(int scanline)
268{
269 struct PicoVideo *pv = &Pico.video;
270 u16 *nametab, *nametab2;
271 int line, tilex, dx, ty, cells;
272 int cellskip = 0; // XXX
273 int maxcells = 32;
274
275 // Find the line in the name table
276 line = pv->reg[9] + scanline; // vscroll + scanline
277
278 // Find name table:
279 nametab = PicoMem.vram;
280 if ((pv->reg[0] & 6) == 6 && (pv->reg[1] & 0x18)) {
281 // 224/240 line mode
282 line &= 0xff;
283 nametab += ((pv->reg[2] & 0x0c) << (10-1)) + (0x700 >> 1);
284 } else {
285 while (line >= 224) line -= 224;
286 nametab += (pv->reg[2] & 0x0e) << (10-1);
287 // old SMS only, masks line:7 with reg[2]:0 for address calculation
288 //if ((pv->reg[2] & 0x01) == 0) line &= 0x7f;
289 }
290 nametab2 = nametab + ((scanline>>3) << (6-1));
291 nametab = nametab + ((line>>3) << (6-1));
292
293 dx = xscroll; // hscroll
294 if (scanline < 16 && (pv->reg[0] & 0x40))
295 dx = 0; // hscroll disabled for top 2 rows (e.g. Fantasy Zone II)
296
297 tilex = (32 - (dx >> 3) + cellskip) & 0x1f;
298 ty = (line & 7) << 1; // Y-Offset into tile
299 cells = maxcells - cellskip - 1;
300
301 dx = (dx & 7);
302 dx += cellskip << 3;
303 dx += line_offset;
304
305 // tiles
306 if (!(pv->debug_p & PVD_KILL_B)) {
307 if (Pico.m.hardware & PMS_HW_LCD) {
308 // on GG render only the center 160 px, but mind hscroll
309 DrawStripM4(nametab , (dx-8) | ((cells-11)<< 16),(tilex+5) | (ty << 16));
310 } else if (pv->reg[0] & 0x80) {
311 // vscroll disabled for rightmost 8 columns (e.g. Gauntlet)
312 int dx2 = dx + (cells-8)*8, tilex2 = tilex + (cells-8), ty2 = scanline&7;
313 DrawStripM4(nametab, dx | ((cells-8) << 16), tilex | (ty << 16));
314 DrawStripM4(nametab2, dx2 | (8 << 16), tilex2 | (ty2 << 17));
315 } else
316 DrawStripM4(nametab , dx | ( cells << 16), tilex | (ty << 16));
317 }
318
319 // sprites
320 if (!(pv->debug_p & PVD_KILL_S_LO))
321 DrawSpritesM4();
322
323 if ((pv->reg[0] & 0x20) && !(Pico.m.hardware & PMS_HW_LCD)) {
324 // first column masked with background, caculate offset to start of line
325 dx = line_offset / 4;
326 ty = ((pv->reg[7]&0x0f)|0x10) * 0x01010101;
327 ((u32 *)Pico.est.HighCol)[dx] = ((u32 *)Pico.est.HighCol)[dx+1] = ty;
328 }
329}
330
331
332/* TMS Modes */
333/*===========*/
334
335/* Background */
336
337#define TMS_PIXELBG(x,p) \
338 t = (pack>>(7-p)) & 0x01; \
339 t = (pal >> (t << 2)) & 0x0f; \
340 if (t) \
341 pd[x] = t;
342
343static void TileNormBgM1(u16 sx, unsigned int pack, int pal) /* Text */
344{
345 u8 *pd = Pico.est.HighCol + sx;
346 unsigned int t;
347
348 TMS_PIXELBG(0, 0)
349 TMS_PIXELBG(1, 1)
350 TMS_PIXELBG(2, 2)
351 TMS_PIXELBG(3, 3)
352 TMS_PIXELBG(4, 4)
353 TMS_PIXELBG(5, 5)
354}
355
356static void TileNormBgM2(u16 sx, int pal) /* Multicolor */
357{
358 u8 *pd = Pico.est.HighCol + sx;
359 unsigned int pack = 0xf0;
360 unsigned int t;
361
362 TMS_PIXELBG(0, 0)
363 TMS_PIXELBG(1, 1)
364 TMS_PIXELBG(2, 2)
365 TMS_PIXELBG(3, 3)
366 TMS_PIXELBG(4, 4)
367 TMS_PIXELBG(5, 5)
368 TMS_PIXELBG(6, 6)
369 TMS_PIXELBG(7, 7)
370}
371
372static void TileNormBgMg(u16 sx, unsigned int pack, int pal) /* Graphics */
373{
374 u8 *pd = Pico.est.HighCol + sx;
375 unsigned int t;
376
377 TMS_PIXELBG(0, 0)
378 TMS_PIXELBG(1, 1)
379 TMS_PIXELBG(2, 2)
380 TMS_PIXELBG(3, 3)
381 TMS_PIXELBG(4, 4)
382 TMS_PIXELBG(5, 5)
383 TMS_PIXELBG(6, 6)
384 TMS_PIXELBG(7, 7)
385}
386
387/* Sprites */
388
389#define TMS_PIXELSP(x,p) \
390 t = (pack>>(7-p)) & 0x01; \
391 if (t) \
392 pd[x] = pal;
393
394static void TileNormSprTMS(u16 sx, unsigned int pack, int pal)
395{
396 u8 *pd = Pico.est.HighCol + sx;
397 unsigned int t;
398
399 TMS_PIXELSP(0, 0)
400 TMS_PIXELSP(1, 1)
401 TMS_PIXELSP(2, 2)
402 TMS_PIXELSP(3, 3)
403 TMS_PIXELSP(4, 4)
404 TMS_PIXELSP(5, 5)
405 TMS_PIXELSP(6, 6)
406 TMS_PIXELSP(7, 7)
407}
408
409static void TileDoubleSprTMS(u16 sx, unsigned int pack, int pal)
410{
411 u8 *pd = Pico.est.HighCol + sx;
412 unsigned int t;
413
414 TMS_PIXELSP(0, 0)
415 TMS_PIXELSP(1, 0)
416 TMS_PIXELSP(2, 1)
417 TMS_PIXELSP(3, 1)
418 TMS_PIXELSP(4, 2)
419 TMS_PIXELSP(5, 2)
420 TMS_PIXELSP(6, 3)
421 TMS_PIXELSP(7, 3)
422 TMS_PIXELSP(8, 4)
423 TMS_PIXELSP(9, 4)
424 TMS_PIXELSP(10, 5)
425 TMS_PIXELSP(11, 5)
426 TMS_PIXELSP(12, 6)
427 TMS_PIXELSP(13, 6)
428 TMS_PIXELSP(14, 7)
429 TMS_PIXELSP(15, 7)
430}
431
432static void ParseSpritesTMS(int scanline)
433{
434 struct PicoVideo *pv = &Pico.video;
435 unsigned int pack;
436 u8 *sat;
437 int xoff;
438 int sprite_base, addr_mask;
439 int zoomed = sprites_zoom & 0x1; // zoomed sprites
440 int i, s, h, m;
441
442 xoff = line_offset;
443
444 sat = (u8 *)PicoMem.vramb + ((pv->reg[5] & 0x7f) << 7);
445 if (sprites_zoom & 2) {
446 addr_mask = 0xfc; h = 16;
447 } else {
448 addr_mask = 0xff; h = 8;
449 }
450 if (zoomed) h *= 2;
451 sprite_base = (pv->reg[6] & 0x7) << 11;
452
453 m = pv->status & SR_C;
454 memset(sprites_map, 0, sizeof(sprites_map));
455 /* find sprites on this scanline */
456 for (i = s = 0; i < 32; i++)
457 {
458 int x, y;
459 y = sat[MEM_LE2(4*i)];
460 if (y == 0xd0)
461 break;
462 if (y >= 0xe0)
463 y -= 256;
464 y &= ~zoomed;
465 if (y + h <= scanline || scanline < y)
466 continue; // not on this line
467 if (s >= 4) {
468 if (scanline >= 0) sprites_status |= SR_SOVR | i;
469 if (!(PicoIn.opt & POPT_DIS_SPRITE_LIM) || s >= 32)
470 break;
471 }
472 x = sat[MEM_LE2(4*i+1)] + xoff;
473 if (sat[MEM_LE2(4*i+3)] & 0x80)
474 x -= 32;
475
476 sprites_c[s] = sat[MEM_LE2(4*i+3)] & 0x0f;
477 sprites_x[s] = x;
478 sprites_addr[s] = sprite_base + ((sat[MEM_LE2(4*i + 2)] & addr_mask) << 3) +
479 ((scanline - y) >> zoomed);
480 if (pv->reg[1] & 0x40) {
481 // collision detection. Do it here since off-screen lines aren't drawn
482 if (sprites_c[s] && x > 0) {
483 pack = PicoMem.vramb[MEM_LE2(sprites_addr[s])];
484 if (!m) m = CollisionDetect(sprites_map, x, pack, zoomed);
485 }
486 x += (zoomed ? 16:8);
487 if (sprites_c[s] && (sprites_zoom & 0x2) && x > 0 && x < 8+256) {
488 pack = PicoMem.vramb[MEM_LE2(sprites_addr[s]+0x10)];
489 if (!m) m = CollisionDetect(sprites_map, x, pack, zoomed);
490 }
491 }
492 s++;
493 }
494 if (m)
495 sprites_status |= SR_C;
496 sprites = s;
497}
498
499/* Draw sprites into a scanline, max 4 */
500static void DrawSpritesTMS(void)
501{
502 unsigned int pack;
503 int zoomed = sprites_zoom & 0x1; // zoomed sprites
504 int s = sprites;
505
506 // now draw all sprites backwards
507 for (--s; s >= 0; s--) {
508 int x, c, w = (zoomed ? 16: 8);
509 x = sprites_x[s];
510 c = sprites_c[s];
511 // c may be 0 (transparent): sprite invisible
512 if (c && x > 0) {
513 pack = PicoMem.vramb[MEM_LE2(sprites_addr[s])];
514 if (zoomed) TileDoubleSprTMS(x, pack, c);
515 else TileNormSprTMS(x, pack, c);
516 }
517 if (c && (sprites_zoom & 0x2) && (x+=w) > 0 && x < 8+256) {
518 pack = PicoMem.vramb[MEM_LE2(sprites_addr[s]+0x10)];
519 if (zoomed) TileDoubleSprTMS(x, pack, c);
520 else TileNormSprTMS(x, pack, c);
521 }
522 }
523}
524
525
526/* Mode 1 - Text */
527/*===============*/
528
529/* Draw the background into a scanline; cells, dx, tilex, ty merged to reduce registers */
530static void DrawStripM1(const u8 *nametab, const u8 *pattab, int cells_dx, int tilex_ty)
531{
532 // Draw tiles across screen:
533 for (; cells_dx >= 0; cells_dx += 6, tilex_ty++, cells_dx -= 0x10000)
534 {
535 unsigned int pack, pal;
536 unsigned code;
537
538 code = nametab[tilex_ty & 0x3f];
539 pal = Pico.video.reg[7];
540 pack = pattab[code << 3];
541 TileNormBgM1(cells_dx, pack, pal);
542 }
543}
544
545/* Draw a scanline */
546static void DrawDisplayM1(int scanline)
547{
548 struct PicoVideo *pv = &Pico.video;
549 u8 *nametab, *pattab;
550 int tilex, dx, cells;
551 int cellskip = 0; // XXX
552 int maxcells = 40;
553 unsigned mask = pv->reg[0] & 0x2 ? 0x2000 : 0x3800; // M3: 2 bits table select
554
555 // name, color, pattern table:
556 nametab = PicoMem.vramb + ((pv->reg[2]<<10) & 0x3c00);
557 pattab = PicoMem.vramb + ((pv->reg[4]<<11) & mask);
558 pattab += ((scanline>>6) << 11) & ~mask; // table select bits for M3
559
560 nametab += ((scanline>>3) * maxcells);
561 pattab += (scanline & 0x7);
562
563 tilex = cellskip & 0x1f;
564 cells = maxcells - cellskip - 1;
565 dx = 8 + (cellskip << 3) + line_offset;
566
567 // tiles
568 if (!(pv->debug_p & PVD_KILL_B))
569 DrawStripM1(nametab, pattab, dx | (cells << 16), tilex | (scanline << 16));
570}
571
572
573/* Mode 2 - Multicolor */
574/*=====================*/
575
576/* Draw the background into a scanline; cells, dx, tilex, ty merged to reduce registers */
577static void DrawStripM2(const u8 *nametab, const u8 *pattab, int cells_dx, int tilex_ty)
578{
579 // Draw tiles across screen:
580 for (; cells_dx >= 0; cells_dx += 8, tilex_ty++, cells_dx -= 0x10000)
581 {
582 unsigned int pal;
583 unsigned code;
584
585 code = nametab[tilex_ty & 0x1f];
586 pal = pattab[code << 3];
587 TileNormBgM2(cells_dx, pal);
588 }
589}
590
591/* Draw a scanline */
592static void DrawDisplayM2(int scanline)
593{
594 struct PicoVideo *pv = &Pico.video;
595 u8 *nametab, *pattab;
596 int tilex, dx, cells;
597 int cellskip = 0; // XXX
598 int maxcells = 32;
599 unsigned mask = pv->reg[0] & 0x2 ? 0x2000 : 0x3800; // M3: 2 bits table select
600
601 // name, color, pattern table:
602 nametab = PicoMem.vramb + ((pv->reg[2]<<10) & 0x3c00);
603 pattab = PicoMem.vramb + ((pv->reg[4]<<11) & mask);
604 pattab += ((scanline>>6) << 11) & ~mask; // table select bits for M3
605
606 nametab += (scanline>>3) << 5;
607 pattab += (scanline>>2) & 0x7;
608
609 tilex = cellskip & 0x1f;
610 cells = maxcells - cellskip - 1;
611 dx = (cellskip << 3) + line_offset;
612
613 // tiles
614 if (!(pv->debug_p & PVD_KILL_B))
615 DrawStripM2(nametab, pattab, dx | (cells << 16), tilex | (scanline << 16));
616
617 // sprites
618 if (!(pv->debug_p & PVD_KILL_S_LO))
619 DrawSpritesTMS();
620}
621
622
623/* Mode 3 - Graphics II */
624/*======================*/
625
626/* Draw the background into a scanline; cells, dx, tilex, ty merged to reduce registers */
627static void DrawStripM3(const u8 *nametab, const u8 *coltab, const u8 *pattab, int cells_dx, int tilex_ty)
628{
629 // Draw tiles across screen:
630 for (; cells_dx >= 0; cells_dx += 8, tilex_ty++, cells_dx -= 0x10000)
631 {
632 unsigned int pack, pal;
633 unsigned code;
634
635 code = nametab[tilex_ty & 0x1f] << 3;
636 pal = coltab[code];
637 pack = pattab[code];
638 TileNormBgMg(cells_dx, pack, pal);
639 }
640}
641
642/* Draw a scanline */
643static void DrawDisplayM3(int scanline)
644{
645 struct PicoVideo *pv = &Pico.video;
646 u8 *nametab, *coltab, *pattab;
647 int tilex, dx, cells;
648 int cellskip = 0; // XXX
649 int maxcells = 32;
650
651 // name, color, pattern table:
652 nametab = PicoMem.vramb + ((pv->reg[2]<<10) & 0x3c00);
653 coltab = PicoMem.vramb + ((pv->reg[3]<< 6) & 0x2000);
654 pattab = PicoMem.vramb + ((pv->reg[4]<<11) & 0x2000);
655
656 nametab += ((scanline>>3) << 5);
657 coltab += ((scanline>>6) <<11) + (scanline & 0x7);
658 pattab += ((scanline>>6) <<11) + (scanline & 0x7);
659
660 tilex = cellskip & 0x1f;
661 cells = maxcells - cellskip - 1;
662 dx = (cellskip << 3) + line_offset;
663
664 // tiles
665 if (!(pv->debug_p & PVD_KILL_B))
666 DrawStripM3(nametab, coltab, pattab, dx | (cells << 16), tilex | (scanline << 16));
667
668 // sprites
669 if (!(pv->debug_p & PVD_KILL_S_LO))
670 DrawSpritesTMS();
671}
672
673
674/* Mode 0 - Graphics I */
675/*=====================*/
676
677/* Draw the background into a scanline; cells, dx, tilex, ty merged to reduce registers */
678static void DrawStripM0(const u8 *nametab, const u8 *coltab, const u8 *pattab, int cells_dx, int tilex_ty)
679{
680 // Draw tiles across screen:
681 for (; cells_dx >= 0; cells_dx += 8, tilex_ty++, cells_dx -= 0x10000)
682 {
683 unsigned int pack, pal;
684 unsigned code;
685
686 code = nametab[tilex_ty & 0x1f];
687 pal = coltab[code >> 3];
688 pack = pattab[code << 3];
689 TileNormBgMg(cells_dx, pack, pal);
690 }
691}
692
693/* Draw a scanline */
694static void DrawDisplayM0(int scanline)
695{
696 struct PicoVideo *pv = &Pico.video;
697 u8 *nametab, *coltab, *pattab;
698 int tilex, dx, cells;
699 int cellskip = 0; // XXX
700 int maxcells = 32;
701
702 // name, color, pattern table:
703 nametab = PicoMem.vramb + ((pv->reg[2]<<10) & 0x3c00);
704 coltab = PicoMem.vramb + ((pv->reg[3]<< 6) & 0x3fc0);
705 pattab = PicoMem.vramb + ((pv->reg[4]<<11) & 0x3800);
706
707 nametab += (scanline>>3) << 5;
708 pattab += (scanline & 0x7);
709
710 tilex = cellskip & 0x1f;
711 cells = maxcells - cellskip - 1;
712 dx = (cellskip << 3) + line_offset;
713
714 // tiles
715 if (!(pv->debug_p & PVD_KILL_B))
716 DrawStripM0(nametab, coltab, pattab, dx | (cells << 16), tilex | (scanline << 16));
717
718 // sprites
719 if (!(pv->debug_p & PVD_KILL_S_LO))
720 DrawSpritesTMS();
721}
722
723
724/* Common/global */
725/*===============*/
726
727static void FinalizeLineRGB555SMS(int line);
728static void FinalizeLine8bitSMS(int line);
729
730void PicoFrameStartSMS(void)
731{
732 struct PicoEState *est = &Pico.est;
733 int lines = 192, columns = 256, loffs, coffs;
734
735 skip_next_line = 0;
736 loffs = screen_offset = 24; // 192 lines is really 224 with top/bottom bars
737 est->rendstatus = PDRAW_32_COLS;
738
739 // if mode changes make palette dirty since some modes switch to a fixed one
740 if (mode != ((Pico.video.reg[0]&0x06) | (Pico.video.reg[1]&0x18))) {
741 mode = (Pico.video.reg[0]&0x06) | (Pico.video.reg[1]&0x18);
742 Pico.m.dirtyPal = 1;
743 }
744
745 switch (mode) {
746 // SMS2 only 224/240 line modes, e.g. Micro Machines
747 case 0x06|0x08:
748 est->rendstatus |= PDRAW_30_ROWS;
749 loffs = screen_offset = 0;
750 lines = 240;
751 break;
752 case 0x06|0x10:
753 loffs = screen_offset = 8;
754 lines = 224;
755 break;
756 }
757
758 Pico.m.hardware &= ~PMS_HW_TMS;
759 if (PicoIn.tmsPalette || (PicoIn.AHW & (PAHW_SG|PAHW_SC)))
760 Pico.m.hardware |= PMS_HW_TMS;
761
762 // Copy LCD enable flag for easier handling
763 Pico.m.hardware &= ~PMS_HW_LCD;
764 if ((PicoIn.opt & POPT_EN_GG_LCD) && (PicoIn.AHW & PAHW_GG)) {
765 Pico.m.hardware |= PMS_HW_LCD;
766
767 // GG LCD always has 160x144 regardless of settings
768 loffs = 48;
769 lines = 144;
770 columns = 160;
771 } else {
772 if ((mode & 4) && (Pico.video.reg[0] & 0x20)) {
773 // SMS mode 4 with 1st column blanked
774 est->rendstatus |= PDRAW_SMS_BLANK_1;
775 columns = 248;
776 }
777 }
778
779 line_offset = 8; // FinalizeLine requires HighCol+8
780 // ugh... nonetheless has offset in 8-bit fast mode if 1st col blanked!
781 coffs = (FinalizeLineSMS == NULL && columns == 248 ? 8 : 0);
782 if (FinalizeLineSMS != NULL && (PicoIn.opt & POPT_EN_SOFTSCALE)) {
783 // softscaling always generates 320px, but no scaling in 8bit fast
784 est->rendstatus |= PDRAW_SOFTSCALE;
785 coffs = 0;
786 columns = 320;
787 } else if (!(PicoIn.opt & POPT_DIS_32C_BORDER)) {
788 est->rendstatus |= PDRAW_BORDER_32;
789 line_offset -= coffs;
790 coffs = (320-columns) / 2;
791 if (FinalizeLineSMS == NULL)
792 line_offset += coffs; // ... else centering done in FinalizeLine
793 }
794
795 if (est->rendstatus != rendstatus_old || lines != rendlines) {
796 // mode_change() might reset rendstatus_old by calling SetOutFormat
797 int rendstatus = est->rendstatus;
798 emu_video_mode_change(loffs, lines, coffs, columns);
799 rendstatus_old = rendstatus;
800 rendlines = lines;
801 sprites = 0;
802 }
803
804 est->HighCol = HighColBase + screen_offset * HighColIncrement;
805 est->DrawLineDest = (char *)DrawLineDestBase + screen_offset * DrawLineDestIncrement;
806
807 if (FinalizeLineSMS == FinalizeLine8bitSMS) {
808 Pico.m.dirtyPal = (Pico.m.dirtyPal || est->SonicPalCount ? 2 : 0);
809 memcpy(est->SonicPal, PicoMem.cram, 0x40*2);
810 }
811 est->SonicPalCount = 0;
812}
813
814void PicoParseSATSMS(int line)
815{
816 if (Pico.video.reg[0] & 0x04) ParseSpritesM4(line);
817 else ParseSpritesTMS(line);
818}
819
820void PicoLineSMS(int line)
821{
822 int skip = skip_next_line;
823 unsigned bgcolor;
824 int first = 48 - screen_offset;
825
826 // GG LCD, render only visible part of screen
827 if ((Pico.m.hardware & PMS_HW_LCD) && (line < first || line >= first+144))
828 goto norender;
829
830 if (PicoScanBegin != NULL && skip == 0)
831 skip = PicoScanBegin(line + screen_offset);
832
833 if (skip) {
834 skip_next_line = skip - 1;
835 return;
836 }
837
838 // Draw screen:
839 bgcolor = (Pico.video.reg[7] & 0x0f) | ((Pico.video.reg[0] & 0x04) << 2);
840 BackFill(bgcolor, 0, &Pico.est); // bgcolor is from 2nd palette in mode 4
841 if (Pico.video.reg[1] & 0x40) {
842 if (Pico.video.reg[0] & 0x04) DrawDisplayM4(line); // also M4+M3
843 else if (Pico.video.reg[1] & 0x08) DrawDisplayM2(line); // also M2+M3
844 else if (Pico.video.reg[1] & 0x10) DrawDisplayM1(line); // also M1+M3
845 else if (Pico.video.reg[0] & 0x02) DrawDisplayM3(line);
846 else DrawDisplayM0(line);
847 }
848
849 // latch current register values (may be overwritten by VDP reg writes later)
850 sprites_zoom = (Pico.video.reg[1] & 0x3) | (Pico.video.reg[0] & 0x8);
851 xscroll = Pico.video.reg[8];
852
853 if (FinalizeLineSMS != NULL)
854 FinalizeLineSMS(line);
855
856 if (PicoScanEnd != NULL)
857 skip_next_line = PicoScanEnd(line + screen_offset);
858
859norender:
860 Pico.est.HighCol += HighColIncrement;
861 Pico.est.DrawLineDest = (char *)Pico.est.DrawLineDest + DrawLineDestIncrement;
862}
863
864/* Palette for TMS9918 mode, see https://www.smspower.org/Development/Palette */
865// RGB values: #000000 #000000 #21c842 #5edc78 #5455ed #7d76fc #d4524d #42ebf5
866// #fc5554 #ff7978 #d4c154 #e6ce80 #21b03b #c95bba #cccccc #ffffff
867static u16 tmspal[] = {
868 // SMS palette
869 0x0000, 0x0000, 0x00a0, 0x00f0, 0x0a00, 0x0f00, 0x0005, 0x0ff0,
870 0x000a, 0x000f, 0x00aa, 0x00ff, 0x0050, 0x0f0f, 0x0aaa, 0x0fff,
871 // TMS palette
872 0x0000, 0x0000, 0x04c2, 0x07d6, 0x0e55, 0x0f77, 0x055c, 0x0ee4,
873 0x055f, 0x077f, 0x05bc, 0x08ce, 0x03a2, 0x0b5c, 0x0ccc, 0x0fff,
874 // SMS palette, closer to the TMS one
875 0x0000, 0x0000, 0x05f0, 0x05f5, 0x0a50, 0x0f55, 0x055a, 0x0ff0,
876 0x055f, 0x0aaf, 0x05aa, 0x05af, 0x00a0, 0x0f5f, 0x0aaa, 0x0fff,
877};
878
879void PicoDoHighPal555SMS(void)
880{
881 u32 *spal = (void *)Pico.est.SonicPal;
882 u32 *dpal = (void *)Pico.est.HighPal;
883 unsigned int cnt = Pico.est.SonicPalCount+1;
884 unsigned int t;
885 int i, j;
886
887 if (FinalizeLineSMS == FinalizeLineRGB555SMS || Pico.m.dirtyPal == 2)
888 Pico.m.dirtyPal = 0;
889
890 // use hardware palette if not in 8bit accurate mode
891 if (FinalizeLineSMS != FinalizeLine8bitSMS)
892 spal = (void *)PicoMem.cram;
893
894 /* SMS 6 bit cram data was already converted to MD/GG format by vdp write,
895 * hence GG/SMS/TMS can all be handled the same here */
896 for (j = cnt; j > 0; j--) {
897 if (!(Pico.video.reg[0] & 0x4)) // fixed palette in TMS modes
898 spal = (u32 *)tmspal + (Pico.m.hardware & PMS_HW_TMS ? 16/2:0);
899 for (i = 0x20/2; i > 0; i--, spal++, dpal++) {
900 t = *spal;
901#if defined(USE_BGR555)
902 t = ((t & 0x000f000f)<<1) | ((t & 0x00f000f0)<<2) | ((t & 0x0f000f00)<<3);
903 t |= (t >> 4) & 0x04210421;
904#elif defined(USE_BGR565)
905 t = ((t & 0x000f000f)<<1) | ((t & 0x00f000f0)<<3) | ((t & 0x0f000f00)<<4);
906 t |= (t >> 4) & 0x08610861;
907#else
908 t = ((t & 0x000f000f)<<12)| ((t & 0x00f000f0)<<3) | ((t & 0x0f000f00)>>7);
909 t |= (t >> 4) & 0x08610861;
910#endif
911 *dpal = t;
912 }
913 memcpy(dpal, dpal-0x20/2, 0x20*2); // for prio bit
914 spal += 0x20/2, dpal += 0x20/2;
915 }
916 Pico.est.HighPal[0xe0] = 0;
917}
918
919static void FinalizeLineRGB555SMS(int line)
920{
921 if (Pico.m.dirtyPal)
922 PicoDoHighPal555SMS();
923
924 // standard FinalizeLine can finish it for us,
925 // with features like scaling and such
926 FinalizeLine555(0, line, &Pico.est);
927}
928
929static void FinalizeLine8bitSMS(int line)
930{
931 FinalizeLine8bit(0, line, &Pico.est);
932}
933
934void PicoDrawSetOutputSMS(pdso_t which)
935{
936 switch (which)
937 {
938 case PDF_8BIT: FinalizeLineSMS = FinalizeLine8bitSMS; break;
939 case PDF_RGB555: FinalizeLineSMS = FinalizeLineRGB555SMS; break;
940 default: FinalizeLineSMS = NULL; // no multiple palettes, no scaling
941 PicoDrawSetInternalBuf(Pico.est.Draw2FB, 328); break;
942 }
943 rendstatus_old = -1;
944 mode = -1;
945}
946
947// vim:shiftwidth=2:ts=2:expandtab
fast MegaDrive/MegaCD/32X emulator