Previous 15994 Revisions Next

r4515 Saturday 18th April, 2009 at 22:04:33 UTC by Wilbert Pol
K1GE/K2GE graphics emulation.
[src/mess/video]k1ge.c* k1ge.h*

src/mess/video/k1ge.c
r0r4515
1/******************************************************************************
2
3K1GE/K2GE graphics emulation
4
5The K1GE graphics were used in the Neogeo pocket mono; the K2GE graphics were
6used in the Neogeo pocket color.
7
8******************************************************************************/
9
10#include "driver.h"
11#include "k1ge.h"
12
13typedef struct k1ge k1ge_t;
14struct k1ge
15{
16   const k1ge_interface *intf;
17   const device_config *screen;
18   devcb_resolved_write8 vblank_pin_w;
19   devcb_resolved_write8 hblank_pin_w;
20   UINT8 *vram;
21   UINT8 reg[0x800];
22   UINT8 wba_h, wba_v, wsi_h, wsi_v;
23
24   void (*draw)( const device_config *device, int line );
25
26   emu_timer *timer;
27   emu_timer *hblank_on_timer;
28   bitmap_t *bitmap;
29};
30
31
32PALETTE_INIT( k1ge )
33{
34   int i;
35
36   for ( i = 0; i < 8; i++ )
37   {
38      int j = ( i << 5 ) | ( i << 2 ) | ( i >> 1 );
39
40      palette_set_color_rgb( machine, 7-i, j, j, j );
41   }
42}
43
44
45PALETTE_INIT( k2ge )
46{
47   int r,g,b;
48
49   for ( b = 0; b < 16; b++ )
50   {
51      for ( g = 0; g < 16; g++ )
52      {
53         for ( r = 0; r < 16; r++ )
54         {
55            palette_set_color_rgb( machine, ( b << 8 ) | ( g << 4 ) | r, ( r << 4 ) | r, ( g << 4 ) | g, ( b << 4 ) | b );
56         }
57      }
58   }
59}
60
61
62INLINE k1ge_t *get_safe_token( const device_config *device )
63{
64   assert( device != NULL );
65   assert( device->token != NULL );
66   assert( device->type == K1GE || device->type == K2GE );
67
68   return ( k1ge_t *) device->token;
69}
70
71
72READ8_DEVICE_HANDLER( k1ge_r )
73{
74   k1ge_t   *k1ge = get_safe_token( device );
75   UINT8   data = k1ge->reg[offset & 0x7ff];
76
77   switch( offset )
78   {
79   case 0x008:      /* RAS.H */
80      data = video_screen_get_hpos( k1ge->screen ) >> 2;
81      break;
82   case 0x009:      /* RAS.V */
83      data = video_screen_get_vpos( k1ge->screen );
84      break;
85   }
86   return data;
87}
88
89
90WRITE8_DEVICE_HANDLER( k1ge_w )
91{
92   k1ge_t   *k1ge = get_safe_token( device );
93
94   switch( offset )
95   {
96   case 0x000:
97      if ( k1ge->vblank_pin_w.write != NULL )
98         devcb_call_write8( &k1ge->vblank_pin_w, 0, ( data & 0x80 ) ? ( ( k1ge->reg[0x010] & 0x40 ) ? 1 : 0 ) : 0 );
99      break;
100   case 0x030:
101      data &= 0x80;
102      break;
103   case 0x101: case 0x102: case 0x103:
104   case 0x105: case 0x106: case 0x107:
105   case 0x109: case 0x10a: case 0x10b:
106   case 0x10d: case 0x10e: case 0x10f:
107   case 0x111: case 0x112: case 0x113:
108   case 0x115: case 0x116: case 0x117:
109      data &= 0x07;
110      break;
111   case 0x7e2:
112      if ( k1ge->reg[0x7f0] != 0xAA )
113         return;
114      data &= 0x80;
115      break;
116   }
117   k1ge->reg[offset & 0x7ff] = data;
118}
119
120
121INLINE void k1ge_draw_scroll_plane( k1ge_t *k1ge, UINT16 *p, UINT16 base, int line, int scroll_x, int scroll_y, int pal_base )
122{
123   int i;
124   int offset_x = ( scroll_x >> 3 ) * 2;
125   int px = scroll_x & 0x07;
126   UINT16 map_data;
127   UINT16 hflip;
128   UINT16 pcode;
129   UINT16 tile_addr;
130   UINT16 tile_data;
131
132   base += ( ( ( ( scroll_y + line ) >> 3 ) * 0x0040 ) & 0x7ff );
133
134   /* setup */
135   map_data = k1ge->vram[ base + offset_x  ] | ( k1ge->vram[ base + offset_x + 1 ] << 8 );
136   hflip = map_data & 0x8000;
137   pcode = pal_base + ( ( map_data & 0x2000 ) ? 4 : 0 );
138   tile_addr = 0x2000 + ( ( map_data & 0x1ff ) * 16 );
139   if ( map_data & 0x4000 )
140      tile_addr += ( 7 - ( ( scroll_y + line ) & 0x07 ) ) * 2;
141   else
142      tile_addr += ( ( scroll_y + line ) & 0x07 ) * 2;
143   tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
144   if ( hflip )
145      tile_data >>= 2 * ( scroll_x & 0x07 );
146   else
147      tile_data <<= 2 * ( scroll_x & 0x07 );
148
149   /* draw pixels */
150   for ( i = 0; i < 160; i++ )
151   {
152      UINT16 col;
153
154      if ( hflip )
155      {
156         col = tile_data & 0x0003;
157         tile_data >>= 2;
158      }
159      else
160      {
161         col = tile_data >> 14;
162         tile_data <<= 2;
163      }
164
165      if ( col )
166      {
167         p[ i ] = k1ge->reg[ pcode + col ];
168      }
169
170      px++;
171      if ( px >= 8 )
172      {
173         offset_x = ( offset_x + 2 ) & 0x3f;
174         map_data = k1ge->vram[ base + offset_x ] | ( k1ge->vram[ base + offset_x + 1 ] << 8 );
175         hflip = map_data & 0x8000;
176         pcode = pal_base + ( ( map_data & 0x2000 ) ? 4 : 0 );
177         tile_addr = 0x2000 + ( ( map_data & 0x1ff ) * 16 );
178         if ( map_data & 0x4000 )
179            tile_addr += ( 7 - ( ( scroll_y + line ) & 0x07 ) ) * 2;
180         else
181            tile_addr += ( ( scroll_y + line ) & 0x07 ) * 2;
182         tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
183         px = 0;
184      }
185   }
186}
187
188
189INLINE void k1ge_draw_sprite_plane( k1ge_t *k1ge, UINT16 *p, UINT16 priority, int line, int scroll_x, int scroll_y )
190{
191   struct {
192      UINT16 spr_data;
193      UINT8 x;
194      UINT8 y;
195   } spr[64];
196   int num_sprites = 0;
197   UINT8 spr_y = 0;
198   UINT8 spr_x = 0;
199   int i;
200
201   priority <<= 11;
202
203   /* Select sprites */
204   for ( i = 0; i < 256; i += 4 )
205   {
206      UINT16 spr_data = k1ge->vram[ 0x800 + i ] | ( k1ge->vram[ 0x801 + i ] << 8 );
207      UINT8 x = k1ge->vram[ 0x802 + i ];
208      UINT8 y = k1ge->vram[ 0x803 + i ];
209
210      spr_x = ( spr_data & 0x0400 ) ? ( spr_x + x ) :  ( scroll_x + x );
211      spr_y = ( spr_data & 0x0200 ) ? ( spr_y + y ) :  ( scroll_y + y );
212
213      if ( ( spr_data & 0x1800 ) == priority )
214      {
215         if ( ( line >= spr_y || spr_y > 0xf8 ) && line < ( ( spr_y + 8 ) & 0xff ) )
216         {
217            spr[num_sprites].spr_data = spr_data;
218            spr[num_sprites].y = spr_y;
219            spr[num_sprites].x = spr_x;
220            num_sprites++;
221         }
222      }
223   }
224
225   /* Draw sprites */
226   for ( i = num_sprites-1; i >= 0; i-- )
227   {
228      int j;
229      UINT16 tile_addr;
230      UINT16 tile_data;
231      UINT16 pcode = 0x100 + ( ( spr[i].spr_data & 0x2000 ) ? 4 : 0 );
232
233      tile_addr = 0x2000 + ( ( spr[i].spr_data & 0x1ff ) * 16 );
234      if ( spr[i].spr_data & 0x4000 )
235         tile_addr += ( 7 - ( line - spr[i].y ) ) * 2;
236      else
237         tile_addr += ( line - spr[i].y ) * 2;
238      tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
239
240      for ( j = 0; j < 8; j++ )
241      {
242         UINT16 col;
243
244         spr_x = spr[i].x + j;
245
246         if ( spr[i].spr_data & 0x8000 )
247         {
248            col = tile_data & 0x03;
249            tile_data >>= 2;
250         }
251         else
252         {
253            col = tile_data >> 14;
254            tile_data <<= 2;
255         }
256
257         if ( spr_x < 160 && col )
258         {
259            p[ spr_x ] = k1ge->reg[ pcode + col ];
260         }
261      }
262   }
263}
264
265
266static void k1ge_draw( const device_config *device, int line )
267{
268   k1ge_t *k1ge = get_safe_token( device );
269   UINT16 *p = BITMAP_ADDR16( k1ge->bitmap, line, 0 );
270   int i;
271
272   if ( line < k1ge->wba_v || line >= k1ge->wba_v + k1ge->wsi_v )
273   {
274      for( i = 0; i < 160; i++ )
275      {
276         p[i] = k1ge->reg[0x012] & 0x07;
277      }
278   }
279   else
280   {
281      for ( i = 0; i < 160; i++ )
282         p[i] = 0;
283
284      if ( k1ge->reg[0x030] & 0x80 )
285      {
286         /* Draw sprites with 01 priority */
287         k1ge_draw_sprite_plane( k1ge, p, 1, line, k1ge->reg[0x020], k1ge->reg[0x021] );
288
289         /* Draw PF1 */
290         k1ge_draw_scroll_plane( k1ge, p, 0x1000, line, k1ge->reg[0x032], k1ge->reg[0x033], 0x108 );
291
292         /* Draw sprites with 10 priority */
293         k1ge_draw_sprite_plane( k1ge, p, 2, line, k1ge->reg[0x020], k1ge->reg[0x021] );
294
295         /* Draw PF2 */
296         k1ge_draw_scroll_plane( k1ge, p, 0x1800, line, k1ge->reg[0x034], k1ge->reg[0x035], 0x110 );
297
298         /* Draw sprites with 11 priority */
299         k1ge_draw_sprite_plane( k1ge, p, 3, line, k1ge->reg[0x020], k1ge->reg[0x021] );
300      }
301      else
302      {
303         /* Draw sprites with 01 priority */
304         k1ge_draw_sprite_plane( k1ge, p, 1, line, k1ge->reg[0x020], k1ge->reg[0x021] );
305
306         /* Draw PF2 */
307         k1ge_draw_scroll_plane( k1ge, p, 0x1800, line, k1ge->reg[0x034], k1ge->reg[0x035], 0x110 );
308
309         /* Draw sprites with 10 priority */
310         k1ge_draw_sprite_plane( k1ge, p, 2, line, k1ge->reg[0x020], k1ge->reg[0x021] );
311
312         /* Draw PF1 */
313         k1ge_draw_scroll_plane( k1ge, p, 0x1000, line, k1ge->reg[0x032], k1ge->reg[0x033], 0x108 );
314
315         /* Draw sprites with 11 priority */
316         k1ge_draw_sprite_plane( k1ge, p, 3, line, k1ge->reg[0x020], k1ge->reg[0x021] );
317      }
318
319      for( i = 0; i < k1ge->wba_h; i++ )
320      {       
321         p[i] = k1ge->reg[0x012] & 0x07;
322      }
323
324      for( i = k1ge->wba_h + k1ge->wsi_h; i < 160; i++ )
325      {       
326         p[i] = k1ge->reg[0x012] & 0x07;
327      }
328   }
329}
330
331
332INLINE void k2ge_draw_scroll_plane( k1ge_t *k1ge, UINT16 *p, UINT16 base, int line, int scroll_x, int scroll_y, UINT16 pal_base )
333{
334   int i;
335   int offset_x = ( scroll_x >> 3 ) * 2;
336   int px = scroll_x & 0x07;
337   UINT16 map_data;
338   UINT16 hflip;
339   UINT16 pcode;
340   UINT16 tile_addr;
341   UINT16 tile_data;
342
343   base += ( ( ( ( scroll_y + line ) >> 3 ) * 0x0040 ) & 0x7ff );
344
345   /* setup */
346   map_data = k1ge->vram[ base + offset_x  ] | ( k1ge->vram[ base + offset_x + 1 ] << 8 );
347   hflip = map_data & 0x8000;
348   pcode = pal_base + ( ( map_data & 0x1e00 ) >> 6 );
349   tile_addr = 0x2000 + ( ( map_data & 0x1ff ) * 16 );
350   if ( map_data & 0x4000 )
351      tile_addr += ( 7 - ( ( scroll_y + line ) & 0x07 ) ) * 2;
352   else
353      tile_addr += ( ( scroll_y + line ) & 0x07 ) * 2;
354   tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
355   if ( hflip )
356      tile_data >>= 2 * ( scroll_x & 0x07 );
357   else
358      tile_data <<= 2 * ( scroll_x & 0x07 );
359
360   /* draw pixels */
361   for ( i = 0; i < 160; i++ )
362   {
363      UINT16 col;
364
365      if ( hflip )
366      {
367         col = tile_data & 0x0003;
368         tile_data >>= 2;
369      }
370      else
371      {
372         col = tile_data >> 14;
373         tile_data <<= 2;
374      }
375
376      if ( col )
377      {
378         p[ i ]  = k1ge->reg[ pcode + col * 2 ] | ( k1ge->reg[ pcode + col * 2 + 1 ] << 8 );
379      }
380
381      px++;
382      if ( px >= 8 )
383      {
384         offset_x = ( offset_x + 2 ) & 0x3f;
385         map_data = k1ge->vram[ base + offset_x ] | ( k1ge->vram[ base + offset_x + 1 ] << 8 );
386         hflip = map_data & 0x8000;
387         pcode = pal_base + ( ( map_data & 0x1e00 ) >> 6 );
388         tile_addr = 0x2000 + ( ( map_data & 0x1ff ) * 16 );
389         if ( map_data & 0x4000 )
390            tile_addr += ( 7 - ( ( scroll_y + line ) & 0x07 ) ) * 2;
391         else
392            tile_addr += ( ( scroll_y + line ) & 0x07 ) * 2;
393         tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
394         px = 0;
395      }
396   }
397}
398
399
400INLINE void k2ge_draw_sprite_plane( k1ge_t *k1ge, UINT16 *p, UINT16 priority, int line, int scroll_x, int scroll_y )
401{
402   struct {
403      UINT16 spr_data;
404      UINT8 x;
405      UINT8 y;
406      UINT8 index;
407   } spr[64];
408   int num_sprites = 0;
409   UINT8 spr_y = 0;
410   UINT8 spr_x = 0;
411   int i;
412
413   priority <<= 11;
414
415   /* Select sprites */
416   for ( i = 0; i < 256; i += 4 )
417   {
418      UINT16 spr_data = k1ge->vram[ 0x800 + i ] | ( k1ge->vram[ 0x801 + i ] << 8 );
419      UINT8 x = k1ge->vram[ 0x802 + i ];
420      UINT8 y = k1ge->vram[ 0x803 + i ];
421
422      spr_x = ( spr_data & 0x0400 ) ? ( spr_x + x ) :  ( scroll_x + x );
423      spr_y = ( spr_data & 0x0200 ) ? ( spr_y + y ) :  ( scroll_y + y );
424
425      if ( ( spr_data & 0x1800 ) == priority )
426      {
427         if ( ( line >= spr_y || spr_y > 0xf8 ) && line < ( ( spr_y + 8 ) & 0xff ) )
428         {
429            spr[num_sprites].spr_data = spr_data;
430            spr[num_sprites].y = spr_y;
431            spr[num_sprites].x = spr_x;
432            spr[num_sprites].index = i >> 2;
433            num_sprites++;
434         }
435      }
436   }
437
438   /* Draw sprites */
439   for ( i = num_sprites-1; i >= 0; i-- )
440   {
441      int j;
442      UINT16 tile_addr;
443      UINT16 tile_data;
444      UINT16 pcode = 0x0200 + ( ( k1ge->vram[0x0c00 + spr[i].index ] & 0x0f ) << 3 );
445
446      tile_addr = 0x2000 + ( ( spr[i].spr_data & 0x1ff ) * 16 );
447      if ( spr[i].spr_data & 0x4000 )
448         tile_addr += ( 7 - ( line - spr[i].y ) ) * 2;
449      else
450         tile_addr += ( line - spr[i].y ) * 2;
451      tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
452
453      for ( j = 0; j < 8; j++ )
454      {
455         UINT16 col;
456
457         spr_x = spr[i].x + j;
458
459         if ( spr[i].spr_data & 0x8000 )
460         {
461            col = tile_data & 0x03;
462            tile_data >>= 2;
463         }
464         else
465         {
466            col = tile_data >> 14;
467            tile_data <<= 2;
468         }
469
470         if ( spr_x < 160 && col )
471         {
472            p[ spr_x ] = k1ge->reg[ pcode + col * 2 ] | ( k1ge->reg[ pcode + col * 2 + 1 ] << 8 );
473         }
474      }
475   }
476}
477
478
479INLINE void k2ge_k1ge_draw_scroll_plane( k1ge_t *k1ge, UINT16 *p, UINT16 base, int line, int scroll_x, int scroll_y, UINT16 pal_lut_base, UINT16 k2ge_lut_base )
480{
481   int i;
482   int offset_x = ( scroll_x >> 3 ) * 2;
483   int px = scroll_x & 0x07;
484   UINT16 map_data;
485   UINT16 hflip;
486   UINT16 pcode;
487   UINT16 tile_addr;
488   UINT16 tile_data;
489
490   base += ( ( ( ( scroll_y + line ) >> 3 ) * 0x0040 ) & 0x7ff );
491
492   /* setup */
493   map_data = k1ge->vram[ base + offset_x  ] | ( k1ge->vram[ base + offset_x + 1 ] << 8 );
494   hflip = map_data & 0x8000;
495   pcode = ( map_data & 0x2000 ) ? 1 : 0;
496   tile_addr = 0x2000 + ( ( map_data & 0x1ff ) * 16 );
497   if ( map_data & 0x4000 )
498      tile_addr += ( 7 - ( ( scroll_y + line ) & 0x07 ) ) * 2;
499   else
500      tile_addr += ( ( scroll_y + line ) & 0x07 ) * 2;
501   tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
502   if ( hflip )
503      tile_data >>= 2 * ( scroll_x & 0x07 );
504   else
505      tile_data <<= 2 * ( scroll_x & 0x07 );
506
507   /* draw pixels */
508   for ( i = 0; i < 160; i++ )
509   {
510      UINT16 col;
511
512      if ( hflip )
513      {
514         col = tile_data & 0x0003;
515         tile_data >>= 2;
516      }
517      else
518      {
519         col = tile_data >> 14;
520         tile_data <<= 2;
521      }
522
523      if ( col )
524      {
525         UINT16 col2 = 16 * pcode + ( k1ge->reg[ pal_lut_base + 4 * pcode + col ] * 2 );
526         p[ i ]  = k1ge->reg[ k2ge_lut_base + col2 ] | ( k1ge->reg[ k2ge_lut_base + col2 + 1 ] << 8 );;
527      }
528
529      px++;
530      if ( px >= 8 )
531      {
532         offset_x = ( offset_x + 2 ) & 0x3f;
533         map_data = k1ge->vram[ base + offset_x ] | ( k1ge->vram[ base + offset_x + 1 ] << 8 );
534         hflip = map_data & 0x8000;
535         pcode = ( map_data & 0x2000 ) ? 1 : 0;
536         tile_addr = 0x2000 + ( ( map_data & 0x1ff ) * 16 );
537         if ( map_data & 0x4000 )
538            tile_addr += ( 7 - ( ( scroll_y + line ) & 0x07 ) ) * 2;
539         else
540            tile_addr += ( ( scroll_y + line ) & 0x07 ) * 2;
541         tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
542         px = 0;
543      }
544   }
545}
546
547
548INLINE void k2ge_k1ge_draw_sprite_plane( k1ge_t *k1ge, UINT16 *p, UINT16 priority, int line, int scroll_x, int scroll_y )
549{
550   struct {
551      UINT16 spr_data;
552      UINT8 x;
553      UINT8 y;
554   } spr[64];
555   int num_sprites = 0;
556   UINT8 spr_y = 0;
557   UINT8 spr_x = 0;
558   int i;
559
560   priority <<= 11;
561
562   /* Select sprites */
563   for ( i = 0; i < 256; i += 4 )
564   {
565      UINT16 spr_data = k1ge->vram[ 0x800 + i ] | ( k1ge->vram[ 0x801 + i ] << 8 );
566      UINT8 x = k1ge->vram[ 0x802 + i ];
567      UINT8 y = k1ge->vram[ 0x803 + i ];
568
569      spr_x = ( spr_data & 0x0400 ) ? ( spr_x + x ) :  ( scroll_x + x );
570      spr_y = ( spr_data & 0x0200 ) ? ( spr_y + y ) :  ( scroll_y + y );
571
572      if ( ( spr_data & 0x1800 ) == priority )
573      {
574         if ( ( line >= spr_y || spr_y > 0xf8 ) && line < ( ( spr_y + 8 ) & 0xff ) )
575         {
576            spr[num_sprites].spr_data = spr_data;
577            spr[num_sprites].y = spr_y;
578            spr[num_sprites].x = spr_x;
579            num_sprites++;
580         }
581      }
582   }
583
584   /* Draw sprites */
585   for ( i = num_sprites-1; i >= 0; i-- )
586   {
587      int j;
588      UINT16 tile_addr;
589      UINT16 tile_data;
590      UINT16 pcode = ( spr[i].spr_data & 0x2000 ) ? 1 : 0;
591
592      tile_addr = 0x2000 + ( ( spr[i].spr_data & 0x1ff ) * 16 );
593      if ( spr[i].spr_data & 0x4000 )
594         tile_addr += ( 7 - ( line - spr[i].y ) ) * 2;
595      else
596         tile_addr += ( line - spr[i].y ) * 2;
597      tile_data = k1ge->vram[ tile_addr ] | ( k1ge->vram[ tile_addr + 1 ] << 8 );
598
599      for ( j = 0; j < 8; j++ )
600      {
601         UINT16 col;
602
603         spr_x = spr[i].x + j;
604
605         if ( spr[i].spr_data & 0x8000 )
606         {
607            col = tile_data & 0x03;
608            tile_data >>= 2;
609         }
610         else
611         {
612            col = tile_data >> 14;
613            tile_data <<= 2;
614         }
615
616         if ( spr_x < 160 && col )
617         {
618            UINT16 col2 = 16 * pcode + k1ge->reg[ 0x100 + 4 * pcode + col ] * 2;
619            p[ spr_x ] = k1ge->reg[ 0x380 + col2 ] | ( k1ge->reg[ 0x381 + col2 ] << 8 );
620         }
621      }
622   }
623}
624
625
626static void k2ge_draw( const device_config *device, int line )
627{
628   k1ge_t *k1ge = get_safe_token( device );
629   UINT16 *p = BITMAP_ADDR16( k1ge->bitmap, line, 0 );
630   UINT16 col;
631   int i;
632
633   if ( line < k1ge->wba_v || line >= k1ge->wba_v + k1ge->wsi_v )
634   {
635      col = ( k1ge->reg[0x012] & 0x07 ) * 2;
636      col = k1ge->reg[0x3f0 + col ] | ( k1ge->reg[0x3f1 + col ] << 8 );
637
638      for( i = 0; i < 160; i++ )
639      {
640         p[i] = col;
641      }
642   }
643   else
644   {
645      if ( ( k1ge->reg[0x118] & 0xc0 ) == 0x80 )
646      {
647         col = ( k1ge->reg[0x118] & 0x07 ) * 2;
648         col = k1ge->reg[0x3e0 + col ] | ( k1ge->reg[0x3e1 + col ] << 8 );
649
650         for ( i = 0; i < 160; i++ )
651         {
652            p[i] = col;
653         }
654      }
655
656      if ( k1ge->reg[0x7e2] & 0x80 )
657      {
658         /* K1GE compatibility mode */
659         if ( k1ge->reg[0x030] & 0x80 )
660         {
661            /* Draw sprites with 01 priority */
662            k2ge_k1ge_draw_sprite_plane( k1ge, p, 1, line, k1ge->reg[0x020], k1ge->reg[0x021] );
663
664            /* Draw PF1 */
665            k2ge_k1ge_draw_scroll_plane( k1ge, p, 0x1000, line, k1ge->reg[0x032], k1ge->reg[0x033], 0x108, 0x3a0 );
666
667            /* Draw sprites with 10 priority */
668            k2ge_k1ge_draw_sprite_plane( k1ge, p, 2, line, k1ge->reg[0x020], k1ge->reg[0x021] );
669
670            /* Draw PF2 */
671            k2ge_k1ge_draw_scroll_plane( k1ge, p, 0x1800, line, k1ge->reg[0x034], k1ge->reg[0x035], 0x110, 0x3c0 );
672
673            /* Draw sprites with 11 priority */
674            k2ge_k1ge_draw_sprite_plane( k1ge, p, 3, line, k1ge->reg[0x020], k1ge->reg[0x021] );
675         }
676         else
677         {
678            /* Draw sprites with 01 priority */
679            k2ge_k1ge_draw_sprite_plane( k1ge, p, 1, line, k1ge->reg[0x020], k1ge->reg[0x021] );
680
681            /* Draw PF2 */
682            k2ge_k1ge_draw_scroll_plane( k1ge, p, 0x1800, line, k1ge->reg[0x034], k1ge->reg[0x035], 0x110, 0x3c0 );
683
684            /* Draw sprites with 10 priority */
685            k2ge_k1ge_draw_sprite_plane( k1ge, p, 2, line, k1ge->reg[0x020], k1ge->reg[0x021] );
686
687            /* Draw PF1 */
688            k2ge_k1ge_draw_scroll_plane( k1ge, p, 0x1000, line, k1ge->reg[0x032], k1ge->reg[0x033], 0x108, 0x3a0 );
689
690            /* Draw sprites with 11 priority */
691            k2ge_k1ge_draw_sprite_plane( k1ge, p, 3, line, k1ge->reg[0x020], k1ge->reg[0x021] );
692         }
693      }
694      else
695      {
696         /* K2GE mode */
697         if ( k1ge->reg[0x030] & 0x80 )
698         {
699            /* Draw sprites with 01 priority */
700            k2ge_draw_sprite_plane( k1ge, p, 1, line, k1ge->reg[0x020], k1ge->reg[0x021] );
701
702            /* Draw PF1 */
703            k2ge_draw_scroll_plane( k1ge, p, 0x1000, line, k1ge->reg[0x032], k1ge->reg[0x033], 0x280 );
704
705            /* Draw sprites with 10 priority */
706            k2ge_draw_sprite_plane( k1ge, p, 2, line, k1ge->reg[0x020], k1ge->reg[0x021] );
707
708            /* Draw PF2 */
709            k2ge_draw_scroll_plane( k1ge, p, 0x1800, line, k1ge->reg[0x034], k1ge->reg[0x035], 0x300 );
710
711            /* Draw sprites with 11 priority */
712            k2ge_draw_sprite_plane( k1ge, p, 3, line, k1ge->reg[0x020], k1ge->reg[0x021] );
713         }
714         else
715         {
716            /* Draw sprites with 01 priority */
717            k2ge_draw_sprite_plane( k1ge, p, 1, line, k1ge->reg[0x020], k1ge->reg[0x021] );
718
719            /* Draw PF2 */
720            k2ge_draw_scroll_plane( k1ge, p, 0x1800, line, k1ge->reg[0x034], k1ge->reg[0x035], 0x300 );
721
722            /* Draw sprites with 10 priority */
723            k2ge_draw_sprite_plane( k1ge, p, 2, line, k1ge->reg[0x020], k1ge->reg[0x021] );
724
725            /* Draw PF1 */
726            k2ge_draw_scroll_plane( k1ge, p, 0x1000, line, k1ge->reg[0x032], k1ge->reg[0x033], 0x280 );
727
728            /* Draw sprites with 11 priority */
729            k2ge_draw_sprite_plane( k1ge, p, 3, line, k1ge->reg[0x020], k1ge->reg[0x021] );
730         }
731      }
732   }
733}
734
735
736static TIMER_CALLBACK( k1ge_hblank_on_timer_callback )
737{
738   const device_config *device = ptr;
739   k1ge_t *k1ge = get_safe_token( device );
740
741   if ( k1ge->hblank_pin_w.write != NULL )
742      devcb_call_write8( &k1ge->hblank_pin_w, 0, 0 );
743}
744
745
746static TIMER_CALLBACK( k1ge_timer_callback )
747{
748   const device_config *device = ptr;
749   k1ge_t *k1ge = get_safe_token( device );
750   int y = video_screen_get_vpos( k1ge->screen );
751
752   /* Check for start of VBlank */
753   if ( y >= 152 )
754   {
755      k1ge->reg[0x010] |= 0x40;
756      if ( ( k1ge->reg[0x000] & 0x80 ) && k1ge->vblank_pin_w.write != NULL )
757            devcb_call_write8( &k1ge->vblank_pin_w, 0, 1 );
758   }
759
760   /* Check for end of VBlank */
761   if ( y == 0 )
762   {
763      k1ge->wba_h = k1ge->reg[0x002];
764      k1ge->wba_v = k1ge->reg[0x003];
765      k1ge->wsi_h = k1ge->reg[0x004];
766      k1ge->wsi_v = k1ge->reg[0x005];
767      k1ge->reg[0x010] &= ~ 0x40;
768      if ( ( k1ge->reg[0x000] & 0x80 ) && k1ge->vblank_pin_w.write != NULL )
769         devcb_call_write8( &k1ge->vblank_pin_w, 0, 0 );
770   }
771
772   /* Check if Hint should be triggered */
773   if ( y == K1GE_SCREEN_HEIGHT - 1 || y < 151 )
774   {
775      if ( k1ge->hblank_pin_w.write != NULL )
776      {
777         if ( k1ge->reg[0x000] & 0x40 )
778            devcb_call_write8( &k1ge->hblank_pin_w, 0, 1 );
779         timer_adjust_oneshot( k1ge->hblank_on_timer, video_screen_get_time_until_pos( k1ge->screen, y, 480 ), 0 );
780      }
781   }
782
783   /* Draw a line when inside visible area */
784   if ( y < 152 )
785   {
786      k1ge->draw( device, y );
787   }
788
789   timer_adjust_oneshot( k1ge->timer, video_screen_get_time_until_pos( k1ge->screen, ( y + 1 ) % K1GE_SCREEN_HEIGHT, 0 ), 0 );
790}
791
792
793void k1ge_update( const device_config *device, bitmap_t *bitmap, const rectangle *cliprect )
794{
795   k1ge_t *k1ge = get_safe_token( device );
796
797   copybitmap( bitmap, k1ge->bitmap, 0, 0, 0, 0, cliprect );
798}
799
800
801static DEVICE_START( k1ge )
802{
803   k1ge_t *k1ge = get_safe_token( device );
804
805   k1ge->intf = device->static_config;
806
807   devcb_resolve_write8( &k1ge->vblank_pin_w, &k1ge->intf->vblank_pin_w, device );
808   devcb_resolve_write8( &k1ge->hblank_pin_w, &k1ge->intf->hblank_pin_w, device );
809
810   k1ge->timer = timer_alloc( device->machine, k1ge_timer_callback, (void *) device );
811   k1ge->hblank_on_timer = timer_alloc( device->machine, k1ge_hblank_on_timer_callback, (void *) device );
812   k1ge->screen = devtag_get_device( device->machine, k1ge->intf->screen_tag );
813   k1ge->vram = memory_region( device->machine, k1ge->intf->vram_tag );
814   k1ge->bitmap = auto_bitmap_alloc( video_screen_get_width(k1ge->screen), video_screen_get_height(k1ge->screen), video_screen_get_format(k1ge->screen) );
815   k1ge->draw = k1ge_draw;
816}
817
818
819static DEVICE_START( k2ge )
820{
821   k1ge_t *k1ge = get_safe_token( device );
822
823   DEVICE_START_CALL( k1ge );
824   k1ge->draw = k2ge_draw;
825}
826
827
828static DEVICE_RESET( k1ge )
829{
830   k1ge_t *k1ge = get_safe_token( device );
831
832   k1ge->reg[0x000] = 0x00;   /* Interrupt enable */
833   k1ge->reg[0x002] = 0x00;   /* WBA.H */
834   k1ge->reg[0x003] = 0x00;   /* WVA.V */
835   k1ge->reg[0x004] = 0xFF;   /* WSI.H */
836   k1ge->reg[0x005] = 0xFF;   /* WSI.V */
837   k1ge->reg[0x007] = 0xc6;   /* REF */
838   k1ge->reg[0x012] = 0x00;   /* 2D control */
839   k1ge->reg[0x020] = 0x00;   /* PO.H */
840   k1ge->reg[0x021] = 0x00;   /* PO.V */
841   k1ge->reg[0x030] = 0x00;   /* PF */
842   k1ge->reg[0x032] = 0x00;   /* S1SO.H */
843   k1ge->reg[0x033] = 0x00;   /* S1SO.V */
844   k1ge->reg[0x034] = 0x00;   /* S2SO.H */
845   k1ge->reg[0x035] = 0x00;   /* S2SO.V */
846   k1ge->reg[0x101] = 0x07;   /* SPPLT01 */
847   k1ge->reg[0x102] = 0x07;   /* SPPLT02 */
848   k1ge->reg[0x103] = 0x07;   /* SPPLT03 */
849   k1ge->reg[0x105] = 0x07;   /* SPPLT11 */
850   k1ge->reg[0x106] = 0x07;   /* SPPLT12 */
851   k1ge->reg[0x107] = 0x07;   /* SPPLT13 */
852   k1ge->reg[0x109] = 0x07;   /* SC1PLT01 */
853   k1ge->reg[0x10a] = 0x07;   /* SC1PLT02 */
854   k1ge->reg[0x10b] = 0x07;   /* SC1PLT03 */
855   k1ge->reg[0x10d] = 0x07;   /* SC1PLT11 */
856   k1ge->reg[0x10e] = 0x07;   /* SC1PLT12 */
857   k1ge->reg[0x10f] = 0x07;   /* SC1PLT13 */
858   k1ge->reg[0x111] = 0x07;   /* SC2PLT01 */
859   k1ge->reg[0x112] = 0x07;   /* SC2PLT02 */
860   k1ge->reg[0x113] = 0x07;   /* SC2PLT03 */
861   k1ge->reg[0x115] = 0x07;   /* SC2PLT11 */
862   k1ge->reg[0x116] = 0x07;   /* SC2PLT12 */
863   k1ge->reg[0x117] = 0x07;   /* SC2PLT13 */
864   k1ge->reg[0x118] = 0x07;   /* BG */
865   k1ge->reg[0x400] = 0xFF;   /* LED control */
866   k1ge->reg[0x402] = 0x80;   /* LEDFREG */
867   k1ge->reg[0x7e0] = 0x52;   /* RESET */
868   k1ge->reg[0x7e2] = 0x00;   /* MODE */
869
870   timer_adjust_oneshot( k1ge->timer, video_screen_get_time_until_pos( k1ge->screen, ( video_screen_get_vpos( k1ge->screen ) + 1 ) % K1GE_SCREEN_HEIGHT, 0 ), 0 );
871}
872
873
874static DEVICE_SET_INFO( k1ge )
875{
876}
877
878
879DEVICE_GET_INFO( k1ge )
880{
881   switch ( state )
882   {
883      /* --- the following bits of info are returned as 64-bit signed integers --- */
884      case DEVINFO_INT_TOKEN_BYTES:         info->i = sizeof( k1ge_t ); break;
885      case DEVINFO_INT_INLINE_CONFIG_BYTES:   info->i = 0; break;
886      case DEVINFO_INT_CLASS:               info->i = DEVICE_CLASS_PERIPHERAL; break;
887
888      /* --- the following bits of info are returned as pointers to data or functions --- */
889      case DEVINFO_FCT_SET_INFO:            info->set_info = DEVICE_SET_INFO_NAME( k1ge ); break;
890      case DEVINFO_FCT_START:               info->start = DEVICE_START_NAME( k1ge ); break;
891      case DEVINFO_FCT_STOP:               break;
892      case DEVINFO_FCT_RESET:               info->reset = DEVICE_RESET_NAME( k1ge ); break;
893
894      /* --- the following bits of info are returned as NULL-terminated strings --- */
895      case DEVINFO_STR_NAME:               strcpy( info->s, "SNK K1GE" ); break;
896      case DEVINFO_STR_FAMILY:            strcpy( info->s, "KxGE" ); break;
897      case DEVINFO_STR_VERSION:            strcpy( info->s, "1.0" ); break;
898      case DEVINFO_STR_SOURCE_FILE:         strcpy( info->s, __FILE__ );
899      case DEVINFO_STR_CREDITS:            strcpy( info->s, "Copyright the MESS team" ); break;
900   }
901}
902
903
904DEVICE_GET_INFO( k2ge )
905{
906   switch ( state )
907   {
908      case DEVINFO_FCT_START:               info->start = DEVICE_START_NAME( k2ge ); break;
909      default:                        DEVICE_GET_INFO_CALL( k1ge ); break;
910   }
911}
912
913
src/mess/video/k1ge.h
r0r4515
1
2#ifndef __K2GE_H_
3#define __K2GE_H_
4
5#include "devcb.h"
6
7
8#define K1GE_SCREEN_HEIGHT   199
9
10
11#define K1GE      DEVICE_GET_INFO_NAME(k1ge)
12#define K2GE      DEVICE_GET_INFO_NAME(k2ge)
13
14
15#define MDRV_K1GE_ADD(_tag, _clock, _config ) \
16   MDRV_DEVICE_ADD( _tag, K1GE, _clock ) \
17   MDRV_DEVICE_CONFIG( _config )
18
19
20#define MDRV_K2GE_ADD(_tag, _clock, _config ) \
21   MDRV_DEVICE_ADD( _tag, K2GE, _clock ) \
22   MDRV_DEVICE_CONFIG( _config )
23
24
25typedef struct _k1ge_interface k1ge_interface;
26struct _k1ge_interface
27{
28   const char      *screen_tag;      /* screen we are drawing on */
29   const char      *vram_tag;         /* memory region we will use for video ram */
30   devcb_write8   vblank_pin_w;      /* called back when VBlank pin may have changed */
31   devcb_write8   hblank_pin_w;      /* called back when HBlank pin may have changed */
32};
33
34
35PALETTE_INIT( k1ge );
36PALETTE_INIT( k2ge );
37
38
39DEVICE_GET_INFO( k1ge );
40DEVICE_GET_INFO( k2ge );
41
42
43WRITE8_DEVICE_HANDLER( k1ge_w );
44READ8_DEVICE_HANDLER( k1ge_r );
45
46void k1ge_update( const device_config *device, bitmap_t *bitmap, const rectangle *cliprect );
47
48#endif
49

Previous 15994 Revisions Next


© 1998-2018 The MESS Team