Previous 15994 Revisions Next

r4265 Friday 13th February, 2009 at 21:18:12 UTC by Wilbert Pol
[SMS/GG] Fixed scrolling for 8 rightmost columns. (bug #1497) [Enik Land]
Code style cleanups.
[docs]messnew.txt
[src/mess/video]smsvdp.c

src/mess/video/smsvdp.c
r4264r4265
7676static const UINT8 sms_pal_224[7]  = { 0xCA, 3, 13, 38, 224, 32, 3 };
7777static const UINT8 sms_pal_240[7]  = { 0xD2, 3, 13, 30, 240, 24, 3 };
7878
79static struct _smsvdp {
79static struct _smsvdp
80{
8081   UINT32      features;
8182   UINT8      reg[NUM_OF_REGISTER];      /* All the registers */
8283   UINT8      status;                  /* Status register */
r4264r4265
123124   M3 = smsvdp.reg[0x01] & 0x08;
124125   M4 = smsvdp.reg[0x00] & 0x04;
125126   smsvdp.y_pixels = 192;
126   if ( M4 ) {
127   if ( M4 )
128   {
127129      /* mode 4 */
128130      smsvdp.vdp_mode = 4;
129      if ( M2 && ( IS_SMS2_VDP || IS_GAMEGEAR_VDP ) ) {
131      if ( M2 && ( IS_SMS2_VDP || IS_GAMEGEAR_VDP ) )
132      {
130133         /* Is it 224-line display */
131         if ( M1 && ! M3 ) {
134         if ( M1 && ! M3 )
135         {
132136            smsvdp.y_pixels = 224;
133         } else if ( ! M1 && M3 ) {
137         }
138         else if ( ! M1 && M3 )
139         {
134140            /* 240-line display */
135141            smsvdp.y_pixels = 240;
136142         }
137143      }
138   } else {
144   }
145   else
146   {
139147      /* original TMS9918 mode */
140      if ( ! M1 && ! M2 && ! M3 ) {
148      if ( ! M1 && ! M2 && ! M3 )
149      {
141150         smsvdp.vdp_mode = 0;
142      } else
143//      if ( M1 && ! M2 && ! M3 ) {
151      }
152      else
153//      if ( M1 && ! M2 && ! M3 )
154//      {
144155//         smsvdp.vdp_mode = 1;
145//      } else
146      if ( ! M1 && M2 && ! M3 ) {
156//      }
157//      else
158      if ( ! M1 && M2 && ! M3 )
159      {
147160         smsvdp.vdp_mode = 2;
148//      } else
149//      if ( ! M1 && ! M2 && M3 ) {
161//      }
162//      else
163//      if ( ! M1 && ! M2 && M3 )
164//      {
150165//         smsvdp.vdp_mode = 3;
151      } else {
166      }
167      else
168      {
152169         logerror( "Unknown video mode detected (M1=%c, M2=%c, M3=%c, M4=%c)\n", M1 ? '1' : '0', M2 ? '1' : '0', M3 ? '1' : '0', M4 ? '1' : '0');
153170      }
154171   }
155   switch( smsvdp.y_pixels ) {
172
173   switch( smsvdp.y_pixels )
174   {
156175   case 192:
157176      smsvdp.sms_frame_timing = ( height == PAL_Y_PIXELS ) ? sms_pal_192 : sms_ntsc_192;
158177      break;
178
159179   case 224:
160180      smsvdp.sms_frame_timing = ( height == PAL_Y_PIXELS ) ? sms_pal_224 : sms_ntsc_224;
161181      break;
182
162183   case 240:
163184      smsvdp.sms_frame_timing = ( height == PAL_Y_PIXELS ) ? sms_pal_240 : sms_ntsc_240;
164185      break;
r4264r4265
166187   smsvdp.cram_dirty = 1;
167188}
168189
169 READ8_HANDLER(sms_vdp_vcount_r) {
190
191 READ8_HANDLER(sms_vdp_vcount_r)
192{
170193   return ( smsvdp.sms_frame_timing[ INIT_VCOUNT ] + video_screen_get_vpos(space->machine->primary_screen) ) & 0xFF;
171194}
172195
173READ8_HANDLER(sms_vdp_hcount_r) {
196
197READ8_HANDLER(sms_vdp_hcount_r)
198{
174199   return video_screen_get_hpos(space->machine->primary_screen) >> 1;
175200}
176201
177void sms_set_ggsmsmode( int mode ) {
202
203void sms_set_ggsmsmode( int mode )
204{
178205   smsvdp.gg_sms_mode = mode;
179206}
180207
208
181209int smsvdp_video_init( running_machine *machine, const smsvdp_configuration *config )
182210{
183211   const device_config *screen = video_screen_first(machine->config);
r4264r4265
221249   return 0;
222250}
223251
224static TIMER_CALLBACK(smsvdp_set_irq) {
252
253static TIMER_CALLBACK(smsvdp_set_irq)
254{
225255   smsvdp.irq_state = 1;
226   if ( smsvdp.int_callback ) {
256   if ( smsvdp.int_callback )
257   {
227258      smsvdp.int_callback( machine, ASSERT_LINE );
228259   }
229260}
230261
262
231263static TIMER_CALLBACK(smsvdp_display_callback)
232264{
233265   rectangle rec;
r4264r4265
239271   rec.min_y = rec.max_y = vpos;
240272
241273   /* Check if we're on the last line of a frame */
242   if ( vpos == vpos_limit - 1 ) {
274   if ( vpos == vpos_limit - 1 )
275   {
243276      sms_check_pause_button( cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM) );
244277      return;
245278   }
r4264r4265
247280   vpos_limit -= smsvdp.sms_frame_timing[BOTTOM_BLANKING];
248281
249282   /* Check if we're below the bottom border */
250   if ( vpos >= vpos_limit ) {
283   if ( vpos >= vpos_limit )
284   {
251285      return;
252286   }
253287
254288   vpos_limit -= smsvdp.sms_frame_timing[BOTTOM_BORDER];
255289
256290   /* Check if we're in the bottom border area */
257   if ( vpos >= vpos_limit ) {
258      if ( vpos == vpos_limit ) {
259         if ( smsvdp.line_counter == 0x00 ) {
291   if ( vpos >= vpos_limit )
292   {
293      if ( vpos == vpos_limit )
294      {
295         if ( smsvdp.line_counter == 0x00 )
296         {
260297            smsvdp.line_counter = smsvdp.reg[0x0A];
261298            smsvdp.status |= STATUS_HINT;
262            if ( smsvdp.reg[0x00] & 0x10 ) {
299
300            if ( smsvdp.reg[0x00] & 0x10 )
301            {
263302               /* Delay triggering of interrupt to allow software to read the status bit before the irq */
264303               timer_set(machine,  video_screen_get_time_until_pos(machine->primary_screen, video_screen_get_vpos(machine->primary_screen), video_screen_get_hpos(machine->primary_screen) + 1 ), NULL, 0, smsvdp_set_irq );
265304            }
266305         }
267306
268307      }
269      if ( vpos == vpos_limit + 1 ) {
308
309      if ( vpos == vpos_limit + 1 )
310      {
270311         smsvdp.status |= STATUS_VINT;
271         if ( smsvdp.reg[0x01] & 0x20 ) {
312
313         if ( smsvdp.reg[0x01] & 0x20 )
314         {
272315            /* Delay triggering of interrupt to allow software to read the status bit before the irq */
273316            timer_set(machine,  video_screen_get_time_until_pos(machine->primary_screen, video_screen_get_vpos(machine->primary_screen), video_screen_get_hpos(machine->primary_screen) + 1 ), NULL, 0, smsvdp_set_irq );
274317         }
275318      }
276      if ( video_skip_this_frame() ) {
319
320      if ( video_skip_this_frame() )
321      {
277322         return;
278323      }
279324      sms_update_palette();
325
280326      /* Draw left border */
281327      rec.min_x = LBORDER_START;
282328      rec.max_x = LBORDER_START + LBORDER_X_PIXELS - 1;
283329      bitmap_fill( tmpbitmap, &rec , machine->pens[smsvdp.current_palette[BACKDROP_COLOR]]);
330
284331      /* Draw right border */
285332      rec.min_x = LBORDER_START + LBORDER_X_PIXELS + 256;
286333      rec.max_x = rec.min_x + RBORDER_X_PIXELS - 1;
287334      bitmap_fill( tmpbitmap, &rec , machine->pens[smsvdp.current_palette[BACKDROP_COLOR]]);
335
288336      /* Draw middle of the border */
289337      /* We need to do this through the regular drawing function so it will */
290338      /* be included in the gamegear scaling functions */
r4264r4265
295343   vpos_limit -= smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V];
296344
297345   /* Check if we're in the active display area */
298   if ( vpos >= vpos_limit ) {
299      if ( vpos == vpos_limit ) {
346   if ( vpos >= vpos_limit )
347   {
348      if ( vpos == vpos_limit )
349      {
300350         smsvdp.line_counter = smsvdp.reg[0x0A];
301351         smsvdp.reg9copy = smsvdp.reg[0x09];
302352      }
303      if ( smsvdp.line_counter == 0x00 ) {
353
354      if ( smsvdp.line_counter == 0x00 )
355      {
304356         smsvdp.line_counter = smsvdp.reg[0x0A];
305357         smsvdp.status |= STATUS_HINT;
306         if ( smsvdp.reg[0x00] & 0x10 ) {
358
359         if ( smsvdp.reg[0x00] & 0x10 )
360         {
307361            /* Delay triggering of interrupt to allow software to read the status bit before the irq */
308362            timer_set(machine,  video_screen_get_time_until_pos(machine->primary_screen, video_screen_get_vpos(machine->primary_screen), video_screen_get_hpos(machine->primary_screen) + 1 ), NULL, 0, smsvdp_set_irq );
309363         }
310      } else {
364      }
365      else
366      {
311367         smsvdp.line_counter -= 1;
312368      }
313      if ( video_skip_this_frame() ) {
369
370      if ( video_skip_this_frame() )
371      {
314372         return;
315373      }
374
316375      sms_update_palette();
317376
318377      /* Check if display is disabled */
319      if ( ! ( smsvdp.reg[0x01] & 0x40 ) ) {
378      if ( ! ( smsvdp.reg[0x01] & 0x40 ) )
379      {
320380         /* set whole line to backdrop color */
321381         rec.min_x = LBORDER_START;
322382         rec.max_x = LBORDER_START + LBORDER_X_PIXELS + 255 + RBORDER_X_PIXELS;
323383         bitmap_fill( tmpbitmap, &rec , machine->pens[smsvdp.current_palette[BACKDROP_COLOR]]);
324      } else {
384      }
385      else
386      {
325387         /* Draw left border */
326388         rec.min_x = LBORDER_START;
327389         rec.max_x = LBORDER_START + LBORDER_X_PIXELS - 1;
328390         bitmap_fill( tmpbitmap, &rec , machine->pens[smsvdp.current_palette[BACKDROP_COLOR]]);
391
329392         /* Draw right border */
330393         rec.min_x = LBORDER_START + LBORDER_X_PIXELS + 256;
331394         rec.max_x = rec.min_x + RBORDER_X_PIXELS - 1;
r4264r4265
338401   vpos_limit -= smsvdp.sms_frame_timing[TOP_BORDER];
339402
340403   /* Check if we're in the top border area */
341   if ( vpos >= vpos_limit ) {
342      if ( video_skip_this_frame() ) {
404   if ( vpos >= vpos_limit )
405   {
406      if ( video_skip_this_frame() )
407      {
343408         return;
344409      }
410
345411      sms_update_palette();
412
346413      /* Draw left border */
347414      rec.min_x = LBORDER_START;
348415      rec.max_x = LBORDER_START + LBORDER_X_PIXELS - 1;
349416      bitmap_fill( tmpbitmap, &rec , machine->pens[smsvdp.current_palette[BACKDROP_COLOR]]);
417
350418      /* Draw right border */
351419      rec.min_x = LBORDER_START + LBORDER_X_PIXELS + 256;
352420      rec.max_x = rec.min_x + RBORDER_X_PIXELS - 1;
353421      bitmap_fill( tmpbitmap, &rec , machine->pens[smsvdp.current_palette[BACKDROP_COLOR]]);
422
354423      /* Draw middle of the border */
355424      /* We need to do this through the regular drawing function so it will */
356425      /* be included in the gamegear scaling functions */
r4264r4265
359428   }
360429}
361430
362 READ8_HANDLER(sms_vdp_data_r) {
431
432 READ8_HANDLER(sms_vdp_data_r)
433{
363434   UINT8 temp;
364435
365436   /* SMS 2 & GG behaviour. Seems like the latched data is passed straight through */
r4264r4265
379450   return (temp);
380451}
381452
382 READ8_HANDLER(sms_vdp_ctrl_r) {
453
454 READ8_HANDLER(sms_vdp_ctrl_r)
455{
383456   UINT8 temp = smsvdp.status;
384457
385458   /* Clear pending write flag */
r4264r4265
387460
388461   smsvdp.status &= ~( STATUS_VINT | STATUS_SPROVR | STATUS_SPRCOL | STATUS_HINT );
389462
390   if (smsvdp.irq_state == 1) {
463   if (smsvdp.irq_state == 1)
464   {
391465      smsvdp.irq_state = 0;
392      if ( smsvdp.int_callback ) {
466
467      if ( smsvdp.int_callback )
468      {
393469         smsvdp.int_callback( space->machine, CLEAR_LINE );
394470      }
395471   }
r4264r4265
397473   return (temp);
398474}
399475
400WRITE8_HANDLER(sms_vdp_data_w) {
476
477WRITE8_HANDLER(sms_vdp_data_w)
478{
401479   /* SMS 2 & GG behaviour. Seems like the latched data is passed straight through */
402480   /* to the address register when in the middle of doing a command.               */
403481   /* Cosmic Spacehead needs this, among others                                    */
404482   /* Clear pending write flag */
405483   smsvdp.pending = 0;
406484
407   switch(smsvdp.addrmode) {
485   switch(smsvdp.addrmode)
486   {
408487      case 0x00:
409488      case 0x01:
410      case 0x02: {
411         int address = (smsvdp.addr & 0x3FFF);
489      case 0x02:
490         {
491            int address = (smsvdp.addr & 0x3FFF);
412492
413         smsvdp.VRAM[address] = data;
414      }
415      break;
416      case 0x03: {
417         int address = smsvdp.addr & smsvdp.cram_mask;
493            smsvdp.VRAM[address] = data;
494         }
495         break;
418496
419         if (data != smsvdp.CRAM[address]) {
420            smsvdp.CRAM[address] = data;
421            smsvdp.cram_dirty = 1;
497      case 0x03:
498         {
499            int address = smsvdp.addr & smsvdp.cram_mask;
500
501            if (data != smsvdp.CRAM[address])
502            {
503               smsvdp.CRAM[address] = data;
504               smsvdp.cram_dirty = 1;
505            }
422506         }
423      }
424      break;
507         break;
425508   }
426509
427510   smsvdp.buffer = data;
428511   smsvdp.addr += 1;
429512}
430513
431WRITE8_HANDLER(sms_vdp_ctrl_w) {
514
515WRITE8_HANDLER(sms_vdp_ctrl_w)
516{
432517   int regNum;
433518
434   if (smsvdp.pending == 0) {
519   if (smsvdp.pending == 0)
520   {
435521      smsvdp.addr = ( smsvdp.addr & 0xff00 ) | data;
436522      smsvdp.pending = 1;
437   } else {
523   }
524   else
525   {
438526      /* Clear pending write flag */
439527      smsvdp.pending = 0;
440528
441529      smsvdp.addrmode = (data >> 6) & 0x03;
442530      smsvdp.addr = ( data << 8 ) | ( smsvdp.addr & 0xff );
443      switch( smsvdp.addrmode ) {
531      switch( smsvdp.addrmode )
532      {
444533      case 0:      /* VRAM reading mode */
445534         smsvdp.buffer = smsvdp.VRAM[ smsvdp.addr & 0x3FFF ];
446535         smsvdp.addr += 1;
447536         break;
537
448538      case 1:      /* VRAM writing mode */
449539         break;
540
450541      case 2:      /* VDP register write */
451542         regNum = data & 0x0F;
452543         smsvdp.reg[regNum] = smsvdp.addr & 0xff;
453         if (regNum == 0 && smsvdp.addr & 0x02) {
544         if (regNum == 0 && smsvdp.addr & 0x02)
545         {
454546            logerror("overscan enabled.\n");
455547         }
456         if ( regNum == 0 || regNum == 1 ) {
548         if ( regNum == 0 || regNum == 1 )
549         {
457550            set_display_settings( space->machine );
458551         }
459         if ( ( regNum == 1 ) && ( smsvdp.reg[0x01] & 0x20 ) && ( smsvdp.status & STATUS_VINT ) ) {
552         if ( ( regNum == 1 ) && ( smsvdp.reg[0x01] & 0x20 ) && ( smsvdp.status & STATUS_VINT ) )
553         {
460554            smsvdp.irq_state = 1;
461555            smsvdp.int_callback( space->machine, ASSERT_LINE );
462556         }
463557         smsvdp.addrmode = 0;
464558         break;
559
465560      case 3:      /* CRAM writing mode */
466561         break;
467562      }
468563   }
469564}
470565
471static void sms_refresh_line_mode4(int *lineBuffer, int line) {
566
567static void sms_refresh_line_mode4(int *lineBuffer, int line)
568{
472569   int tileColumn;
473570   int xScroll, yScroll, xScrollStartColumn;
474571   int spriteIndex;
r4264r4265
476573   int spriteX, spriteY, spriteLine, spriteTileSelected, spriteHeight, spriteZoom;
477574   int spriteBuffer[8], spriteBufferCount, spriteBufferIndex;
478575   int bitPlane0, bitPlane1, bitPlane2, bitPlane3;
576   int scroll_mod;
479577   UINT16 nameTableAddress;
480578   UINT8 *nameTable;
481579   UINT8 *spriteTable = smsvdp.VRAM + ( (smsvdp.reg[0x05] << 7) & 0x3F00 );
482580
483   if ( smsvdp.y_pixels != 192 ) {
484      nameTableAddress = (((smsvdp.reg[0x02] & 0x0C) << 10) | 0x0700) + ((((line + smsvdp.reg9copy) % 256) >> 3) << 6);
485   } else {
486      nameTableAddress = ((smsvdp.reg[0x02] << 10) & 0x3800) + ((((line + smsvdp.reg9copy) % 224) >> 3) << 6);
581   if ( smsvdp.y_pixels != 192 )
582   {
583      nameTableAddress = ((smsvdp.reg[0x02] & 0x0C) << 10) | 0x0700;
584      scroll_mod = 256;
487585   }
488   if ( IS_SMS1_VDP ) {
586   else
587   {
588      nameTableAddress = (smsvdp.reg[0x02] << 10) & 0x3800;
589      scroll_mod = 224;
590   }
591
592   if ( IS_SMS1_VDP )
593   {
489594      nameTableAddress = nameTableAddress & (((smsvdp.reg[0x02] & 0x01) << 10) | 0x3BFF);
490595   }
491   nameTable = smsvdp.VRAM + nameTableAddress;
492596
493597   /* if top 2 rows of screen not affected by horizontal scrolling, then xScroll = 0 */
494598   /* else xScroll = reg[0x08] (SMS Only)                                            */
495   if ( IS_GAMEGEAR_VDP ) {
599   if ( IS_GAMEGEAR_VDP )
600   {
496601      xScroll = 0x0100 - smsvdp.reg[0x08];
497   } else {
602   }
603   else
604   {
498605      xScroll = (((smsvdp.reg[0x00] & 0x40) && (line < 16)) ? 0 : 0x0100 - smsvdp.reg[0x08]);
499606   }
500607
501608   xScrollStartColumn = (xScroll >> 3);          /* x starting column tile */
502609
503610   /* Draw background layer */
504   for (tileColumn = 0; tileColumn < 33; tileColumn++) {
611   for (tileColumn = 0; tileColumn < 33; tileColumn++)
612   {
505613      UINT16 tileData;
506614      int tileSelected, palletteSelected, horizSelected, vertSelected, prioritySelect;
507615      int tileLine;
508616
509617      /* Rightmost 8 columns for SMS (or 2 columns for GG) not affected by */
510618      /* vertical scrolling when bit 7 of reg[0x00] is set */
511      if ( IS_GAMEGEAR_VDP ) {
512         yScroll = (((smsvdp.reg[0x00] & 0x80) && (tileColumn > 29)) ? 0 : (smsvdp.reg9copy) % 224);
513      } else {
514         yScroll = (((smsvdp.reg[0x00] & 0x80) && (tileColumn > 23)) ? 0 : (smsvdp.reg9copy) % 224);
515      }
619      yScroll = ((smsvdp.reg[0x00] & 0x80) && (tileColumn > 23)) ? 0 : smsvdp.reg9copy;
516620
621      nameTable = smsvdp.VRAM + nameTableAddress + ((((line + yScroll) % scroll_mod) >> 3) << 6);
622
517623      tileLine = ( ( tileColumn + xScrollStartColumn ) & 0x1F ) * 2;
518624      tileData = nameTable[ tileLine ] | ( nameTable[ tileLine + 1 ] << 8 );
519625
r4264r4265
524630      horizSelected = (tileData >> 9) & 0x01;
525631
526632      tileLine = line - ((0x07 - (yScroll & 0x07)) + 1);
527      if (vertSelected) {
633      if (vertSelected)
634      {
528635         tileLine = 0x07 - tileLine;
529636      }
530637      bitPlane0 = smsvdp.VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x00];
r4264r4265
532639      bitPlane2 = smsvdp.VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x02];
533640      bitPlane3 = smsvdp.VRAM[((tileSelected << 5) + ((tileLine & 0x07) << 2)) + 0x03];
534641
535      for (pixelX = 0; pixelX < 8 ; pixelX++) {
642      for (pixelX = 0; pixelX < 8 ; pixelX++)
643      {
536644         UINT8 penBit0, penBit1, penBit2, penBit3;
537645         UINT8 penSelected;
538646
r4264r4265
542650         penBit3 = (bitPlane3 >> (7 - pixelX)) & 0x01;
543651
544652         penSelected = (penBit3 << 3 | penBit2 << 2 | penBit1 << 1 | penBit0);
545         if (palletteSelected) {
653         if (palletteSelected)
654         {
546655            penSelected |= 0x10;
547656         }
548657
549         if (!horizSelected) {
658         if (!horizSelected)
659         {
550660            pixelPlotX = pixelX;
551         } else {
661         }
662         else
663         {
552664            pixelPlotX = 7 - pixelX;
553665         }
554666         pixelPlotX = (0 - (xScroll & 0x07) + (tileColumn << 3) + pixelPlotX);
555         if (pixelPlotX >= 0 && pixelPlotX < 256) {
667         if (pixelPlotX >= 0 && pixelPlotX < 256)
668         {
556669//            logerror("%x %x\n", pixelPlotX + pixelOffsetX, pixelPlotY);
557670            lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
558671            prioritySelected[pixelPlotX] = prioritySelect | ( penSelected & 0x0F );
r4264r4265
563676   /* Draw sprite layer */
564677   spriteHeight = (smsvdp.reg[0x01] & 0x02 ? 16 : 8);
565678   spriteZoom = 1;
566   if (smsvdp.reg[0x01] & 0x01) {
679   if (smsvdp.reg[0x01] & 0x01)
680   {
567681      /* sprite doubling */
568682      spriteZoom = 2;
569683   }
570684   spriteBufferCount = 0;
571   for (spriteIndex = 0; (spriteIndex < 64) && (spriteTable[spriteIndex] != 0xD0 || smsvdp.y_pixels != 192) && (spriteBufferCount < 9); spriteIndex++) {
685   for (spriteIndex = 0; (spriteIndex < 64) && (spriteTable[spriteIndex] != 0xD0 || smsvdp.y_pixels != 192) && (spriteBufferCount < 9); spriteIndex++)
686   {
572687      spriteY = spriteTable[spriteIndex] + 1; /* sprite y position starts at line 1 */
573      if (spriteY > 240) {
688      if (spriteY > 240)
689      {
574690         spriteY -= 256; /* wrap from top if y position is > 240 */
575691      }
576      if ((line >= spriteY) && (line < (spriteY + spriteHeight * spriteZoom))) {
577         if (spriteBufferCount < 8) {
692      if ((line >= spriteY) && (line < (spriteY + spriteHeight * spriteZoom)))
693      {
694         if (spriteBufferCount < 8)
695         {
578696            spriteBuffer[spriteBufferCount] = spriteIndex;
579         } else {
697         }
698         else
699         {
580700            /* Too many sprites per line */
581701            smsvdp.status |= STATUS_SPROVR;
582702         }
583703         spriteBufferCount++;
584704      }
585705   }
586   if ( spriteBufferCount > 8 ) {
706   if ( spriteBufferCount > 8 )
707   {
587708      spriteBufferCount = 8;
588709   }
589710   memset(smsvdp.collision_buffer, 0, SMS_X_PIXELS);
590711   spriteBufferCount--;
591   for (spriteBufferIndex = spriteBufferCount; spriteBufferIndex >= 0; spriteBufferIndex--) {
712   for (spriteBufferIndex = spriteBufferCount; spriteBufferIndex >= 0; spriteBufferIndex--)
713   {
592714      spriteIndex = spriteBuffer[spriteBufferIndex];
593715      spriteY = spriteTable[spriteIndex] + 1; /* sprite y position starts at line 1 */
594      if (spriteY > 240) {
716      if (spriteY > 240)
717      {
595718         spriteY -= 256; /* wrap from top if y position is > 240 */
596719      }
597720
598721      spriteX = spriteTable[0x80 + (spriteIndex << 1)];
599      if (smsvdp.reg[0x00] & 0x08) {
722      if (smsvdp.reg[0x00] & 0x08)
723      {
600724         spriteX -= 0x08;    /* sprite shift */
601725      }
602726      spriteTileSelected = spriteTable[0x81 + (spriteIndex << 1)];
603      if (smsvdp.reg[0x06] & 0x04) {
727      if (smsvdp.reg[0x06] & 0x04)
728      {
604729         spriteTileSelected += 256; /* pattern table select */
605730      }
606      if (smsvdp.reg[0x01] & 0x02) {
731      if (smsvdp.reg[0x01] & 0x02)
732      {
607733         spriteTileSelected &= 0x01FE; /* force even index */
608734      }
609735      spriteLine = ( line - spriteY ) / spriteZoom;
610736
611      if (spriteLine > 0x07) {
737      if (spriteLine > 0x07)
738      {
612739         spriteTileSelected += 1;
613740      }
614741
r4264r4265
617744      bitPlane2 = smsvdp.VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x02];
618745      bitPlane3 = smsvdp.VRAM[((spriteTileSelected << 5) + ((spriteLine & 0x07) << 2)) + 0x03];
619746
620      for (pixelX = 0; pixelX < 8 ; pixelX++) {
747      for (pixelX = 0; pixelX < 8 ; pixelX++)
748      {
621749         UINT8 penBit0, penBit1, penBit2, penBit3;
622750         int penSelected;
623751
r4264r4265
628756
629757         penSelected = (penBit3 << 3 | penBit2 << 2 | penBit1 << 1 | penBit0) | 0x10;
630758
631         if ( penSelected == 0x10 ) {   /* Transparent palette so skip draw */
759         if ( penSelected == 0x10 )      /* Transparent palette so skip draw */
760         {
632761            continue;
633762         }
634763
635         if (smsvdp.reg[0x01] & 0x01) {
764         if (smsvdp.reg[0x01] & 0x01)
765         {
636766            /* sprite doubling is enabled */
637767            pixelPlotX = spriteX + (pixelX << 1);
638768
639769            /* check to prevent going outside of active display area */
640            if ( pixelPlotX < 0 || pixelPlotX > 255 ) {
770            if ( pixelPlotX < 0 || pixelPlotX > 255 )
771            {
641772               continue;
642773            }
643774
644            if ( ! ( prioritySelected[pixelPlotX] & PRIORITY_BIT ) ) {
775            if ( ! ( prioritySelected[pixelPlotX] & PRIORITY_BIT ) )
776            {
645777               lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
646778               lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected];
647            } else {
648               if ( prioritySelected[pixelPlotX] == PRIORITY_BIT ) {
779            }
780            else
781            {
782               if ( prioritySelected[pixelPlotX] == PRIORITY_BIT )
783               {
649784                  lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
650785               }
651               if ( prioritySelected[pixelPlotX + 1] == PRIORITY_BIT ) {
786               if ( prioritySelected[pixelPlotX + 1] == PRIORITY_BIT )
787               {
652788                  lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected];
653789               }
654790            }
655            if (smsvdp.collision_buffer[pixelPlotX] != 1) {
791            if (smsvdp.collision_buffer[pixelPlotX] != 1)
792            {
656793               smsvdp.collision_buffer[pixelPlotX] = 1;
657            } else {
794            }
795            else
796            {
658797               /* sprite collision occurred */
659798               smsvdp.status |= STATUS_SPRCOL;
660799            }
661            if (smsvdp.collision_buffer[pixelPlotX + 1] != 1) {
800            if (smsvdp.collision_buffer[pixelPlotX + 1] != 1)
801            {
662802               smsvdp.collision_buffer[pixelPlotX + 1] = 1;
663            } else {
803            }
804            else
805            {
664806               /* sprite collision occurred */
665807               smsvdp.status |= STATUS_SPRCOL;
666808            }
667         } else {
809         }
810         else
811         {
668812            pixelPlotX = spriteX + pixelX;
669813
670814            /* check to prevent going outside of active display area */
671            if ( pixelPlotX < 0 || pixelPlotX > 255 ) {
815            if ( pixelPlotX < 0 || pixelPlotX > 255 )
816            {
672817               continue;
673818            }
674819
675            if ( ! ( prioritySelected[pixelPlotX] & PRIORITY_BIT ) ) {
820            if ( ! ( prioritySelected[pixelPlotX] & PRIORITY_BIT ) )
821            {
676822               lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
677            } else {
678               if ( prioritySelected[pixelPlotX] == PRIORITY_BIT ) {
823            }
824            else
825            {
826               if ( prioritySelected[pixelPlotX] == PRIORITY_BIT )
827               {
679828                  lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
680829               }
681830            }
682            if (smsvdp.collision_buffer[pixelPlotX] != 1) {
831            if (smsvdp.collision_buffer[pixelPlotX] != 1)
832            {
683833               smsvdp.collision_buffer[pixelPlotX] = 1;
684            } else {
834            }
835            else
836            {
685837               /* sprite collision occurred */
686838               smsvdp.status |= STATUS_SPRCOL;
687839            }
r4264r4265
690842   }
691843
692844   /* Fill column 0 with overscan color from reg[0x07] */
693   if (smsvdp.reg[0x00] & 0x20) {
845   if (smsvdp.reg[0x00] & 0x20)
846   {
694847      lineBuffer[0] = smsvdp.current_palette[BACKDROP_COLOR];
695848      lineBuffer[1] = smsvdp.current_palette[BACKDROP_COLOR];
696849      lineBuffer[2] = smsvdp.current_palette[BACKDROP_COLOR];
r4264r4265
702855   }
703856}
704857
705static void sms_refresh_tms9918_sprites(int *lineBuffer, int line) {
858
859static void sms_refresh_tms9918_sprites(int *lineBuffer, int line)
860{
706861   int pixelPlotX;
707862   int spriteHeight, spriteBufferCount, spriteIndex, spriteBuffer[4], spriteBufferIndex;
708863   UINT8 *spriteTable, *spritePatternTable;
r4264r4265
711866   spriteTable = smsvdp.VRAM + ( ( smsvdp.reg[0x05] & 0x7F ) << 7 );
712867   spritePatternTable = smsvdp.VRAM + ( ( smsvdp.reg[0x06] & 0x07 ) << 11 );
713868   spriteHeight = 8;
869
714870   if ( smsvdp.reg[0x01] & 0x02 )                         /* Check if SI is set */
715871      spriteHeight = spriteHeight * 2;
716872   if ( smsvdp.reg[0x01] & 0x01 )                         /* Check if MAG is set */
717873      spriteHeight = spriteHeight * 2;
874
718875   spriteBufferCount = 0;
719   for ( spriteIndex = 0; (spriteIndex < 32*4 ) && ( spriteTable[spriteIndex] != 0xD0 ) && ( spriteBufferCount < 5); spriteIndex+= 4 ) {
876   for ( spriteIndex = 0; (spriteIndex < 32*4 ) && ( spriteTable[spriteIndex] != 0xD0 ) && ( spriteBufferCount < 5); spriteIndex+= 4 )
877   {
720878      int spriteY = spriteTable[spriteIndex] + 1;
721      if ( spriteY > 240 ) {
879
880      if ( spriteY > 240 )
881      {
722882         spriteY -= 256;
723883      }
724      if ( ( line >= spriteY ) && ( line < ( spriteY + spriteHeight ) ) ) {
725         if ( spriteBufferCount < 5 ) {
884
885      if ( ( line >= spriteY ) && ( line < ( spriteY + spriteHeight ) ) )
886      {
887         if ( spriteBufferCount < 5 )
888         {
726889            spriteBuffer[spriteBufferCount] = spriteIndex;
727         } else {
890         }
891         else
892         {
728893            /* Too many sprites per line */
729894            smsvdp.status |= STATUS_SPROVR;
730895         }
731896         spriteBufferCount++;
732897      }
733898   }
734   if ( spriteBufferCount > 4 ) {
899
900   if ( spriteBufferCount > 4 )
901   {
735902      spriteBufferCount = 4;
736903   }
904
737905   memset( smsvdp.collision_buffer, 0, SMS_X_PIXELS );
738906   spriteBufferCount--;
739   for ( spriteBufferIndex = spriteBufferCount; spriteBufferIndex >= 0; spriteBufferIndex-- ) {
907
908   for ( spriteBufferIndex = spriteBufferCount; spriteBufferIndex >= 0; spriteBufferIndex-- )
909   {
740910      int penSelected;
741911      int spriteLine, pixelX, spriteX, spriteTileSelected;
742912      int spriteY;
743913      UINT8 pattern;
914
744915      spriteIndex = spriteBuffer[ spriteBufferIndex ];
745916      spriteY = spriteTable[ spriteIndex ] + 1;
746      if ( spriteY > 240 ) {
917
918      if ( spriteY > 240 )
919      {
747920         spriteY -= 256;
748921      }
922
749923      spriteX = spriteTable[ spriteIndex + 1 ];
750924      penSelected = spriteTable[ spriteIndex + 3 ] & 0x0F;
751      if ( IS_GAMEGEAR_VDP ) {
925
926      if ( IS_GAMEGEAR_VDP )
927      {
752928         penSelected |= 0x10;
753929      }
754      if ( spriteTable[ spriteIndex + 3 ] & 0x80 ) {
930
931      if ( spriteTable[ spriteIndex + 3 ] & 0x80 )
932      {
755933         spriteX -= 32;
756934      }
935
757936      spriteTileSelected = spriteTable[ spriteIndex + 2 ];
758937      spriteLine = line - spriteY;
759      if ( smsvdp.reg[0x01] & 0x01 ) {
938
939      if ( smsvdp.reg[0x01] & 0x01 )
940      {
760941         spriteLine >>= 1;
761942      }
762      if ( smsvdp.reg[0x01] & 0x02 ) {
943
944      if ( smsvdp.reg[0x01] & 0x02 )
945      {
763946         spriteTileSelected &= 0xFC;
764         if ( spriteLine > 0x07 ) {
947
948         if ( spriteLine > 0x07 )
949         {
765950            spriteTileSelected += 1;
766951            spriteLine -= 8;
767952         }
768953      }
954
769955      pattern = spritePatternTable[ spriteTileSelected * 8 + spriteLine ];
770956
771      for ( pixelX = 0; pixelX < 8; pixelX++ ) {
772         if ( smsvdp.reg[0x01] & 0x01 ) {
957      for ( pixelX = 0; pixelX < 8; pixelX++ )
958      {
959         if ( smsvdp.reg[0x01] & 0x01 )
960         {
773961            pixelPlotX = spriteX + pixelX * 2;
774            if ( pixelPlotX < 0 || pixelPlotX > 255 ) {
962            if ( pixelPlotX < 0 || pixelPlotX > 255 )
963            {
775964               continue;
776965            }
777            if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) {
966
967            if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) )
968            {
778969               lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
779               if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) {
970
971               if ( smsvdp.collision_buffer[pixelPlotX] != 1 )
972               {
780973                  smsvdp.collision_buffer[pixelPlotX] = 1;
781               } else {
974               }
975               else
976               {
782977                  smsvdp.status |= STATUS_SPRCOL;
783978               }
979
784980               lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected];
785               if ( smsvdp.collision_buffer[pixelPlotX + 1] != 1 ) {
981
982               if ( smsvdp.collision_buffer[pixelPlotX + 1] != 1 )
983               {
786984                  smsvdp.collision_buffer[pixelPlotX + 1] = 1;
787               } else {
985               }
986               else
987               {
788988                  smsvdp.status |= STATUS_SPRCOL;
789989               }
790990            }
791         } else {
991         }
992         else
993         {
792994            pixelPlotX = spriteX + pixelX;
793            if ( pixelPlotX < 0 || pixelPlotX > 255 ) {
995
996            if ( pixelPlotX < 0 || pixelPlotX > 255 )
997            {
794998               continue;
795999            }
796            if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) {
1000
1001            if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) )
1002            {
7971003               lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
798               if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) {
1004
1005               if ( smsvdp.collision_buffer[pixelPlotX] != 1 )
1006               {
7991007                  smsvdp.collision_buffer[pixelPlotX] = 1;
800               } else {
1008               }
1009               else
1010               {
8011011                  smsvdp.status |= STATUS_SPRCOL;
8021012               }
8031013            }
8041014         }
8051015      }
8061016
807      if ( smsvdp.reg[0x01] & 0x02 ) {
1017      if ( smsvdp.reg[0x01] & 0x02 )
1018      {
8081019         spriteTileSelected += 2;
8091020         pattern = spritePatternTable[ spriteTileSelected * 8 + spriteLine ];
8101021         spriteX += ( smsvdp.reg[0x01] & 0x01 ? 16 : 8 );
811         for ( pixelX = 0; pixelX < 8; pixelX++ ) {
812            if ( smsvdp.reg[0x01] & 0x01 ) {
1022
1023         for ( pixelX = 0; pixelX < 8; pixelX++ )
1024         {
1025            if ( smsvdp.reg[0x01] & 0x01 )
1026            {
8131027               pixelPlotX = spriteX + pixelX * 2;
814               if ( pixelPlotX < 0 || pixelPlotX > 255 ) {
1028
1029               if ( pixelPlotX < 0 || pixelPlotX > 255 )
1030               {
8151031                  continue;
8161032               }
817               if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) {
1033
1034               if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) )
1035               {
8181036                  lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
819                  if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) {
1037
1038                  if ( smsvdp.collision_buffer[pixelPlotX] != 1 )
1039                  {
8201040                     smsvdp.collision_buffer[pixelPlotX] = 1;
821                  } else {
1041                  }
1042                  else
1043                  {
8221044                     smsvdp.status |= STATUS_SPRCOL;
8231045                  }
1046
8241047                  lineBuffer[pixelPlotX+1] = smsvdp.current_palette[penSelected];
825                  if ( smsvdp.collision_buffer[pixelPlotX + 1] != 1 ) {
1048
1049                  if ( smsvdp.collision_buffer[pixelPlotX + 1] != 1 )
1050                  {
8261051                     smsvdp.collision_buffer[pixelPlotX + 1] = 1;
827                  } else {
1052                  }
1053                  else
1054                  {
8281055                     smsvdp.status |= STATUS_SPRCOL;
8291056                  }
8301057               }
831            } else {
1058            }
1059            else
1060            {
8321061               pixelPlotX = spriteX + pixelX;
833               if ( pixelPlotX < 0 || pixelPlotX > 255 ) {
1062
1063               if ( pixelPlotX < 0 || pixelPlotX > 255 )
1064               {
8341065                  continue;
8351066               }
836               if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) ) {
1067
1068               if ( penSelected && ( pattern & ( 1 << ( 7 - pixelX ) ) ) )
1069               {
8371070                  lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
838                  if ( smsvdp.collision_buffer[pixelPlotX] != 1 ) {
1071
1072                  if ( smsvdp.collision_buffer[pixelPlotX] != 1 )
1073                  {
8391074                     smsvdp.collision_buffer[pixelPlotX] = 1;
840                  } else {
1075                  }
1076                  else
1077                  {
8411078                     smsvdp.status |= STATUS_SPRCOL;
8421079                  }
8431080               }
r4264r4265
8471084   }
8481085}
8491086
850static void sms_refresh_line_mode2(int *lineBuffer, int line) {
1087
1088static void sms_refresh_line_mode2(int *lineBuffer, int line)
1089{
8511090   int tileColumn;
8521091   int pixelX, pixelPlotX;
8531092   UINT8 *nameTable, *colorTable, *patternTable;
r4264r4265
8601099   patternTable = smsvdp.VRAM + ( ( smsvdp.reg[0x04] & 0x04 ) << 11 );
8611100   patternMask = ( ( smsvdp.reg[0x04] & 0x03 ) << 8 ) | 0xFF;
8621101   patternOffset = ( line & 0xC0 ) << 2;
863   for ( tileColumn = 0; tileColumn < 32; tileColumn++ ) {
1102
1103   for ( tileColumn = 0; tileColumn < 32; tileColumn++ )
1104   {
8641105      UINT8 pattern;
8651106      UINT8 colors;
1107
8661108      pattern = patternTable[ ( ( ( patternOffset + nameTable[tileColumn] ) & patternMask ) * 8 ) + ( line & 0x07 ) ];
8671109      colors = colorTable[ ( ( ( patternOffset + nameTable[tileColumn] ) & colorMask ) * 8 ) + ( line & 0x07 ) ];
868      for ( pixelX = 0; pixelX < 8; pixelX++ ) {
1110
1111      for ( pixelX = 0; pixelX < 8; pixelX++ )
1112      {
8691113         UINT8 penSelected;
870         if ( pattern & ( 1 << ( 7 - pixelX ) ) ) {
1114
1115         if ( pattern & ( 1 << ( 7 - pixelX ) ) )
1116         {
8711117            penSelected = colors >> 4;
872         } else {
1118         }
1119         else
1120         {
8731121            penSelected = colors & 0x0F;
8741122         }
875         if ( ! penSelected ) {
1123
1124         if ( ! penSelected )
1125         {
8761126            penSelected = BACKDROP_COLOR;
8771127         }
1128
8781129         pixelPlotX = ( tileColumn << 3 ) + pixelX;
879         if ( IS_GAMEGEAR_VDP ) {
1130
1131         if ( IS_GAMEGEAR_VDP )
1132         {
8801133            penSelected |= 0x10;
8811134         }
1135
8821136         lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
8831137      }
8841138   }
r4264r4265
8871141   sms_refresh_tms9918_sprites( lineBuffer, line );
8881142}
8891143
890static void sms_refresh_line_mode0(int *lineBuffer, int line) {
1144
1145static void sms_refresh_line_mode0(int *lineBuffer, int line)
1146{
8911147   int tileColumn;
8921148   int pixelX, pixelPlotX;
8931149   UINT8 *nameTable, *colorTable, *patternTable;
r4264r4265
8961152   nameTable = smsvdp.VRAM + ( ( smsvdp.reg[0x02] & 0x0F ) << 10 ) + ( ( line >> 3 ) * 32 );
8971153   colorTable = smsvdp.VRAM + ( ( smsvdp.reg[0x03] << 6 ) & ( VRAM_SIZE - 1 ) );
8981154   patternTable = smsvdp.VRAM + ( ( smsvdp.reg[0x04] << 11 ) & ( VRAM_SIZE - 1 ) );
899   for ( tileColumn = 0; tileColumn < 32; tileColumn++ ) {
1155
1156   for ( tileColumn = 0; tileColumn < 32; tileColumn++ )
1157   {
9001158      UINT8 pattern;
9011159      UINT8 colors;
1160
9021161      pattern = patternTable[ ( nameTable[tileColumn] * 8 ) + ( line & 0x07 ) ];
9031162      colors = colorTable[ nameTable[tileColumn] >> 3 ];
904      for ( pixelX = 0; pixelX < 8; pixelX++ ) {
1163
1164      for ( pixelX = 0; pixelX < 8; pixelX++ )
1165      {
9051166         int penSelected;
906         if ( pattern & ( 1 << ( 7 - pixelX ) ) ) {
1167
1168         if ( pattern & ( 1 << ( 7 - pixelX ) ) )
1169         {
9071170            penSelected = colors >> 4;
908         } else {
1171         }
1172         else
1173         {
9091174            penSelected = colors & 0x0F;
9101175         }
911         if ( IS_GAMEGEAR_VDP ) {
1176
1177         if ( IS_GAMEGEAR_VDP )
1178         {
9121179            penSelected |= 0x10;
9131180         }
1181
9141182         pixelPlotX = ( tileColumn << 3 ) + pixelX;
9151183         lineBuffer[pixelPlotX] = smsvdp.current_palette[penSelected];
9161184      }
r4264r4265
9201188   sms_refresh_tms9918_sprites( lineBuffer, line );
9211189}
9221190
923static void sms_refresh_line( running_machine *machine, bitmap_t *bitmap, int pixelOffsetX, int pixelPlotY, int line ) {
1191
1192static void sms_refresh_line( running_machine *machine, bitmap_t *bitmap, int pixelOffsetX, int pixelPlotY, int line )
1193{
9241194   int x;
9251195   int *blitLineBuffer = smsvdp.line_buffer;
9261196
927   if ( line >= 0 && line < smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V] ) {
928      switch( smsvdp.vdp_mode ) {
1197   if ( line >= 0 && line < smsvdp.sms_frame_timing[ACTIVE_DISPLAY_V] )
1198   {
1199      switch( smsvdp.vdp_mode )
1200      {
9291201      case 0:
9301202         sms_refresh_line_mode0( blitLineBuffer, line );
9311203         break;
1204
9321205      case 2:
9331206         sms_refresh_line_mode2( blitLineBuffer, line );
9341207         break;
1208
9351209      case 4:
9361210      default:
9371211         sms_refresh_line_mode4( blitLineBuffer, line );
9381212         break;
9391213      }
940   } else {
941      for ( x = 0; x < 256; x++ ) {
1214   }
1215   else
1216   {
1217      for ( x = 0; x < 256; x++ )
1218      {
9421219         blitLineBuffer[x] = smsvdp.current_palette[BACKDROP_COLOR];
9431220      }
9441221   }
9451222
946   if ( IS_GAMEGEAR_VDP && smsvdp.gg_sms_mode ) {
1223   if ( IS_GAMEGEAR_VDP && smsvdp.gg_sms_mode )
1224   {
9471225      int *combineLineBuffer = smsvdp.line_buffer + ( ( line & 0x03 ) + 1 ) * 256;
9481226      int plotX = 48;
9491227
9501228      /* Do horizontal scaling */
951      for( x = 8; x < 248; ) {
1229      for( x = 8; x < 248; )
1230      {
9521231         int   combined;
9531232
9541233         /* Take red and green from first pixel, and blue from second pixel */
r4264r4265
9811260
9821261         /* First make sure there's enough data to draw anything */
9831262         /* We need one more line of data if we're on line 8, 11, 14, 17, etc */
984         if ( myLine < 6 || myLine > 220 || ( ( myLine - 8 ) % 3 == 0 ) ) {
1263         if ( myLine < 6 || myLine > 220 || ( ( myLine - 8 ) % 3 == 0 ) )
1264         {
9851265            return;
9861266         }
1267
9871268         ggLine = ( ( myLine - 6 ) / 3 ) * 2;
1269
9881270         /* If we're on SMS line 7, 10, 13, etc we're on an odd GG line */
989         if ( myLine % 3 ) {
1271         if ( myLine % 3 )
1272         {
9901273            ggLine++;
9911274         }
1275
9921276         /* Calculate the line we will be drawing on */
9931277         pixelPlotY = TBORDER_START + NTSC_192_TBORDER_Y_PIXELS + 24 + ggLine;
9941278
r4264r4265
9981282         line3 = smsvdp.line_buffer + ( ( ( myLine - 1 ) & 0x03 ) + 1 ) * 256;
9991283         line4 = smsvdp.line_buffer + ( ( ( myLine - 0 ) & 0x03 ) + 1 ) * 256;
10001284
1001         for( x = 0+48; x < 160+48; x++ ) {
1285         for( x = 0+48; x < 160+48; x++ )
1286         {
10021287            rgb_t   c1 = machine->pens[line1[x]];
10031288            rgb_t   c2 = machine->pens[line2[x]];
10041289            rgb_t   c3 = machine->pens[line3[x]];
r4264r4265
10131298      blitLineBuffer = combineLineBuffer;
10141299   }
10151300
1016   for( x = 0; x < 256; x++ ) {
1301   for( x = 0; x < 256; x++ )
1302   {
10171303      *BITMAP_ADDR32( bitmap, pixelPlotY + line, pixelOffsetX + x) = machine->pens[blitLineBuffer[x]];
10181304   }
10191305}
10201306
1021static void sms_update_palette(void) {
1307
1308static void sms_update_palette(void)
1309{
10221310   int i;
10231311
10241312   /* Exit if palette is has no changes */
1025   if (smsvdp.cram_dirty == 0) {
1313   if (smsvdp.cram_dirty == 0)
1314   {
10261315      return;
10271316   }
10281317   smsvdp.cram_dirty = 0;
10291318
1030   if ( smsvdp.vdp_mode != 4 && ! IS_GAMEGEAR_VDP ) {
1031      for( i = 0; i < 16; i++ ) {
1319   if ( smsvdp.vdp_mode != 4 && ! IS_GAMEGEAR_VDP )
1320   {
1321      for( i = 0; i < 16; i++ )
1322      {
10321323         smsvdp.current_palette[i] = 64+i;
10331324      }
10341325      return;
10351326   }
10361327
1037   if ( IS_GAMEGEAR_VDP ) {
1038      if ( smsvdp.gg_sms_mode ) {
1039         for ( i = 0; i < 32; i++ ) {
1328   if ( IS_GAMEGEAR_VDP )
1329   {
1330      if ( smsvdp.gg_sms_mode )
1331      {
1332         for ( i = 0; i < 32; i++ )
1333         {
10401334            smsvdp.current_palette[i] = ( ( smsvdp.CRAM[i] & 0x30 ) << 6 ) | ( ( smsvdp.CRAM[i] & 0x0C ) << 4 ) | ( ( smsvdp.CRAM[i] & 0x03 ) << 2 );
10411335         }
1042      } else {
1043         for ( i = 0; i < 32; i++ ) {
1336      }
1337      else
1338      {
1339         for ( i = 0; i < 32; i++ )
1340         {
10441341            smsvdp.current_palette[i] = ( ( smsvdp.CRAM[i*2+1] << 8 ) | smsvdp.CRAM[i*2] ) & 0x0FFF;
10451342         }
10461343      }
1047   } else {
1048      for ( i = 0; i < 32; i++ ) {
1344   }
1345   else
1346   {
1347      for ( i = 0; i < 32; i++ )
1348      {
10491349         smsvdp.current_palette[i] = smsvdp.CRAM[i] & 0x3F;
10501350      }
10511351   }
10521352}
10531353
1354
10541355VIDEO_UPDATE(sms)
10551356{
10561357   int width = video_screen_get_width(screen);
10571358   int height = video_screen_get_height(screen);
10581359   int x, y;
10591360
1060   if (smsvdp.prev_bitmap_saved) {
1061   for (y = 0; y < height; y++) {
1062      for (x = 0; x < width; x++) {
1063         *BITMAP_ADDR32(bitmap, y, x) = (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x)) >> 2;
1064         logerror("%x %x %x\n", *BITMAP_ADDR32(tmpbitmap, y, x), *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x), (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x)) >> 2);
1361   if (smsvdp.prev_bitmap_saved)
1362   {
1363      for (y = 0; y < height; y++)
1364      {
1365         for (x = 0; x < width; x++)
1366         {
1367            *BITMAP_ADDR32(bitmap, y, x) = (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x)) >> 2;
1368            logerror("%x %x %x\n", *BITMAP_ADDR32(tmpbitmap, y, x), *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x), (*BITMAP_ADDR32(tmpbitmap, y, x) + *BITMAP_ADDR32(smsvdp.prev_bitmap, y, x)) >> 2);
1369         }
10651370      }
10661371   }
1067   } else {
1372   else
1373   {
10681374      copybitmap(bitmap, tmpbitmap, 0, 0, 0, 0, cliprect);
10691375   }
1070   if (!smsvdp.prev_bitmap_saved) {
1376
1377   if (!smsvdp.prev_bitmap_saved)
1378   {
10711379      copybitmap(smsvdp.prev_bitmap, tmpbitmap, 0, 0, 0, 0, cliprect);
10721380   //smsvdp.prev_bitmap_saved = 1;
10731381   }
1382
10741383   return 0;
10751384}
10761385
docs/messnew.txt
r4264r4265
4646- [SAMCOUPE] Added centronics printer support.  [Dirk Best]
4747
4848- [SF7000] Updated to use the new centronics support.  [Dirk Best]
49 
50- [SMS/GG] Fixed scrolling for 8 rightmost columns.  (bug #1497) [Enik Land]
4951
5052- [TI81, TI85, TI86] Added the new ROM_DEFAULT_BIOS feature to select the most
5153  recent rom versions.  [Hobie Troxell]

Previous 15994 Revisions Next


© 1998-2018 The MESS Team