summaryrefslogtreecommitdiffstatshomepage
path: root/src/mame/video/liberatr.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mame/video/liberatr.cpp')
-rw-r--r--src/mame/video/liberatr.cpp313
1 files changed, 0 insertions, 313 deletions
diff --git a/src/mame/video/liberatr.cpp b/src/mame/video/liberatr.cpp
deleted file mode 100644
index eb24737053d..00000000000
--- a/src/mame/video/liberatr.cpp
+++ /dev/null
@@ -1,313 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:Stefan Jokisch
-/***************************************************************************
-
- video/liberatr.c
-
- Functions to emulate the video hardware of the machine.
-
- Liberator's screen is 256 pixels by 256 pixels. The
- round planet in the middle of the screen is 128 pixels
- tall by 96 equivalent (192 at double pixel rate). The
- emulator needs to account for the aspect ratio of 4/3
- from the arcade video system in order to make the planet
- appear round.
-
-***************************************************************************/
-
-#include "emu.h"
-#include "includes/liberatr.h"
-
-
-#define NUM_PENS (0x18)
-
-
-
-
-WRITE8_MEMBER( liberatr_state::bitmap_xy_w )
-{
- m_videoram[(*m_ycoord << 8) | *m_xcoord] = data & 0xe0;
-}
-
-
-READ8_MEMBER( liberatr_state::bitmap_xy_r )
-{
- return m_videoram[(*m_ycoord << 8) | *m_xcoord];
-}
-
-
-WRITE8_MEMBER( liberatr_state::bitmap_w )
-{
- uint8_t x, y;
-
- m_bitmapram[offset] = data;
-
- offset += 3;
- x = (offset & 0x3f) << 2;
- y = offset >> 6;
-
- data = data & 0xe0;
-
- m_videoram[(y << 8) | x | 0] = data;
- m_videoram[(y << 8) | x | 1] = data;
- m_videoram[(y << 8) | x | 2] = data;
- m_videoram[(y << 8) | x | 3] = data;
-}
-
-
-/********************************************************************************************
- liberatr_init_planet()
-
- The data for the planet is stored in ROM using a run-length type of encoding. This
- function does the conversion to the above structures and then a smaller
- structure which is quicker to use in real time.
-
- Its a multi-step process, reflecting the history of the code. Not quite as efficient
- as it might be, but this is not realtime stuff, so who cares...
- ********************************************************************************************/
-
-void liberatr_state::init_planet(planet &liberatr_planet, uint8_t *planet_rom)
-{
- uint16_t longitude;
-
- const uint8_t *latitude_scale = memregion("user1")->base();
- const uint8_t *longitude_scale = memregion("user2")->base();
-
- /* for each starting longitude */
- for (longitude = 0; longitude < 0x100; longitude++)
- {
- uint8_t i, latitude, start_segment, segment_count;
- uint8_t *buffer;
-
- planet_frame frame;
- planet_frame_line *line = nullptr;
-
- uint16_t total_segment_count = 0;
-
- /* for each latitude */
- for (latitude = 0; latitude < 0x80; latitude++)
- {
- uint8_t segment, longitude_scale_factor, latitude_scale_factor, color, x=0;
- uint8_t x_array[32], color_array[32], visible_array[32];
-
- /* point to the structure which will hold the data for this line */
- line = &frame.lines[latitude];
-
- latitude_scale_factor = latitude_scale[latitude];
-
- /* for this latitude, load the 32 segments into the arrays */
- for (segment = 0; segment < 0x20; segment++)
- {
- uint16_t length, planet_data, address;
-
- /*
- read the planet picture ROM and get the
- latitude and longitude scaled from the scaling PROMS
- */
- address = (latitude << 5) + segment;
- planet_data = (planet_rom[address] << 8) | planet_rom[address + 0x1000];
-
- color = (planet_data >> 8) & 0x0f;
- length = ((planet_data << 1) & 0x1fe) + ((planet_data >> 15) & 0x01);
-
-
- /* scale the longitude limit (adding the starting longitude) */
- address = longitude + ( length >> 1 ) + ( length & 1 ); /* shift with rounding */
- visible_array[segment] = (( address & 0x100 ) ? 1 : 0);
- if (address & 0x80)
- {
- longitude_scale_factor = 0xff;
- }
- else
- {
- address = ((address & 0x7f) << 1) + (((length & 1) || visible_array[segment]) ? 0 : 1);
- longitude_scale_factor = longitude_scale[address];
- }
-
- x_array[segment] = (((uint16_t)latitude_scale_factor * (uint16_t)longitude_scale_factor) + 0x80) >> 8; /* round it */
- color_array[segment] = color;
- }
-
- /*
- determine which segment is the western horizon and
- leave 'segment' indexing it.
- */
- for (segment = 0; segment < 0x1f; segment++) /* if not found, 'segment' = 0x1f */
- if (visible_array[segment]) break;
-
- /* transfer from the temporary arrays to the structure */
- line->max_x = (latitude_scale_factor * 0xc0) >> 8;
- if (line->max_x & 1)
- line->max_x += 1; /* make it even */
-
- /*
- as part of the quest to reduce memory usage (and to a lesser degree
- execution time), stitch together segments that have the same color
- */
- segment_count = 0;
- i = 0;
- start_segment = segment;
-
- do
- {
- color = color_array[segment];
- while (color == color_array[segment])
- {
- x = x_array[segment];
- segment = (segment+1) & 0x1f;
- if (segment == start_segment)
- break;
- }
-
- line->color_array[i] = color;
- line->x_array[i] = (x > line->max_x) ? line->max_x : x;
- i++;
- segment_count++;
- } while ((i < 32) && (x <= line->max_x));
-
- total_segment_count += segment_count;
- line->segment_count = segment_count;
- }
-
- /* now that the all the lines have been processed, and we know how
- many segments it will take to store the description, allocate the
- space for it and copy the data to it.
- */
- buffer = auto_alloc_array(machine(), uint8_t, 2*(128 + total_segment_count));
-
- liberatr_planet.frames[longitude] = buffer;
-
- for (latitude = 0; latitude < 0x80; latitude++)
- {
- uint8_t last_x;
-
-
- line = &frame.lines[latitude];
- segment_count = line->segment_count;
- *buffer++ = segment_count;
- last_x = 0;
-
- /* calculate the bitmap's x coordinate for the western horizon
- center of bitmap - (the number of planet pixels) / 4 */
- *buffer++ = (m_screen->width() / 2) - ((line->max_x + 2) / 4);
-
- for (i = 0; i < segment_count; i++)
- {
- uint8_t current_x = (line->x_array[i] + 1) / 2;
-
- *buffer++ = line->color_array[i];
- *buffer++ = current_x - last_x;
-
- last_x = current_x;
- }
- }
- }
-}
-
-
-/***************************************************************************
-
- Start the video hardware emulation.
-
-***************************************************************************/
-
-void liberatr_state::video_start()
-{
- // for each planet in the planet ROMs
- init_planet(m_planets[0], &memregion("gfx1")->base()[0x2000]);
- init_planet(m_planets[1], &memregion("gfx1")->base()[0x0000]);
-
- save_item(NAME(m_planet_select));
-}
-
-
-void liberatr_state::get_pens(pen_t *pens)
-{
- offs_t i;
-
- for (i = 0; i < NUM_PENS; i++)
- {
- uint8_t r,g,b;
-
- /* handle the hardware flip of the bit order from 765 to 576 that
- hardware does between vram and color ram */
- static const offs_t penmap[] = { 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
- 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
- 0x10, 0x12, 0x14, 0x16, 0x11, 0x13, 0x15, 0x17 };
-
- uint8_t data = m_colorram[i];
-
- /* scale it from 0x00-0xff */
- r = ((~data >> 3) & 0x07) * 0x24 + 3; if (r == 3) r = 0;
- g = ((~data >> 0) & 0x07) * 0x24 + 3; if (g == 3) g = 0;
- b = ((~data >> 5) & 0x06) * 0x24 + 3; if (b == 3) b = 0;
-
- pens[penmap[i]] = rgb_t(r, g, b);
- }
-}
-
-
-void liberatr_state::draw_planet(bitmap_rgb32 &bitmap, pen_t *pens)
-{
- uint8_t latitude;
-
- uint8_t *buffer = m_planets[m_planet_select].frames[*m_planet_frame];
-
- /* for each latitude */
- for (latitude = 0; latitude < 0x80; latitude++)
- {
- uint8_t segment;
-
- /* grab the color value for the base (if any) at this latitude */
- uint8_t base_color = m_base_ram[latitude >> 3] ^ 0x0f;
-
- uint8_t segment_count = *buffer++;
- uint8_t x = *buffer++;
- uint8_t y = 64 + latitude;
-
- /* run through the segments, drawing its color until its x_array value comes up. */
- for (segment = 0; segment < segment_count; segment++)
- {
- uint8_t i;
-
- uint8_t color = *buffer++;
- uint8_t segment_length = *buffer++;
-
- if ((color & 0x0c) == 0x0c)
- color = base_color;
-
- for (i = 0; i < segment_length; i++, x++)
- bitmap.pix32(y, x) = pens[color];
- }
- }
-}
-
-
-void liberatr_state::draw_bitmap(bitmap_rgb32 &bitmap, pen_t *pens)
-{
- offs_t offs;
-
- for (offs = 0; offs < 0x10000; offs++)
- {
- uint8_t data = m_videoram[offs];
-
- uint8_t y = offs >> 8;
- uint8_t x = offs & 0xff;
-
- if (data)
- bitmap.pix32(y, x) = pens[(data >> 5) | 0x10];
- }
-}
-
-
-uint32_t liberatr_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
-{
- pen_t pens[NUM_PENS];
- get_pens(pens);
-
- bitmap.fill(rgb_t::black(), cliprect);
- draw_planet(bitmap, pens);
- draw_bitmap(bitmap, pens);
-
- return 0;
-}