texplay 0.2.983pre2-i386-mingw32 → 0.3.0-i386-mingw32

data/ext/texplay/utils.h

@@ -0,0 +1,153 @@
+#ifndef GUARD_UTILS_H
+#define GUARD_UTILS_H
+
+
+/* for use with get_image_local, and set_image_local */
+#define DRAW_OFFSET 0
+#define LAZY_BOUNDS 1
+#define IMAGE_COLOR 2
+#define USER_DEFAULTS 3 
+
+/* shared global */
+extern const rgba not_a_color_v;
+
+/* color and pixel related functions */
+rgba find_color_from_string(char * try_color);
+bool cmp_color(rgba color1, rgba color2);
+bool cmp_color_with_tolerance(rgba color1, rgba color2, float tolerance);
+void color_copy(float * source, float * dest);
+rgba get_pixel_color(texture_info * tex, int x, int y) ;
+float* get_pixel_data(texture_info * tex, int x, int y);
+void set_pixel_color(rgba * pixel_color, texture_info * tex, int x, int y);
+void zero_color(float * tex);
+bool not_a_color(rgba color1);
+bool is_a_color(rgba color1);
+VALUE convert_rgba_to_rb_color(rgba * pix);
+rgba convert_rb_color_to_rgba(VALUE cval);
+VALUE gosu_color_class();
+bool is_gosu_color(VALUE try_color);
+bool is_rb_raw_color(VALUE cval);
+bool not_rb_raw_color(VALUE cval);
+rgba convert_gosu_to_rgba_color(VALUE gcolor);
+VALUE convert_rgba_to_gosu_color(rgba * pix);
+
+
+VALUE save_rgba_to_image_local_color(VALUE image, rgba color);
+rgba convert_image_local_color_to_rgba(VALUE image);
+
+
+/* string/symbol related functions */
+char* lowercase(char*);
+char* sym2string(VALUE);
+VALUE string2sym(char*);
+
+/* is it a hash? */
+bool is_a_hash(VALUE try_hash);
+
+/* is an array? */
+bool is_an_array(VALUE try_array);
+
+/* is a num? */
+bool is_a_num(VALUE try_num);
+
+/* helpful C wrapper for rb_hash_aref */
+VALUE get_from_hash(VALUE hash, char * sym);
+
+/* a wrapper for rb_hash_aset */
+VALUE set_hash_value(VALUE hash, char * sym, VALUE val);
+
+/* a wrapper for rb_hash_delete */
+VALUE delete_from_hash(VALUE hash, char * sym);
+
+/* does the hash key 'sym' map to value 'val'? */
+bool hash_value_is(VALUE hash, char * sym, VALUE val);
+
+/* determine whether (1) hash is a T_HASH (2) the sym exists in the hash */
+bool has_optional_hash_arg(VALUE hash, char * sym);
+
+
+/* helpful C wrapper for rb_array_store */
+VALUE set_array_value(VALUE array, int index, VALUE val);
+
+/* helpful C wrapper for rb_array_entry */
+VALUE get_from_array(VALUE array, int index);
+
+/* set the lazy_bounds ivar for an image */
+VALUE set_ivar_array(VALUE obj, char * ivar, int argc, ...);
+
+/* initialize lazy_bounds */
+void init_lazy_bounds(VALUE image);
+
+/* initialize the image_local var array */
+VALUE init_image_local(VALUE image);
+
+/* return an image local variable */
+VALUE get_image_local(VALUE image, int name);
+
+/* set an image local variable */
+void set_image_local(VALUE image, int name, VALUE val);
+
+/* error checking functions */
+void check_mask(VALUE mask);
+
+void check_image(VALUE image);
+
+/* is try_image a Gosu::Image ? */
+bool is_gosu_image(VALUE try_image);
+
+
+/* make boundaries sane */
+void constrain_boundaries(int * x0, int * y0, int * x1, int * y1, int width, int height);
+
+/* line clipping */
+void cohen_sutherland_clip (int * x0, int * y0,int * x1, int * y1, int xmin, int ymin,
+                            int xmax, int ymax);
+
+/* check if point is bound by rect and inner thickness */
+bool bound_by_rect_and_inner(int x, int y, int x0, int y0, int x1, int y1, int inner);
+
+/* check if point is bound by rect */
+bool bound_by_rect(int x, int y, int x0, int y0, int x1, int y1);
+
+/* calculate the array offset for a given pixel */
+int calc_pixel_offset(texture_info * tex, int x, int y);
+
+/* calculate the array offset for a given pixel in an action context */
+int calc_pixel_offset_for_action(action_struct * cur, texture_info * tex, int x, int y);
+
+/* return a pointer to a new texture */
+float* allocate_texture(int width, int height);
+
+/* other function prototypes, get info for a texture */
+void get_texture_info(VALUE image, texture_info * tex);
+
+/* ensure gl_tex_info returns non nil */
+VALUE check_for_texture_info(VALUE image);
+
+/* responsible for syncing a subimage to gl */
+void sync_to_gl(int tex_name, int x_offset, int y_offset, int width, int height, void * sub);
+
+/* create a subtexture and sync to gl */
+void create_subtexture_and_sync_to_gl(image_bounds * img_bounds, texture_info * tex);
+
+float * get_image_chunk(texture_info * tex, int xmin, int ymin, int xmax, int ymax);
+
+rgba get_pixel_color_from_chunk(float * chunk, int width, int height, int x, int y);
+
+/* from Texture.cpp in Gosu Graphics folder */
+unsigned max_quad_size(void);
+
+/* point utils */
+bool is_a_point(VALUE try_point);
+VALUE point_x(VALUE point);
+VALUE point_y(VALUE point);
+
+/* mathematical utils, used by bezier curves */
+double power(float base, int exp);
+unsigned fact(int n);
+unsigned comb(int n, int k);
+unsigned perm(int n, int r);
+
+double bernstein(int n, int k, float u);
+
+#endif

data/lib/texplay.rb

@@ -1,225 +1,331 @@
 
 # (C) John Mair 2009, under the MIT licence
 
-begin
-    require 'rubygems'
-rescue LoadError
-end
-
-direc = File.dirname(__FILE__)
+direc = File.expand_path(File.dirname(__FILE__))
 
 # include gosu first
 require 'rbconfig'
 require 'gosu'
 require "#{direc}/texplay/version"
-require "#{direc}/texplay/patches"
 
 module TexPlay
-    class << self
-        def on_setup(&block)
-            raise "need a block" if !block
-            
-            @__init_procs__ ||= []
-            @__init_procs__.push(block)
-        end
-
-        def setup(receiver)
-            if @__init_procs__ then
-                @__init_procs__.each do |init_proc|
-                    receiver.instance_eval(&init_proc)
-                end
-            end
-        end
-
-        def create_image(window, width, height, options={})
-          options = {
-            :color => :alpha,
-            :caching => false,
-          }.merge!(options)
+  RENDER_CLEAR_COLOR = Gosu::Color.new(255, 0, 0, 0)
 
-          raise ArgumentError, "Height and width must be positive" if height <= 0 or width <= 0
-          
-          img = Gosu::Image.new(window, EmptyImageStub.new(width, height), :caching => options[:caching])
-          img.rect 0, 0, img.width - 1, img.height - 1, :color => options[:color], :fill => true 
+  class << self
+    def on_setup(&block)
+      raise "need a block" if !block
+      
+      @__init_procs__ ||= []
+      @__init_procs__.push(block)
+    end
 
-          img
+    def setup(receiver)
+      if @__init_procs__ then
+        @__init_procs__.each do |init_proc|
+          receiver.instance_eval(&init_proc)
         end
+      end
+    end
 
-        alias_method :create_blank_image, :create_image
-
-        # Image can be :tileable, but it will break if it is tileable AND gets modified after creation.
-        def from_blob(window, blob_data, width, height, options={})
-          options = {
-            :caching => @options[:caching],
-            :tileable => false,
-          }.merge!(options)
+    def create_image(window, width, height, options={})
+      options = {
+        :color => :alpha,
+        :caching => false,
+      }.merge!(options)
 
-          raise ArgumentError, "Height and width must be positive (received #{width}x#{height})" if height <= 0 or width <= 0
+      raise ArgumentError, "Height and width must be positive" if height <= 0 or width <= 0
+      
+      img = Gosu::Image.new(window, EmptyImageStub.new(width, height), :caching => options[:caching])
+      img.rect 0, 0, img.width - 1, img.height - 1, :color => options[:color], :fill => true 
 
-          expected_size = height * width * 4
-          if blob_data.size != expected_size
-            raise ArgumentError, "Blob data is not of the correct size (expected #{expected_size} but received #{blob_data.size} bytes)"
-          end
+      img
+    end
 
-          Gosu::Image.new(window, ImageStub.new(blob_data, width, height), options[:tileable], :caching => options[:caching])
-        end
+    alias_method :create_blank_image, :create_image
 
-        def set_options(options = {})
-            @options.merge!(options)
-        end
+    # Image can be :tileable, but it will break if it is tileable AND gets modified after creation.
+    def from_blob(window, blob_data, width, height, options={})
+      options = {
+        :caching => @options[:caching],
+        :tileable => false,
+      }.merge!(options)
 
-        def get_options
-            @options
-        end
+      raise ArgumentError, "Height and width must be positive (received #{width}x#{height})" if height <= 0 or width <= 0
 
-        # default values defined here
-        def set_defaults
-          @options = {
-              :caching => true
-          }
-        end
+      expected_size = height * width * 4
+      if blob_data.size != expected_size
+        raise ArgumentError, "Blob data is not of the correct size (expected #{expected_size} but received #{blob_data.size} bytes)"
+      end
 
-        def init
-            set_defaults
-        end
+      Gosu::Image.new(window, ImageStub.new(blob_data, width, height), options[:tileable], :caching => options[:caching])
     end
 
-    module Colors
-        Red = [1, 0, 0, 1]
-        Green = [0, 1, 0, 1]
-        Blue = [0, 0, 1, 1]
-        Black = [0, 0, 0, 1]
-        White = [1, 1, 1, 1]
-        Grey = [0.5, 0.5, 0.5, 1]
-        Alpha = [0, 0, 0, 0]
-        Purple = [1, 0, 1, 1]
-        Yellow = [1, 1, 0, 1]
-        Cyan = [0, 1, 1, 1]
-        Orange = [1, 0.5, 0, 1]
-        Brown = [0.39, 0.26, 0.13, 1]
-        Turquoise = [1, 0.6, 0.8, 1]
-        Tyrian = [0.4, 0.007, 0.235, 1]
+    def set_options(options = {})
+      @options.merge!(options)
     end
-    include Colors
 
-    # extra instance methods defined in Ruby
-
-    # clear an image (with an optional clear color)
-    def clear(options = {})
-      options = {
-        :color => :alpha,
-        :fill => true
-      }.merge!(options)
+    def get_options
+      @options
+    end
 
-      capture {
-        rect 0, 0, width - 1, height - 1, options
-      
-        self
+    # default values defined here
+    def set_defaults
+      @options = {
+        :caching => true
       }
     end
-      
-end
 
-# Used to create images from blob data.
-class ImageStub
+    def init
+      set_defaults
+    end
+  end
+
+  module Colors
+    Red = [1, 0, 0, 1]
+    Green = [0, 1, 0, 1]
+    Blue = [0, 0, 1, 1]
+    Black = [0, 0, 0, 1]
+    White = [1, 1, 1, 1]
+    Grey = [0.5, 0.5, 0.5, 1]
+    Alpha = [0, 0, 0, 0]
+    Purple = [1, 0, 1, 1]
+    Yellow = [1, 1, 0, 1]
+    Cyan = [0, 1, 1, 1]
+    Orange = [1, 0.5, 0, 1]
+    Brown = [0.39, 0.26, 0.13, 1]
+    Turquoise = [1, 0.6, 0.8, 1]
+    Tyrian = [0.4, 0.007, 0.235, 1]
+  end
+  include Colors
+
+  # extra instance methods defined in Ruby
+
+  # Clear an image.
+  #
+  # @option options :color (:alpha) Colour of the image.
+  # @return [Gosu::Image]
+  def clear(options = {})
+    options = {
+      :color => :alpha,
+      :fill => true
+    }.merge!(options)
+
+    capture {
+      rect 0, 0, width - 1, height - 1, options
+      
+      self
+    }
+  end
+
+  # Used internally to create images from raw binary (blob) data (TexPlay::from_blob).
+  #
+  # This object duck-types an RMagick image (#rows, #columns, #to_blob), so that Gosu will import it.
+  class ImageStub
+    # @return [Integer]
     attr_reader :rows, :columns
-    
+
+    # The first pixel in the blob will be at the top left hand corner of the created image, since that is the orientation
+    # of Gosu images.
+    #
+    # @param [String] blob_data Raw data string to import. Must be RGBA ordered, (4 * width * height) bytes in length.
+    # @param [Integer] width Number of pixels wide.
+    # @param [Integer] height Number of pixels high.
     def initialize(blob_data, width, height)
-        @data, @columns, @rows = blob_data, width, height
+      @data, @columns, @rows = blob_data, width, height
     end
-    
+
+    # @return [String]
     def to_blob
-        @data
+      @data
     end
-end
-
-# Used to create blank images.
-# credit to philomory for this class
-class EmptyImageStub < ImageStub
+  end
+
+  # Used internally to create blank images (red/blue/green/alpha all 0) (TexPlay::create_image).
+  #
+  # Credit to philomory for this class.
+  class EmptyImageStub < ImageStub
+    # @param width (see ImageStub#initialize)
+    # @param height (see ImageStub#initialize)
     def initialize(width, height)
-        super("\0" * (width * height * 4), width, height)
+      super("\0" * (width * height * 4), width, height)
     end
+  end
 end
 
 # bring in user-defined extensions to TexPlay
-direc = File.dirname(__FILE__)
 dlext = Config::CONFIG['DLEXT']
 begin
-    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
-        require "#{direc}/1.9/texplay.#{dlext}"
-    else
-        require "#{direc}/1.8/texplay.#{dlext}"
-    end
+  if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+    require "#{direc}/1.9/texplay.#{dlext}"
+  else
+    require "#{direc}/1.8/texplay.#{dlext}"
+  end
 rescue LoadError => e
-    require "#{direc}/texplay.#{dlext}"
+  require "#{direc}/texplay.#{dlext}"
 end
-    
+
 require "#{direc}/texplay-contrib"
 
 # monkey patching the Gosu::Image class to add image manipulation functionality
 module Gosu
-    class Image
+  class Image
+
+    # bring in the TexPlay image manipulation methods
+    include TexPlay
+
+    attr_reader :__window__
+    protected :__window__
+    
+    class << self 
+      alias_method :original_new, :new
 
-        # bring in the TexPlay image manipulation methods
-        include TexPlay
+      def new(*args, &block)
 
-        attr_reader :__window__
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        # invoke old behaviour
+        obj = original_new(*args, &block)
+
+        prepare_image(obj, args.first, options)
+      end
+      
+      alias_method :original_from_text, :from_text
+
+      def from_text(*args, &block)
+
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        # invoke old behaviour
+        obj = original_from_text(*args, &block)
+
+        prepare_image(obj, args.first, options)
+      end
+
+      def prepare_image(obj, window, options={})
+        options = {
+          :caching => TexPlay.get_options[:caching]
+        }.merge!(options)
         
-        class << self 
-            alias_method :original_new, :new
-            
-            def new(*args, &block)
-
-                options = args.last.is_a?(Hash) ? args.pop : {}
-                # invoke old behaviour
-                obj = original_new(*args, &block)
-
-                prepare_image(obj, args.first, options)
-            end
-            
-            alias_method :original_from_text, :from_text
-
-            def from_text(*args, &block)
-
-                options = args.last.is_a?(Hash) ? args.pop : {}
-                # invoke old behaviour
-                obj = original_from_text(*args, &block)
-
-                prepare_image(obj, args.first, options)
-            end
-
-            def prepare_image(obj, window, options={})
-                options = {
-                  :caching => TexPlay.get_options[:caching]
-                }.merge!(options)
-                
-                # refresh the TexPlay image cache
-                if obj.width <= (TexPlay::TP_MAX_QUAD_SIZE) &&
-                    obj.height <= (TexPlay::TP_MAX_QUAD_SIZE) && obj.quad_cached? then
-                    obj.refresh_cache if options[:caching]
-                end
-                
-                # run custom setup
-                TexPlay.setup(obj)
-              
-                obj.instance_variable_set(:@__window__, window)
-
-                obj
-            end
-            
-            private :prepare_image
+        # refresh the TexPlay image cache
+        if obj.width <= (TexPlay::TP_MAX_QUAD_SIZE) &&
+            obj.height <= (TexPlay::TP_MAX_QUAD_SIZE) && obj.quad_cached? then
+          obj.refresh_cache if options[:caching]
         end
+        
+        # run custom setup
+        TexPlay.setup(obj)
+        
+        obj.instance_variable_set(:@__window__, window)
+
+        obj
+      end
+      
+      private :prepare_image
+    end
+
+    alias_method :rows, :height
+    alias_method :columns, :width             
+  end
+
+  class Window
+    # Render directly into an existing image, optionally only to a specific region of that image.
+    #
+    # Since this operation utilises the window's back buffer, the image (or clipped area, if specified) cannot be larger than the
+    # window itself. Larger images can be rendered to only in separate sections using :clip_to areas, each no larger
+    # than the window).
+    #
+    # @note *Warning!* This operation will corrupt an area of the screen, at the bottom left corner, equal in size to the image rendered to (or the clipped area), so should be performed in #draw _before_ any other rendering.
+    #
+    # @note The final alpha of the image will be 255, regardless of what it started with or what is drawn onto it.
+    #
+    # @example
+    #   class Gosu
+    #     class Window
+    #       def draw
+    #         # Always render images before regular drawing to the screen.
+    #         unless @rendered_image
+    #           @rendered_image = TexPlay.create_image(self, 300, 300, :color => :blue)
+    #           render_to_image(@rendered_image) do
+    #             @an_image.draw 0, 0, 0
+    #             @another_image.draw 130, 0, 0
+    #             draw_line(0, 0, Color.new(255, 0, 0, 0), 100, 100, Color.new(255, 0, 0, 0), 0)
+    #             @font.draw("Hello world!", 0, 50, 0)
+    #           end
+    #         end
+    #
+    #         # Perform regular screen rendering.
+    #         @rendered_image.draw 0, 0
+    #       end
+    #     end
+    #   end
+    #
+    #
+    # @param [Gosu::Image] image Existing image to render onto.
+    # @option options [Array<Integer>] :clip_to ([0, 0, image.width, image.height]) Area of the image to render into. This area cannot be larger than the window, though the image may be.
+    # @return [Gosu::Image] The image that has been rendered to.
+    # @yield to a block that renders to the image.
+    def render_to_image(image, options = {})
+      raise ArgumentError, "image parameter must be a Gosu::Image to be rendered to" unless image.is_a? Gosu::Image
+      raise ArgumentError, "rendering block required" unless block_given?
+
+      options = {
+        :clip_to => [0, 0, image.width, image.height],
+      }.merge! options
+
+      texture_info = image.gl_tex_info
+      tex_name = texture_info.tex_name
+      x_offset = (texture_info.left * Gosu::MAX_TEXTURE_SIZE).to_i
+      y_offset = (texture_info.top * Gosu::MAX_TEXTURE_SIZE).to_i
+
+      raise ArgumentError, ":clip_to rectangle must contain exactly 4 elements" unless options[:clip_to].size == 4
+
+      left, top, width, height = *(options[:clip_to].map {|n| n.to_i })
+
+      raise ArgumentError, ":clip_to rectangle cannot be wider or taller than the window" unless width <= self.width and height <= self.height
+      raise ArgumentError, ":clip_to rectangle width and height must be positive" unless width > 0 and height > 0
 
-        alias_method :rows, :height
-        alias_method :columns, :width             
+      right = left + width - 1
+      bottom = top + height - 1
+
+      unless (0...image.width).include? left and (0...image.width).include? right and
+          (0...image.height).include? top and (0...image.height).include? bottom
+        raise ArgumentError, ":clip_to rectangle out of bounds of the image"
+      end
+
+      # Since to_texture copies an inverted copy of the screen, what the user renders needs to be inverted first.
+      scale(1, -1) do
+        translate(-left, -top - self.height) do
+          # TODO: Once Gosu is fixed, we can just pass width/height to clip_to
+          clip_to(left, top, width, height) do
+            # Draw over the background (which is assumed to be blank) with the original image texture,
+            # to get us to the base image.
+            image.draw(0, 0, 0)
+            flush
+
+            # Allow the user to overwrite the texture.
+            yield
+          end
+
+          # Copy the modified texture back from the screen buffer to the image.
+          to_texture(tex_name, x_offset + left, y_offset + top, 0, 0, width, height)
+
+          # Clear the clipped zone to black again, ready for the regular screen drawing.
+          # Quad can be a pixel out, so just make sure with a slightly larger shape.
+          draw_quad(left - 2, top - 2, TexPlay::RENDER_CLEAR_COLOR,
+                    right + 2, top - 2, TexPlay::RENDER_CLEAR_COLOR,
+                    right + 2, bottom + 2, TexPlay::RENDER_CLEAR_COLOR,
+                    left - 2, bottom + 2, TexPlay::RENDER_CLEAR_COLOR)
         end
+      end
+
+      image
+    end
+  end
 end
 
 # a bug in ruby 1.8.6 rb_eval_string() means i must define this here (rather than in texplay.c)
 class Proc  
-    def __context__
-        eval('self', self.binding)
-    end
+  def __context__
+    eval('self', self.binding)
+  end
 end