retrograph 0.5-x86-mswin32

data/COPYING

@@ -0,0 +1,19 @@
+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.

data/README

@@ -0,0 +1,264 @@
+== 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 currently supports Ruby/SDL for output; other
+output targets may be added in the future.
+
+== Feature Overview ==
+
+ * 256x244 pixel display
+ * 16k VRAM
+ * 64 colors total
+ * max 31 simultaneous colors (16 background, 15 sprite)
+ * 40x25 and 32x28 text modes
+ * 32x32 tile background, 8x8 pixel tiles
+ * 64 8x8 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.  The method Retrograph::VDU#write_byte
+is also provided for writing individual bytes.
+
+(See the end of this document for a map of registers and
+memory locations within the VDU's address space.)
+
+To render a frame of video with SDL, use
+Retrograph::VDU#render_frame_sdl, which returns an
+SDL::Surface containing the VDU output.  The returned
+surface remains valid until the next call to
+Retrograph::VDU#render_frame_sdl on the same VDU instance.
+
+Scanline-based effects are possible if you provide a block
+to Retrograph::VDU#render_frame_sdl.  Ordinarily, rendering
+will not begin until the block completes, but within the
+block you can call Retrograph::VDU#wait_scanlines to render
+a given number of scanlines before continuing.  This allows
+you to make changes to the VDU state part-way through
+rendering a frame.
+
+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:
+
+ require 'retrograph/sdl'
+
+ output = vdu.render_frame_sdl do
+   vdu.write_byte(0x7f00, 0x03)
+   vdu.wait_scanlines(Retrograph::DISPLAY_HEIGHT/2)
+   vdu.write_byte(0x7f00, 0x30)
+ end
+
+== Important Notes ==
+
+Nothing is displayed by default.  To be shown, the
+background layer (and the sprite, in graphical modes) must
+be explicitly enabled by setting bit 2 (bit 3 for sprites)
+of register $7FF8.
+
+Patterns and name tables may overlap in memory (which is
+in fact unavoidable in graphics modes); typically you
+cannot have simultaneously valid pattern and name data at
+the same location, so in such cases you will need to
+sacrifice particular name or pattern entries.
+
+In text modes, you will need to load your own font into the
+pattern table; the VDU does not provide one by default.
+
+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,
+a (mis)feature shared with the Sega Master System.
+
+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.
+
+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.
+
+Lastly, unlike a real 8-bit system, there is no deadline
+imposed on code running in between scanlines or in between
+frames.  On real hardware, if you have code running
+in between scanlines (that is, during horizontal retrace)
+you will only have a short period of time available before
+the next scanline will begin rendering, whether or not you
+are finished what you are doing.  However, such a
+limitation would be very difficult to recreate in Ruby.
+
+== 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
+                          addr may be one of:
+                            $0000, $1000, $2000, or $3000
+                        Graphics A + B:
+                          addr = (base & 0b00100000) << 8
+                          addr may be one of:
+                            $0000 or $2000
+                 $7FFA: Name Table Base
+                        addr = ((base & 0b00110000) |
+                                0b00001000) << 8
+                        addr may be one of:
+                          $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.  For
+example, for a 4bpp tile, the following row would display
+with the pixels of color 1 on the *left* side, and the
+pixels of color 0 on the *right* side:
+
+ 0x00001111
+
+(little-endian byte ordering is assumed)
+
+Different display modes have different pattern bit depths:
+
+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 2048 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,71 @@
+require 'rake'
+require 'rake/gempackagetask'
+begin
+  require 'rake/extensiontask'
+  have_rake_compiler = true
+rescue LoadError
+  $stderr.puts "*** The rake-compiler gem is required to compile. ***"
+  have_rake_compiler = false
+end
+begin
+  require 'spec/rake/spectask'
+  have_rspec = true
+rescue LoadError
+  $stderr.puts "*** The rspec gem is required to run specs. ***"
+  have_rspec = false
+end
+require 'rake/clean'
+
+GEM_VERSION = '0.5'
+
+CLEAN.include("spec/**/*-output.bmp")
+CLOBBER.include("lib/1.8")
+CLOBBER.include("lib/1.9")
+
+task :clobber => [:clean]
+
+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', 'COPYING',
+                           'src/**/*.h', 'src/**/*.c', 'lib/**/*.rb',
+                           'ext/**/extconf.rb', 'ext/**/*.c', 'ext/**/*.h',
+                           'spec/**/*_spec.rb', 'spec/**/*.case',
+                           'spec/**/*.png']
+  gemspec.extensions = FileList['ext/**/extconf.rb']
+  gemspec.require_paths = ['lib']
+  gemspec.platform = Gem::Platform::RUBY
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.need_tar = true
+end
+
+if have_rake_compiler
+  Rake::ExtensionTask.new('retrograph', gemspec) do |ext|
+    ext.cross_compile = true
+    ext.cross_platform = 'i386-mswin32'
+  end
+end
+
+if have_rspec
+  Spec::Rake::SpecTask.new do |task|
+    task.ruby_opts << '-rrubygems'
+    task.libs << 'lib'
+    task.spec_files = FileList["spec/**/*_spec.rb"]
+  end
+  task :spec => [:compile]
+  task :default => [:clean, :spec]
+elsif have_rake_compiler
+  task :default => [:clean, :compile]
+end

data/ext/retrograph/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+if RUBY_VERSION =~ /^1\.8\./
+  $CPPFLAGS += ' -DRUBY_1_8'
+end
+create_makefile('retrograph')

data/ext/retrograph/retrograph.c

@@ -0,0 +1,324 @@
+/* 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>
+#ifdef RUBY_1_8
+#include <intern.h>
+#else
+#include <ruby/intern.h>
+#endif
+#include <string.h>
+
+#include "../../src/retrograph.h"
+#include "../../src/retrograph.c"
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) RSTRING(str)->len
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+
+#define UPSCALE_FACTOR 2
+#define UPSCALE_REPEAT(stmts) stmts; stmts;
+#define UPSCALE_REPEAT_MINUS1(stmts) stmts;
+
+/* 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;
+    retrograph_pixel_t buffer[RETROGRAPH_DISPLAY_WIDTH];
+    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;
+    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;
+    vdu->vdu = retrograph_new();
+    check_errors(vdu->vdu);
+    return Qnil;
+}
+
+void alloc_sdl_surface(vdu_wrapper_t *vdu) {
+    VALUE surface;
+    surface = rb_funcall(cSurface, SYM2ID(CREATE_SURFACE_METHOD_NAME), 8,
+                         INT2FIX(0), /* flags */
+                         INT2FIX(RETROGRAPH_DISPLAY_WIDTH * UPSCALE_FACTOR),
+                         INT2FIX(RETROGRAPH_DISPLAY_HEIGHT * UPSCALE_FACTOR),
+                         INT2FIX(RETROGRAPH_BITS_PER_PIXEL),
+                         INT2FIX(RETROGRAPH_RED_MASK),
+                         INT2FIX(RETROGRAPH_GREEN_MASK),
+                         INT2FIX(RETROGRAPH_BLUE_MASK),
+                         INT2FIX(RETROGRAPH_ALPHA_MASK));
+    vdu->surface = surface;
+}
+
+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_PTR(data_r),
+                     (size_t)RSTRING_LEN(data_r));
+    return Qnil;
+}
+
+static VALUE vdu_write_byte(VALUE self, VALUE start_address_r, VALUE byte_r) {
+    vdu_wrapper_t *vdu;
+    uint8_t byte;
+    retrograph_addr_t start_address;
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    start_address = (retrograph_addr_t)NUM2INT(start_address_r);
+    byte = (uint8_t)NUM2INT(byte_r);
+    retrograph_write(vdu->vdu, start_address, &byte, 1);
+    return Qnil;
+}
+
+static inline copy_upscale(uint8_t *output, uint8_t const * input, size_t count) {
+    for (; count; count--) {
+        UPSCALE_REPEAT(
+            memcpy(output, input, RETROGRAPH_BYTES_PER_PIXEL);
+            output += RETROGRAPH_BYTES_PER_PIXEL;
+        )
+        input += RETROGRAPH_BYTES_PER_PIXEL;
+    }
+}
+
+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) {
+        return Qnil;
+    }
+
+    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 * UPSCALE_FACTOR;
+    for (; vdu->scanline < max_scanline; vdu->scanline++) {
+        uint8_t *output;
+        uint8_t const *input;
+        retrograph_render_scanline(vdu->vdu, vdu->buffer, sizeof(vdu->buffer));
+        check_errors(vdu->vdu);
+        copy_upscale(current_line, (uint8_t const *)vdu->buffer,
+                     RETROGRAPH_DISPLAY_WIDTH);
+        current_line += surface->pitch;
+        UPSCALE_REPEAT_MINUS1(
+            memcpy(current_line, current_line - surface->pitch,
+                   RETROGRAPH_DISPLAY_WIDTH * RETROGRAPH_BYTES_PER_PIXEL *
+                   UPSCALE_FACTOR);
+            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;
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    if (vdu->scanline != NOT_IN_FRAME) {
+        rb_raise(eRenderError, "Already in frame");
+    }
+    if (vdu->surface == Qnil) {
+        alloc_sdl_surface(vdu);
+    }
+    rb_ensure(vdu_render_frame_inner, self, vdu_render_frame_cleanup, self);
+    return vdu->surface;
+}
+
+static VALUE init_sdl(VALUE self) {
+    VALUE rubysdl_version;
+    mSDL = rb_const_get(rb_cObject, rb_intern("SDL"));
+
+    rubysdl_version = rb_const_get(mSDL, rb_intern("VERSION"));
+    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");
+    }
+
+    cSurface = rb_const_get(mSDL, rb_intern("Surface"));
+    rb_define_method(cVDU, "render_frame_sdl", vdu_render_frame, 0);
+}
+
+void Init_retrograph(void) {
+    rb_global_variable(&mSDL);
+    rb_global_variable(&cSurface);
+    rb_global_variable(&CREATE_SURFACE_METHOD_NAME);
+
+    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_const_set(mRetrograph, rb_intern("OUTPUT_WIDTH"),
+                 INT2FIX(RETROGRAPH_DISPLAY_WIDTH * UPSCALE_FACTOR));
+    rb_const_set(mRetrograph, rb_intern("OUTPUT_HEIGHT"),
+                 INT2FIX(RETROGRAPH_DISPLAY_HEIGHT * UPSCALE_FACTOR));
+
+    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, "write_byte", vdu_write_byte, 2);
+    rb_define_method(cVDU, "wait_scanlines", vdu_render_scanlines, 1);
+
+    rb_define_singleton_method(mRetrograph, "_init_sdl", init_sdl, 0);
+}