sdl2_ffi 0.0.2 → 0.0.3

data/lib/sdl2/palette.rb

@@ -1,15 +1,73 @@
 require 'sdl2'
 
 module SDL2
+
   #SDL_pixels.h:261~267
-  class Palette < FFI::Struct
+  class Palette < Struct
     layout :ncolors, :int,
-      :colors, :pointer,
-      :version, :uint32,
-      :refcount, :int
-      
+    :colors, :pointer,
+    :version, :uint32,
+    :refcount, :int
+
+    def self.create(num_colors)
+      SDL2.alloc_palette!(num_colors)
+    end
+
     def self.release(pointer)
       SDL2.free_palette(pointer)
-    end      
+    end
+
+    # \brief Set a range of colors in a palette
+    # \param colors: An array of colors to copy into the palette
+    # - Can be a FFI::Pointer, which is passed directly to the routine.
+    # - Can be a ruby array, an FFI::Pointer array will be created and values
+# copied:
+    #   - Elements that are arrays are converted to SDL_Color in the FFI::Pointer
+# array.
+    #   - Elements that are Color structs are copied into the array.
+    # \param firstcolor: The index of the first palette entry to modify.
+    # \param ncolors: The number of entries to modify
+    # - This defaults to the length of colors if colors is a Ruby Array
+    def set_colors(colors, firstcolor = 0, ncolors = nil)
+      
+      if colors.kind_of? Array
+        
+        ncolors = colors.count if ncolors.nil?
+        
+        raise "(ncolors = #{ncolors} > colors.count #{colors.count}" if ncolors > colors.count
+        
+        # We must build our on colors pointer:
+        colors_ptr = FFI::MemoryPointer.new(Color, ncolors)
+        
+        colors.each_with_index() { |color, idx|
+          
+          puts "color##{idx} = #{color.inspect}"
+          
+          if idx < ncolors # Skip when the array count is more than ncolors
+        
+            color_ptr = Color.new(colors_ptr[idx])
+            
+            if color.kind_of? Array          
+              color_ptr.set(*color)
+            elsif color.kind_of? Color
+              color_ptr.copy_from(color)
+            else
+              raise "Invalid Array Member"
+            end#if color.kind_of?
+            
+          end
+          
+        }#colors.each_with_index
+        
+        colors = colors_ptr # Replace the passed in argument with our pointer
+        
+      elsif colors.kind_of? FFI::Pointer
+        raise "ncolors must be specified" if ncolors.nil?
+        # Then we can just continue using it as is below.
+      end# if
+      
+      SDL2.set_palette_colors(self, colors, firstcolor, ncolors)
+            
+    end
   end
 end

data/lib/sdl2/pixel_format.rb

@@ -2,27 +2,115 @@ require 'sdl2'
 require 'sdl2/palette'
 
 module SDL2
-  #SDL_pixels.h:272~293
+
+  # SDL_pixels.h:272~293:typdef struct SDL_PixelFormat
+  # \note Everything in the pixel format structure is read-only.
   class PixelFormat < FFI::Struct
+
+    private :[] # see note
+
     layout :format, :pixel_format,
-      :palette, Palette.by_ref,
-      :bits_per_pixel, :uint8,
-      :bytes_per_pixel, :uint8,
-      :padding, [:uint8, 2],
-      :r_mask, :uint32,
-      :g_mask, :uint32,
-      :b_mask, :uint32,
-      :a_mask, :uint32,
-      :r_loss, :uint8,
-      :g_loss, :uint8,
-      :b_loss, :uint8,
-      :a_loss, :uint8,
-      :refcount, :int,
-      :next, PixelFormat.by_ref
-      
+    :palette, Palette.by_ref,
+    :bits_per_pixel, :uint8,
+    :bytes_per_pixel, :uint8,
+    :padding, [:uint8, 2],
+    :r_mask, :uint32,
+    :g_mask, :uint32,
+    :b_mask, :uint32,
+    :a_mask, :uint32,
+    :r_loss, :uint8,
+    :g_loss, :uint8,
+    :b_loss, :uint8,
+    :a_loss, :uint8,
+    :refcount, :int,
+    :next, PixelFormat.by_ref
+
+    # Because the struct is read-only
+    [:format, :palette, :bytes_per_pixel, :bits_per_pixel,
+      :padding, :r_mask, :g_mask, :b_mask, :a_mask,
+      :r_loss, :g_loss, :b_loss, :refcount, :next].each do |field|
+      define_method field do
+        self[field]
+      end
+    end
+
+    # Get the human readable name of a pixel format
+    def self.get_name(pixel_format)
+      SDL2.get_pixel_format_name(pixel_format)
+    end
+
+    # Get the human readable name of this pixel format
+    def get_name
+      self.class.get_name self.format
+    end
+
+    # Convert enumerated pixel value format to bpp & RGBA mask values
+    # TODO: Review why this is needed?  Why not just read the Struct fields?
+    def self.to_masks(format)
+      p = Hash.new(){UInt32Struct.new}
+      p[:bpp] = IntStruct.new
+      SDL2.pixel_format_enum_to_masks(format, p[:bpp], p[:Rmask], p[:Bmask],p[:Amask])
+      result = []
+      p.each_value{|s|result << s[:value]}
+      p.each(&:free)
+      return result
+    end
+    
+    # TODO Review Redundancy: Basically return the masks you could read directly anyway?
+    def to_masks()
+      self.class.to_masks(self.format)
+    end
+    
+    # SDL_AllocFormat, renamed 'create' to follow ruby paradigms.
+    # Create an PixelFormat from the Enumerated format value.
+    def self.create(pixel_format)
+      SDL2.alloc_format!(pixel_format)
+    end
+       
+    # SDL_FreeFormat, renamed 'release' to follow FFI paradigms.
     def self.release(pointer)
       SDL2.free_format(pointer)
     end
+
+    # Set the palette
+    def set_palette(palette)
+      SDL2.set_pixel_format_palette(self, palette)
+    end
+    
+    alias_method :palette=, :set_palette
+    
+    # Maps an RGB triple (array) to an opaque pixel value    
+    def map_rgb(rgb)
+      r, g, b = *rgb
+      SDL2.map_rgb(self, r, g, b)
+    end
+
+    # Maps an RGBA quadruple (array) to a pixel value
+    def map_rgba(rgba)
+      r, g, b, a = *rgba
+      SDL2.map_rgba(self, r, g, b, a)
+    end
+    
+    # Get the RGB components (array) from a pixel value
+    def get_rgb(pixel)
+      ptr = Hash.new(){UInt8Struct.new}
+      SDL2.get_rgb(pixel, self, ptr[:r], ptr[:g], ptr[:b])
+      result = []
+      ptr.each_value{|s|result << s[:value]}
+      ptr.each(&:free)
+      return result
+    end
+
+    # Get the RGBA components (array) from a pixel value
+    def get_rgba(pixel)
+      ptr = Hash.new(){UInt8Struct.new}
+      SDL2.get_rgba(pixel, self, ptr[:r], ptr[:g], ptr[:b], ptr[:a])
+      result = []
+      ptr.each_value{|s|result << s[:value]}
+      ptr.each(&:free)
+      return result
+    end
+
   end
-  
+
 end

data/lib/sdl2/pixels.rb

@@ -1,35 +1,258 @@
-require 'sdl2'
+require 'sdl2/error'
 require 'sdl2/color'
 require 'sdl2/pixel_format'
+require 'yinum'
 
+# SDL_pixels.h API
 module SDL2
-  
   ALPHA_OPAQUE = 255
   ALPHA_TRANSPARENT = 0
-  
-  enum :pixeltype, [:unknown, :index1, :index4, :index8, 
-    :packed8, :packed16, :packed32, 
-    :arrayU8, :arrayU16, :arrayU32, 
-    :arrayF16, :arrayF32
-  ]
-  enum :bitmaporder, [:none, :_4321, :_1234]
-  enum :packedorder, [:none, :xrgb, :rgbx, :argb, :rgba, :xbgr, :bgrx, :abgr, :bgra]  
-  enum :arrayorder, [:none, :rgb, :rgba, :argb, :bgr, :bgra, :abgr]
-  enum :packedlayout, [:none, :_332, :_4444, :_1555, :_5551, :_565, :_8888, :_2101010, :_1010102]
-    
+
+  PIXELTYPE = Enum.new :PIXELTYPE, {
+    UNKNOWN: 0,
+    INDEX1: 1,
+    INDEX4: 2,
+    INDEX8: 3,
+    PACKED8: 4,
+    PACKED16: 5,
+    PACKED32: 6,
+    ARRAYU8: 7,
+    ARRAYU16: 8,
+    ARRAYU32: 9,
+    ARRAYF16: 10,
+    ARRAYF32: 11
+  }
+  enum :pixeltype, PIXELTYPE.by_name
+
+  BITMAPORDER = Enum.new :BITMAPORDER, {
+    NONE: 0,
+    _4321: 1,
+    _1234: 2
+  }
+  enum :bitmaporder, BITMAPORDER.by_name
+
+  PACKEDORDER = Enum.new :PACKEDORDER, {
+    NONE: 0,
+    XRGB: 1,
+    RGBX: 2,
+    ARGB: 3,
+    RGBA: 4,
+    XBGR: 5,
+    BGRX: 6,
+    ABGR: 7,
+    BGRA: 8
+  }
+  enum :packedorder, PACKEDORDER.by_name
+
+  ARRAYORDER = Enum.new :ARRAYORDER, {
+    NONE: 0,
+    RGB: 1,
+    RGBA: 2,
+    ARGB: 3,
+    BGR: 4,
+    BGRA: 5,
+    ABGR: 6
+  }
+  enum :arrayorder, ARRAYORDER.by_name
+
+  PACKEDLAYOUT = Enum.new :PACKEDLAYOUT, {
+    NONE: 0,
+    _332: 1,
+    _4444: 2,
+    _1555: 3,
+    _5551: 4,
+    _565: 5,
+    _8888: 6,
+    _2101010: 7,
+    _1010102: 8
+  }
+  enum :packedlayout, PACKEDLAYOUT.by_name
+
+  #MACRO: SDL_DEFINE_PIXELFOURCC(A, B, C, D) SDL_FOURCC(A, B, C, D)
+  def self.define_pixelfourcc(a,b,c,d); SDL2.fourcc(a,b,c,d); end
+
+  #MACRO: SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes) \
+  #    ((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | \
+  #     ((bits) << 8) | ((bytes) << 0))
+  def self.define_pixelformat(type, order, layout, bits, bytes)
+    ((1 << 28) | ((type) << 24) | ((order) << 20) | ((layout) << 16) | ((bits) << 8) | ((bytes) << 0))
+  end
+
+  #MACRO: SDL_PIXELFLAG(X)    (((X) >> 28) & 0x0F)
+  def self.pixelflag(x);      (((x) >> 28) & 0x0F); end
+
+  #MACRO: SDL_PIXELTYPE(X)    (((X) >> 24) & 0x0F)
+  def self.pixeltype(x);      (((x) >> 24) & 0x0F); end
+
+  #MACRO: SDL_PIXELORDER(X)   (((X) >> 20) & 0x0F)
+  def self.pixelorder(x);     (((x) >> 20) & 0x0F); end
+
+  #MACRO: SDL_PIXELLAYOUT(X)  (((X) >> 16) & 0x0F)
+  def self.pixellayout(x);    (((x) >> 16) & 0x0F); end
+
+  #MACRO: SDL_BITSPERPIXEL(X) (((X) >> 8) & 0xFF)
+  def self.bitsperpixel(x);   (((x) >> 8) & 0xFF); end
+
+  #MACRO: SDL_BYTESPERPIXEL(X) \
+  #    (SDL_ISPIXELFORMAT_FOURCC(X) ? \
+  #        ((((X) == SDL_PIXELFORMAT_YUY2) || \
+  #          ((X) == SDL_PIXELFORMAT_UYVY) || \
+  #          ((X) == SDL_PIXELFORMAT_YVYU)) ? 2 : 1) : (((X) >> 0) & 0xFF))
+  def self.bytesperpixel(x)
+    (ispixelformat_fourcc(x) ?
+    ((( x == PIXELFORMAT.YUV2 ) ||
+    ( x == PIXELFORMAT.UYVY ) ||
+    ( x == PIXELFORMAT.YVYU )) ? 2 : 1) : ((x >> 0) & 0xFF))
+  end
+
+  #MACRO: SDL_ISPIXELFORMAT_INDEXED(format)   \
+  #(!SDL_ISPIXELFORMAT_FOURCC(format) && \
+  #((SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX1) || \
+  #(SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX4) || \
+  #(SDL_PIXELTYPE(format) == SDL_PIXELTYPE_INDEX8)))
+  def self.ispixelformat_indexed(format)
+    (!ispixelformat_fourcc(format) &&
+    ((pixeltype(format) == PIXELTYPE.INDEX1) ||
+    (pixeltype(format) == PIXELTYPE.INDEX4) ||
+    (pixeltype(format) == PIXELTYPE.INDEX8)))
+  end
+
+  #MACRO: SDL_ISPIXELFORMAT_ALPHA(format)   \
+  #(!SDL_ISPIXELFORMAT_FOURCC(format) && \
+  #((SDL_PIXELORDER(format) == SDL_PACKEDORDER_ARGB) || \
+  #(SDL_PIXELORDER(format) == SDL_PACKEDORDER_RGBA) || \
+  #(SDL_PIXELORDER(format) == SDL_PACKEDORDER_ABGR) || \
+  #(SDL_PIXELORDER(format) == SDL_PACKEDORDER_BGRA)))
+  def self.ispixelformat_alpha(format)
+    (!pixelformat_fourcc(format) &&
+    ((pixelorder(format) == PACKEDORDER.ARGB) ||
+    (pixelorder(format) == PACKEDORDER.RGBA) ||
+    (pixelorder(format) == PACKEDORDER.ABGR) ||
+    (pixelorder(format) == PACKEDORDER.BGRA)))
+  end
+
+  #MACRO: SDL_ISPIXELFORMAT_FOURCC(format)    \
+  #((format) && (SDL_PIXELFLAG(format) != 1))
+  def self.ispixelformat_fourcc(format)
+    ((format) && (pixelflag(format) != 1))
+  end
+
+  PIXELFORMAT = Enum.new(:PIXELFORMAT, {
+    UNKNOWN: 0,
+    INDEX1LSB:
+    define_pixelformat(PIXELTYPE.INDEX1, BITMAPORDER._4321, 0,
+    1, 0),
+    INDEX1MSB:
+    define_pixelformat(PIXELTYPE.INDEX1, BITMAPORDER._1234, 0,
+    1, 0),
+    INDEX4LSB:
+    define_pixelformat(PIXELTYPE.INDEX4, BITMAPORDER._4321, 0,
+    4, 0),
+    INDEX4MSB:
+    define_pixelformat(PIXELTYPE.INDEX4, BITMAPORDER._1234, 0,
+    4, 0),
+    INDEX8:
+    define_pixelformat(PIXELTYPE.INDEX8, 0, 0, 8, 1),
+    RGB332:
+    define_pixelformat(PIXELTYPE.PACKED8, PACKEDORDER.XRGB,
+    PACKEDLAYOUT._332, 8, 1),
+    RGB444:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XRGB,
+    PACKEDLAYOUT._4444, 12, 2),
+    RGB555:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XRGB,
+    PACKEDLAYOUT._1555, 15, 2),
+    BGR555:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XBGR,
+    PACKEDLAYOUT._1555, 15, 2),
+    ARGB4444:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ARGB,
+    PACKEDLAYOUT._4444, 16, 2),
+    RGBA4444:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.RGBA,
+    PACKEDLAYOUT._4444, 16, 2),
+    ABGR4444:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ABGR,
+    PACKEDLAYOUT._4444, 16, 2),
+    BGRA4444:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.BGRA,
+    PACKEDLAYOUT._4444, 16, 2),
+    ARGB1555:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ARGB,
+    PACKEDLAYOUT._1555, 16, 2),
+    RGBA5551:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.RGBA,
+    PACKEDLAYOUT._5551, 16, 2),
+    ABGR1555:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.ABGR,
+    PACKEDLAYOUT._1555, 16, 2),
+    BGRA5551:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.BGRA,
+    PACKEDLAYOUT._5551, 16, 2),
+    RGB565:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XRGB,
+    PACKEDLAYOUT._565, 16, 2),
+    BGR565:
+    define_pixelformat(PIXELTYPE.PACKED16, PACKEDORDER.XBGR,
+    PACKEDLAYOUT._565, 16, 2),
+    RGB24:
+    define_pixelformat(PIXELTYPE.ARRAYU8, ARRAYORDER.RGB, 0,
+    24, 3),
+    BGR24:
+    define_pixelformat(PIXELTYPE.ARRAYU8, ARRAYORDER.BGR, 0,
+    24, 3),
+    RGB888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.XRGB,
+    PACKEDLAYOUT._8888, 24, 4),
+    RGBX8888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.RGBX,
+    PACKEDLAYOUT._8888, 24, 4),
+    BGR888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.XBGR,
+    PACKEDLAYOUT._8888, 24, 4),
+    BGRX8888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.BGRX,
+    PACKEDLAYOUT._8888, 24, 4),
+    ARGB8888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.ARGB,
+    PACKEDLAYOUT._8888, 32, 4),
+    RGBA8888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.RGBA,
+    PACKEDLAYOUT._8888, 32, 4),
+    ABGR8888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.ABGR,
+    PACKEDLAYOUT._8888, 32, 4),
+    BGRA8888:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.BGRA,
+    PACKEDLAYOUT._8888, 32, 4),
+    ARGB2101010:
+    define_pixelformat(PIXELTYPE.PACKED32, PACKEDORDER.ARGB,
+    PACKEDLAYOUT._2101010, 32, 4),
+
+    YV12:
+    define_pixelfourcc('Y', 'V', '1', '2'),
+    IYUV:
+    define_pixelfourcc('I', 'Y', 'U', 'V'),
+    YUY2:
+    define_pixelfourcc('Y', 'U', 'Y', '2'),
+    UYVY:
+    define_pixelfourcc('U', 'Y', 'V', 'Y'),
+    YVYU:
+    define_pixelfourcc('Y', 'V', 'Y', 'U')
+  })
+
   api :SDL_GetPixelFormatName, [:pixel_format], :string
   api :SDL_PixelFormatEnumToMasks, [:pixel_format, IntStruct.by_ref, UInt32Struct.by_ref, UInt32Struct.by_ref,UInt32Struct.by_ref,UInt32Struct.by_ref,], :bool
   api :SDL_MasksToPixelFormatEnum, [:int, :uint32, :uint32, :uint32, :uint32], :pixel_format
-  api :SDL_AllocFormat, [:pixel_format], PixelFormat.auto_ptr
+  api :SDL_AllocFormat, [:pixel_format], PixelFormat.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
   api :SDL_FreeFormat, [PixelFormat.by_ref], :void
-  api :SDL_AllocPalette, [:count], Palette.auto_ptr
+  api :SDL_AllocPalette, [:count], Palette.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
   api :SDL_SetPixelFormatPalette, [PixelFormat.by_ref, Palette.by_ref], :int
-  api :SDL_SetPaletteColors, [Palette.by_ref, Color.by_ref, :int, :count], :int
+  api :SDL_SetPaletteColors, [Palette.by_ref, :pointer, :int, :count], :int
   api :SDL_FreePalette, [Palette.by_ref], :void
   api :SDL_MapRGB, [PixelFormat.by_ref, :uint8, :uint8, :uint8], :uint32
   api :SDL_MapRGBA, [PixelFormat.by_ref, :uint8, :uint8, :uint8, :uint8], :uint32
   api :SDL_GetRGB, [:uint32, PixelFormat.by_ref, UInt8Struct.by_ref,UInt8Struct.by_ref,UInt8Struct.by_ref], :void
   api :SDL_GetRGBA, [:uint32, PixelFormat.by_ref, UInt8Struct.by_ref,UInt8Struct.by_ref,UInt8Struct.by_ref,UInt8Struct.by_ref], :void
-  
-  
+
 end