retrograph 0.2.1 → 0.5

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

@@ -6,19 +6,18 @@ 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.
+Retrograph currently supports Ruby/SDL for output; other
+output targets may be added in the future.
 
 == 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
+ * 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 ==
 
@@ -27,65 +26,54 @@ 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.
+a string to write.  The method Retrograph::VDU#write_byte
+is also provided for writing individual bytes.
 
-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.
+(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 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")
+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
 
-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.
+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 (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.
+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.
 
-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
@@ -94,7 +82,28 @@ 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.
+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 ==
 
@@ -117,19 +126,17 @@ $7FF8 - $7FFF: VDU Registers (8 bytes)
                  $7FF9: Pattern Table Base
                         Text A + B:
                           addr = (base & 0b00110000) << 8
-                          base = $00, $10, $20, or $30
-                          addr = $0000, $1000, $2000, or
-                                 $3000
+                          addr may be one of:
+                            $0000, $1000, $2000, or $3000
                         Graphics A + B:
                           addr = (base & 0b00100000) << 8
-                          base = $00 or $20
-                          addr = $0000 or $2000
+                          addr may be one of:
+                            $0000 or $2000
                  $7FFA: Name Table Base
                         addr = ((base & 0b00110000) |
                                 0b00001000) << 8
-                        base = $00, $10, $20, or $30
-                        addr = $0800, $1800, $2800, or
-                               $3800
+                        addr may be one of:
+                          $0800, $1800, $2800, or $3800
                  $7FFB: unused
                  $7FFC: BG scroll X*
                  $7FFD: BG scroll Y**
@@ -149,7 +156,16 @@ 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.
+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
@@ -209,9 +225,9 @@ 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.
+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
 

data/Rakefile

@@ -1,54 +1,71 @@
 require 'rake'
 require 'rake/gempackagetask'
-require 'spec/rake/spectask'
+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.2.1'
+GEM_VERSION = '0.5'
 
-CLEAN.include("**/*.o")
-CLEAN.include("**/*.so")
 CLEAN.include("spec/**/*-output.bmp")
-CLOBBER.include("ext/Makefile")
+CLOBBER.include("lib/1.8")
+CLOBBER.include("lib/1.9")
 
 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.
+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',
+  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 = ['ext/extconf.rb']
-  gemspec.require_paths = ['ext']
+  gemspec.extensions = FileList['ext/**/extconf.rb']
+  gemspec.require_paths = ['lib']
   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]
+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.c → retrograph/retrograph.c}

@@ -21,11 +21,24 @@
  * 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"
+#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 {
@@ -44,6 +57,7 @@ typedef struct rubysdl2_surface_tag {
 typedef struct vdu_wrapper_tag {
     retrograph_vdu_t vdu;
     VALUE surface;
+    retrograph_pixel_t buffer[RETROGRAPH_DISPLAY_WIDTH];
     int scanline;
 } vdu_wrapper_t;
 
@@ -107,7 +121,6 @@ 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;
@@ -120,20 +133,23 @@ static VALUE alloc_vdu(VALUE klass) {
 
 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),
-                         INT2FIX(RETROGRAPH_DISPLAY_HEIGHT),
+                         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;
-    vdu->vdu = retrograph_new();
-    check_errors(vdu->vdu);
-    return Qnil;
 }
 
 static VALUE vdu_write(VALUE self, VALUE start_address_r, VALUE data_r) {
@@ -142,15 +158,30 @@ static VALUE vdu_write(VALUE self, VALUE start_address_r, VALUE data_r) {
     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);
+    retrograph_write(vdu->vdu, start_address, RSTRING_PTR(data_r),
+                     (size_t)RSTRING_LEN(data_r));
     return Qnil;
 }
 
-static VALUE vdu_get_surface(VALUE self) {
+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);
-    return vdu->surface;
+    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) {
@@ -162,7 +193,7 @@ static VALUE vdu_render_scanlines(VALUE self, VALUE n_scanlines_r) {
     Data_Get_Struct(self, vdu_wrapper_t, vdu);
 
     if (vdu->scanline == NOT_IN_FRAME) {
-        rb_raise(eRenderError, "Not in frame");
+        return Qnil;
     }
 
     surface = get_rubysdl_surface(vdu->surface);
@@ -172,13 +203,21 @@ static VALUE vdu_render_scanlines(VALUE self, VALUE n_scanlines_r) {
         max_scanline = RETROGRAPH_DISPLAY_HEIGHT;
     }
 
-    current_line = (uint8_t *)surface->pixels + vdu->scanline * surface->pitch;
+    current_line = (uint8_t *)surface->pixels + vdu->scanline * surface->pitch * UPSCALE_FACTOR;
     for (; vdu->scanline < max_scanline; vdu->scanline++) {
-        retrograph_render_scanline(vdu->vdu, current_line,
-                                   RETROGRAPH_DISPLAY_WIDTH *
-                                   RETROGRAPH_BYTES_PER_PIXEL);
+        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;
@@ -206,27 +245,22 @@ static VALUE vdu_render_frame_cleanup(VALUE self) {
 
 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");
     }
+    if (vdu->surface == Qnil) {
+        alloc_sdl_surface(vdu);
+    }
     rb_ensure(vdu_render_frame_inner, self, vdu_render_frame_cleanup, self);
     return vdu->surface;
 }
 
-void Init_retrograph(void) {
+static VALUE init_sdl(VALUE self) {
     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;
@@ -237,6 +271,15 @@ void Init_retrograph(void) {
         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");
 
@@ -260,6 +303,11 @@ void Init_retrograph(void) {
 
 #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);
 
@@ -269,7 +317,8 @@ void Init_retrograph(void) {
 
     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);
+    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);
 }

data/lib/retrograph/sdl.rb

@@ -0,0 +1,26 @@
+# retrograph/sdl
+# 
+# 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.
+
+require 'retrograph'
+require 'sdl'
+
+Retrograph._init_sdl

data/lib/retrograph.rb

@@ -0,0 +1,29 @@
+# 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.
+#
+
+# augment search path for fat binary gems
+ruby_version = /^\d+\.\d+/.match(RUBY_VERSION)[0]
+base_dir = File.dirname(__FILE__)
+$:.push File.join(base_dir, ruby_version)
+
+require 'retrograph.so'

data/spec/retrograph_spec.rb

@@ -1,10 +1,11 @@
-require 'sdl'
-require 'retrograph'
+require 'retrograph/sdl'
 
 describe Retrograph do
   constants = [
     [:DISPLAY_WIDTH, 256],
     [:DISPLAY_HEIGHT, 224],
+    [:OUTPUT_WIDTH, 512],
+    [:OUTPUT_HEIGHT, 448],
     [:BYTES_PER_PIXEL, 4],
     [:BITS_PER_PIXEL, 32],
     [:RED_SHIFT, 16],
@@ -69,16 +70,16 @@ module ImageTests
       for offset, data in writes
         vdu.write(offset, data)
       end
-      output_image = vdu.render_frame
+      output_image = vdu.render_frame_sdl
       output_file = image_file.sub(/\.[^.]*$/, '-output.bmp')
       output_image.save_bmp(output_file)
 
       raw_image = SDL::Surface.load(image_file)
       raw_image.set_alpha(0, SDL::ALPHA_OPAQUE)
       raw_image.set_color_key(0, 0)
-      reference_image = SDL::Surface.new(0, 256, 224, 32,
+      reference_image = SDL::Surface.new(0, raw_image.w, raw_image.h, 32,
                                          RMASK, GMASK, BMASK, AMASK)
-      SDL::Surface.blit(raw_image, 0, 0, 256, 224, reference_image, 0, 0)
+      SDL::Surface.blit(raw_image, 0, 0, 0, 0, reference_image, 0, 0)
       raw_image = nil
       if output_image.pixels != reference_image.pixels
         raise "Output does not match."
@@ -92,12 +93,12 @@ describe Retrograph::VDU do
     @vdu = Retrograph::VDU.new
   end
 
-  it "should have a surface with the right characteristics" do
-    surface = @vdu.surface
+  it "should render to a surface with the right characteristics" do
+    surface = @vdu.render_frame_sdl
     surface.should be_an_instance_of(SDL::Surface)
     surface.flags.should == 0
-    surface.w.should == Retrograph::DISPLAY_WIDTH
-    surface.h.should == Retrograph::DISPLAY_HEIGHT
+    surface.w.should == Retrograph::OUTPUT_WIDTH
+    surface.h.should == Retrograph::OUTPUT_HEIGHT
     surface.bpp.should == Retrograph::BITS_PER_PIXEL
     surface.Rmask.should == Retrograph::RED_MASK
     surface.Gmask.should == Retrograph::GREEN_MASK
@@ -105,29 +106,29 @@ describe Retrograph::VDU do
     surface.Amask.should == Retrograph::ALPHA_MASK
   end
 
-  it "should return that surface each time from #render_frame" do
-    output = @vdu.render_frame
-    output.should == @vdu.surface
+  it "should have a write method which takes an offset and a byte string" do
+    @vdu.write(0x0001, "foobar")
   end
 
-  it "should not allow nested calls to #render_frame" do
+  it "should have a write_bytes method which takes an offset and a byte" do
+    @vdu.write_byte(0x0001, 42)
+  end
+
+  it "should not allow nested calls to #render_frame_sdl" do
     lambda {
-      @vdu.render_frame { @vdu.render_frame }
+      @vdu.render_frame_sdl { @vdu.render_frame_sdl }
     }.should raise_error(Retrograph::RenderError, "Already in frame")
   end
 
-  it "should not allow naked calls to #render_scanlines" do
-    lambda {
-      @vdu.render_scanlines(30)
-    }.should raise_error(Retrograph::RenderError, "Not in frame")
+  it "should allow naked calls to #wait_scanlines (as a noop)" do
+    @vdu.wait_scanlines(30)
   end
 
-  it "should allow calls to #render_scanlines within a frame" do
-    @vdu.render_frame { @vdu.render_scanlines(30) }
+  it "should allow calls to #wait_scanlines within a frame" do
+    @vdu.render_frame_sdl { @vdu.wait_scanlines(30) }
   end
 
   extend ImageTests
-  spec_dir = File.join(File.split(__FILE__).first,
-                            'image-specs')
+  spec_dir = File.join(File.split(__FILE__).first, 'image-specs')
   build_image_specs(spec_dir)
 end

data/src/retrograph.c

@@ -91,9 +91,9 @@ struct retrograph_vdu_tag {
     uint8_t bg_scroll_y;
 
     unsigned current_scanline;
-    uint32_t palette_cache[32];
+    retrograph_pixel_t palette_cache[32];
     /* +16 to accomodate double-width sprites */
-    uint32_t row_buffer[RETROGRAPH_DISPLAY_WIDTH + 16];
+    retrograph_pixel_t row_buffer[RETROGRAPH_DISPLAY_WIDTH + 16];
 };
 
 static retrograph_error_t no_memory_error = RETROGRAPH_NO_MEMORY;
@@ -283,7 +283,9 @@ static void update_palette_cache(retrograph_vdu_t vdu) {
     }
 }
 
-static void clear_row_buffer(uint32_t * const out_buffer, uint32_t const color) {
+static void clear_row_buffer(retrograph_pixel_t * const out_buffer,
+                             retrograph_pixel_t const color)
+{
     int i;
     for (i = 0; i < RETROGRAPH_DISPLAY_WIDTH; i++) {
         out_buffer[i] = color;
@@ -291,14 +293,14 @@ static void clear_row_buffer(uint32_t * const out_buffer, uint32_t const color)
 }
 
 #define DEFINE_RENDER_CHAR(width) \
-static inline void render_char ## width(uint32_t * const out_buffer, \
+static inline void render_char ## width(retrograph_pixel_t * const out_buffer, \
                                         uint8_t const c, \
                                         uint8_t const attrs, \
                                         uint8_t const * const patterns, \
-                                        uint32_t const * const palette) \
+                                        retrograph_pixel_t const * const palette) \
 { \
     uint8_t pattern_row; \
-    uint32_t colors[2]; \
+    retrograph_pixel_t colors[2]; \
     int i; \
     colors[1] = palette[attrs % 16]; \
     colors[0] = palette[attrs / 16]; \
@@ -312,9 +314,9 @@ static inline void render_char ## width(uint32_t * const out_buffer, \
 DEFINE_RENDER_CHAR(6)
 DEFINE_RENDER_CHAR(8)
 
-static void render_line_text_a(uint32_t *out_buffer, uint8_t const *names,
+static void render_line_text_a(retrograph_pixel_t *out_buffer, uint8_t const *names,
                                uint8_t y_fine, uint8_t const *patterns,
-                               uint32_t const *palette, char enable_bg)
+                               retrograph_pixel_t const *palette, char enable_bg)
 {
     int i;
 
@@ -333,9 +335,9 @@ static void render_line_text_a(uint32_t *out_buffer, uint8_t const *names,
     }
 }
 
-static void render_line_text_b(uint32_t *out_buffer, uint8_t const *names,
+static void render_line_text_b(retrograph_pixel_t *out_buffer, uint8_t const *names,
                                uint8_t y_fine, uint8_t const *patterns,
-                               uint32_t const *palette, char enable_bg)
+                               retrograph_pixel_t const *palette, char enable_bg)
 {
     int i;
     if (enable_bg) {
@@ -361,10 +363,10 @@ static inline uint32_t unpack_uint32(uint8_t const * const bytes) {
                             out_buffer[i*2+1] = palette[color | base_color]
 
 #define DEFINE_RENDER_TILE(bpp, suffix, RENDER_PIXEL, row_type, unpack_row) \
-static inline void render_ ## suffix ## bpp(uint32_t *out_buffer, \
+static inline void render_ ## suffix ## bpp(retrograph_pixel_t *out_buffer, \
                                             uint16_t cell, \
                                             uint8_t const *vflip_patterns[2], \
-                                            uint32_t const *palette) \
+                                            retrograph_pixel_t const *palette) \
 { \
     row_type pattern_row; \
     uint8_t base_color; \
@@ -405,12 +407,12 @@ DEFINE_RENDER_TILE(4, tile, RENDER_SINGLE_PIXEL, uint32_t, unpack_uint32)
 DEFINE_RENDER_TILE(4, tile_double, RENDER_DOUBLE_PIXEL, uint32_t, unpack_uint32)
 
 #define DEFINE_RENDER_BG_LINE(bpp) \
-static void render_bg_line ## bpp(uint32_t *out_buffer, \
+static void render_bg_line ## bpp(retrograph_pixel_t *out_buffer, \
                                   uint8_t x_coarse, uint8_t x_fine, \
                                   uint8_t const *names, \
                                   uint8_t const *vflip_patterns[2], \
                                   uint16_t toggle_bits, \
-                                  uint32_t const *palette) \
+                                  retrograph_pixel_t const *palette) \
 { \
     int i; \
     uint8_t const *name_cursor; \
@@ -457,10 +459,10 @@ static inline unsigned compute_sprite_line(uint8_t row, uint8_t const *sprite) {
     return sprite_line;
 }
 
-static void render_sprites_line(uint32_t *out_buffer, uint8_t row,
+static void render_sprites_line(retrograph_pixel_t *out_buffer, uint8_t row,
                                 uint8_t const *sprites,
                                 uint8_t const *patterns,
-                                uint32_t const *palette)
+                                retrograph_pixel_t const *palette)
 {
     unsigned sprite_lines[MAX_SPRITES];
     int i, n_sprites;
@@ -509,14 +511,14 @@ static void render_sprites_line(uint32_t *out_buffer, uint8_t row,
     }
 }
 
-static void render_line_graphics_a(uint32_t *out_buffer,
+static void render_line_graphics_a(retrograph_pixel_t *out_buffer,
                                    uint8_t const * const names,
                                    uint8_t x_coarse, uint8_t x_fine,
                                    uint8_t y_fine, uint8_t row,
                                    uint8_t const *patterns,
                                    retrograph_addr_t pattern_base,
                                    uint8_t const *sprites,
-                                   uint32_t const *palette,
+                                   retrograph_pixel_t const *palette,
                                    char enable_bg, char enable_sprites)
 {
     uint8_t const *vflip_patterns[2];
@@ -540,13 +542,13 @@ static void render_line_graphics_a(uint32_t *out_buffer,
     }
 }
 
-static void render_line_graphics_b(uint32_t *out_buffer, uint8_t const *names,
+static void render_line_graphics_b(retrograph_pixel_t *out_buffer, uint8_t const *names,
                                    uint8_t x_coarse, uint8_t x_fine,
                                    uint8_t y_fine, uint8_t row,
                                    uint8_t const *patterns,
                                    retrograph_addr_t pattern_base,
                                    uint8_t const *sprites,
-                                   uint32_t const *palette,
+                                   retrograph_pixel_t const *palette,
                                    char enable_bg, char enable_sprites)
 {
     uint8_t const *vflip_patterns[2];

data/src/retrograph.h

@@ -29,7 +29,8 @@
 #define RETROGRAPH_DISPLAY_WIDTH 256
 #define RETROGRAPH_DISPLAY_HEIGHT 224
 
-#define RETROGRAPH_BYTES_PER_PIXEL 4
+typedef uint32_t retrograph_pixel_t;
+#define RETROGRAPH_BYTES_PER_PIXEL sizeof(retrograph_pixel_t)
 #define RETROGRAPH_BITS_PER_PIXEL (RETROGRAPH_BYTES_PER_PIXEL * 8)
 
 #define RETROGRAPH_RED_SHIFT 16

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: retrograph
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: "0.5"
 platform: ruby
 authors: 
 - MenTaLguY <mental@rydia.net>
@@ -9,37 +9,32 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-22 00:00:00 -04:00
+date: 2009-07-24 00:00:00 -04:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rubysdl
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.3.0
-    version: 
+dependencies: []
+
 description: |
-  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.
+  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.
 
 email: mental@rydia.net
 executables: []
 
 extensions: 
-- ext/extconf.rb
+- ext/retrograph/extconf.rb
 extra_rdoc_files: []
 
 files: 
 - Rakefile
 - README
+- COPYING
 - src/retrograph.h
 - src/retrograph.c
-- ext/extconf.rb
-- ext/retrograph.c
+- lib/retrograph.rb
+- lib/retrograph/sdl.rb
+- ext/retrograph/extconf.rb
+- ext/retrograph/retrograph.c
 - spec/retrograph_spec.rb
 - spec/image-specs/sprites-doubling.case
 - spec/image-specs/text-colors.case
@@ -79,7 +74,7 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-- ext
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="

data/ext/extconf.rb

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