graphics 1.0.0b1 → 1.0.0b4

data/ext/sdl/sge/sge_tt_text.h

@@ -0,0 +1,114 @@
+/*
+*	SDL Graphics Extension
+*	Text/TrueType functions (header)
+*
+*	Started 990815
+*
+*	License: LGPL v2+ (see the file LICENSE)
+*	(c)1999-2003 Anders Lindstr�m
+*
+*	Uses the excellent FreeType 2 library, available at:
+*	http://www.freetype.org/
+*/
+
+/*********************************************************************
+ *  This library is free software; you can redistribute it and/or    *
+ *  modify it under the terms of the GNU Library General Public      *
+ *  License as published by the Free Software Foundation; either     *
+ *  version 2 of the License, or (at your option) any later version. *
+ *********************************************************************/
+
+#ifndef sge_tt_text_H
+#define sge_tt_text_H
+
+#include "SDL.h"
+#include "sge_internal.h"
+
+/* Text input flags */
+#define SGE_IBG SGE_FLAG1
+#define SGE_IDEL SGE_FLAG2
+#define SGE_INOKR SGE_FLAG3
+
+#ifndef _SGE_NOTTF
+
+/* the truetype font structure */
+typedef struct _sge_TTFont sge_TTFont;
+
+/* Font style */
+#define SGE_TTF_NORMAL SGE_FLAG0
+#define SGE_TTF_BOLD SGE_FLAG1
+#define SGE_TTF_ITALIC SGE_FLAG2
+#define SGE_TTF_UNDERLINE SGE_FLAG3
+
+/* ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark) */
+#define UNICODE_BOM_NATIVE	0xFEFF
+#define UNICODE_BOM_SWAPPED	0xFFFE
+
+#endif /* _SGE_NOTTF */
+
+
+
+#ifdef _SGE_C
+extern "C" {
+#endif
+#ifndef _SGE_NOTTF
+DECLSPEC void sge_TTF_AAOff(void);
+DECLSPEC void sge_TTF_AAOn(void);
+DECLSPEC void sge_TTF_AA_Alpha(void);
+DECLSPEC void sge_TTF_ByteSwappedUNICODE(int swapped);
+
+DECLSPEC int sge_TTF_Init(void);
+DECLSPEC sge_TTFont *sge_TTF_OpenFont(const char *file, int ptsize);
+DECLSPEC sge_TTFont *sge_TTF_OpenFontRW( SDL_RWops *src, int freesrc, int ptsize, int xdpi, int ydpi);
+DECLSPEC sge_TTFont *sge_TTF_OpenFontIndex(const char *file, int ptsize, long index, int xdpi, int ydpi);
+DECLSPEC sge_TTFont *sge_TTF_OpenFontIndexRW(SDL_RWops *src, int freesrc, int ptsize, long index, int xdpi, int ydpi);
+DECLSPEC int sge_TTF_SetFontSize(sge_TTFont *font, int ptsize);
+DECLSPEC int sge_TTF_SetFontSizeDPI(sge_TTFont *font, int ptsize, int xdpi, int ydpi);
+
+DECLSPEC int sge_TTF_FontHeight(sge_TTFont *font);
+DECLSPEC int sge_TTF_FontAscent(sge_TTFont *font);
+DECLSPEC int sge_TTF_FontDescent(sge_TTFont *font);
+DECLSPEC int sge_TTF_FontLineSkip(sge_TTFont *font);
+DECLSPEC long sge_TTF_FontFaces(sge_TTFont *font);
+DECLSPEC int sge_TTF_FontFaceIsFixedWidth(sge_TTFont *font);
+DECLSPEC char *sge_TTF_FontFaceFamilyName(sge_TTFont *font);
+DECLSPEC char *sge_TTF_FontFaceStyleName(sge_TTFont *font);
+
+DECLSPEC void sge_TTF_SetFontStyle(sge_TTFont *font, Uint8 style);
+DECLSPEC Uint8 sge_TTF_GetFontStyle(sge_TTFont *font);
+
+DECLSPEC void sge_TTF_CloseFont(sge_TTFont *font);
+
+DECLSPEC SDL_Rect sge_TTF_TextSizeUNI(sge_TTFont *font, const Uint16 *text);
+DECLSPEC SDL_Rect sge_TTF_TextSize(sge_TTFont *Font, char *Text);
+
+DECLSPEC SDL_Rect sge_tt_textout(SDL_Surface *Surface, sge_TTFont *font, const char *string, Sint16 x, Sint16 y, Uint32 fcolor, Uint32 bcolor, int Alpha);
+DECLSPEC SDL_Rect sge_tt_textout_UTF8(SDL_Surface *Surface, sge_TTFont *font, const char *string, Sint16 x, Sint16 y, Uint32 fcolor, Uint32 bcolor, int Alpha);
+DECLSPEC SDL_Rect sge_tt_textout_UNI(SDL_Surface *Surface, sge_TTFont *font, const Uint16 *uni, Sint16 x, Sint16 y, Uint32 fcolor, Uint32 bcolor, int Alpha);
+
+DECLSPEC SDL_Rect sge_tt_textoutf(SDL_Surface *Surface, sge_TTFont *font, Sint16 x, Sint16 y, Uint8 fR, Uint8 fG, Uint8 fB, Uint8 bR, Uint8 bG, Uint8 bB, int Alpha ,char *format,...);
+
+DECLSPEC int sge_tt_input_UNI(SDL_Surface *screen,sge_TTFont *font,Uint16 *string,Uint8 flags, int pos,int len,Sint16 x,Sint16 y, Uint32 fcol, Uint32 bcol, int Alpha);
+DECLSPEC int sge_tt_input(SDL_Surface *screen,sge_TTFont *font,char *string,Uint8 flags, int pos,int len,Sint16 x,Sint16 y, Uint32 fcol, Uint32 bcol, int Alpha);
+
+DECLSPEC SDL_Surface *sge_TTF_Render(sge_TTFont *font,const Uint16 *text, SDL_Color fg, SDL_Color bg, int alpha_level);
+DECLSPEC SDL_Surface *sge_TTF_RenderUNICODE(sge_TTFont *font,const Uint16 *text, SDL_Color fg, SDL_Color bg);
+#endif /* _SGE_NOTTF */
+
+DECLSPEC Uint16 *sge_Latin1_Uni(const char *text);
+#ifdef _SGE_C
+}
+#endif
+
+
+#ifndef sge_C_ONLY
+#ifndef _SGE_NOTTF
+DECLSPEC SDL_Rect sge_tt_textout(SDL_Surface *Surface, sge_TTFont *font, const char *string, Sint16 x, Sint16 y, Uint8 fR, Uint8 fG, Uint8 fB, Uint8 bR, Uint8 bG, Uint8 bB, int Alpha);
+DECLSPEC SDL_Rect sge_tt_textout_UTF8(SDL_Surface *Surface, sge_TTFont *font, const char *string, Sint16 x, Sint16 y, Uint8 fR, Uint8 fG, Uint8 fB, Uint8 bR, Uint8 bG, Uint8 bB, int Alpha);
+DECLSPEC SDL_Rect sge_tt_textout_UNI(SDL_Surface *Surface, sge_TTFont *font, const Uint16 *uni, Sint16 x, Sint16 y, Uint8 fR, Uint8 fG, Uint8 fB, Uint8 bR, Uint8 bG, Uint8 bB, int Alpha);
+DECLSPEC int sge_tt_input_UNI(SDL_Surface *screen,sge_TTFont *font,Uint16 *string,Uint8 flags, int pos,int len,Sint16 x,Sint16 y, Uint8 fR, Uint8 fG, Uint8 fB, Uint8 bR,Uint8 bG,Uint8 bB, int Alpha);
+DECLSPEC int sge_tt_input(SDL_Surface *screen,sge_TTFont *font,char *string,Uint8 flags, int pos,int len,Sint16 x,Sint16 y, Uint8 fR, Uint8 fG, Uint8 fB, Uint8 bR,Uint8 bG,Uint8 bB, int Alpha);
+#endif /* _SGE_NOTTF */
+#endif /* sge_C_ONLY */
+
+#endif /* sge_tt_text_H */

data/graphics_setup.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+set -e
+
+for pkg in sdl sdl_image sdl_ttf sdl_mixer sdl_gfx smpeg freetype libogg libvorbis libsmpeg libpng libtiff; do
+    brew uninstall $pkg || true
+done
+
+for gem in graphics rubysdl rsdl; do
+    gem uninstall -ax $gem || true
+done
+
+# brew update
+
+brew install sdl
+brew install sdl_mixer --with-smpeg
+brew install sdl_ttf
+brew install sdl_image
+
+if [ -f $0 ]; then
+    rake clean package
+    gem install pkg/graphics*.gem
+else
+    gem install graphics --pre
+fi
+
+rsdl -rgraphics -e 'Class.new(Graphics::Simulation) { def draw n; clear :white; text "hit escape to quit", 100, 100, :black; end; }.new(500, 250, 0, "Working!").run'

data/lib/graphics.rb

@@ -2,7 +2,7 @@
 # The top-level namespace.
 
 class Graphics
-  VERSION = "1.0.0b1" # :nodoc:
+  VERSION = "1.0.0b4" # :nodoc:
 end
 
 require "graphics/simulation"

data/lib/graphics/body.rb

@@ -27,7 +27,35 @@ class Graphics::Body
            :west  => 0,
            }
 
-  attr_accessor :x, :y, :a, :ga, :m, :w # :nodoc:
+  ##
+  # Body's x coordinate.
+
+  attr_accessor :x
+
+  ##
+  # Body's y coordinate.
+
+  attr_accessor :y
+
+  ##
+  # Body's angle, in degrees.
+
+  attr_accessor :a
+
+  ##
+  # Body's goal angle, in degrees.
+
+  attr_accessor :ga
+
+  ##
+  # Body's magnitude.
+
+  attr_accessor :m
+
+  ##
+  # Body's window.
+
+  attr_accessor :w
 
   ##
   # Create a new body in windowing system +w+ with a random x/y and
@@ -92,6 +120,25 @@ class Graphics::Body
     [dx, dy]
   end
 
+  ##
+  # Return the angle to another body in degrees.
+
+  def angle_to body
+    dx = body.x - self.x
+    dy = body.y - self.y
+
+    (R2D * Math.atan2(dy, dx)).degrees
+  end
+
+  ##
+  # Return the distance to another body, squared.
+
+  def distance_to_squared p
+    dx = p.x - x
+    dy = p.y - y
+    dx * dx + dy * dy
+  end
+
   def m_a # :nodoc:
     [m, a]
   end
@@ -139,10 +186,10 @@ class Graphics::Body
 
     if y < 0 then
       self.y = 0
-      return :north
+      return :south
     elsif y > max_h then
       self.y = max_h
-      return :south
+      return :north
     end
 
     nil

data/lib/graphics/extensions.rb

@@ -1,3 +1,6 @@
+##
+# Integer extensions for graphics
+
 class Integer
   ##
   # Calculate a random chance using easy notation: 1 =~ 50 :: 1 in 50 chance
@@ -7,6 +10,9 @@ class Integer
   end
 end
 
+##
+# Numeric extensions for graphics
+
 class Numeric
   ##
   # Is M close to N within a certain delta?
@@ -30,16 +36,16 @@ class Numeric
   # Consider this method private, even tho it is in use by the demos.
 
   def relative_angle n, max
-    deltaCW = (self - n).degrees
-    deltaCC = (n - self).degrees
+    delta_cw = (self - n).degrees
+    delta_cc = (n - self).degrees
 
-    return if deltaCC < 0.1 || deltaCW < 0.1
+    return if delta_cc < 0.1 || delta_cw < 0.1
 
-    if deltaCC.abs < max then
-      deltaCC
-    elsif deltaCW.close_to? 180 then
+    if delta_cc.abs < max then
+      delta_cc
+    elsif delta_cw.close_to? 180 then
       [-max, max].sample
-    elsif deltaCW < deltaCC then
+    elsif delta_cw < delta_cc then
       -max
     else
       max

data/lib/graphics/simulation.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-require "sdl"
+require "sdl/sdl"
 
 module SDL; end # :nodoc: -- stupid rdoc :(
 
@@ -38,6 +38,12 @@ class Graphics::Simulation
   # A hash of color values to their rgb values. For text, apparently. *shrug*
   attr_accessor :rgb
 
+  # Number of update iterations per drawing tick.
+  attr_accessor :iter_per_tick
+
+  # Procs registered to handle key events.
+  attr_accessor :key_handler
+
   ##
   # Create a new simulation of a certain width and height. Optionally,
   # you can set the bits per pixel (0 for current screen settings),
@@ -47,11 +53,10 @@ class Graphics::Simulation
 
   def initialize w, h, bpp = 0, name = self.class.name, full = false
     SDL.init SDL::INIT_VIDEO
-    SDL::TTF.init
 
     full = full ? SDL::FULLSCREEN : 0
 
-    self.font = SDL::TTF.open("/System/Library/Fonts/Menlo.ttc", 32, 0)
+    self.font = find_font("Menlo", 32)
 
     SDL::WM.set_caption name, name
 
@@ -59,8 +64,29 @@ class Graphics::Simulation
     self.w, self.h = screen.w, screen.h
 
     self.color = {}
-    self.rgb   = Hash.new { |hash, k| hash[k] = screen.get_rgb(color[k]) }
+    self.rgb   = Hash.new { |hash, k| hash[k] = screen.format.get_rgb(color[k]) }
+    self.paused = false
 
+    self.iter_per_tick = 1
+
+    self.key_handler = []
+
+    initialize_keys
+    initialize_colors
+  end
+
+  ##
+  # Register default key events. Handles ESC & Q (quit) and P (pause).
+
+  def initialize_keys
+    add_key_handler(:ESCAPE) { exit }
+    add_key_handler(:Q)      { exit }
+    add_key_handler(:P)      { self.paused = !paused }
+    add_key_handler(:SLASH)  { self.iter_per_tick += 1 }
+    add_key_handler(:MINUS)  { self.iter_per_tick -= 1; self.iter_per_tick = 1  if iter_per_tick < 1 }
+  end
+
+  def initialize_colors # :nodoc:
     register_color :black,     0,   0,   0
     register_color :white,     255, 255, 255
     register_color :red,       255, 0,   0
@@ -72,13 +98,27 @@ class Graphics::Simulation
 
     (0..99).each do |n|
       m = (255 * (n / 100.0)).to_i
-      register_color ("gray%02d"  % n).to_sym, m, m, m
-      register_color ("red%02d"   % n).to_sym, m, 0, 0
-      register_color ("green%02d" % n).to_sym, 0, m, 0
-      register_color ("blue%02d"  % n).to_sym, 0, 0, m
+      register_color(("gray%02d"  % n).to_sym, m, m, m)
+      register_color(("red%02d"   % n).to_sym, m, 0, 0)
+      register_color(("green%02d" % n).to_sym, 0, m, 0)
+      register_color(("blue%02d"  % n).to_sym, 0, 0, m)
     end
+  end
 
-    self.paused = false
+  sys_font  = "/System/Library/Fonts"
+  lib_font  = "/Library/Fonts"
+  user_font = File.expand_path "~/Library/Fonts/"
+  FONT_GLOB = "{#{sys_font},#{lib_font},#{user_font}}" # :nodoc:
+
+  ##
+  # Find and open a (TTF) font. Should be as system agnostic as possible.
+
+  def find_font name, size = 16
+    font = Dir["#{FONT_GLOB}/#{name}.{ttc,ttf}"].first
+
+    raise ArgumentError, "Can't find font named '#{name}'" unless font
+
+    SDL::TTF.open(font, size)
   end
 
   ##
@@ -97,7 +137,8 @@ class Graphics::Simulation
     n.times.map {
       o = klass.new self
       yield o if block_given?
-      o }
+      o
+    }
   end
 
   ##
@@ -110,15 +151,22 @@ class Graphics::Simulation
   end
 
   ##
-  # Handle key events. By default handles ESC & Q (quit) and P
-  # (pause). Override this if you want to handle more key events. Be
-  # sure to call super or provide your own means of quitting and/or
-  # pausing.
+  # Register a block to run for a particular key-press.
+
+  def add_key_handler k, remove = nil, &b
+    k = SDL::Key.const_get k
+    key_handler.delete_if { |a, _| k==a } if remove
+    key_handler.unshift [k, b]
+  end
+
+  ##
+  # Handle key events by looking through key_handler and running any
+  # blocks that match the key(s) being pressed.
 
   def handle_keys
-    exit                  if SDL::Key.press? SDL::Key::ESCAPE
-    exit                  if SDL::Key.press? SDL::Key::Q
-    self.paused = !paused if SDL::Key.press? SDL::Key::P
+    key_handler.each do |k, blk|
+      blk[self] if SDL::Key.press? k
+    end
   end
 
   ##
@@ -131,18 +179,16 @@ class Graphics::Simulation
     self.start_time = Time.now
     n = 0
     event = nil
+
     loop do
       handle_event event, n while event = SDL::Event.poll
       SDL::Key.scan
       handle_keys
 
-      unless paused then
-        update n unless paused
-
-        draw_and_flip n
+      next if paused
 
-        n += 1 unless paused
-      end
+      iter_per_tick.times { update n; n += 1 }
+      draw_and_flip n
     end
   end
 
@@ -179,7 +225,7 @@ class Graphics::Simulation
 
   def line x1, y1, x2, y2, c
     h = self.h
-    screen.draw_line x1, h-y1, x2, h-y2, color[c], :antialiased
+    screen.draw_line x1, h-y1-1, x2, h-y2-1, color[c]
   end
 
   ##
@@ -203,7 +249,7 @@ class Graphics::Simulation
   def polygon *points, color
     points << points.first
     points.each_cons(2) do |p1, p2|
-      w.line(*p1, *p2, color)
+      line(*p1, *p2, color)
     end
   end
 
@@ -219,14 +265,14 @@ class Graphics::Simulation
   # Draw a rect at x/y with w by h dimensions in color c. Ignores blending.
 
   def fast_rect x, y, w, h, c
-    screen.fill_rect x, self.h-y-h, w, h, color[c]
+    screen.fast_rect x, self.h-y-h, w, h, color[c]
   end
 
   ##
   # Draw a point at x/y w/ color c.
 
   def point x, y, c
-    screen[x, h-y] = color[c]
+    screen[x, h-y-1] = color[c]
   end
 
   ##
@@ -242,21 +288,36 @@ class Graphics::Simulation
   # Draw a rect at x/y with w by h dimensions in color c.
 
   def rect x, y, w, h, c, fill = false
-    screen.draw_rect x, self.h-y-h, w, h, color[c], fill
+    y = self.h-y-h-1
+    if fill then
+      screen.fill_rect x, y, w, h, color[c]
+    else
+      screen.draw_rect x, y, w, h, color[c]
+    end
   end
 
   ##
   # Draw a circle at x/y with radius r in color c.
 
   def circle x, y, r, c, fill = false
-    screen.draw_circle x, h-y, r, color[c], fill, :antialiased
+    y = h-y-1
+    if fill then
+      screen.fill_circle x, y, r, color[c]
+    else
+      screen.draw_circle x, y, r, color[c]
+    end
   end
 
   ##
   # Draw a circle at x/y with radiuses w/h in color c.
 
   def ellipse x, y, w, h, c, fill = false
-    screen.draw_ellipse x, self.h-y, w, h, color[c], fill, :antialiased
+    y = self.h-y-1
+    if fill then
+      screen.fill_ellipse x, y, w, h, color[c]
+    else
+      screen.draw_ellipse x, y, w, h, color[c]
+    end
   end
 
   ##
@@ -265,7 +326,7 @@ class Graphics::Simulation
 
   def bezier x1, y1, cx1, cy1, cx2, cy2, x2, y2, c, l = 7
     h = self.h
-    screen.draw_bezier x1, h-y1, cx1, h-cy1, cx2, h-cy2, x2, h-y2, l, color[c], :antialiased
+    screen.draw_bezier x1, h-y1-1, cx1, h-cy1, cx2, h-cy2, x2, h-y2-1, l, color[c]
   end
 
   ## Text
@@ -281,14 +342,15 @@ class Graphics::Simulation
   # Return the rendered text s in color c in font f.
 
   def render_text s, c, f = font
-    f.render_solid_utf8 s, *rgb[c]
+    f.render screen, s, color[c]
   end
 
   ##
   # Draw text s at x/y in color c in font f.
 
   def text s, x, y, c, f = font
-    f.draw_solid_utf8 screen, s, x, self.h-y-f.height, *rgb[c]
+    y = self.h-y-f.height-1
+    f.draw screen, s, x, y, color[c]
   end
 
   ##
@@ -313,15 +375,7 @@ class Graphics::Simulation
 
   ### Blitting Methods:
 
-  ## utilities for later
-
-  # put_pixel(x, y, color)
-  # []=(x, y, color)
-  # get_pixel(x, y)
-  # [](x, y)
-  # put(src, x, y) # see blit
-  # copy_rect(x,y,w,h)
-  # transform_surface(bgcolor,angle,xscale,yscale,flags)
+  # TODO: copy_rect(x,y,w,h)
 
   ##
   # Load an image at path into a new surface.
@@ -330,6 +384,20 @@ class Graphics::Simulation
     SDL::Surface.load path
   end
 
+  ##
+  # Load an audio file at path
+
+  def audio path
+    SDL::Audio.load path
+  end
+
+  ##
+  # Open the audio mixer with a number of +channels+ open.
+
+  def open_mixer channels = 1
+    SDL::Audio.open channels
+  end
+
   ##
   # Return the current mouse state: x, y, buttons.
 
@@ -340,10 +408,22 @@ class Graphics::Simulation
   end
 
   ##
-  # Draw a bitmap at x/y with an angle and optional x/y scale.
+  # Draw a bitmap centered at x/y with optional angle, x/y scale, and flags.
+
+  def blit src, x, y, a° = 0, xscale = 1, yscale = 1, flags = 0
+    img = src.transform src.format.colorkey, -a°, xscale, yscale, flags
+
+    SDL::Surface.blit img, 0, 0, 0, 0, screen, x-img.w/2, h-y-img.h/2
+  end
+
+  ##
+  # Draw a bitmap at x/y with optional angle, x/y scale, and flags.
+
+  def put src, x, y, a° = 0, xscale = 1, yscale = 1, flags = 0
+    img = src.transform src.format.colorkey, -a°, xscale, yscale, flags
 
-  def blit o, x, y, a°, xs=1, ys=1, opt=0
-    SDL::Surface.transform_blit o, screen, -a°, 1, 1, o.w/2, o.h/2, x, h-y, opt
+    # why x-1? because transform adds a pixel to all sides even if a°==0
+    SDL::Surface.blit img, 0, 0, 0, 0, screen, x-1, h-y-img.h
   end
 
   ##
@@ -352,7 +432,7 @@ class Graphics::Simulation
   # primitives will work and the resulting surface is returned.
 
   def sprite w, h
-    new_screen = SDL::Surface.new SDL::SWSURFACE, w, h, screen
+    new_screen = SDL::Surface.new w, h, screen.format
     old_screen = screen
     old_w, old_h = self.w, self.h
     self.w, self.h = w, h