/[VRac]/Screen.pm

This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!

Diff of /Screen.pm

Parent Directory | Revision Log | View Patch Patch

-M6502/Screen.pm
revision 73 by dpavlin,
Tue Jul 31 21:43:57 2007 UTC
+Screen.pm
revision 216 by dpavlin,
Thu Sep  3 10:24:34 2009 UTC
 Line 8 
 use warnings;
  use SDL::App;
  use SDL::Rect;
  use SDL::Color;
+ use SDL::Constants;
  use Carp qw/confess/;
+ use Data::Dump qw/dump/;
+ use Exporter 'import';
+ our @EXPORT = qw'$white $black @flip';
  use base qw(Class::Accessor Prefs);
- __PACKAGE__->mk_accessors(qw(app));
+ __PACKAGE__->mk_accessors(qw(app event screen_width screen_height window_width window_height));
  =head1 NAME
- Screen - simulated 256*256 pixels monochrome screen using SDL
+ Screen - simulated monochrome screen using SDL
+ =head1 Architecture dependent
+ You may override following methods if you want to implement keyboard on each
+ keypress event. Alternative is to use <read> hook and trap memory access.
+ =head2 screen_width
+ Width of emulated screen (256 by default)
+ =head2 screen_height
+ Height of emulated screen (256 by default)
+ =head2 key_down
+   $self->key_down( 'a' );
+ =cut
+ sub key_down {}
+ =head2 key_up
+   $self->key_up( 'a' );
+ =cut
+ sub key_up {}
+ =head1 Architecture independent
+ You don't need to override any of following function in your architecture,
+ but you might want to call them.
  =head2 open_screen
-Line 36 
 sub open_screen {
+Line 76 
 sub open_screen {
                  warn "using default unscaled display\n";
          }
+         $self->screen_width( 256 ) unless defined $self->screen_width;
+         $self->screen_height( 256 ) unless defined $self->screen_height;
+         my $w = $self->screen_width * $self->scale + ( $self->show_mem ? 256 : 0 );
+         $self->window_width( $w );
+         my $h = $self->screen_height;
+         # expand screen size to show whole 64k 256*256 memory map
+         $h = 256 if $self->show_mem && $h < 256;
+         $h *= $self->scale;
+         $self->window_height( $h );
          $app = SDL::App->new(
-                 -width  => 256 * $self->scale + ( $self->show_mem ? 256 : 0 ),
+                 -width  => $w,
-                 -height => 256 * $self->scale,
+                 -height => $h,
                  -depth  => 16,
+ #               -flags=>SDL_DOUBLEBUF | SDL_HWSURFACE | SDL_HWACCEL,
          );
-         #$app->grab_input( 0 );
+         #$app->grab_input( SDL_GRAB_QUERY );
+         $app->grab_input( SDL::App::SDL_GRAB_OFF );
+         $app->title( ref($self) );
-         warn "# created SDL::App\n";
          $self->app( $app );
+         my $event = SDL::Event->new();
+         $self->event( $event );
+         warn "# created SDL::App with screen ", $self->screen_width, "x", $self->screen_height, " in window ",
+                 $self->window_width, "x", $self->window_height, "\n";
  }
- my $white       = SDL::Color->new( -r => 0xff, -g => 0xff, -b => 0xff );
+ our $white      = SDL::Color->new( -r => 0xff, -g => 0xff, -b => 0xff );
- my $black       = SDL::Color->new( -r => 0x80, -g => 0x80, -b => 0x80 );
+ our $black      = SDL::Color->new( -r => 0x80, -g => 0x80, -b => 0x80 );
  my $red         = SDL::Color->new( -r => 0xff, -g => 0x00, -b => 0x00 );
  my $green       = SDL::Color->new( -r => 0x00, -g => 0xff, -b => 0x00 );
  my $blue        = SDL::Color->new( -r => 0x00, -g => 0x00, -b => 0xff );
- =head2 p
-  $screen->p( $x, $y, 1 );
- =cut
- sub p {
-         my $self = shift;
-         my ($x,$y,$w) = (@_);
-         warn "p($x,$y,$w)\n" if $self->debug;
-         my $scale = $self->scale;
-         my $rect = SDL::Rect->new(
-                 -height => $scale,
-                 -width  => $scale,
-                 -x      => $x * $scale,
-                 -y      => $y * $scale,
-         );
-         $app->fill( $rect, $w ? $white : $black );
-         $app->update( $rect );
- }
  =head2 mem_xy
  Helper to return x and y coordinates in memory map
-Line 91 
 sub mem_xy {
+Line 126 
 sub mem_xy {
          my $self = shift;
          my $offset = shift;
          my $x = $offset & 0xff;
-         $x += 256 * $self->scale;
+         $x += $self->screen_width * $self->scale;
          my $y = $offset >> 8;
          return ($x,$y);
  }
- =head2 vram
- Push byte to video memory and draw it
-   $screen->vram( $offset, $byte );
- =cut
- my $_vram_counter;
- sub vram {
-         my ( $self, $offset, $byte ) = @_;
-         my $x = ( $offset % 32 ) << 3;
-         my $y = $offset >> 5;
-         my $mask = 1;
-         my $scale = $self->scale;
-         printf "## vram %04x %02x*%02x %02x\n", $offset, $x, $y, $byte if $self->trace;
-         foreach ( 0 .. 7 ) {
-                 my $on = $byte & $mask;
-                 if ( $scale == 1 ) {
-                         $app->pixel( $x + $_, $y, $on ? $white : $black );
-                 } else {
-                         $self->p($x + $_, $y, $on );
-                 }
-                 $mask = $mask << 1;
-         }
-         $app->sync if ( $_vram_counter++ % 10 == 0 );
- }
  =head2 mmap_pixel
  Draw pixel in memory map
-Line 166 
 sub sync {
+Line 169 
 sub sync {
          $app->sync;
  }
- =head2 render
+ =head2 render_vram
+ Render one frame of video ram
+   $self->render_vram;
+ =cut
+ sub render_vram {
+         my $self = shift;
+         confess "please implement $self::render_vram";
+ }
+ =head2 render_frame
+ Render one frame of video ram
+   $self->render_frame( $vram_sdl_surface );
+ =cut
+ sub render_frame {
+         my $self = shift;
+         my $vram = shift;
+         confess "need SDL::Surface as argument" unless ref($vram) eq 'SDL::Surface';
+         $vram->display_format;
+         my $scale = $self->scale || confess "no scale?";
+         my $rect        = SDL::Rect->new( -x => 0, -y => 0, -width => $self->screen_width * $scale, -height => $self->screen_height * $scale );
+         my $rect_screen = SDL::Rect->new( -x => 0, -y => 0, -width => $self->screen_width * $scale, -height => $self->screen_height * $scale );
+         if ( $scale > 1 ) {
+                 use SDL::Tool::Graphic;
+                 # last parametar is anti-alias
+                 my $zoomed = SDL::Tool::Graphic->zoom( $vram, $self->scale, $self->scale, 1 );
+                 $zoomed->blit( $rect, $app, $rect_screen );
+         } else {
+                 $vram->blit( $rect, $app, $rect_screen );
+         }
+         $app->sync;
+ }
-   $self->render( @video_memory );
+ =head2 render_mem
+   $self->render_mem( @mem );
+   $self->render_mem( $memory_bytes );
  =cut
- sub render {
+ sub render_mem {
          my $self = shift;
-         die "this function isn't supported if scale isn't 1" unless $self->scale == 1;
+         return unless $self->show_mem;
+         my $pixels;
+         if ( defined $# ) {
+                 $pixels = pack("C*", @_);
+         } else {
+                 $pixels = shift;
+         }
+         my $vram = SDL::Surface->new(
+                 -width => 256,
+                 -height => 256,
+                 -depth => 8,    # 1 bit per pixel
+                 -pitch => 256,  # bytes per line
+                 -from => $pixels,
+                 -Rmask => 0xffff00ff,
+                 -Gmask => 0xffff00ff,
+                 -Bmask => 0xffff00ff,
+         );
+         $vram->display_format;
+         my $rect     = SDL::Rect->new( -x => 0, -y => 0, -width => $self->screen_width, -height => $self->window_height );
+         my $rect_mem = SDL::Rect->new( -x => $self->screen_width * $self->scale, -y => 0, -width => 256, -height => 256 );
+         $vram->blit( $rect, $app, $rect_mem );
-         $app->lock;
+         $app->sync;
+ }
+ =head2 key_pressed
+ Check SDL event loop if there are any pending keys
+   my $key = $self->key_pressed;
-         my ( $x, $y ) = ( 0,0 );
+   if ( $self->key_pressed( 1 ) ) {
+         # just to check other events, don't process
+         # key
+   }
-         foreach my $b ( @_ ) {
+ =cut
-                 foreach my $p ( split(//, unpack("B8",pack("C",$b)) ) ) {
-                         $app->pixel( $x, $y, $p ? $white : $black );
+ my $pending_key;
-                         $x++;
+ my $key_active;
+ my $run_for = 2000;
+ sub key_pressed {
+         my $self = shift;
+         # don't take key, just pull event
+         my $just_checking = shift || 0;
+         my $event = $self->event || confess "no event?";
+         if ( ! $event->poll ) {
+                 return $pending_key unless $self->can('session_event');
+                 if ( my $h = $self->session_event('key_pressed') ) {
+                         my ( $key, $state ) = %$h;
+                         if ( $state ) {
+                                 $pending_key = $key;
+                                 $self->key_down( $key );
+                                 $key_active->{$key} = 1;
+                         } else {
+                                 undef $pending_key;
+                                 $self->key_up( $key );
+                                 $key_active->{$key} = 0;
+                         }
                  }
-                 if ( $x == 256 ) {
+                 return $pending_key;
-                         $x = 0;
+         }
-                         $y++;
+         my $type = $event->type();
+         exit if ($type == SDL::App::SDL_QUIT);
+         my $k = $pending_key;
+         if ($type == SDL::App::SDL_KEYDOWN) {
+                 $k = $event->key_name();
+                 if ( $k eq 'escape' ) {
+                         $run_for = $self->cli;
+                         warn "will check event loop every $run_for cycles\n";
+                         $pending_key = '~';
+                 } else {
+                         warn "SDL_KEYDOWN ($type) = '$k'", $just_checking ? ' fake' : '', "\n";
+                         $pending_key = $k;
+                         $self->key_down( $k );
+                         $key_active->{$k} = 1;
+                         $self->record_session('key_pressed', { $k => 1 });
                  }
+         } elsif ( $type == SDL::App::SDL_KEYUP ) {
+                 my $up = $event->key_name();
+                 warn "SDL_KEYUP ($type) = '$up'", $just_checking ? ' fake' : '', "\n";
+                 $self->key_up( $up );
+                 $key_active->{$up} = 0;
+                 $self->record_session('key_pressed', { $up => 0 });
+                 undef $pending_key;
          }
-         $app->unlock;
+         warn "key_pressed = $pending_key\n" if ( $pending_key );
-         $app->sync;
-         warn "Screen::render over\n";
+         return $pending_key;
+ }
+ =head2 key_active
+ Is key currently pressed on keyboard or in session?
+   $self->key_active( 'left shift', 'right shift', 'a' );
+ =cut
+ sub key_active {
+         my $self = shift;
+         my @keys = @_;
+         confess "Regexp is no longer supported" if ref($_[0]) eq 'Regexp';
+         my $active = 0;
+         foreach my $key ( @keys ) {
+                 $active++ if $key_active->{$key};
+         }
+         warn "## key_active(",dump(@keys),") = $active\n" if $active;
+         return $active;
+ }
+ =head2 loop
+ Implement CPU run for C<$run_run> cycles inside SDL event loop
+   $self->loop( sub {
+         my $run_for = shift;
+         CPU::exec( $run_for );
+         $self->render_vram;
+   } );
+ =cut
+ sub loop {
+         my $self = shift;
+         my $exec = shift;
+         confess "need coderef as argument" unless ref($exec) eq 'CODE';
+         my $event = SDL::Event->new();
+         while ( 1 ) {
+                 $self->key_pressed( 1 );
+                 $exec->($run_for);
+         }
+ }
+ =head2 @flip
+ Exported helper array used to flip bytes (from character roms for example)
+   my $flipped = $flip[ $byte ];
+ =cut
+ our @flip;
+ foreach my $i ( 0 .. 255 ) {
+         my $t = 0;
+         $i & 0b00000001 and $t = $t | 0b10000000;
+         $i & 0b00000010 and $t = $t | 0b01000000;
+         $i & 0b00000100 and $t = $t | 0b00100000;
+         $i & 0b00001000 and $t = $t | 0b00010000;
+         $i & 0b00010000 and $t = $t | 0b00001000;
+         $i & 0b00100000 and $t = $t | 0b00000100;
+         $i & 0b01000000 and $t = $t | 0b00000010;
+         $i & 0b10000000 and $t = $t | 0b00000001;
+         #warn "$i = $t\n";
+         $flip[$i] = $t;
  }
  =head1 SEE ALSO
-Line 214 
 This program is free software; you can r
+Line 420 
 This program is free software; you can r
  under the same terms as Perl itself.
  =cut
 ;

 Legend:



Removed from v.73
 


changed lines


 
Added in v.216
 Legend:



Removed from v.73
 


changed lines


 
Added in v.216
-Removed from v.73
+Added in v.216

	ViewVC Help
Powered by ViewVC 1.1.26