retrograph 0.2.1

data/README

@@ -0,0 +1,248 @@
+== What is Retrograph? ==
+
+Retrograph is a Ruby library which emulates the video
+display unit from a hypothetical late-80s 8-bit game
+console.  It is similar in capability to the Sega Master
+System's VDP, with some additional features and direct
+support for text modes.
+
+Retrograph requires Ruby/SDL and outputs to an SDL
+surface.
+
+== Feature Overview ==
+
+ * 256x244 pixel display
+ * 16k VRAM
+ * 40x25 and 32x28 text modes
+ * 2bpp and 4bpp graphics modes
+ * 64 colors total
+ * 31 simultaneous colors (16 background, 15 sprite)
+ * 32x32 background layer
+ * 64 sprites, max 8 per scanline
+
+== Usage ==
+
+Retrograph's simulated Video Display Unit (or VDU) is
+represented by an instance of the Retrograph::VDU class.
+You can interact with the VDU by writing byte strings
+into its memory using Retrograph::VDU#write, which takes
+a start address (in the VDU's 16-bit address space) and
+a string to write.
+
+To render a frame of video, use
+Retrograph::VDU#render_frame.  The SDL surface which
+serves as an output buffer is available via
+Retrograph::VDU#surface.
+
+Scanline-based effects are possible if you provide a block
+to Retrograph::VDU#render_frame and call
+Retrograph::VDU#render_scanlines to render scanlines in
+between the execution of Ruby code.  For example, if we
+wanted palette entry 0 to be blue within the top half of
+the display and red within the bottom half of the display,
+we could write:
+
+ vdu.render_frame do
+   vdu.write(0x7f00, "\x03")
+   vdu.render_scanlines(Retrograph::DISPLAY_HEIGHT/2)
+   vdu.write(0x7f00, "\x30")
+ end
+
+The integer passed to Retrograph::VDU#render_scanlines is
+an integer count of scanlines to render; each call renders
+an additional number of scanlines.  Any remaining scanlines
+not rendered by calls to Retrograph::VDU#render_scanlines
+are rendered by Retrograph::VDU#render_frame when the block
+completes.
+
+See the end of this document for a map of registers and
+memory locations within the VDU's address space.
+
+== Important Notes ==
+
+Both background (and sprites, in graphics modes) must be
+explicitly enabled by setting bits 2 (and 3) of register
+$7FF8 or else they will not be displayed.
+
+Patterns and name tables may overlap in memory (they must
+do so in graphics modes); typically you cannot have
+simultaneously valid pattern and name data at the same
+location, so in those cases you will need to sacrifice
+particular name or pattern entries.
+
+Unlike most authentic 8-bit systems, any register or memory
+location may be changed in between scanlines, including the
+vertical scroll register and even the video mode.  This
+permits fairly powerful split-screen effects, and in some
+cases may be used to exceed simultaneous color, sprite, or
+pattern limitations.
+
+In text modes, you will need to load your own font into the
+pattern table; the VDU does not provide one by default.
+
+Also unlike most authentic 8-bit systems, Retrograph uses a
+packed rather than a planar representation for pattern
+data.  Additionally, within each byte of pattern data, the
+leftmost pixels are in the least significant position,
+which may be backwards from what you expect.
+
+Sprites patterns are always 4bpp, even in the 2bpp mode.
+In Graphics A, one half of VRAM is occupied by 512 2bpp
+patterns (for the background), and the other half by 256
+4bpp patterns for sprites.  In Graphics B, the entirety
+of VRAM is occupied by just 512 4bpp patterns, with the
+upper half of those available to sprites.
+
+When scrolling horizontally, the leftmost background
+column will not be displayed if it is partway offscreen.
+
+== VDU Memory Map ==
+
+$0000 - $3FFF: VRAM (16 kbytes)
+$4000 - $7DFF: VRAM (mirror) (16 kbytes - 512 bytes)
+$7E00 - $7EFF: Sprite Table* (256 bytes)
+$7F00 - $7F0F: BG Palette (16 bytes)
+$7F10 - $7F1F: BG/Sprite Palette* (16 bytes)
+$7F20 - $7FF7: unused (216 bytes)
+$7FF8 - $7FFF: VDU Registers (8 bytes)
+                 $7FF8: Flags
+                        4-7: unused
+                        3: Enable Sprites*
+                        2: Enable BG
+                        0-1: Mode
+                               00 - Text A (40x25)
+                               01 - Text B (32x28)
+                               10 - Graphics A (2bpp)
+                               11 - Graphics B (4bpp)
+                 $7FF9: Pattern Table Base
+                        Text A + B:
+                          addr = (base & 0b00110000) << 8
+                          base = $00, $10, $20, or $30
+                          addr = $0000, $1000, $2000, or
+                                 $3000
+                        Graphics A + B:
+                          addr = (base & 0b00100000) << 8
+                          base = $00 or $20
+                          addr = $0000 or $2000
+                 $7FFA: Name Table Base
+                        addr = ((base & 0b00110000) |
+                                0b00001000) << 8
+                        base = $00, $10, $20, or $30
+                        addr = $0800, $1800, $2800, or
+                               $3800
+                 $7FFB: unused
+                 $7FFC: BG scroll X*
+                 $7FFD: BG scroll Y**
+                 $7FFE-7FFF: unused
+$8000 - $FFFF: mirror of $0000 - $7FFF
+
+Notes:
+  *Ignored in text modes
+  **In text modes, the lower 3 bits of the vertical scroll
+    register are ignored and it wraps at 200 (Text A) or
+    224 (Text B)
+
+=== Pattern Table ===
+
+The starting address of the pattern table is determined by
+register $7FF9.
+
+The rows constituting each pattern in the table are given
+in sequence from top to bottom.  Within each byte, the
+leftmost pixel is in the least significant position.
+
+Text A: 256 patterns * 8 bytes per pattern = 2k
+        6x8 pixel patterns
+        1 byte per pattern row, 1 bit per pixel
+        most significant 2 bits ignored
+
+Text B: 256 patterns * 8 bytes per pattern = 2k
+        8x8 pixel patterns
+        1 byte per patern row, 1 bit per pixel
+
+Graphics A: 512 bg patterns * 16 bytes per pattern +
+            256 sprite patterns * 32 bytes/pattern = 16k
+            8x8 pixel patterns
+            2 bytes/pattern row, 2 bits/pixel (bg)
+            4 bytes/pattern row, 4 bits/pixel (sprites)
+
+Graphics B: 512 patterns * 32 bytes per pattern = 16k
+            8x8 pixel patterns
+            4 bytes/pattern row, 4 bits/pixel
+            last 256 patterns shared with sprites
+
+=== Name Table ===
+
+The starting address of the name table is determined by
+register $7FFA.
+
+Table sizes:
+
+  Text A: 40x25 characters * 2 bytes/character = 2000 bytes
+  Text B: 32x28 characters * 2 bytes/character = 1792 bytes
+  Graphics A + B: 32x32 tiles * 2 bytes per tile = 2k
+
+Cell formats:
+
+  Text: pppppppp bbbbffff
+    p - pattern index
+    f - foreground color
+    b - background color
+
+  Graphics: pppppppp -bhvcccP
+    p - low byte of pattern index
+    P - high bit of pattern index
+    c - high bits of color
+    h - horizontal flip
+    v - vertical flip
+    b - background priority
+
+In graphics modes, the color is computed by taking the high
+color bits and oring them with the pattern color to get a
+color in the range 0-31 (with the upper 16 colors coming
+from the sprite palette):
+
+ color = pattern_color | (high_bits << 2)
+
+(However, a pattern color of 0 is always transparent
+regardless of the high color bits.)
+
+=== Sprite Table ===
+
+Sprite patterns start 2k bytes after the pattern table base
+address specified in register $7FF9.  The sprite table
+itself always begins at $7E00.
+
+4 bytes * 64 sprites = 256 bytes
+
+xxxxxxxx yyyyyyyy pppppppp --hvHVcc
+
+  x - X position (left edge)
+  y - Y position + 1 (top edge) (0 = hidden)
+  p - pattern index
+  h - horizontal flip
+  v - vertical flip
+  H - double size horizontally
+  V - double size vertically
+  c - high bits of color
+
+Sprite colors are computed as follows:
+
+ color = pattern_color | (high_bits << 2) | 16;
+
+(As with tiles, a pattern color of 0 is always transparent.)
+
+=== Palette Table ===
+
+The palette table always begins at $7F00.
+
+1 byte * 32 colors (16 bg, 16 bg/sprite)
+
+--rrggbb
+
+r - red
+g - green
+b - blue
+
+Note that the first sprite color (color 16) is effectively
+never used.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rake'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'rake/clean'
+
+GEM_VERSION = '0.2.1'
+
+CLEAN.include("**/*.o")
+CLEAN.include("**/*.so")
+CLEAN.include("spec/**/*-output.bmp")
+CLOBBER.include("ext/Makefile")
+
+task :clobber => [:clean]
+
+Spec::Rake::SpecTask.new do |task|
+  task.ruby_opts << '-rrubygems'
+  task.libs << 'ext'
+  task.spec_files = FileList["spec/**/*_spec.rb"]
+end
+
+task :build do
+  sh "cd ext && #{Gem.ruby} extconf.rb && make"
+end
+
+gemspec = Gem::Specification.new do |gemspec|
+  gemspec.name = "retrograph"
+  gemspec.version = GEM_VERSION
+  gemspec.author = "MenTaLguY <mental@rydia.net>"
+  gemspec.summary = "Retrograph, a retrodisplay."
+  gemspec.description = <<EOS
+Retrograph is a software scanline renderer which simulates a late-era 8-bit display.
+Its graphical capabilities are similar to those of the Sega Master System.
+EOS
+  gemspec.homepage = "http://rubyforge.org/projects/retrograph"
+  gemspec.email = "mental@rydia.net"
+  gemspec.rubyforge_project = 'retrograph'
+  gemspec.files = FileList['Rakefile', 'README',
+                           'src/retrograph.h', 'src/retrograph.c',
+                           'ext/extconf.rb', 'ext/retrograph.c',
+                           'spec/**/*_spec.rb', 'spec/**/*.case',
+                           'spec/**/*.png']
+  gemspec.extensions = ['ext/extconf.rb']
+  gemspec.require_paths = ['ext']
+  gemspec.platform = Gem::Platform::RUBY
+  gemspec.add_dependency("rubysdl", ">= 1.3.0")
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.need_tar = true
+end
+
+task :spec => [:build]
+task :package => [:clean, :spec]
+task :default => [:clean, :spec]

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('retrograph')

data/ext/retrograph.c

@@ -0,0 +1,275 @@
+/* retrograph
+ * 
+ * Copyright (c) 2009  MenTaLguY <mental@rydia.net>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <ruby.h>
+#include <intern.h>
+#include <string.h>
+
+#include "../src/retrograph.h"
+#include "../src/retrograph.c"
+
+/* First few fields of SDL_Surface */
+typedef struct surface_header_tag {
+    uint32_t flags;
+    struct pixelformat_tag *format; /* abstract */
+    int w, h;
+    uint16_t pitch;
+    void *pixels;
+} surface_header_t;
+
+/* for Ruby/SDL 2.x, which indirectly wraps surfaces */
+typedef struct rubysdl2_surface_tag {
+    surface_header_t *surface;
+} rubysdl2_surface_t;
+
+typedef struct vdu_wrapper_tag {
+    retrograph_vdu_t vdu;
+    VALUE surface;
+    int scanline;
+} vdu_wrapper_t;
+
+#define NOT_IN_FRAME -1
+
+static VALUE mRetrograph = Qnil;
+static VALUE cVDU = Qnil;
+static VALUE eRenderError = Qnil;
+static VALUE mSDL = Qnil;
+static VALUE cSurface = Qnil;
+static VALUE CREATE_SURFACE_METHOD_NAME = Qnil;
+
+static surface_header_t *get_rubysdl_surface_1_x(VALUE surface_r) {
+    surface_header_t *surface;
+    Data_Get_Struct(surface_r, surface_header_t, surface);
+    return surface;
+}
+
+static surface_header_t *get_rubysdl_surface_2_x(VALUE surface_r) {
+    rubysdl2_surface_t *surface;
+    Data_Get_Struct(surface_r, rubysdl2_surface_t, surface);
+    return surface->surface;
+}
+
+static surface_header_t *(*get_rubysdl_surface)(VALUE surface_r) = NULL;
+
+static void check_errors(retrograph_vdu_t vdu) {
+    retrograph_error_t error;
+    error = retrograph_get_error(vdu);
+    switch (error) {
+    case RETROGRAPH_OK:
+        return;
+    case RETROGRAPH_NO_MEMORY:
+        rb_memerror();
+    case RETROGRAPH_INVALID_ARGUMENT:
+        rb_raise(rb_const_get(rb_cObject, rb_intern("ArgumentError")),
+                 "Invalid argument");
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown error");
+    }
+}
+
+static void mark_vdu(vdu_wrapper_t *vdu) {
+    rb_gc_mark(vdu->surface);
+}
+
+static void free_vdu(vdu_wrapper_t *vdu) {
+    if (vdu->vdu) {
+        retrograph_destroy(vdu->vdu);
+    }
+    xfree(vdu);
+}
+
+static VALUE rescue_free_vdu(VALUE data, VALUE exc) {
+    free_vdu((vdu_wrapper_t *)data);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE alloc_vdu2(VALUE data);
+
+static VALUE alloc_vdu(VALUE klass) {
+    vdu_wrapper_t *vdu;
+    VALUE vdu_r;
+    vdu = ALLOC(vdu_wrapper_t);
+    vdu->vdu = NULL;
+    vdu->surface = Qnil;
+    vdu->scanline = NOT_IN_FRAME;
+    rb_rescue2(alloc_vdu2, (VALUE)vdu,
+               rescue_free_vdu, (VALUE)vdu,
+               rb_eException, (VALUE)0);
+    return Data_Wrap_Struct(klass, mark_vdu, free_vdu, vdu);
+}
+
+VALUE alloc_vdu2(VALUE data) {
+    vdu_wrapper_t *vdu=(vdu_wrapper_t *)data;
+    VALUE surface;
+    surface = rb_funcall(cSurface, SYM2ID(CREATE_SURFACE_METHOD_NAME), 8,
+                         INT2FIX(0), /* flags */
+                         INT2FIX(RETROGRAPH_DISPLAY_WIDTH),
+                         INT2FIX(RETROGRAPH_DISPLAY_HEIGHT),
+                         INT2FIX(RETROGRAPH_BITS_PER_PIXEL),
+                         INT2FIX(RETROGRAPH_RED_MASK),
+                         INT2FIX(RETROGRAPH_GREEN_MASK),
+                         INT2FIX(RETROGRAPH_BLUE_MASK),
+                         INT2FIX(RETROGRAPH_ALPHA_MASK));
+    vdu->surface = surface;
+    vdu->vdu = retrograph_new();
+    check_errors(vdu->vdu);
+    return Qnil;
+}
+
+static VALUE vdu_write(VALUE self, VALUE start_address_r, VALUE data_r) {
+    vdu_wrapper_t *vdu;
+    retrograph_addr_t start_address;
+    Check_Type(data_r, T_STRING);
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    start_address = (retrograph_addr_t)NUM2INT(start_address_r);
+    retrograph_write(vdu->vdu, start_address, RSTRING(data_r)->ptr,
+                     (size_t)RSTRING(data_r)->len);
+    return Qnil;
+}
+
+static VALUE vdu_get_surface(VALUE self) {
+    vdu_wrapper_t *vdu;
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    return vdu->surface;
+}
+
+static VALUE vdu_render_scanlines(VALUE self, VALUE n_scanlines_r) {
+    vdu_wrapper_t *vdu;
+    surface_header_t *surface;
+    uint8_t *current_line;
+    int max_scanline;
+
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+
+    if (vdu->scanline == NOT_IN_FRAME) {
+        rb_raise(eRenderError, "Not in frame");
+    }
+
+    surface = get_rubysdl_surface(vdu->surface);
+
+    max_scanline = (int)NUM2UINT(n_scanlines_r) + vdu->scanline;
+    if (max_scanline > RETROGRAPH_DISPLAY_HEIGHT) {
+        max_scanline = RETROGRAPH_DISPLAY_HEIGHT;
+    }
+
+    current_line = (uint8_t *)surface->pixels + vdu->scanline * surface->pitch;
+    for (; vdu->scanline < max_scanline; vdu->scanline++) {
+        retrograph_render_scanline(vdu->vdu, current_line,
+                                   RETROGRAPH_DISPLAY_WIDTH *
+                                   RETROGRAPH_BYTES_PER_PIXEL);
+        check_errors(vdu->vdu);
+        current_line += surface->pitch;
+    }
+
+    return Qnil;
+}
+
+static VALUE vdu_render_frame_inner(VALUE self) {
+    vdu_wrapper_t *vdu;
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    retrograph_begin_frame(vdu->vdu);
+    check_errors(vdu->vdu);
+    vdu->scanline = 0;
+    if (rb_block_given_p()) {
+        rb_yield(Qundef);
+    }
+    vdu_render_scanlines(self, INT2FIX(RETROGRAPH_DISPLAY_HEIGHT));
+    return Qnil;
+}
+
+static VALUE vdu_render_frame_cleanup(VALUE self) {
+    vdu_wrapper_t *vdu;
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    vdu->scanline = NOT_IN_FRAME;
+    return Qnil;
+}
+
+static VALUE vdu_render_frame(VALUE self) {
+    vdu_wrapper_t *vdu;
+    int block_given;
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    block_given = rb_block_given_p();
+    if (vdu->scanline != NOT_IN_FRAME) {
+        rb_raise(eRenderError, "Already in frame");
+    }
+    rb_ensure(vdu_render_frame_inner, self, vdu_render_frame_cleanup, self);
+    return vdu->surface;
+}
+
+void Init_retrograph(void) {
+    VALUE rubysdl_version;
+    rb_require("sdl");
+
+    rb_global_variable(&mSDL);
+    mSDL = rb_const_get(rb_cObject, rb_intern("SDL"));
+    rb_global_variable(&cSurface);
+    cSurface = rb_const_get(mSDL, rb_intern("Surface"));
+
+    rubysdl_version = rb_const_get(mSDL, rb_intern("VERSION"));
+    rb_global_variable(&CREATE_SURFACE_METHOD_NAME);
+    if (!strncmp(StringValueCStr(rubysdl_version), "1.", 2)) {
+        CREATE_SURFACE_METHOD_NAME = ID2SYM(rb_intern("new"));
+        get_rubysdl_surface = get_rubysdl_surface_1_x;
+    } else if (!strncmp(StringValueCStr(rubysdl_version), "2.", 2)) {
+        CREATE_SURFACE_METHOD_NAME = ID2SYM(rb_intern("createWithFormat"));
+        get_rubysdl_surface = get_rubysdl_surface_2_x;
+    } else {
+        rb_raise(rb_eLoadError, "Unrecognized Ruby/SDL version");
+    }
+
+    rb_global_variable(&mRetrograph);
+    mRetrograph = rb_define_module("Retrograph");
+
+#define DEFINE_CONSTANT(base_name) \
+    rb_const_set(mRetrograph, rb_intern(#base_name), \
+                 INT2FIX(RETROGRAPH_##base_name))
+
+    DEFINE_CONSTANT(DISPLAY_WIDTH);
+    DEFINE_CONSTANT(DISPLAY_HEIGHT);
+    DEFINE_CONSTANT(BYTES_PER_PIXEL);
+    DEFINE_CONSTANT(BITS_PER_PIXEL);
+
+    DEFINE_CONSTANT(RED_SHIFT);
+    DEFINE_CONSTANT(GREEN_SHIFT);
+    DEFINE_CONSTANT(BLUE_SHIFT);
+
+    DEFINE_CONSTANT(RED_MASK);
+    DEFINE_CONSTANT(GREEN_MASK);
+    DEFINE_CONSTANT(BLUE_MASK);
+    DEFINE_CONSTANT(ALPHA_MASK);
+
+#undef DEFINE_CONSTANT
+
+    rb_global_variable(&cVDU);
+    cVDU = rb_define_class_under(mRetrograph, "VDU", rb_cObject);
+
+    rb_global_variable(&eRenderError);
+    eRenderError = rb_define_class_under(mRetrograph, "RenderError",
+                                         rb_eRuntimeError);
+
+    rb_define_alloc_func(cVDU, alloc_vdu);
+    rb_define_method(cVDU, "write", vdu_write, 2);
+    rb_define_method(cVDU, "surface", vdu_get_surface, 0);
+    rb_define_method(cVDU, "render_frame", vdu_render_frame, 0);
+    rb_define_method(cVDU, "render_scanlines", vdu_render_scanlines, 1);
+}

data/spec/image-specs/color-blue-bits.case

@@ -0,0 +1,2 @@
+should use color bits 0-1 for blue
+7f00: 03

data/spec/image-specs/color-green-bits.case

@@ -0,0 +1,2 @@
+should use color bits 2-3 for green
+7f00: 0c

data/spec/image-specs/color-red-bits.case

@@ -0,0 +1,2 @@
+should use color bits 4-5 for red
+7f00: 30

data/spec/image-specs/default-screen-black.case

@@ -0,0 +1 @@
+should fill the screen with black by default

data/spec/image-specs/default-screen-color-0.case

@@ -0,0 +1,2 @@
+should fill the screen with color 0 by default
+7f00: ff

data/spec/image-specs/scroll-mode1.case

@@ -0,0 +1,7 @@
+should support text-style scrolling in mode 1
+7ff8: 05
+7ffc: 0c 0c
+7f00: 00 ff
+0008: 01 03 07 0f 1f 3f 7f ff ff 7f 3f 1f 0f 07 03 01
+0800: 0101
+0840: 0102

data/spec/image-specs/scroll-mode2.case

@@ -0,0 +1,10 @@
+should support smooth scrolling in mode 2
+7ff8: 06
+7ffc: 0c 84
+7f00: 00 ff
+0010: 0001 0005 0015 0055  0155 0555 1555 5555
+0020: 5555 1555 0555 0155  0055 0015 0005 0001
+0030: 1111 4444 1111 4444  1111 4444 1111 4444
+0c00: 0002
+0ac0: 0001
+0b00: 0003

data/spec/image-specs/scroll-mode3.case

@@ -0,0 +1,10 @@
+should support smooth scrolling in mode 3
+7ff8: 07
+7ffc: 0c 84
+7f00: 00 ff
+0020: 00000001 00000011 00000111 00001111  00011111 00111111 01111111 11111111
+0040: 11111111 01111111 00111111 00011111  00001111 00000111 00000011 00000001
+0060: 01010101 10101010 01010101 10101010  01010101 10101010 01010101 10101010
+0c00: 0002
+0ac0: 0001
+0b00: 0003

data/spec/image-specs/sprites-doubling.case

@@ -0,0 +1,5 @@
+should render doubled sprites
+7ff8: 0b
+7f10: 00 3f
+7e00: 00 01 0001   10 01 0801  00 11 0401  10 11 0c01
+2020: 10101010 01010101 10101010 01010101  10101010 01010101 10101010 01010101

data/spec/image-specs/sprites-mode2.case

@@ -0,0 +1,8 @@
+should show first 8 sprites per line in mode 2
+7ff8: 0a
+7f10: 00 02 08 0a  20 22 38 2a  15 17 1d 1f  35 37 3d 3f
+7e00: 00 01 0001   08 01 0002  10 01 0101  18 01 0102
+7e10: 20 01 0201   28 01 0202  30 01 0301  38 01 0302
+7e20: 40 01 0001   48 01 0002  50 01 0001  58 01 0002
+2020: 11111111 11111111 11111111 11111111  11111111 11111111 11111111 11111111
+2040: 20202020 02020202 20202020 02020202  20202020 02020202 20202020 02020202

data/spec/image-specs/sprites-mode3.case

@@ -0,0 +1,8 @@
+should show first 8 sprites per line in mode 3
+7ff8: 0b
+7f10: 00 02 08 0a  20 22 38 2a  15 17 1d 1f  35 37 3d 3f
+7e00: 00 01 0001   08 01 0002  10 01 0101  18 01 0102
+7e10: 20 01 0201   28 01 0202  30 01 0301  38 01 0302
+7e20: 40 01 0001   48 01 0002  50 01 0001  58 01 0002
+2020: 11111111 11111111 11111111 11111111  11111111 11111111 11111111 11111111
+2040: 20202020 02020202 20202020 02020202  20202020 02020202 20202020 02020202