retrograph 0.5 → 0.5.1

data/README

@@ -6,8 +6,22 @@ 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.
+Retrograph doesn't do its own screen output but rather
+works with other libraries.  Currently, it supports
+Ruby/SDL, but other output targets are planned for the
+future.
+
+== Where can I get it? ==
+
+Retrograph is available via RubyGems, or via Rubyforge
+downloads:
+
+ http://rubyforge.org/frs/?group_id=8410
+
+Cursory documentation is available on the
+corresponding github wiki:
+
+ http://wiki.github.com/mental/retrograph
 
 == Feature Overview ==
 
@@ -52,12 +66,16 @@ of the display, we could write:
 
  require 'retrograph/sdl'
 
+ vdu = Retrograph::VDU.new
+ vdu.write_byte(0x7f00, 0x03)
  output = vdu.render_frame_sdl do
-   vdu.write_byte(0x7f00, 0x03)
    vdu.wait_scanlines(Retrograph::DISPLAY_HEIGHT/2)
    vdu.write_byte(0x7f00, 0x30)
  end
 
+(It is still necessary at this point to copy output to the
+screen.)
+
 == Important Notes ==
 
 Nothing is displayed by default.  To be shown, the

data/Rakefile

@@ -16,7 +16,7 @@ rescue LoadError
 end
 require 'rake/clean'
 
-GEM_VERSION = '0.5'
+GEM_VERSION = '0.5.1'
 
 CLEAN.include("spec/**/*-output.bmp")
 CLOBBER.include("lib/1.8")

data/ext/retrograph/retrograph.c

@@ -36,10 +36,6 @@
 #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;
@@ -57,7 +53,6 @@ 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;
 
@@ -142,8 +137,8 @@ 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_DISPLAY_WIDTH * 2),
+                         INT2FIX(RETROGRAPH_DISPLAY_HEIGHT * 2),
                          INT2FIX(RETROGRAPH_BITS_PER_PIXEL),
                          INT2FIX(RETROGRAPH_RED_MASK),
                          INT2FIX(RETROGRAPH_GREEN_MASK),
@@ -152,6 +147,19 @@ void alloc_sdl_surface(vdu_wrapper_t *vdu) {
     vdu->surface = surface;
 }
 
+static VALUE vdu_initialize_copy(VALUE self, VALUE from) {
+    vdu_wrapper_t *vdu;
+    vdu_wrapper_t *from_vdu;
+    if (CLASS_OF(self) != CLASS_OF(from)) {
+        rb_raise(rb_eTypeError, "Mismatched class for copy");
+    }
+    Data_Get_Struct(self, vdu_wrapper_t, vdu);
+    Data_Get_Struct(from, vdu_wrapper_t, from_vdu);
+    retrograph_clone(vdu->vdu, from_vdu->vdu);
+    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;
@@ -160,6 +168,7 @@ static VALUE vdu_write(VALUE self, VALUE start_address_r, VALUE data_r) {
     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));
+    check_errors(vdu->vdu);
     return Qnil;
 }
 
@@ -171,19 +180,10 @@ static VALUE vdu_write_byte(VALUE self, VALUE start_address_r, VALUE byte_r) {
     start_address = (retrograph_addr_t)NUM2INT(start_address_r);
     byte = (uint8_t)NUM2INT(byte_r);
     retrograph_write(vdu->vdu, start_address, &byte, 1);
+    check_errors(vdu->vdu);
     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;
@@ -203,21 +203,18 @@ 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 * UPSCALE_FACTOR;
+    current_line = (uint8_t *)surface->pixels +
+                   vdu->scanline * surface->pitch * 2;
     for (; vdu->scanline < max_scanline; vdu->scanline++) {
         uint8_t *output;
         uint8_t const *input;
-        retrograph_render_scanline(vdu->vdu, vdu->buffer, sizeof(vdu->buffer));
+        retrograph_render_scanline_2x(vdu->vdu, current_line,
+                                      RETROGRAPH_DISPLAY_WIDTH *
+                                      RETROGRAPH_BYTES_PER_PIXEL * 2);
         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;
-        )
+        memcpy(current_line + surface->pitch, current_line,
+               RETROGRAPH_DISPLAY_WIDTH * RETROGRAPH_BYTES_PER_PIXEL * 2);
+        current_line += surface->pitch * 2;
     }
 
     return Qnil;
@@ -304,9 +301,9 @@ void Init_retrograph(void) {
 #undef DEFINE_CONSTANT
 
     rb_const_set(mRetrograph, rb_intern("OUTPUT_WIDTH"),
-                 INT2FIX(RETROGRAPH_DISPLAY_WIDTH * UPSCALE_FACTOR));
+                 INT2FIX(RETROGRAPH_DISPLAY_WIDTH * 2));
     rb_const_set(mRetrograph, rb_intern("OUTPUT_HEIGHT"),
-                 INT2FIX(RETROGRAPH_DISPLAY_HEIGHT * UPSCALE_FACTOR));
+                 INT2FIX(RETROGRAPH_DISPLAY_HEIGHT * 2));
 
     rb_global_variable(&cVDU);
     cVDU = rb_define_class_under(mRetrograph, "VDU", rb_cObject);
@@ -316,6 +313,7 @@ void Init_retrograph(void) {
                                          rb_eRuntimeError);
 
     rb_define_alloc_func(cVDU, alloc_vdu);
+    rb_define_method(cVDU, "initialize_copy", vdu_initialize_copy, 1);
     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);

data/spec/retrograph_spec.rb

@@ -82,7 +82,7 @@ module ImageTests
       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."
+        raise "Output file #{output_file} does not match."
       end
     end
   end
@@ -114,6 +114,12 @@ describe Retrograph::VDU do
     @vdu.write_byte(0x0001, 42)
   end
 
+  it "should clone VDU state when dup-ed" do
+    @vdu.write_byte(0x7f00, 0x33);
+    vdu2 = @vdu.dup
+    @vdu.render_frame_sdl.pixels.should == vdu2.render_frame_sdl.pixels
+  end
+
   it "should not allow nested calls to #render_frame_sdl" do
     lambda {
       @vdu.render_frame_sdl { @vdu.render_frame_sdl }

data/src/retrograph.c

@@ -143,6 +143,28 @@ retrograph_vdu_t retrograph_new() {
     return vdu;
 }
 
+void retrograph_clone(retrograph_vdu_t vdu, retrograph_vdu_t from_vdu) {
+    if (!vdu || vdu->error) {
+        return;
+    }
+    if (from_vdu->error) {
+        /* XXX is this desirable? */
+        vdu->error = from_vdu->error;
+        return;
+    }
+    memcpy(vdu->vram, from_vdu->vram, sizeof(vdu->vram));
+    memcpy(vdu->sprites, from_vdu->sprites, sizeof(vdu->sprites));
+    memcpy(vdu->palette, from_vdu->palette, sizeof(vdu->palette));
+    vdu->enable_bg = from_vdu->enable_bg;
+    vdu->enable_sprites = from_vdu->enable_sprites;
+    vdu->mode = from_vdu->mode;
+    vdu->text_pattern_base = from_vdu->text_pattern_base;
+    vdu->bg_pattern_base = from_vdu->bg_pattern_base;
+    vdu->name_base = from_vdu->name_base;
+    vdu->bg_scroll_x = from_vdu->bg_scroll_x;
+    vdu->bg_scroll_y = from_vdu->bg_scroll_y;
+}
+
 void retrograph_ref(retrograph_vdu_t vdu) {
     if (vdu && !is_singleton_vdu(vdu)) {
         vdu->refcount++;
@@ -574,7 +596,8 @@ static void render_line_graphics_b(retrograph_pixel_t *out_buffer, uint8_t const
     }
 }
 
-static void render_line(retrograph_vdu_t vdu, unsigned scanline, uint8_t *dest)
+static void render_line(retrograph_vdu_t vdu, unsigned scanline,
+                        retrograph_pixel_t *row_buffer)
 {
     uint8_t const *name_row;
     uint8_t bg_x_coarse;
@@ -618,8 +641,6 @@ static void render_line(retrograph_vdu_t vdu, unsigned scanline, uint8_t *dest)
         bg_y_fine = (uint8_t)(bg_y % 8);
     }
 
-    update_palette_cache(vdu);
-
     switch (vdu->mode) {
     case TEXT_A:
         /* stride is 40 2-byte cells */
@@ -630,25 +651,25 @@ static void render_line(retrograph_vdu_t vdu, unsigned scanline, uint8_t *dest)
         name_row = vdu->vram + vdu->name_base + bg_y_coarse * (32 * 2);
     }
 
-    clear_row_buffer(vdu->row_buffer, vdu->palette_cache[0]);
+    clear_row_buffer(row_buffer, vdu->palette_cache[0]);
     switch (vdu->mode) {
     case TEXT_A:
         /* 12px padding above and below display */
         if (scanline >= 12 ||
             scanline < RETROGRAPH_DISPLAY_HEIGHT - 12)
         {
-            render_line_text_a(vdu->row_buffer, name_row, bg_y_fine,
+            render_line_text_a(row_buffer, name_row, bg_y_fine,
                                vdu->vram + vdu->text_pattern_base,
                                vdu->palette_cache, vdu->enable_bg);
         }
         break;
     case TEXT_B:
-        render_line_text_b(vdu->row_buffer, name_row, bg_y_fine,
+        render_line_text_b(row_buffer, name_row, bg_y_fine,
                            vdu->vram + vdu->text_pattern_base,
                            vdu->palette_cache, vdu->enable_bg);
         break;
     case GRAPHICS_A:
-        render_line_graphics_a(vdu->row_buffer, name_row,
+        render_line_graphics_a(row_buffer, name_row,
                                bg_x_coarse, bg_x_fine, bg_y_fine,
                                scanline, vdu->vram,
                                vdu->bg_pattern_base,
@@ -657,7 +678,7 @@ static void render_line(retrograph_vdu_t vdu, unsigned scanline, uint8_t *dest)
                                vdu->enable_bg, vdu->enable_sprites);
         break;
     case GRAPHICS_B:
-        render_line_graphics_b(vdu->row_buffer, name_row,
+        render_line_graphics_b(row_buffer, name_row,
                                bg_x_coarse, bg_x_fine, bg_y_fine,
                                scanline, vdu->vram,
                                vdu->bg_pattern_base,
@@ -666,7 +687,6 @@ static void render_line(retrograph_vdu_t vdu, unsigned scanline, uint8_t *dest)
                                vdu->enable_bg, vdu->enable_sprites);
         break;
     }
-    memcpy(dest, vdu->row_buffer, ROW_BYTES);
 }
 
 void retrograph_begin_frame(retrograph_vdu_t vdu) {
@@ -676,6 +696,30 @@ void retrograph_begin_frame(retrograph_vdu_t vdu) {
     vdu->current_scanline = 0;
 }
 
+static void retrograph_render_scanline_inner(retrograph_vdu_t vdu,
+                                             retrograph_pixel_t *row_buffer)
+{
+    update_palette_cache(vdu);
+    if (vdu->current_scanline < RETROGRAPH_DISPLAY_HEIGHT) {
+        render_line(vdu, vdu->current_scanline, row_buffer);
+        vdu->current_scanline++;
+    } else {
+        clear_row_buffer(row_buffer, vdu->palette_cache[0]);
+    }
+}
+
+static inline void copy_line_2x(uint8_t *output, uint8_t const *input,
+                                size_t count)
+{
+    for (; count; count--) {
+        memcpy(output, input, RETROGRAPH_BYTES_PER_PIXEL); 
+        output += RETROGRAPH_BYTES_PER_PIXEL;
+        memcpy(output, input, RETROGRAPH_BYTES_PER_PIXEL);
+        output += RETROGRAPH_BYTES_PER_PIXEL;
+        input += RETROGRAPH_BYTES_PER_PIXEL;
+    }
+}
+
 void retrograph_render_scanline(retrograph_vdu_t vdu, void *dest,
                                 size_t dest_size)
 {
@@ -686,12 +730,21 @@ void retrograph_render_scanline(retrograph_vdu_t vdu, void *dest,
         return;
     }
 
-    if (vdu->current_scanline < RETROGRAPH_DISPLAY_HEIGHT) {
-        render_line(vdu, vdu->current_scanline, (uint8_t *)dest);
-        vdu->current_scanline++;
-    } else {
-        update_palette_cache(vdu);
-        clear_row_buffer(vdu->row_buffer, vdu->palette_cache[0]);
-        memcpy(dest, vdu->row_buffer, ROW_BYTES);
+    retrograph_render_scanline_inner(vdu, vdu->row_buffer);
+    memcpy(dest, vdu->row_buffer, ROW_BYTES);
+}
+
+void retrograph_render_scanline_2x(retrograph_vdu_t vdu, void *dest,
+                                   size_t dest_size)
+{
+    if (!vdu || vdu->error) {
+        return;
+    }
+    if (dest_size < ROW_BYTES * 2) {
+        return;
     }
+
+    retrograph_render_scanline_inner(vdu, vdu->row_buffer);
+    copy_line_2x(dest, (uint8_t const *)vdu->row_buffer,
+                 ROW_BYTES / RETROGRAPH_BYTES_PER_PIXEL);
 }

data/src/retrograph.h

@@ -58,10 +58,13 @@ void retrograph_destroy(retrograph_vdu_t vdu);
 
 retrograph_error_t retrograph_get_error(retrograph_vdu_t vdu);
 
+void retrograph_clone(retrograph_vdu_t vdu, retrograph_vdu_t from_vdu);
 void retrograph_write(retrograph_vdu_t vdu, retrograph_addr_t start_address,
                       void const *data, size_t n_bytes);
 void retrograph_begin_frame(retrograph_vdu_t vdu);
 void retrograph_render_scanline(retrograph_vdu_t vdu, void *dest,
                                 size_t dest_size);
+void retrograph_render_scanline_2x(retrograph_vdu_t vdu, void *dest,
+                                   size_t dest_size);
 
 #endif

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: retrograph
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: 0.5.1
 platform: ruby
 authors: 
 - MenTaLguY <mental@rydia.net>
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-24 00:00:00 -04:00
+date: 2009-07-26 00:00:00 -04:00
 default_executable: 
 dependencies: []