/src/mame/video/segaic16.c

https://github.com/yoshisuga/MAME4iOS · C · 2122 lines · 974 code · 294 blank · 854 comment · 175 complexity · 3404b624a11d32c09b4a2269e4f0b9dd MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /***************************************************************************

    2. 

  2. 

    3. 

  3.     Sega 16-bit common hardware

    4. 

  4. 

    5. 

  5. ****************************************************************************

    6. 

  6. 

    7. 

  7.     Hang On

    8. 

  8.     -------

    9. 

  9.         Control Board (834-5668):

    10. 

  10.             315-5011       -- sprite line comparitor

    11. 

  11.             315-5012       -- sprite generator control

    12. 

  12.             315-5049 (x2)  -- tilemaps

    13. 

  13.             315-5107 (PAL x2) -- horizontal timing control

    14. 

  14.             315-5108       -- vertical timing control

    15. 

  15.             315-5122 (PAL) -- timing

    16. 

  16. 

    17. 

  17.     Enduro Racer

    18. 

  18.     ------------

    19. 

  19.         CPU Side (171-5319):

    20. 

  20.             315-5164 (PAL)

    21. 

  21.             315-5165 (PAL)

    22. 

  22.             315-5166 (PAL)

    23. 

  23.             315-5167 (PAL)

    24. 

  24. 

    25. 

  25.         Video Side (171-5320):

    26. 

  26.             315-5049 (x2)  -- tilemaps

    27. 

  27.             315-5011       -- sprite line comparitor

    28. 

  28.             315-5012       -- sprite generator control

    29. 

  29.             315-5106 (PAL)

    30. 

  30.             315-5107 (PAL)

    31. 

  31.             315-5108 (PAL)

    32. 

  32.             315-5168 (PAL)

    33. 

  33.             315-5170 (PAL)

    34. 

  34.             315-5171 (PAL)

    35. 

  35.             315-5172 (PAL)

    36. 

  36. 

    37. 

  37.     Pre-System 16

    38. 

  38.     -------------

    39. 

  39.         Main Board (171-5335):

    40. 

  40.             315-5011       -- sprite line comparitor

    41. 

  41.             315-5012       -- sprite generator control

    42. 

  42.             315-5049 (x2)  -- tilemaps

    43. 

  43.             315-5107 (PAL) -- display timing

    44. 

  44.             315-5108 (PAL) -- display timing

    45. 

  45.             315-5141 (PAL) -- Z80 address decoding

    46. 

  46.             315-5143 (PAL) -- sprite-related?

    47. 

  47.             315-5144 (PAL) -- sprite-related?

    48. 

  48.             315-5147 (PAL) -- unknown, DTACK-related

    49. 

  49.             315-5149 (PAL) -- video mixing

    50. 

  50.             315-5193 (PAL) -- 68000/MCU interface & address decoding

    51. 

  51.             315-5202 (PAL) -- 68000/MCU interface & address decoding

    52. 

  52. 

    53. 

  53.     Sega System 16A

    54. 

  54.     ---------------

    55. 

  55.         Bottom Board (171-5307):

    56. 

  56.             315-5011       -- sprite line comparitor

    57. 

  57.             315-5012       -- sprite generator control

    58. 

  58.             315-5049 (x2)  -- tilemaps

    59. 

  59.             315-5107 (PAL) -- display timing

    60. 

  60.             315-5108 (PAL) -- display timing

    61. 

  61.             315-5143 (PAL) -- sprite-related?

    62. 

  62.             315-5144 (PAL) -- sprite-related?

    63. 

  63.             315-5145 (PAL)

    64. 

  64. 

    65. 

  65.         Top Board (171-5306):

    66. 

  66.             315-5141 (PAL) -- Z80 address decoding

    67. 

  67.             315-5142 (PAL)

    68. 

  68.             315-5149 (PAL) -- video mixing

    69. 

  69.             315-5150 (PAL)

    70. 

  70. 

    71. 

  71.     Sega System 16B

    72. 

  72.     ---------------

    73. 

  73.         Main Board (171-5357):

    74. 

  74.             315-5195       -- memory mapper

    75. 

  75.             315-5196       -- sprite generator

    76. 

  76.             315-5197       -- tilemap generator

    77. 

  77.             315-5213 (PAL) -- sprite-related

    78. 

  78.             315-5214 (PAL) -- unknown

    79. 

  79. 

    80. 

  80.         ROM Board (171-5521):

    81. 

  81.             315-5298 (PAL)

    82. 

  82. 

    83. 

  83.         ROM Board (171-5704):

    84. 

  84.             315-5298 (PAL)

    85. 

  85. 

    86. 

  86.         ROM Board (171-5797):

    87. 

  87.             315-5248       -- hardware multiplier

    88. 

  88.             315-5250       -- compare/timer

    89. 

  89.             315-5298 (PAL)

    90. 

  90. 

    91. 

  91.     Sega System 18

    92. 

  92.     --------------

    93. 

  93.         Main Board (171-5873B):

    94. 

  94.             315-5242       -- color encoder

    95. 

  95.             315-5296       -- I/O chip

    96. 

  96.             315-5313       -- VDP

    97. 

  97.             315-5360       -- memory mapper?

    98. 

  98.             315-5361       -- sprite generator

    99. 

  99.             315-5362       -- tilemap generator

    100. 

  100.             315-5373 (PAL) -- video mixing

    101. 

  101.             315-5374 (PAL) -- sprite timing

    102. 

  102.             315-5375 (PAL) -- system timing

    103. 

  103.             315-5389 (PAL) -- VDP sync

    104. 

  104.             315-5390 (PAL)

    105. 

  105.             315-5391 (PAL) -- Z80 address decoding

    106. 

  106. 

    107. 

  107.         Main Board (171-5873-02B):

    108. 

  108.             315-5242       -- color encoder

    109. 

  109.             315-5296       -- I/O chip

    110. 

  110.             315-5313       -- VDP

    111. 

  111.             315-5360       -- memory mapper?

    112. 

  112.             315-5361       -- sprite generator

    113. 

  113.             315-5362       -- tilemap generator

    114. 

  114.             315-5374 (PAL) -- sprite timing

    115. 

  115.             315-5375 (PAL) -- system timing

    116. 

  116.             315-5389 (PAL) -- VDP sync

    117. 

  117.             315-5391 (PAL) -- Z80 address decoding

    118. 

  118.             315-5430 (PAL) -- video mixing

    119. 

  119. 

    120. 

  120.         ROM Board (171-5987A):

    121. 

  121.             315-5436       -- tile/sprite banking

    122. 

  122. 

    123. 

  123.     Sega System C

    124. 

  124.     -------------

    125. 

  125.         Main Board:

    126. 

  126.             315-5242       -- color encoder

    127. 

  127.             315-5296       -- I/O chip

    128. 

  128.             315-5313       -- VDP

    129. 

  129.             315-5393 (PAL)

    130. 

  130.             315-5394 (PAL)

    131. 

  131.             315-5395 (PAL)

    132. 

  132. 

    133. 

  133.     Super Hang On

    134. 

  134.     -------------

    135. 

  135.         CPU Board 171-5376-01:

    136. 

  136.             315-5195       -- memory mapper

    137. 

  137.             315-5218       -- PCM sound controller

    138. 

  138.             315-5155 (PAL x2) -- road bit extraction

    139. 

  139.             315-5222 (PAL) -- road mixing

    140. 

  140.             315-5223a (PAL)

    141. 

  141.             315-5224 (PAL)

    142. 

  142.             315-5225 (PAL)

    143. 

  143.             315-5226 (PAL)

    144. 

  144. 

    145. 

  145.         VIDEO Board: (not the same as out run !) 171-5480

    146. 

  146.             315-5196       -- sprite generator

    147. 

  147.             315-5197       -- tilemap generator

    148. 

  148.             315-5213 (PAL) -- sprite-related

    149. 

  149.             315-5242       -- color encoder

    150. 

  150.             315-5251 (PAL)

    151. 

  151. 

    152. 

  152.     Out Run

    153. 

  153.     -------

    154. 

  154.         CPU Board 837-6063-01:

    155. 

  155.             315-5195       -- memory mapper

    156. 

  156.             315-5218       -- PCM sound controller

    157. 

  157.             315-5155 (PAL x2) -- road bit extraction

    158. 

  158.             315-5222 (PAL) -- road mixing

    159. 

  159.             315-5223a (PAL)

    160. 

  160.             315-5224 (PAL)

    161. 

  161.             315-5225 (PAL)

    162. 

  162.             315-5226 (PAL)

    163. 

  163. 

    164. 

  164.         VIDEO Board: 837-6064, 171-5377-01

    165. 

  165.             315-5197       -- tilemap generator

    166. 

  166.             315-5211       -- sprite generator

    167. 

  167.             315-5227a (PAL)

    168. 

  168.             315-5228 (PAL)

    169. 

  169.             315-5242       -- color encoder

    170. 

  170. 

    171. 

  171.     Sega System 32

    172. 

  172.     --------------

    173. 

  173.         Main Board (317-5964):

    174. 

  174.             315-5242       -- color encoder

    175. 

  175.             315-5296       -- I/O chip

    176. 

  176.             315-5385

    177. 

  177.             315-5386       -- tilemap generator

    178. 

  178.             315-5387       -- sprite generator

    179. 

  179.             315-5388       -- video mixing

    180. 

  180.             315-5441 (PAL)

    181. 

  181.             315-5476

    182. 

  182. 

    183. 

  183.     X-Board

    184. 

  184.     -------

    185. 

  185.         Main Board:

    186. 

  186.             315-5197       -- tilemap generator

    187. 

  187.             315-5211A      -- sprite generator

    188. 

  188.             315-5218       -- PCM sound controller

    189. 

  189.             315-5242       -- color encoder

    190. 

  190.             315-5248 (x2)  -- hardware multiplier

    191. 

  191.             315-5249 (x2)  -- hardware divider

    192. 

  192.             315-5250 (x2)  -- compare/timer

    193. 

  193.             315-5275       -- road generator

    194. 

  194.             315-5278 (PAL) -- sprite ROM bank control

    195. 

  195.             315-5279 (PAL) -- video mixing (Afterburner)

    196. 

  196.             315-5280 (PAL) -- Z80 address decoding

    197. 

  197.             315-5290 (PAL) -- main CPU address decoding

    198. 

  198.             315-5291 (PAL) -- main CPU address decoding

    199. 

  199.             315-5304 (PAL) -- video mixing (Line of Fire)

    200. 

  200. 

    201. 

  201.     Y-Board

    202. 

  202.     -------

    203. 

  203.         Main Board (837-6565):

    204. 

  204.             315-5218       -- PCM sound controller

    205. 

  205.             315-5248 (x3)  -- hardware multiplier

    206. 

  206.             315-5249 (x3)  -- hardware divider

    207. 

  207.             315-5280 (PAL) -- Z80 address decoding

    208. 

  208.             315-5296       -- I/O chip

    209. 

  209.             315-5314 (PAL)

    210. 

  210.             315-5315 (PAL)

    211. 

  211.             315-5316 (PAL)

    212. 

  212.             315-5317 (PAL)

    213. 

  213.             315-5318 (PAL)

    214. 

  214.             315-5328 (PAL)

    215. 

  215. 

    216. 

  216.         Video Board (837-6566):

    217. 

  217.             315-5196       -- sprite generator

    218. 

  218.             315-5213 (PAL) -- sprite-related

    219. 

  219.             315-5242       -- color encoder

    220. 

  220.             315-5305       -- sprite generator

    221. 

  221.             315-5306 (x2)  -- video sync and rotation

    222. 

  222.             315-5312       -- video mixing

    223. 

  223.             315-5319 (PAL)

    224. 

  224.             315-5325 (PAL)

    225. 

  225. 

    226. 

  226. 

    227. 

  227.     Custom parts

    228. 

  228.     ------------

    229. 

  229.                    SYS1  SYS2  HANG  ENDU  PR16  S16A  S16B  SY18  SHNG  ORUN  XBRD  YBRD  SYSC  SY24  SY32

    230. 

  230.         315-5011:   xx    xx    xx    xx    xx    xx                                                         -- sprite line comparitor

    231. 

  231.         315-5012:   xx    xx    xx    xx    xx    xx                                                         -- sprite generator control

    232. 

  232.         315-5049:         xx    x2    x2    x2    x2                                                         -- tilemap generator

    233. 

  233.         315-5195:                                       xx          xx    xx                                 -- memory mapper

    234. 

  234.         315-5196:                                       xx          xx                xx                     -- sprite genereator

    235. 

  235.         315-5197:                                       xx          xx    xx    xx                           -- tilemap generator

    236. 

  236.         315-5211:                                                         xx                                 -- sprite generator

    237. 

  237.         315-5211A:                                                              xx                           -- sprite generator

    238. 

  238.         315-5218:                                                   xx    xx    xx    xx                     -- PCM sound controller

    239. 

  239.         315-5242:                                             xx    xx    xx    xx    xx    xx    xx    xx   -- color encoder

    240. 

  240.         315-5248:                                       xx                      x2    x3                     -- hardware multiplier

    241. 

  241.         315-5249:                                                               x2    x3                     -- hardware divider

    242. 

  242.         315-5250:                                       xx                      x2                           -- compare/timer

    243. 

  243.         315-5275:                                                               xx                           -- road generator

    244. 

  244.         315-5296:                                             xx                      xx    xx          xx   -- I/O chip

    245. 

  245.         315-5305:                                                                     xx                     --

    246. 

  246.         315-5312:                                                                     xx                     -- video mixing

    247. 

  247.         315-5313:                                             xx                            xx               -- VDP

    248. 

  248.         315-5360:                                             xx                                             -- memory mapper

    249. 

  249.         315-5361:                                             xx                                             -- sprite generator

    250. 

  250.         315-5362:                                             xx                                             -- tilemap generator

    251. 

  251.         315-5385:                                                                                       xx   -- ???

    252. 

  252.         315-5386:                                                                                       xx   -- tilemap generator

    253. 

  253.         315-5387:                                                                                       xx   -- sprite generator

    254. 

  254.         315-5388:                                                                                       xx   -- video mixing

    255. 

  255.         315-5436:                                             xx                                             -- sprite/tile banking

    256. 

  256.         315-5476:                                                                                       xx   -- ????

    257. 

  257. 

    258. 

  258. ****************************************************************************

    259. 

  259. 

    260. 

  260.   Sega system16 and friends hardware

    261. 

  261. 

    262. 

  262.                CPU      Tiles      Sprites   Priority  Color     SCPU  Sound                Other

    263. 

  263. System C       68000    315-5313                       315-5242  z80   ym3438               315-5296(IO)

    264. 

  264. Space Harrier  68000x2                                 (c)       z80   ym2203 pcm(b)

    265. 

  265. System 16B     68000    315-5197   315-5196  GAL       (c)       z80   ym2151 upd7759       315-5195

    266. 

  266. After Burner   68000x2  315-5197   315-5211A GAL       315-5242  z80   ym2151 315-5218      315-5250(a) 315-5248(x2) 315-5249(x2) 315-5275(road)

    267. 

  267. System 18      68000    315-536x   315-536x            315-5242  z80   ym3834(x2) RF5c68(d) 315-3296(IO) 315-5313(vdp)

    268. 

  268. System 24      68000x2  315-5292   315-5293  315-5294  315-5242        ym2151 dac           315-5195(x3) 315-5296(IO)

    269. 

  269. Galaxy Force   68000x3             315-5296+ 315-5312  315-5242  z80   ym2151 315-5218      315-5296(IO)

    270. 

  270. System 32      V60      315-5386A  315-5387  315-5388  315-5242  z80   ym3834(x2) RF5c68(d) 315-5296(IO)

    271. 

  271. 

    272. 

  272. a) 315-5250: 68000 glue and address decoding

    273. 

  273. 

    274. 

  274. b) 8x8-bit voices entirely in TTL.  The 315-5218 is believed to be the

    275. 

  275.    integrated version of that

    276. 

  276. 

    277. 

  277. c) Resistor network and latches believed to be equivalent to the 315-5242

    278. 

  278. 

    279. 

  279. d) Also seen as 315-5476A and ASSP 5c105 and ASSP 5c68a

    280. 

  280. 

    281. 

  281. Quick review of the system16 hardware:

    282. 

  282. 

    283. 

  283.   Hang-on hardware:

    284. 

  284.     The first one.  Two tilemap planes, one sprite plane, one road

    285. 

  285.     plane.  The shadow capability doesn't seem to be used, the

    286. 

  286.     highlight/shadow switch in the 5242-equivalent is global for all

    287. 

  287.     colors.

    288. 

  288. 

    289. 

  289.   Space harrier hardware:

    290. 

  290.     Similar to hang-on, with per-color highlight/shadow selection, and

    291. 

  291.     the shadows are used.

    292. 

  292. 

    293. 

  293.   System16a / Pre-system16:

    294. 

  294.     Space harrier without the road generator.

    295. 

  295. 

    296. 

  296.   System16b:

    297. 

  297.     4-layer tilemap hardware in two pairs, with selection between each

    298. 

  298.     members on the pairs on a 8-lines basis.  Slightly better sprites.

    299. 

  299. 

    300. 

  300.   System18

    301. 

  301.     System 16b plus a genesis vdp.

    302. 

  302. 

    303. 

  303.   Outrun:

    304. 

  304.     System 16b tilemaps, frame buffered sprites with better zooming

    305. 

  305.     capabilities, and a road generator able to handle two roads

    306. 

  306.     simultaneously.

    307. 

  307. 

    308. 

  308.   Super hang-on:

    309. 

  309.     Outrun lite, with System 16b sprites instead of the frame buffered

    310. 

  310.     sprites, and only one of the two roads is actually used.

    311. 

  311. 

    312. 

  312.   X-Board:

    313. 

  313.     Outrun with a better fillrate and an even more flexible road

    314. 

  314.     generator.

    315. 

  315. 

    316. 

  316.   Y-Board:

    317. 

  317.     New design, with two sprite planes and no tilemaps.  The back

    318. 

  318.     sprite plane has a huge fillrate and the capability to have its

    319. 

  319.     frame buffer completely rotated.  Also, it has a palette

    320. 

  320.     indirection capability to allows for easier palette rotations.

    321. 

  321.     The front sprite plane is System 16b.

    322. 

  322. 

    323. 

  323.   System24:

    324. 

  324.     The odd one out.  Medium resolution.  Entirely ram-based, no

    325. 

  325.     graphics roms.  4-layer tilemap hardware in two pairs, selection

    326. 

  326.     on a 8-pixels basis.  Tile-based sprites(!) organised as a linked

    327. 

  327.     list.  The tilemap chip has been reused for model1 and model2,

    328. 

  328.     probably because they had it handy and it handles medium res.

    329. 

  329. 

    330. 

  330.   System32:

    331. 

  331.     5-layer tilemap hardware consisting of 4 independent rom-based

    332. 

  332.     layers with linescroll, lineselection, linezoom and window

    333. 

  333.     clipping capability and one simpler ram-based text plane.  Mixed

    334. 

  334.     ram/rom sprite engine with palette indirection, per-color priority

    335. 

  335.     (thankfully not actually used).  The sprite list includes jumping

    336. 

  336.     and clipping capabilities, and advanced hot-spot positioning.  The

    337. 

  337.     mixer chip adds totally dynamic priorities, alpha-blending of the

    338. 

  338.     tilemaps, per-component color control, and some other funnies we

    339. 

  339.     have not been able to decypher.

    340. 

  340. 

    341. 

  341.   ST-V (also know as Titan or the Saturn console):

    342. 

  342.     The ultimate 2D system.  Even more advanced tilemaps, with 6-dof

    343. 

  343.     roz support, alpha up to the wazoo and other niceties, known as

    344. 

  344.     the vdp2.  Ths sprite engine, vdp1, allows for any 4-point

    345. 

  345.     streching of the sprites, actually giving polygonal 3D

    346. 

  346.     capabilities.  Interestingly, the mixer capabilities took a hit,

    347. 

  347.     with no real per-sprite mixer priority, which could be considered

    348. 

  348.     annoying for a 2D system.  It still allowed some beauties like

    349. 

  349.     Radiant Silvergun.

    350. 

  350. 

    351. 

  351. ***************************************************************************/

    352. 

  352. 

    353. 

  353. #include "emu.h"

    354. 

  354. #include "segaic16.h"

    355. 

  355. #include "video/resnet.h"

    356. 

  356. 

    357. 

  357. 

    358. 

  358. 

    359. 

  359. /*************************************

    360. 

  360.  *

    361. 

  361.  *  Debugging

    362. 

  362.  *

    363. 

  363.  *************************************/

    364. 

  364. 

    365. 

  365. #define PRINT_UNUSUAL_MODES		(0)

    366. 

  366. 

    367. 

  367. 

    368. 

  368. 

    369. 

  369. 

    370. 

  370. 

    371. 

  371. 

    372. 

  372. /*************************************

    373. 

  373.  *

    374. 

  374.  *  Globals

    375. 

  375.  *

    376. 

  376.  *************************************/

    377. 

  377. 

    378. 

  378. UINT8 segaic16_display_enable;

    379. 

  379. UINT16 *segaic16_tileram_0;

    380. 

  380. UINT16 *segaic16_textram_0;

    381. 

  381. UINT16 *segaic16_roadram_0;

    382. 

  382. UINT16 *segaic16_rotateram_0;

    383. 

  383. UINT16 *segaic16_paletteram;

    384. 

  384. 

    385. 

  385. struct palette_info segaic16_palette;

    386. 

  386. struct rotate_info segaic16_rotate[SEGAIC16_MAX_ROTATE];

    387. 

  387. struct road_info segaic16_road[SEGAIC16_MAX_ROADS];

    388. 

  388. 

    389. 

  389. 

    390. 

  390. 

    391. 

  391. /*************************************

    392. 

  392.  *

    393. 

  393.  *  Statics

    394. 

  394.  *

    395. 

  395.  *************************************/

    396. 

  396. 

    397. 

  397. static struct tilemap_info bg_tilemap[SEGAIC16_MAX_TILEMAPS];

    398. 

  398. 

    399. 

  399. 

    400. 

  400. 

    401. 

  401. /*************************************

    402. 

  402.  *

    403. 

  403.  *  Misc functions

    404. 

  404.  *

    405. 

  405.  *************************************/

    406. 

  406. 

    407. 

  407. void segaic16_set_display_enable(running_machine *machine, int enable)

    408. 

  408. {

    409. 

  409. 	enable = (enable != 0);

    410. 

  410. 	if (segaic16_display_enable != enable)

    411. 

  411. 	{

    412. 

  412. 		machine->primary_screen->update_partial(machine->primary_screen->vpos());

    413. 

  413. 		segaic16_display_enable = enable;

    414. 

  414. 	}

    415. 

  415. }

    416. 

  416. 

    417. 

  417. 

    418. 

  418. 

    419. 

  419. /*************************************

    420. 

  420.  *

    421. 

  421.  *  Palette computation

    422. 

  422.  *

    423. 

  423.  *************************************/

    424. 

  424. 

    425. 

  425. /*

    426. 

  426.     Color generation details

    427. 

  427. 

    428. 

  428.     Each color is made up of 5 bits, connected through one or more resistors like so:

    429. 

  429. 

    430. 

  430.     Bit 0 = 1 x 3.9K ohm

    431. 

  431.     Bit 1 = 1 x 2.0K ohm

    432. 

  432.     Bit 2 = 1 x 1.0K ohm

    433. 

  433.     Bit 3 = 2 x 1.0K ohm

    434. 

  434.     Bit 4 = 4 x 1.0K ohm

    435. 

  435. 

    436. 

  436.     Another data bit is connected by a tristate buffer to the color output through a

    437. 

  437.     470 ohm resistor. The buffer allows the resistor to have no effect (tristate),

    438. 

  438.     halve brightness (pull-down) or double brightness (pull-up). The data bit source

    439. 

  439.     is bit 15 of each color RAM entry.

    440. 

  440. */

    441. 

  441. 

    442. 

  442. void segaic16_palette_init(int entries)

    443. 

  443. {

    444. 

  444. 	static const int resistances_normal[6] = { 3900, 2000, 1000, 1000/2, 1000/4, 0   };

    445. 

  445. 	static const int resistances_sh[6]     = { 3900, 2000, 1000, 1000/2, 1000/4, 470 };

    446. 

  446. 	double weights[2][6];

    447. 

  447. 	int i;

    448. 

  448. 	struct palette_info *info = &segaic16_palette;

    449. 

  449. 

    450. 

  450. 	/* compute the number of palette entries */

    451. 

  451. 	info->entries = entries;

    452. 

  452. 

    453. 

  453. 	/* compute weight table for regular palette entries */

    454. 

  454. 	compute_resistor_weights(0, 255, -1.0,

    455. 

  455. 		6, resistances_normal, weights[0], 0, 0,

    456. 

  456. 		0, NULL, NULL, 0, 0,

    457. 

  457. 		0, NULL, NULL, 0, 0);

    458. 

  458. 

    459. 

  459. 	/* compute weight table for shadow/hilight palette entries */

    460. 

  460. 	compute_resistor_weights(0, 255, -1.0,

    461. 

  461. 		6, resistances_sh, weights[1], 0, 0,

    462. 

  462. 		0, NULL, NULL, 0, 0,

    463. 

  463. 		0, NULL, NULL, 0, 0);

    464. 

  464. 

    465. 

  465. 	/* compute R, G, B for each weight */

    466. 

  466. 	for (i = 0; i < 32; i++)

    467. 

  467. 	{

    468. 

  468. 		int i4 = (i >> 4) & 1;

    469. 

  469. 		int i3 = (i >> 3) & 1;

    470. 

  470. 		int i2 = (i >> 2) & 1;

    471. 

  471. 		int i1 = (i >> 1) & 1;

    472. 

  472. 		int i0 = (i >> 0) & 1;

    473. 

  473. 

    474. 

  474. 		info->normal[i] = combine_6_weights(weights[0], i0, i1, i2, i3, i4, 0);

    475. 

  475. 		info->shadow[i] = combine_6_weights(weights[1], i0, i1, i2, i3, i4, 0);

    476. 

  476. 		info->hilight[i] = combine_6_weights(weights[1], i0, i1, i2, i3, i4, 1);

    477. 

  477. 	}

    478. 

  478. }

    479. 

  479. 

    480. 

  480. 

    481. 

  481. 

    482. 

  482. /*************************************

    483. 

  483.  *

    484. 

  484.  *  Palette accessors

    485. 

  485.  *

    486. 

  486.  *************************************/

    487. 

  487. 

    488. 

  488. WRITE16_HANDLER( segaic16_paletteram_w )

    489. 

  489. {

    490. 

  490. 	UINT16 newval;

    491. 

  491. 	int r, g, b;

    492. 

  492. 	struct palette_info *info = &segaic16_palette;

    493. 

  493. 

    494. 

  494. 	/* get the new value */

    495. 

  495. 	newval = segaic16_paletteram[offset];

    496. 

  496. 	COMBINE_DATA(&newval);

    497. 

  497. 	segaic16_paletteram[offset] = newval;

    498. 

  498. 

    499. 

  499. 	/*     byte 0    byte 1 */

    500. 

  500. 	/*  sBGR BBBB GGGG RRRR */

    501. 

  501. 	/*  x000 4321 4321 4321 */

    502. 

  502. 	r = ((newval >> 12) & 0x01) | ((newval << 1) & 0x1e);

    503. 

  503. 	g = ((newval >> 13) & 0x01) | ((newval >> 3) & 0x1e);

    504. 

  504. 	b = ((newval >> 14) & 0x01) | ((newval >> 7) & 0x1e);

    505. 

  505. 

    506. 

  506. 	/* normal colors */

    507. 

  507. 	palette_set_color_rgb(space->machine, offset + 0 * info->entries, info->normal[r],  info->normal[g],  info->normal[b]);

    508. 

  508. 	palette_set_color_rgb(space->machine, offset + 1 * info->entries, info->shadow[r],  info->shadow[g],  info->shadow[b]);

    509. 

  509. 	palette_set_color_rgb(space->machine, offset + 2 * info->entries, info->hilight[r], info->hilight[g], info->hilight[b]);

    510. 

  510. }

    511. 

  511. 

    512. 

  512. 

    513. 

  513. 

    514. 

  514. /*************************************

    515. 

  515.  *

    516. 

  516.  *  Draw a split tilemap in up to

    517. 

  517.  *  four pieces

    518. 

  518.  *

    519. 

  519.  *************************************/

    520. 

  520. 

    521. 

  521. static void segaic16_draw_virtual_tilemap(running_machine *machine, struct tilemap_info *info, bitmap_t *bitmap, const rectangle *cliprect, UINT16 pages, UINT16 xscroll, UINT16 yscroll, UINT32 flags, UINT32 priority)

    522. 

  522. {

    523. 

  523. 	int leftmin = -1, leftmax = -1, rightmin = -1, rightmax = -1;

    524. 

  524. 	int topmin = -1, topmax = -1, bottommin = -1, bottommax = -1;

    525. 

  525. 	rectangle pageclip;

    526. 

  526. 	int page;

    527. 

  527. 

    528. 

  528. 	int width = machine->primary_screen->width();

    529. 

  529. 	int height = machine->primary_screen->height();

    530. 

  530. 

    531. 

  531. 	/* which half/halves of the virtual tilemap do we intersect in the X direction? */

    532. 

  532. 	if (xscroll < 64*8 - width)

    533. 

  533. 	{

    534. 

  534. 		leftmin = 0;

    535. 

  535. 		leftmax = width - 1;

    536. 

  536. 		rightmin = -1;

    537. 

  537. 	}

    538. 

  538. 	else if (xscroll < 64*8)

    539. 

  539. 	{

    540. 

  540. 		leftmin = 0;

    541. 

  541. 		leftmax = 64*8 - xscroll - 1;

    542. 

  542. 		rightmin = leftmax + 1;

    543. 

  543. 		rightmax = width - 1;

    544. 

  544. 	}

    545. 

  545. 	else if (xscroll < 128*8 - width)

    546. 

  546. 	{

    547. 

  547. 		rightmin = 0;

    548. 

  548. 		rightmax = width - 1;

    549. 

  549. 		leftmin = -1;

    550. 

  550. 	}

    551. 

  551. 	else

    552. 

  552. 	{

    553. 

  553. 		rightmin = 0;

    554. 

  554. 		rightmax = 128*8 - xscroll - 1;

    555. 

  555. 		leftmin = rightmax + 1;

    556. 

  556. 		leftmax = width - 1;

    557. 

  557. 	}

    558. 

  558. 

    559. 

  559. 	/* which half/halves of the virtual tilemap do we intersect in the Y direction? */

    560. 

  560. 	if (yscroll < 32*8 - height)

    561. 

  561. 	{

    562. 

  562. 		topmin = 0;

    563. 

  563. 		topmax = height - 1;

    564. 

  564. 		bottommin = -1;

    565. 

  565. 	}

    566. 

  566. 	else if (yscroll < 32*8)

    567. 

  567. 	{

    568. 

  568. 		topmin = 0;

    569. 

  569. 		topmax = 32*8 - yscroll - 1;

    570. 

  570. 		bottommin = topmax + 1;

    571. 

  571. 		bottommax = height - 1;

    572. 

  572. 	}

    573. 

  573. 	else if (yscroll < 64*8 - height)

    574. 

  574. 	{

    575. 

  575. 		bottommin = 0;

    576. 

  576. 		bottommax = height - 1;

    577. 

  577. 		topmin = -1;

    578. 

  578. 	}

    579. 

  579. 	else

    580. 

  580. 	{

    581. 

  581. 		bottommin = 0;

    582. 

  582. 		bottommax = 64*8 - yscroll - 1;

    583. 

  583. 		topmin = bottommax + 1;

    584. 

  584. 		topmax = height - 1;

    585. 

  585. 	}

    586. 

  586. 

    587. 

  587. 	/* if the tilemap is flipped, we need to flip our sense within each quadrant */

    588. 

  588. 	if (info->flip)

    589. 

  589. 	{

    590. 

  590. 		if (leftmin != -1)

    591. 

  591. 		{

    592. 

  592. 			int temp = leftmin;

    593. 

  593. 			leftmin = width - 1 - leftmax;

    594. 

  594. 			leftmax = width - 1 - temp;

    595. 

  595. 		}

    596. 

  596. 		if (rightmin != -1)

    597. 

  597. 		{

    598. 

  598. 			int temp = rightmin;

    599. 

  599. 			rightmin = width - 1 - rightmax;

    600. 

  600. 			rightmax = width - 1 - temp;

    601. 

  601. 		}

    602. 

  602. 		if (topmin != -1)

    603. 

  603. 		{

    604. 

  604. 			int temp = topmin;

    605. 

  605. 			topmin = height - 1 - topmax;

    606. 

  606. 			topmax = height - 1 - temp;

    607. 

  607. 		}

    608. 

  608. 		if (bottommin != -1)

    609. 

  609. 		{

    610. 

  610. 			int temp = bottommin;

    611. 

  611. 			bottommin = height - 1 - bottommax;

    612. 

  612. 			bottommax = height - 1 - temp;

    613. 

  613. 		}

    614. 

  614. 	}

    615. 

  615. 

    616. 

  616. 	/* draw the upper-left chunk */

    617. 

  617. 	if (leftmin != -1 && topmin != -1)

    618. 

  618. 	{

    619. 

  619. 		pageclip.min_x = (leftmin < cliprect->min_x) ? cliprect->min_x : leftmin;

    620. 

  620. 		pageclip.max_x = (leftmax > cliprect->max_x) ? cliprect->max_x : leftmax;

    621. 

  621. 		pageclip.min_y = (topmin < cliprect->min_y) ? cliprect->min_y : topmin;

    622. 

  622. 		pageclip.max_y = (topmax > cliprect->max_y) ? cliprect->max_y : topmax;

    623. 

  623. 		if (pageclip.min_x <= pageclip.max_x && pageclip.min_y <= pageclip.max_y)

    624. 

  624. 		{

    625. 

  625. 			page = (pages >> 0) & 0xf;

    626. 

  626. 			tilemap_set_scrollx(info->tilemaps[page], 0, xscroll);

    627. 

  627. 			tilemap_set_scrolly(info->tilemaps[page], 0, yscroll);

    628. 

  628. 			tilemap_draw(bitmap, &pageclip, info->tilemaps[page], flags, priority);

    629. 

  629. 		}

    630. 

  630. 	}

    631. 

  631. 

    632. 

  632. 	/* draw the upper-right chunk */

    633. 

  633. 	if (rightmin != -1 && topmin != -1)

    634. 

  634. 	{

    635. 

  635. 		pageclip.min_x = (rightmin < cliprect->min_x) ? cliprect->min_x : rightmin;

    636. 

  636. 		pageclip.max_x = (rightmax > cliprect->max_x) ? cliprect->max_x : rightmax;

    637. 

  637. 		pageclip.min_y = (topmin < cliprect->min_y) ? cliprect->min_y : topmin;

    638. 

  638. 		pageclip.max_y = (topmax > cliprect->max_y) ? cliprect->max_y : topmax;

    639. 

  639. 		if (pageclip.min_x <= pageclip.max_x && pageclip.min_y <= pageclip.max_y)

    640. 

  640. 		{

    641. 

  641. 			page = (pages >> 4) & 0xf;

    642. 

  642. 			tilemap_set_scrollx(info->tilemaps[page], 0, xscroll);

    643. 

  643. 			tilemap_set_scrolly(info->tilemaps[page], 0, yscroll);

    644. 

  644. 			tilemap_draw(bitmap, &pageclip, info->tilemaps[page], flags, priority);

    645. 

  645. 		}

    646. 

  646. 	}

    647. 

  647. 

    648. 

  648. 	/* draw the lower-left chunk */

    649. 

  649. 	if (leftmin != -1 && bottommin != -1)

    650. 

  650. 	{

    651. 

  651. 		pageclip.min_x = (leftmin < cliprect->min_x) ? cliprect->min_x : leftmin;

    652. 

  652. 		pageclip.max_x = (leftmax > cliprect->max_x) ? cliprect->max_x : leftmax;

    653. 

  653. 		pageclip.min_y = (bottommin < cliprect->min_y) ? cliprect->min_y : bottommin;

    654. 

  654. 		pageclip.max_y = (bottommax > cliprect->max_y) ? cliprect->max_y : bottommax;

    655. 

  655. 		if (pageclip.min_x <= pageclip.max_x && pageclip.min_y <= pageclip.max_y)

    656. 

  656. 		{

    657. 

  657. 			page = (pages >> 8) & 0xf;

    658. 

  658. 			tilemap_set_scrollx(info->tilemaps[page], 0, xscroll);

    659. 

  659. 			tilemap_set_scrolly(info->tilemaps[page], 0, yscroll);

    660. 

  660. 			tilemap_draw(bitmap, &pageclip, info->tilemaps[page], flags, priority);

    661. 

  661. 		}

    662. 

  662. 	}

    663. 

  663. 

    664. 

  664. 	/* draw the lower-right chunk */

    665. 

  665. 	if (rightmin != -1 && bottommin != -1)

    666. 

  666. 	{

    667. 

  667. 		pageclip.min_x = (rightmin < cliprect->min_x) ? cliprect->min_x : rightmin;

    668. 

  668. 		pageclip.max_x = (rightmax > cliprect->max_x) ? cliprect->max_x : rightmax;

    669. 

  669. 		pageclip.min_y = (bottommin < cliprect->min_y) ? cliprect->min_y : bottommin;

    670. 

  670. 		pageclip.max_y = (bottommax > cliprect->max_y) ? cliprect->max_y : bottommax;

    671. 

  671. 		if (pageclip.min_x <= pageclip.max_x && pageclip.min_y <= pageclip.max_y)

    672. 

  672. 		{

    673. 

  673. 			page = (pages >> 12) & 0xf;

    674. 

  674. 			tilemap_set_scrollx(info->tilemaps[page], 0, xscroll);

    675. 

  675. 			tilemap_set_scrolly(info->tilemaps[page], 0, yscroll);

    676. 

  676. 			tilemap_draw(bitmap, &pageclip, info->tilemaps[page], flags, priority);

    677. 

  677. 		}

    678. 

  678. 	}

    679. 

  679. }

    680. 

  680. 

    681. 

  681. 

    682. 

  682. 

    683. 

  683. /*******************************************************************************************

    684. 

  684.  *

    685. 

  685.  *  Hang On/System 16A-style tilemaps

    686. 

  686.  *

    687. 

  687.  *  4 total pages (Hang On)

    688. 

  688.  *  8 total pages (System 16A)

    689. 

  689.  *  Column/rowscroll enabled via external signals

    690. 

  690.  *

    691. 

  691.  *  Tile format:

    692. 

  692.  *      Bits               Usage

    693. 

  693.  *      ??------ --------  Unknown

    694. 

  694.  *      --b----- --------  Tile bank select

    695. 

  695.  *      ---p---- --------  Tile priority versus sprites

    696. 

  696.  *      ----cccc ccc-----  Tile color palette

    697. 

  697.  *      ----nnnn nnnnnnnn  Tile index

    698. 

  698.  *

    699. 

  699.  *  Text format:

    700. 

  700.  *      Bits               Usage

    701. 

  701.  *      ????---- --------  Unknown

    702. 

  702.  *      ----p--- --------  Priority

    703. 

  703.  *      -----ccc --------  Tile color palette

    704. 

  704.  *      -------- nnnnnnnn  Tile index

    705. 

  705.  *

    706. 

  706.  *  Text RAM:

    707. 

  707.  *      Offset   Bits               Usage

    708. 

  708.  *      E8C      -aaa-bbb -ccc-ddd  Background tilemap page select (screen flipped)

    709. 

  709.  *      E8E      -aaa-bbb -ccc-ddd  Foreground tilemap page select (screen flipped)

    710. 

  710.  *      E9C      -aaa-bbb -ccc-ddd  Background tilemap page select

    711. 

  711.  *      E9E      -aaa-bbb -ccc-ddd  Foreground tilemap page select

    712. 

  712.  *      F24      -------- vvvvvvvv  Foreground tilemap vertical scroll

    713. 

  713.  *      F26      -------- vvvvvvvv  Background tilemap vertical scroll

    714. 

  714.  *      F30-F7D  -------- vvvvvvvv  Foreground tilemap per-16-pixel-column vertical scroll (every 2 words)

    715. 

  715.  *      F32-F7F  -------- vvvvvvvv  Background tilemap per-16-pixel-column vertical scroll (every 2 words)

    716. 

  716.  *      F80-FED  -------h hhhhhhhh  Foreground tilemap per-8-pixel-row horizontal scroll (every 2 words)

    717. 

  717.  *      F82-FEF  -------h hhhhhhhh  Background tilemap per-8-pixel-row horizontal scroll (every 2 words)

    718. 

  718.  *      FF8      -------h hhhhhhhh  Foreground tilemap horizontal scroll

    719. 

  719.  *      FFA      -------h hhhhhhhh  Background tilemap horizontal scroll

    720. 

  720.  *

    721. 

  721.  *******************************************************************************************/

    722. 

  722. 

    723. 

  723. static TILE_GET_INFO( segaic16_tilemap_16a_tile_info )

    724. 

  724. {

    725. 

  725. 	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)param;

    726. 

  726. 	UINT16 data = info->rambase[tile_index];

    727. 

  727. 	int code = ((data >> 1) & 0x1000) | (data & 0xfff);

    728. 

  728. 	int color = (data >> 5) & 0x7f;

    729. 

  729. 

    730. 

  730. 	SET_TILE_INFO(0, code, color, 0);

    731. 

  731. 	tileinfo->category = (data >> 12) & 1;

    732. 

  732. }

    733. 

  733. 

    734. 

  734. 

    735. 

  735. static TILE_GET_INFO( segaic16_tilemap_16a_text_info )

    736. 

  736. {

    737. 

  737. 	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)param;

    738. 

  738. 	UINT16 data = info->rambase[tile_index];

    739. 

  739. 	int color = (data >> 8) & 0x07;

    740. 

  740. 	int code = data & 0xff;

    741. 

  741. 

    742. 

  742. 	SET_TILE_INFO(0, code, color, 0);

    743. 

  743. 	tileinfo->category = (data >> 11) & 1;

    744. 

  744. }

    745. 

  745. 

    746. 

  746. 

    747. 

  747. static void segaic16_tilemap_16a_draw_layer(running_machine *machine, struct tilemap_info *info, bitmap_t *bitmap, const rectangle *cliprect, int which, int flags, int priority)

    748. 

  748. {

    749. 

  749. 	UINT16 *textram = info->textram;

    750. 

  750. 

    751. 

  751. 	/* note that the scrolling for these games can only scroll as much as the top-left */

    752. 

  752. 	/* page; in order to scroll beyond that they swap pages and reset the scroll value */

    753. 

  753. 	UINT16 xscroll = textram[0xff8/2 + which] & 0x1ff;

    754. 

  754. 	UINT16 yscroll = textram[0xf24/2 + which] & 0x0ff;

    755. 

  755. 	UINT16 pages = textram[(info->flip ? 0xe8e/2 : 0xe9e/2) - which];

    756. 

  756. 	int x, y;

    757. 

  757. 

    758. 

  758. 	/* pages are swapped along the X direction, and there are only 8 of them */

    759. 

  759. 	pages = ((pages >> 4) & 0x0707) | ((pages << 4) & 0x7070);

    760. 

  760. 	if (info->numpages == 4)

    761. 

  761. 		pages &= 0x3333;

    762. 

  762. 

    763. 

  763. 	/* column AND row scroll */

    764. 

  764. 	if (info->colscroll && info->rowscroll)

    765. 

  765. 	{

    766. 

  766. 		if (PRINT_UNUSUAL_MODES) mame_printf_debug("Column AND row scroll\n");

    767. 

  767. 

    768. 

  768. 		/* loop over row chunks */

    769. 

  769. 		for (y = cliprect->min_y & ~7; y <= cliprect->max_y; y += 8)

    770. 

  770. 		{

    771. 

  771. 			int rowscrollindex = (info->flip ? (216 - y) : y) / 8;

    772. 

  772. 			rectangle rowcolclip;

    773. 

  773. 

    774. 

  774. 			/* adjust to clip this row only */

    775. 

  775. 			rowcolclip.min_y = (y < cliprect->min_y) ? cliprect->min_y : y;

    776. 

  776. 			rowcolclip.max_y = (y + 7 > cliprect->max_y) ? cliprect->max_y : y + 7;

    777. 

  777. 

    778. 

  778. 			/* loop over column chunks */

    779. 

  779. 			for (x = cliprect->min_x & ~15; x <= cliprect->max_x; x += 16)

    780. 

  780. 			{

    781. 

  781. 				UINT16 effxscroll, effyscroll;

    782. 

  782. 

    783. 

  783. 				/* adjust to clip this column only */

    784. 

  784. 				rowcolclip.min_x = (x < cliprect->min_x) ? cliprect->min_x : x;

    785. 

  785. 				rowcolclip.max_x = (x + 15 > cliprect->max_x) ? cliprect->max_x : x + 15;

    786. 

  786. 

    787. 

  787. 				/* get the effective scroll values */

    788. 

  788. 				effxscroll = textram[0xf80/2 + rowscrollindex * 2 + which] & 0x1ff;

    789. 

  789. 				effyscroll = textram[0xf30/2 + (x/16) * 2 + which] & 0x0ff;

    790. 

  790. 

    791. 

  791. 				/* adjust the xscroll for flipped screen */

    792. 

  792. 				if (info->flip)

    793. 

  793. 					effxscroll += 17;

    794. 

  794. 

    795. 

  795. 				/* draw the chunk */

    796. 

  796. 				effxscroll = (0xc8 - effxscroll + info->xoffs) & 0x3ff;

    797. 

  797. 				effyscroll = effyscroll & 0x1ff;

    798. 

  798. 				segaic16_draw_virtual_tilemap(machine, info, bitmap, &rowcolclip, pages, effxscroll, effyscroll, flags, priority);

    799. 

  799. 			}

    800. 

  800. 		}

    801. 

  801. 	}

    802. 

  802. 	else if (info->colscroll)

    803. 

  803. 	{

    804. 

  804. 		if (PRINT_UNUSUAL_MODES) mame_printf_debug("Column scroll\n");

    805. 

  805. 

    806. 

  806. 		/* loop over column chunks */

    807. 

  807. 		for (x = cliprect->min_x & ~15; x <= cliprect->max_x; x += 16)

    808. 

  808. 		{

    809. 

  809. 			rectangle colclip = *cliprect;

    810. 

  810. 			UINT16 effxscroll, effyscroll;

    811. 

  811. 

    812. 

  812. 			/* adjust to clip this row only */

    813. 

  813. 			colclip.min_x = (x < cliprect->min_x) ? cliprect->min_x : x;

    814. 

  814. 			colclip.max_x = (x + 15 > cliprect->max_x) ? cliprect->max_x : x + 15;

    815. 

  815. 

    816. 

  816. 			/* get the effective scroll values */

    817. 

  817. 			effxscroll = xscroll;

    818. 

  818. 			effyscroll = textram[0xf30/2 + (x/16) * 2 + which] & 0x0ff;

    819. 

  819. 

    820. 

  820. 			/* adjust the xscroll for flipped screen */

    821. 

  821. 			if (info->flip)

    822. 

  822. 				effxscroll += 17;

    823. 

  823. 

    824. 

  824. 			/* draw the chunk */

    825. 

  825. 			effxscroll = (0xc8 - effxscroll + info->xoffs) & 0x3ff;

    826. 

  826. 			effyscroll = effyscroll & 0x1ff;

    827. 

  827. 			segaic16_draw_virtual_tilemap(machine, info, bitmap, &colclip, pages, effxscroll, effyscroll, flags, priority);

    828. 

  828. 		}

    829. 

  829. 	}

    830. 

  830. 	else if (info->rowscroll)

    831. 

  831. 	{

    832. 

  832. 		if (PRINT_UNUSUAL_MODES) mame_printf_debug("Row scroll\n");

    833. 

  833. 

    834. 

  834. 		/* loop over row chunks */

    835. 

  835. 		for (y = cliprect->min_y & ~7; y <= cliprect->max_y; y += 8)

    836. 

  836. 		{

    837. 

  837. 			int rowscrollindex = (info->flip ? (216 - y) : y) / 8;

    838. 

  838. 			rectangle rowclip = *cliprect;

    839. 

  839. 			UINT16 effxscroll, effyscroll;

    840. 

  840. 

    841. 

  841. 			/* adjust to clip this row only */

    842. 

  842. 			rowclip.min_y = (y < cliprect->min_y) ? cliprect->min_y : y;

    843. 

  843. 			rowclip.max_y = (y + 7 > cliprect->max_y) ? cliprect->max_y : y + 7;

    844. 

  844. 

    845. 

  845. 			/* get the effective scroll values */

    846. 

  846. 			effxscroll = textram[0xf80/2 + rowscrollindex * 2 + which] & 0x1ff;

    847. 

  847. 			effyscroll = yscroll;

    848. 

  848. 

    849. 

  849. 			/* adjust the xscroll for flipped screen */

    850. 

  850. 			if (info->flip)

    851. 

  851. 				effxscroll += 17;

    852. 

  852. 

    853. 

  853. 			/* draw the chunk */

    854. 

  854. 			effxscroll = (0xc8 - effxscroll + info->xoffs) & 0x3ff;

    855. 

  855. 			effyscroll = effyscroll & 0x1ff;

    856. 

  856. 			segaic16_draw_virtual_tilemap(machine, info, bitmap, &rowclip, pages, effxscroll, effyscroll, flags, priority);

    857. 

  857. 		}

    858. 

  858. 	}

    859. 

  859. 	else

    860. 

  860. 	{

    861. 

  861. 		/* adjust the xscroll for flipped screen */

    862. 

  862. 		if (info->flip)

    863. 

  863. 			xscroll += 17;

    864. 

  864. 		xscroll = (0xc8 - xscroll + info->xoffs) & 0x3ff;

    865. 

  865. 		yscroll = yscroll & 0x1ff;

    866. 

  866. 		segaic16_draw_virtual_tilemap(machine, info, bitmap, cliprect, pages, xscroll, yscroll, flags, priority);

    867. 

  867. 	}

    868. 

  868. }

    869. 

  869. 

    870. 

  870. 

    871. 

  871. 

    872. 

  872. /*******************************************************************************************

    873. 

  873.  *

    874. 

  874.  *  System 16B-style tilemaps

    875. 

  875.  *

    876. 

  876.  *  16 total pages

    877. 

  877.  *  Column/rowscroll enabled via bits in text layer

    878. 

  878.  *  Alternate tilemap support

    879. 

  879.  *

    880. 

  880.  *  Tile format:

    881. 

  881.  *      Bits               Usage

    882. 

  882.  *      p------- --------  Tile priority versus sprites

    883. 

  883.  *      -??----- --------  Unknown

    884. 

  884.  *      ---ccccc cc------  Tile color palette

    885. 

  885.  *      ---nnnnn nnnnnnnn  Tile index

    886. 

  886.  *

    887. 

  887.  *  Text format:

    888. 

  888.  *      Bits               Usage

    889. 

  889.  *      p------- --------  Tile priority versus sprites

    890. 

  890.  *      -???---- --------  Unknown

    891. 

  891.  *      ----ccc- --------  Tile color palette

    892. 

  892.  *      -------n nnnnnnnn  Tile index

    893. 

  893.  *

    894. 

  894.  *  Alternate tile format:

    895. 

  895.  *      Bits               Usage

    896. 

  896.  *      p------- --------  Tile priority versus sprites

    897. 

  897.  *      -??----- --------  Unknown

    898. 

  898.  *      ----cccc ccc-----  Tile color palette

    899. 

  899.  *      ---nnnnn nnnnnnnn  Tile index

    900. 

  900.  *

    901. 

  901.  *  Alternate text format:

    902. 

  902.  *      Bits               Usage

    903. 

  903.  *      p------- --------  Tile priority versus sprites

    904. 

  904.  *      -???---- --------  Unknown

    905. 

  905.  *      -----ccc --------  Tile color palette

    906. 

  906.  *      -------- nnnnnnnn  Tile index

    907. 

  907.  *

    908. 

  908.  *  Text RAM:

    909. 

  909.  *      Offset   Bits               Usage

    910. 

  910.  *      E80      aaaabbbb ccccdddd  Foreground tilemap page select

    911. 

  911.  *      E82      aaaabbbb ccccdddd  Background tilemap page select

    912. 

  912.  *      E84      aaaabbbb ccccdddd  Alternate foreground tilemap page select

    913. 

  913.  *      E86      aaaabbbb ccccdddd  Alternate background tilemap page select

    914. 

  914.  *      E90      c------- --------  Foreground tilemap column scroll enable

    915. 

  915.  *               -------v vvvvvvvv  Foreground tilemap vertical scroll

    916. 

  916.  *      E92      c------- --------  Background tilemap column scroll enable

    917. 

  917.  *               -------v vvvvvvvv  Background tilemap vertical scroll

    918. 

  918.  *      E94      -------v vvvvvvvv  Alternate foreground tilemap vertical scroll

    919. 

  919.  *      E96      -------v vvvvvvvv  Alternate background tilemap vertical scroll

    920. 

  920.  *      E98      r------- --------  Foreground tilemap row scroll enable

    921. 

  921.  *               ------hh hhhhhhhh  Foreground tilemap horizontal scroll

    922. 

  922.  *      E9A      r------- --------  Background tilemap row scroll enable

    923. 

  923.  *               ------hh hhhhhhhh  Background tilemap horizontal scroll

    924. 

  924.  *      E9C      ------hh hhhhhhhh  Alternate foreground tilemap horizontal scroll

    925. 

  925.  *      E9E      ------hh hhhhhhhh  Alternate background tilemap horizontal scroll

    926. 

  926.  *      F16-F3F  -------- vvvvvvvv  Foreground tilemap per-16-pixel-column vertical scroll

    927. 

  927.  *      F56-F7F  -------- vvvvvvvv  Background tilemap per-16-pixel-column vertical scroll

    928. 

  928.  *      F80-FB7  a------- --------  Foreground tilemap per-8-pixel-row alternate tilemap enable

    929. 

  929.  *               -------h hhhhhhhh  Foreground tilemap per-8-pixel-row horizontal scroll

    930. 

  930.  *      FC0-FF7  a------- --------  Background tilemap per-8-pixel-row alternate tilemap enable

    931. 

  931.  *               -------h hhhhhhhh  Background tilemap per-8-pixel-row horizontal scroll

    932. 

  932.  *

    933. 

  933.  *******************************************************************************************/

    934. 

  934. 

    935. 

  935. static TILE_GET_INFO( segaic16_tilemap_16b_tile_info )

    936. 

  936. {

    937. 

  937. 	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)param;

    938. 

  938. 	UINT16 data = info->rambase[tile_index];

    939. 

  939. 	int color = (data >> 6) & 0x7f;

    940. 

  940. 	int code = data & 0x1fff;

    941. 

  941. 

    942. 

  942. 	code = info->bank[code / info->banksize] * info->banksize + code % info->banksize;

    943. 

  943. 

    944. 

  944. 	SET_TILE_INFO(0, code, color, 0);

    945. 

  945. 	tileinfo->category = (data >> 15) & 1;

    946. 

  946. }

    947. 

  947. 

    948. 

  948. 

    949. 

  949. static TILE_GET_INFO( segaic16_tilemap_16b_text_info )

    950. 

  950. {

    951. 

  951. 	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)param;

    952. 

  952. 	UINT16 data = info->rambase[tile_index];

    953. 

  953. 	int bank = info->bank[0];

    954. 

  954. 	int color = (data >> 9) & 0x07;

    955. 

  955. 	int code = data & 0x1ff;

    956. 

  956. 

    957. 

  957. 	SET_TILE_INFO(0, bank * info->banksize + code, color, 0);

    958. 

  958. 	tileinfo->category = (data >> 15) & 1;

    959. 

  959. }

    960. 

  960. 

    961. 

  961. 

    962. 

  962. static TILE_GET_INFO( segaic16_tilemap_16b_alt_tile_info )

    963. 

  963. {

    964. 

  964. 	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)param;

    965. 

  965. 	UINT16 data = info->rambase[tile_index];

    966. 

  966. 	int color = (data >> 5) & 0x7f;

    967. 

  967. 	int code = data & 0x1fff;

    968. 

  968. 

    969. 

  969. 	code = info->bank[code / info->banksize] * info->banksize + code % info->banksize;

    970. 

  970. 

    971. 

  971. 	SET_TILE_INFO(0, code, color, 0);

    972. 

  972. 	tileinfo->category = (data >> 15) & 1;

    973. 

  973. }

    974. 

  974. 

    975. 

  975. 

    976. 

  976. static TILE_GET_INFO( segaic16_tilemap_16b_alt_text_info )

    977. 

  977. {

    978. 

  978. 	const struct tilemap_callback_info *info = (const struct tilemap_callback_info *)param;

    979. 

  979. 	UINT16 data = info->rambase[tile_index];

    980. 

  980. 	int bank = info->bank[0];

    981. 

  981. 	int color = (data >> 8) & 0x07;

    982. 

  982. 	int code = data & 0xff;

    983. 

  983. 

    984. 

  984. 	SET_TILE_INFO(0, bank * info->banksize + code, color, 0);

    985. 

  985. 	tileinfo->category = (data >> 15) & 1;

    986. 

  986. }

    987. 

  987. 

    988. 

  988. 

    989. 

  989. static void segaic16_tilemap_16b_draw_layer(running_machine *machine, struct tilemap_info *info, bitmap_t *bitmap, const rectangle *cliprect, int which, int flags, int priority)

    990. 

  990. {

    991. 

  991. 	UINT16 *textram = info->textram;

    992. 

  992. 	UINT16 xscroll, yscroll, pages;

    993. 

  993. 	int x, y;

    994. 

  994. 

    995. 

  995. 	/* get global values */

    996. 

  996. 	xscroll = info->latched_xscroll[which];

    997. 

  997. 	yscroll = info->latched_yscroll[which];

    998. 

  998. 	pages = info->latched_pageselect[which];

    999. 

  999. 

    1000. 

  1000. 	/* column scroll? */

    1001. 

  1001. 	if (yscroll & 0x8000)

    1002. 

  1002. 	{

    1003. 

  1003. 		if (PRINT_UNUSUAL_MODES) mame_printf_debug("Column AND row scroll\n");

    1004. 

  1004. 

    1005. 

  1005. 		/* loop over row chunks */

    1006. 

  1006. 		for (y = cliprect->min_y & ~7; y <= cliprect->max_y; y += 8)

    1007. 

  1007. 		{

    1008. 

  1008. 			int rowscrollindex = (info->flip ? (216 - y) : y) / 8;

    1009. 

  1009. 			rectangle rowcolclip;

    1010. 

  1010. 

    1011. 

  1011. 			/* adjust to clip this row only */

    1012. 

  1012. 			rowcolclip.min_y = (y < cliprect->min_y) ? cliprect->min_y : y;

    1013. 

  1013. 			rowcolclip.max_y = (y + 7 > cliprect->max_y) ? cliprect->max_y : y + 7;

    1014. 

  1014. 

    1015. 

  1015. 			/* loop over column chunks */

    1016. 

  1016. 			for (x = ((cliprect->min_x + 8) & ~15) - 8; x <= cliprect->max_x; x += 16)

    1017. 

  1017. 			{

    1018. 

  1018. 				UINT16 effxscroll, effyscroll, rowscroll;

    1019. 

  1019. 				UINT16 effpages = pages;

    1020. 

  1020. 

    1021. 

  1021. 				/* adjust to clip this column only */

    1022. 

  1022. 				rowcolclip.min_x = (x < cliprect->min_x) ? cliprect->min_x : x;

    1023. 

  1023. 				rowcolclip.max_x = (x + 15 > cliprect->max_x) ? cliprect->max_x : x + 15;

    1024. 

  1024. 

    1025. 

  1025. 				/* get the effective scroll values */

    1026. 

  1026. 				rowscroll = textram[0xf80/2 + 0x40/2 * which + rowscrollindex];

    1027. 

  1027. 				effxscroll = (xscroll & 0x8000) ? rowscroll : xscroll;

    1028. 

  1028. 				effyscroll = textram[0xf16/2 + 0x40/2 * which + (x+8)/16];

    1029. 

  1029. 

    1030. 

  1030. 				/* are we using an alternate? */

    1031. 

  1031. 				if (rowscroll & 0x8000)

    1032. 

  1032. 				{

    1033. 

  1033. 					effxscroll = info->latched_xscroll[which + 2];

    1034. 

  1034. 					effyscroll = info->latched_yscroll[which + 2];

    1035. 

  1035. 					effpages = info->latched_pageselect[which + 2];

    1036. 

  1036. 				}

    1037. 

  1037. 

    1038. 

  1038. 				/* draw the chunk */

    1039. 

  1039. 				effxscroll = (0xc0 - effxscroll + info->xoffs) & 0x3ff;

    1040. 

  1040. 				effyscroll = effyscroll & 0x1ff;

    1041. 

  1041. 				segaic16_draw_virtual_tilemap(machine, info, bitmap, &rowcolclip, effpages, effxscroll, effyscroll, flags, priority);

    1042. 

  1042. 			}

    1043. 

  1043. 		}

    1044. 

  1044. 	}

    1045. 

  1045. 	else

    1046. 

  1046. 	{

    1047. 

  1047. 		if (PRINT_UNUSUAL_MODES) mame_printf_debug("Row scroll\n");

    1048. 

  1048. 

    1049. 

  1049. 		/* loop over row chunks */

    1050. 

  1050. 		for (y = cliprect->min_y & ~7; y <= cliprect->max_y; y += 8)

    1051. 

  1051. 		{

    1052. 

  1052. 			int rowscrollindex = (info->flip ? (216 - y) : y) / 8;

    1053. 

  1053. 			rectangle rowclip = *cliprect;

    1054. 

  1054. 			UINT16 effxscroll, effyscroll, rowscroll;

    1055. 

  1055. 			UINT16 effpages = pages;

    1056. 

  1056. 

    1057. 

  1057. 			/* adjust to clip this row only */

    1058. 

  1058. 			rowclip.min_y = (y < cliprect->min_y) ? cliprect->min_y : y;

    1059. 

  1059. 			rowclip.max_y = (y + 7 > cliprect->max_y) ? cliprect->max_y : y + 7;

    1060. 

  1060. 

    1061. 

  1061. 			/* get the effective scroll values */

    1062. 

  1062. 			rowscroll = textram[0xf80/2 + 0x40/2 * which + rowscrollindex];

    1063. 

  1063. 			effxscroll = (xscroll & 0x8000) ? rowscroll : xscroll;

    1064. 

  1064. 			effyscroll = yscroll;

    1065. 

  1065. 

    1066. 

  1066. 			/* are we using an alternate? */

    1067. 

  1067. 			if (rowscroll & 0x8000)

    1068. 

  1068. 			{

    1069. 

  1069. 				effxscroll = info->latched_xscroll[which + 2];

    1070. 

  1070. 				effyscroll = info->latched_yscroll[which + 2];

    1071. 

  1071. 				effpages = info->latched_pageselect[which + 2];

    1072. 

  1072. 			}

    1073. 

  1073. 

    1074. 

  1074. 			/* draw the chunk */

    1075. 

  1075. 			effxscroll = (0xc0 - effxscroll + info->xoffs) & 0x3ff;

    1076. 

  1076. 			effyscroll = effyscroll & 0x1ff;

    1077. 

  1077. 			segaic16_draw_virtual_tilemap(machine, info, bitmap, &rowclip, effpages, effxscroll, effyscroll, flags, priority);

    1078. 

  1078. 		}

    1079. 

  1079. 	}

    1080. 

  1080. }

    1081. 

  1081. 

    1082. 

  1082. 

    1083. 

  1083. static TIMER_CALLBACK( segaic16_tilemap_16b_latch_values )

    1084. 

  1084. {

    1085. 

  1085. 	struct tilemap_info *info = &bg_tilemap[param];

    1086. 

  1086. 	UINT16 *textram = info->textram;

    1087. 

  1087. 	int i;

    1088. 

  1088. 

    1089. 

  1089. 	/* latch the scroll and page select values */

    1090. 

  1090. 	for (i = 0; i < 4; i++)

    1091. 

  1091. 	{

    1092. 

  1092. 		info->latched_pageselect[i] = textram[0xe80/2 + i];

    1093. 

  1093. 		info->latched_yscroll[i] = textram[0xe90/2 + i];

    1094. 

  1094. 		info->latched_xscroll[i] = textram[0xe98/2 + i];

    1095. 

  1095. 	}

    1096. 

  1096. 

    1097. 

  1097. 	/* set a timer to do this again next frame */

    1098. 

  1098. 	//timer_set(machine, machine->primary_screen->time_until_pos(261), NULL, param, segaic16_tilemap_16b_latch_values);

    1099. 

  1099.     timer_adjust_oneshot(info->latch_timer,machine->primary_screen->time_until_pos(261),param);

    1100. 

  1100. }

    1101. 

  1101. 

    1102. 

  1102. 

    1103. 

  1103. static void segaic16_tilemap_16b_reset(running_machine *machine, struct tilemap_info *info)

    1104. 

  1104. {

    1105. 

  1105. 	/* set a timer to latch values on scanline 261 */

    1106. 

  1106. 	//timer_set(machine, machine->primary_screen->time_until_pos(261), NULL, info->index, segaic16_tilemap_16b_latch_values);

    1107. 

  1107.     timer_adjust_oneshot(info->latch_timer,machine->primary_screen->time_until_pos(261),info->index);

    1108. 

  1108. }

    1109. 

  1109. 

    1110. 

  1110. 

    1111. 

  1111. 

    1112. 

  1112. /*************************************

    1113. 

  1113.  *

    1114. 

  1114.  *  General tilemap initialization

    1115. 

  1115.  *

    1116. 

  1116.  *************************************/

    1117. 

  1117. 

    1118. 

  1118. void segaic16_tilemap_init(running_machine *machine, int which, int type, int colorbase, int xoffs, int numbanks)

    1119. 

  1119. {

    1120. 

  1120. 	struct tilemap_info *info = &bg_tilemap[which];

    1121. 

  1121. 	tile_get_info_func get_text_info;

    1122. 

  1122. 	tile_get_info_func get_tile_info;

    1123. 

  1123. 	int pagenum;

    1124. 

  1124. 	int i;

    1125. 

  1125. 

    1126. 

  1126. 	/* reset the tilemap info */

    1127. 

  1127. 	memset(info, 0, sizeof(*info));

    1128. 

  1128. 	info->index = which;

    1129. 

  1129. 	info->type = type;

    1130. 

  1130. 	for (i = 0; i < numbanks; i++)

    1131. 

  1131. 		info->bank[i] = i;

    1132. 

  1132. 	info->banksize = 0x2000 / numbanks;

    1133. 

  1133. 	info->xoffs = xoffs;

    1134. 

  1134. 

    1135. 

  1135. 	/* set up based on which tilemap */

    1136. 

  1136. 	switch (which)

    1137. 

  1137. 	{

    1138. 

  1138. 		case 0:

    1139. 

  1139. 			info->textram = segaic16_textram_0;

    1140. 

  1140. 			info->tileram = segaic16_tileram_0;

    1141. 

  1141. 			break;

    1142. 

  1142. 

    1143. 

  1143. 		default:

    1144. 

  1144. 			fatalerror("Invalid tilemap index specified in segaic16_tilemap_init");

    1145. 

  1145. 	}

    1146. 

  1146. 

    1147. 

  1147. 	/* determine the parameters of the tilemaps */

    1148. 

  1148. 	switch (type)

    1149. 

  1149. 	{

    1150. 

  1150. 		case SEGAIC16_TILEMAP_HANGON:

    1151. 

  1151. 			get_text_info = segaic16_tilemap_16a_text_info;

    1152. 

  1152. 			get_tile_info = segaic16_tilemap_16a_tile_info;

    1153. 

  1153. 			info->numpages = 4;

    1154. 

  1154. 			info->draw_layer = segaic16_tilemap_16a_draw_layer;

    1155. 

  1155. 			info->reset = NULL;

    1156. 

  1156.             info->latch_timer = NULL;

    1157. 

  1157. 			break;

    1158. 

  1158. 

    1159. 

  1159. 		case SEGAIC16_TILEMAP_16A:

    1160. 

  1160. 			get_text_info = segaic16_tilemap_16a_text_info;

    1161. 

  1161. 			get_tile_info = segaic16_tilemap_16a_tile_info;

    1162. 

  1162. 			info->numpages = 8;

    1163. 

  1163. 			info->draw_layer = segaic16_tilemap_16a_draw_layer;

    1164. 

  1164. 			info->reset = NULL;

    1165. 

  1165.             info->latch_timer = NULL;

    1166. 

  1166. 			break;

    1167. 

  1167. 

    1168. 

  1168. 		case SEGAIC16_TILEMAP_16B:

    1169. 

  1169. 			get_text_info = segaic16_tilemap_16b_text_info;

    1170. 

  1170. 			get_tile_info = segaic16_tilemap_16b_tile_info;

    1171. 

  1171. 			info->numpages = 16;

    1172. 

  1172. 			info->draw_layer = segaic16_tilemap_16b_draw_layer;

    1173. 

  1173. 			info->reset = segaic16_tilemap_16b_reset;

    1174. 

  1174.             //DAV FIX

    1175. 

  1175.             info->latch_timer = timer_alloc(machine,segaic16_tilemap_16b_latch_values,NULL);

    1176. 

  1176. 			break;

    1177. 

  1177. 

    1178. 

  1178. 		case SEGAIC16_TILEMAP_16B_ALT:

    1179. 

  1179. 			get_text_info = segaic16_tilemap_16b_alt_text_info;

    1180. 

  1180. 			get_tile_info = segaic16_tilemap_16b_alt_tile_info;

    1181. 

  1181. 			info->numpages = 16;

    1182. 

  1182. 			info->draw_layer = segaic16_tilemap_16b_draw_layer;

    1183. 

  1183. 			info->reset = segaic16_tilemap_16b_reset;

    1184. 

  1184.             //DAV FIX

    1185. 

  1185.             info->latch_timer = timer_alloc(machine,segaic16_tilemap_16b_latch_values,NULL);

    1186. 

  1186. 			break;

    1187. 

  1187. 

    1188. 

  1188. 		default:

    1189. 

  1189. 			fatalerror("Invalid tilemap type specified in segaic16_tilemap_init");

    1190. 

  1190. 	}

    1191. 

  1191. 

    1192. 

  1192. 	/* create the tilemap for the text layer */

    1193. 

  1193. 	info->textmap = tilemap_create(machine, get_text_info, tilemap_scan_rows,  8,8, 64,28);

    1194. 

  1194. 

    1195. 

  1195. 	/* configure it */

    1196. 

  1196. 	info->textmap_info.rambase = info->textram;

    1197. 

  1197. 	info->textmap_info.bank = info->bank;

    1198. 

  1198. 	info->textmap_info.banksize = info->banksize;

    1199. 

  1199. 	tilemap_set_user_data(info->textmap, &info->textmap_info);

    1200. 

  1200. 	tilemap_set_palette_offset(info->textmap, colorbase);

    1201. 

  1201. 	tilemap_set_transparent_pen(info->textmap, 0);

    1202. 

  1202. 	tilemap_set_scrolldx(info->textmap, -192 + xoffs, -170 + xoffs);

    1203. 

  1203. 	tilemap_set_scrolldy(info->textmap, 0, 38);

    1204. 

  1204. 

    1205. 

  1205. 	/* create the tilemaps for the tile pages */

    1206. 

  1206. 	for (pagenum = 0; pagenum < info->numpages; pagenum++)

    1207. 

  1207. 	{

    1208. 

  1208. 		/* each page is 64x32 */

    1209. 

  1209. 		info->tilemaps[pagenum] = tilemap_create(machine, get_tile_info, tilemap_scan_rows,  8,8, 64,32);

    1210. 

  1210. 

    1211. 

  1211. 		/* configure the tilemap */

    1212. 

  1212. 		info->tmap_info[pagenum].rambase = info->tileram + pagenum * 64*32;

    1213. 

  1213. 		info->tmap_info[pagenum].bank = info->bank;

    1214. 

  1214. 		info->tmap_info[pagenum].banksize = info->banksize;

    1215. 

  1215. 		tilemap_set_user_data(info->tilemaps[pagenum], &info->tmap_info[pagenum]);

    1216. 

  1216. 		tilemap_set_palette_offset(info->tilemaps[pagenum], colorbase);

    1217. 

  1217. 		tilemap_set_transparent_pen(info->tilemaps[pagenum], 0);

    1218. 

  1218. 		tilemap_set_scrolldx(info->tilemaps[pagenum], 0, 22);

    1219. 

  1219. 		tilemap_set_scrolldy(info->tilemaps[pagenum], 0, 38);

    1220. 

  1220. 	}

    1221. 

  1221. }

    1222. 

  1222. 

    1223. 

  1223. 

    1224. 

  1224. 

    1225. 

  1225. /*************************************

    1226. 

  1226.  *

    1227. 

  1227.  *  General tilemap rendering

    1228. 

  1228.  *

    1229. 

  1229.  *************************************/

    1230. 

  1230. 

    1231. 

  1231. void segaic16_tilemap_draw(running_device *screen, bitmap_t *bitmap, const rectangle *cliprect, int which, int map, int priority, int priority_mark)

    1232. 

  1232. {

    1233. 

  1233. 	running_machine *machine = screen->machine;

    1234. 

  1234. 	struct tilemap_info *info = &bg_tilemap[which];

    1235. 

  1235. 

    1236. 

  1236. 	/* text layer is a special common case */

    1237. 

  1237. 	if (map == SEGAIC16_TILEMAP_TEXT)

    1238. 

  1238. 		tilemap_draw(bitmap, cliprect, info->textmap, priority, priority_mark);

    1239. 

  1239. 

    1240. 

  1240. 	/* other layers are handled differently per-system */

    1241. 

  1241. 	else

    1242. 

  1242. 		(*info->draw_layer)(machine, info, bitmap, cliprect, map, priority, priority_mark);

    1243. 

  1243. }

    1244. 

  1244. 

    1245. 

  1245. 

    1246. 

  1246. 

    1247. 

  1247. /*************************************

    1248. 

  1248.  *

    1249. 

  1249.  *  General tilemap reset

    1250. 

  1250.  *

    1251. 

  1251.  *************************************/

    1252. 

  1252. 

    1253. 

  1253. void segaic16_tilemap_reset(running_machine *machine, int which)

    1254. 

  1254. {

    1255. 

  1255. 	struct tilemap_info *info = &bg_tilemap[which];

    1256. 

  1256. 

    1257. 

  1257. 	if (info->reset)

    1258. 

  1258. 		(*info->reset)(machine, info);

    1259. 

  1259. }

    1260. 

  1260. 

    1261. 

  1261. 

    1262. 

  1262. 

    1263. 

  1263. /*************************************

    1264. 

  1264.  *

    1265. 

  1265.  *  General tilemap banking

    1266. 

  1266.  *

    1267. 

  1267.  *************************************/

    1268. 

  1268. 

    1269. 

  1269. void segaic16_tilemap_set_bank(running_machine *machine, int which, int banknum, int offset)

    1270. 

  1270. {

    1271. 

  1271. 	struct tilemap_info *info = &bg_tilemap[which];

    1272. 

  1272. 

    1273. 

  1273. 	if (info->bank[banknum] != offset)

    1274. 

  1274. 	{

    1275. 

  1275. 		screen_device *screen = machine->primary_screen;

    1276. 

  1276. 		screen->update_partial(screen->vpos());

    1277. 

  1277. 		info->bank[banknum] = offset;

    1278. 

  1278. 		tilemap_mark_all_tiles_dirty_all(machine);

    1279. 

  1279. 	}

    1280. 

  1280. }

    1281. 

  1281. 

    1282. 

  1282. 

    1283. 

  1283. 

    1284. 

  1284. /*************************************

    1285. 

  1285.  *

    1286. 

  1286.  *  General tilemap screen flipping

    1287. 

  1287.  *

    1288. 

  1288.  *************************************/

    1289. 

  1289. 

    1290. 

  1290. void segaic16_tilemap_set_flip(running_machine *machine, int which, int flip)

    1291. 

  1291. {

    1292. 

  1292. 	struct tilemap_info *info = &bg_tilemap[which];

    1293. 

  1293. 	int pagenum;

    1294. 

  1294. 

    1295. 

  1295. 	flip = (flip != 0);

    1296. 

  1296. 	if (info->flip != flip)

    1297. 

  1297. 	{

    1298. 

  1298. 		screen_device *screen = machine->primary_screen;

    1299. 

  1299. 		screen->update_partial(screen->vpos());

    1300. 

  1300. 		info->flip = flip;

    1301. 

  1301. 		tilemap_set_flip(info->textmap, flip ? (TILEMAP_FLIPX | TILEMAP_FLIPY) : 0);

    1302. 

  1302. 		for (pagenum = 0; pagenum < info->numpages; pagenum++)

    1303. 

  1303. 			tilemap_set_flip(info->tilemaps[pagenum], flip ? (TILEMAP_FLIPX | TILEMAP_FLIPY) : 0);

    1304. 

  1304. 	}

    1305. 

  1305. }

    1306. 

  1306. 

    1307. 

  1307. 

    1308. 

  1308. 

    1309. 

  1309. /*************************************

    1310. 

  1310.  *

    1311. 

  1311.  *  General tilemap row scroll enable

    1312. 

  1312.  *

    1313. 

  1313.  *************************************/

    1314. 

  1314. 

    1315. 

  1315. void segaic16_tilemap_set_rowscroll(running_machine *machine, int which, int enable)

    1316. 

  1316. {

    1317. 

  1317. 	struct tilemap_info *info = &bg_tilemap[which];

    1318. 

  1318. 

    1319. 

  1319. 	enable = (enable != 0);

    1320. 

  1320. 	if (info->rowscroll != enable)

    1321. 

  1321. 	{

    1322. 

  1322. 		screen_device *screen = machine->primary_screen;

    1323. 

  1323. 		screen->update_partial(screen->vpos());

    1324. 

  1324. 		info->rowscroll = enable;

    1325. 

  1325. 	}

    1326. 

  1326. }

    1327. 

  1327. 

    1328. 

  1328. 

    1329. 

  1329. 

    1330. 

  1330. /*************************************

    1331. 

  1331.  *

    1332. 

  1332.  *  General tilemap column scroll enable

    1333. 

  1333.  *

    1334. 

  1334.  *************************************/

    1335. 

  1335. 

    1336. 

  1336. void segaic16_tilemap_set_colscroll(running_machine *machine, int which, int enable)

    1337. 

  1337. {

    1338. 

  1338. 	struct tilemap_info *info = &bg_tilemap[which];

    1339. 

  1339. 

    1340. 

  1340. 	enable = (enable != 0);

    1341. 

  1341. 	if (info->colscroll != enable)

    1342. 

  1342. 	{

    1343. 

  1343. 		screen_device *screen = machine->primary_screen;

    1344. 

  1344. 		screen->update_partial(screen->vpos());

    1345. 

  1345. 		info->colscroll = enable;

    1346. 

  1346. 	}

    1347. 

  1347. }

    1348. 

  1348. 

    1349. 

  1349. 

    1350. 

  1350. 

    1351. 

  1351. /*************************************

    1352. 

  1352.  *

    1353. 

  1353.  *  General tilemap write handlers

    1354. 

  1354.  *

    1355. 

  1355.  *************************************/

    1356. 

  1356. 

    1357. 

  1357. WRITE16_HANDLER( segaic16_tileram_0_w )

    1358. 

  1358. {

    1359. 

  1359. 	COMBINE_DATA(&segaic16_tileram_0[offset]);

    1360. 

  1360. 	tilemap_mark_tile_dirty(bg_tilemap[0].tilemaps[offset / (64*32)], offset % (64*32));

    1361. 

  1361. }

    1362. 

  1362. 

    1363. 

  1363. 

    1364. 

  1364. WRITE16_HANDLER( segaic16_textram_0_w )

    1365. 

  1365. {

    1366. 

  1366. 	/* certain ranges need immediate updates */

    1367. 

  1367. 	if (offset >= 0xe80/2)

    1368. 

  1368. 		space->machine->primary_screen->update_partial(space->machine->primary_screen->vpos());

    1369. 

  1369. 

    1370. 

  1370. 	COMBINE_DATA(&segaic16_textram_0[offset]);

    1371. 

  1371. 	tilemap_mark_tile_dirty(bg_tilemap[0].textmap, offset);

    1372. 

  1372. }

    1373. 

  1373. 

    1374. 

  1374. 

    1375. 

  1375. 

    1376. 

  1376. 

    1377. 

  1377. 

    1378. 

  1378. /*******************************************************************************************

    1379. 

  1379.  *

    1380. 

  1380.  *  Hang On/Space Harrier-style road chip

    1381. 

  1381.  *

    1382. 

  1382.  *  Road RAM:

    1383. 

  1383.  *      Offset   Bits               Usage

    1384. 

  1384.  *      000-1FF  ----pp-- --------  road priority versus tilemaps and sprites

    1385. 

  1385.  *               ------s- --------  (Hang On only) Stripe coloring enable (1=enable)

    1386. 

  1386.  *               ------s- --------  (Space Harrier only) Solid color fill (1=solid, 0=from ROM)

    1387. 

  1387.  *               -------m --------  mirror enable (1=enable)

    1388. 

  1388.  *               -------- iiiiiiii  index for other tables

    1389. 

  1389.  *               -------- rrrrrrrr  road ROM line select

    1390. 

  1390.  *      200-3FF  ----hhhh hhhhhhhh  horizontal scroll

    1391. 

  1391.  *      400-5FF  --bbbbbb --------  background color (colorset 0)

    1392. 

  1392.  *               -------- --bbbbbb  background color (colorset 1)

    1393. 

  1393.  *      600-7FF  -------- s-------  stripe color index (colorset 1)

    1394. 

  1394.  *               -------- -s------  stripe color index (colorset 0)

    1395. 

  1395.  *               -------- --a-----  pixel value 2 color index (colorset 1)

    1396. 

  1396.  *               -------- ---a----  pixel value 2 color index (colorset 0)

    1397. 

  1397.  *               -------- ----b---  pixel value 1 color index (colorset 1)

    1398. 

  1398.  *               -------- -----b--  pixel value 1…
    1399.