sdl2_ffi 0.0.6 → 0.0.7

data/lib/sdl2/renderer.rb

@@ -1,41 +1,358 @@
 require 'sdl2'
 require 'sdl2/renderer_info'
+
 module SDL2
-  
+  ##
+  # Constants used to describe Renderer features (flags)
   module RENDERER
     include EnumerableConstants
-    
-    SOFTWARE       = 0x00000001         
-    ACCELERATED    = 0x00000002      
-    PRESENTVSYNC   = 0x00000004     
+
+    SOFTWARE       = 0x00000001
+    ACCELERATED    = 0x00000002
+    PRESENTVSYNC   = 0x00000004
     TARGETTEXTURE  = 0x00000008
   end
-  
+
+  ##
+  # Render: Interface for 2D accelerated rendering.
+  # Supports the following:
+  #   - pixel points
+  #   - pixel lines
+  #   - filled rectangles
+  #   - texture images
+  #
+  # Also supports:
+  #   - additive modes
+  #   - blending/opaqueness
+  #
+  # Note: Does not support threading, single thread only.
+  #
+  # https://wiki.libsdl.org/CategoryRender
   class Renderer < Struct
     include RENDERER
+    ##
+    # Enumerates the available Renderer Drivers
+    class Drivers
+      def self.count
+        SDL2.get_num_render_drivers!
+      end
+
+      def self.[](idx)
+        info = SDL2::RendererInfo.create()
+        SDL2.get_render_driver_info!(idx, info)
+        info
+      end
+    end
+
+    layout :blank, :uint8 # Ignore Structure?
+#    layout :magic, :pointer,
+#    :window_event, :pointer,
+#    :get_output_size, :pointer,
+#    :create_texture, :pointer,
+#    :set_texture_color_mod, :pointer,
+#    :set_texture_alpha_mod, :pointer,
+#    :set_texture_blend_mode, :pointer,
+#    :update_texture, :pointer,
+#    #:update_texture_yuv, :pointer,
+#    :lock_texture, :pointer,
+#    :unlock_texture, :pointer,
+#    :set_render_target, :pointer,
+#    :update_viewport, :pointer,
+#    :update_clip_rect, :pointer,
+#    :render_clear, :pointer,
+#    :render_draw_points, :pointer,
+#    :render_draw_lines, :pointer,
+#    :render_fill_rects, :pointer,
+#    :render_copy, :pointer,
+#    :render_copy_ex, :pointer,
+#    :render_read_pixels, :pointer,
+#    :render_present, :pointer,
+#    :destroy_texture, :pointer,
+#    :destroy_renderer, :pointer,
+#    :gl_bind_texture, :pointer,
+#    :gl_unbind_texture, :pointer,
+#    :info, SDL2::RendererInfo.ptr,
+#    :window, SDL2::Window.ptr,
+#    :hidden, :bool,
+#    :logical_w, :int,
+#    :logical_h, :int,
+#    :logical_w_backup, :int,
+#    :logical_h_backup, :int,
+#    :viewport, SDL2::Rect.ptr,
+#    :viewport_backup, SDL2::Rect.ptr,
+#    :clip_rect, SDL2::Rect.ptr,
+#    :clip_rect_backup, SDL2::Rect.ptr,
+#    :scale, [:float, 2],
+#    :scale_backup, [:float, 2],
+#    :texture, :pointer,
+#    :target, :pointer,
+#    :r, :uint8,
+#    :g, :uint8,
+#    :b, :uint8,
+#    :a, :uint8,
+#    :blend_mode, :int,
+#    :driverdata, :pointer
+
+    ##
+    # Constructs a Renderer for a window.
+    # @param flags: Combination of RENDERER flags requested
+    def self.create(window, flags = 0, driver_idx = -1)
+      SDL2.create_renderer!(window, driver_idx, flags)
+    end
+
+    ##
+    # Returns the rendering context for a window
+    def self.get(window)
+      SDL2.get_renderer!(window)
+    end
+
+    ##
+    # Create a 2D software rendering context to be able
+    # to write directly to a surface (not a window).
+    def self.create_software(surface)
+      SDL2.create_software_renderer(surface)
+    end
+
+    ##
+    # Release a render
+    def self.release(pointer)
+      SDL2.destroy_renderer(pointer)
+    end
+
+    ##
+    #
+    def destroy
+      SDL2.destroy_renderer(self)
+    end
+    ##
+    # Present the renderer (AKA: Draw/Flip/Update/Flush)
+    def present
+      SDL2.render_present(self)
+    end
+
+    ##
+    # Return the Draw Blend Mode
+    def draw_blend_mode
+      blend_mode = SDL2::TypedPointer::BlendMode.new
+      SDL2.get_render_draw_blend_mode!(self, blend_mode)
+      blend_mode.value
+    end
+
+    ##
+    # Change the Draw Blend Mode
+    def draw_blend_mode=(blend_mode)
+      SDL2.set_render_draw_blend_mode!(self, blend_mode)
+    end
+
+    ##
+    # Get the Draw Color
+    # Returns an SDL2::Color
+    def draw_color
+      colors = 4.times.map{SDL2::TypedPointer::UInt8.new}
+      SDL2.get_render_draw_color!(self, *colors)
+      colors = colors.map(&:value)
+      SDL2::Color.cast(colors)
+    end
+
+    ##
+    # Set the Draw Color
+    def draw_color=(color)
+      color = SDL2::Color.cast(color)
+      SDL2.set_render_draw_color!(self, *color.to_a)
+    end
+
+    ##
+    # Get the target
+    # Returns nil if default when 'default' render target set
+    def target
+      target = SDL2.get_render_target(self)
+      target.null? ? nil : target
+    end
+
+    ##
+    # Set the target
+    #
+    def target=(texture)
+      SDL2.set_render_target!(self, texture)
+    end
+
+    ##
+    # Retrive the Render Driver Info for this Renderer
+    def info
+      render_info = SDL2::RendererInfo.new
+      SDL2.get_renderer_info!(self, render_info)
+      render_info
+    end
+
+    ##
+    # Get the output size
+    # @returns the [width, height]
+    def output_size
+      wh = 2.times.map{SDL2::TypedPointer::Int.new}
+      SDL2.get_renderer_output_size!(self, *wh)
+      wh.map(&:value)
+    end
+
+    ##
+    # This writes draw_color to entire rendering volume
+    def clear
+      SDL2.render_clear(self)
+    end
+
+    ##
+    # Create a texture from a surface
+    def texture_from_surface(surface)
+      SDL2.create_texture_from_surface!(self, surface)
+    end
+
+    ##
+    # Render a Texture or a portion of a texture to the rendering target
+    def copy(texture, src_cords = nil, dst_cords = nil)
+      src_rect = SDL2::Rect.cast(src_cords)
+      dst_rect = SDL2::Rect.cast(dst_cords)
+      SDL2.render_copy!(self, texture, src_rect, dst_rect)
+    end
+
+    ##
+    # Render a Texture or a portion of a texture to the rendering target
+    # optionally rotating it by an angle around the given center
+    # and also flipping it top-bottom and/or left-right
+    def copy_ex(texture, src_cords = nil, dst_cords = nil, angle = 0.0, center_cords = nil, flip = :NONE)
+      src_rect = SDL2::Rect.cast(src_cords)
+      dst_rect = SDL2::Rect.cast(dst_cords)
+      center_point = SDL2::Point.cast(center_cords)
+      SDL2.render_copy_ex(self, texture, src_rect, dst_rect, angle, center_point, flip)
+    end
+
+    ##
+    # Draw a single pixel line
+    def draw_line(x1, y1, x2, y2)
+      SDL2.render_draw_line!(self, x1, y1, x2, y2)
+    end
+
+    ##
+    # Draw lines connecting all points specified.
+    # Each individual point should either be an SDL2::Point or
+    # something that can be cast into one.
+    def draw_lines(*cords)
+      points = SDL2::StructArray.clone_from(cords, SDL2::Point)
+      SDL2.render_draw_lines!(self, points.first, points.count)
+    end
+
+    ##
+    # Draw a point
+    def draw_point(x,y)
+      SDL2.render_draw_point!(self, x, y)
+    end
+
+    ##
+    # Draw each specified point.  Each argument must be an X/Y point,
+    # either as an arrray [2,3], hash {x: 2, y: 3} or an SDL2::Point
+    def draw_points(*cords)
+      points = SDL2::StructArray.clone_from(cords, SDL2::Point)
+      SDL2.render_draw_points!(self, points.first, points.count)
+    end
+
+    ##
+    # Draw a rectangle.
+    # Should be able to accept an: SDL2::Rect,
+    # A hash with :x, :y, :w, :h
+    # An array with 2 or 4 integer values.
+    def draw_rect(cords)
+      rect = SDL2::Rect.cast(cords)
+      SDL2.render_draw_rect(self, rect)
+    end
+
+    ##
+    # Draw many rectangles at once..  each parameter should be something that
+    # SDL2::Renderer#draw_rect can take, however this routine sends all points
+    # to SDL directly.
+    def draw_rects(*cords)
+      rects = SDL2::StructArray.clone_from(cords, SDL2::Rect)
+      SDL2.render_draw_rects!(self, rects.first(), rects.count)
+    end
+
+    ##
+    # Fill a rectangle
+    def fill_rect(cord)
+      rect = SDL2::Rect.cast(cord)
+      SDL2.render_fill_rect!(self, rect)
+    end
+
+    ##
+    # Fill many rectangles at once
+    def fill_rects(*cords)
+      rects = SDL2::StructArray.clone_from(cords, SDL2::Rect)
+      SDL2.render_fill_rects!(self, rects.first(), rects.count)
+    end
     
-    layout :blank, :uint8 # Ignore Structure?    
+    ##
+    # Get the clipping rectangle 
+    def clip_rect
+      rect = SDL2::Rect.new
+      SDL2.render_get_clip_rect(self, rect)
+      rect
+    end
     
-    def self.create(window, driver_idx, flags)
-      create_render(window, driver_idx, flags)
+    ##
+    # Set the clipping rectangle 
+    def clip_rect=(cords)
+      rect = SDL2::Rect.cast(cords)
+      SDL2.render_set_clip_rect!(self, rect)
+      rect
     end
     
-    def self.get(window)
-      get_renderer(window)
+    ##
+    # Get the logical size of the renderer, returns [w, h]
+    def logical_size
+      size = 2.times.map{SDL2::TypedPointer::Int.new}
+      SDL2.render_get_logical_size(self, *size)
+      size.map(&:value)
     end
     
-    def self.create_software(surface)
-      create_software_renderer(surface)
-    end         
+    ##
+    # Set the logical size of the renderer, expects [w, h]
+    def logical_size=(wh)
+      SDL2.render_set_logical_size!(self, *wh)
+      wh
+    end
     
-    def self.release(pointer)
-      destroy_renderer(pointer)
+    ##
+    # Get the scale of the renderer, returns [x,y] floats
+    def scale
+      scale = 2.times.map{SDL2::TypedPointer::Float.new}
+      SDL2.render_get_scale(self, *scale)
+      scale.map(&:value)
     end
     
-    def clear
-      render_clear(self)
+    ##
+    # Set the scale of the renderer, expects [x,y] floats
+    def scale=(scale)
+      SDL2.render_set_scale!(self, *scale)
+      scale
+    end
+    
+    ##
+    # Get the viewport rect
+    def viewport
+      viewport = SDL2::Rect.new
+      SDL2.render_get_viewport(self, viewport)
+      viewport
     end
     
-  end    
-   
+    ##
+    # Set the viewport rect
+    def viewport=(cords)
+      viewport = SDL2::Rect.cast(cords)
+      SDL2.render_set_viewport!(self, viewport)
+      viewport
+    end
+    
+    ##
+    # Indicates if Targeted Rendering is supported.
+    def target_supported?
+      SDL2.render_target_supported?(self)
+    end
+    
+  end
 end

data/lib/sdl2/rwops.rb

@@ -1,16 +1,36 @@
 require 'sdl2'
 
+##
+# SDL_rwops.h => sdl2/rwops.rb
+# - RWops Structs
 module SDL2
-  #Forward Declaration for callbacks
+  #NOTE: This is just a forward declaration for the callbacks
   class RWops < Struct 
   end 
+  
+  #NOTE: The aforementioned callbacks
   callback :rwops_size, [RWops.by_ref], :int64
   callback :rwops_seek, [RWops.by_ref, :int64, :int], :int64
   callback :rwops_read, [RWops.by_ref, :pointer, :size_t, :size_t], :size_t
   callback :rwops_write, [RWops.by_ref, :pointer, :size_t, :size_t], :size_t
   callback :rwops_close, [RWops.by_ref], :int
 
+  ##
+  # "This is the read/write operation structure -- very basic"
+  #   size    - " Return the size of the file in this rwops, or -1 if unkown
+  #   seek    - "Seek to \c offset relative to \c whence, one of stdio's whence values:
+  #               RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
+  #               return the final offset in the data stream, or -1 on error.
+  #   read    - "Read up to \c maxnum objects each of size \c size from the data
+  #               stream to the area pointed at by \c ptr.
+  #               Return the number of objects read, or 0 at error or end of file.
+  #   write   - "Write eactly \c num objects each of size \c size from the area
+  #               pointed at by \c ptr to data stream.
+  #               Return the number of objects written, or 0 at error or end of file.
+  #   close   - "Close and free an allocated SDL_RWops structure.
+  #               Return 0 if successful or -1 on write error when flushing data.
   class RWops < Struct
+    private
     class AndroidIO < Struct
       layout :fileNameRef, :pointer,
         :inputSteramRef, :pointer,
@@ -40,9 +60,9 @@ module SDL2
     end
     
     class Mem <Struct
-      layout :base, UInt8Struct.by_ref,
-        :here, UInt8Struct.by_ref,
-        :stop, UInt8Struct.by_ref
+      layout :base, TypedPointer::UInt8.by_ref,
+        :here, TypedPointer::UInt8.by_ref,
+        :stop, TypedPointer::UInt8.by_ref
     end
     
     class Unkown < Struct
@@ -58,6 +78,7 @@ module SDL2
         :unkown, Unkown
     end
     
+    public 
     
     layout :size, :rwops_size,
       :seek, :rwops_seek,
@@ -67,40 +88,70 @@ module SDL2
       :type, :uint32,
       :hidden, Hidden      
       
+    ##
+    # Release this structure using SDL_FreeRW
     def self.release(pointer)
       SDL2.free_rw(pointer)
     end
     
-    # CONSTANTS
+    ##
+    # "Seek from the beginning of data"
     SEEK_SET = 0
+    ##
+    # "Seek relative to current read point"
     SEEK_CUR = 1
+    ##
+    # "Seek relative to the end of data"
     SEEK_END = 2       
     
+    ##
+    # Create RWOps from file name
     def self.from_file(file_name, mode)
       SDL2.rw_from_file!(file_name, mode)
     end
     
     # Read/Write Macros re-implemented: Lines #184~189
+    
+    ##
+    # "Return the size of the file in this rwops, or -1 if unkown"
     def size
       self[:size].call
     end
     
+    ##
+    # "Seek to \c offset in the data stream, or -1 on error."
+    # "\return the number of objects read, or 0 at error or end of file"
     def seek(offset, whence)
       self[:seek].call(self, offset, whence)
     end
     
+    ##
+    # BadQuanta: "I suppose this returns the current position"
+    # SDL_rwops.h:186.
     def tell
       self[:seek].call(self, 0, SEEK_CUR)
     end
     
+    ##
+    # "Read up to \c maxnum objects each of size \c size from the data
+    #  stream to the area pointed at by \c ptr."
+    #  "\return the number of objects read, or 0 at error or end of file." 
     def read(pointer, size, n)
       self[:read].call(self, pointer, size, n)
     end
     
+    ##
+    #  "Write exactly \c num objects each of size \c size from the area
+    #  pointed at by \c ptr to data stream."
+    #
+    #  "\return the number of objects written, or 0 at error or end of file."    
     def write(pointer, size, n)
       self[:write].call(self, pointer, size, n)
     end
     
+    ##
+    # "Close and free an allocated SDL_RWops structure."
+    #  "\return 0 if successful or -1 on write error when flushing data."
     def close
       self[:close].call(self)
     end
@@ -108,64 +159,72 @@ module SDL2
   end
   
   ##
-	#
-	api :SDL_RWFromFile, [:string, :string], RWops.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
+	# Load from a file
+  #   *  file - filename string (existing)
+  #   *  mode - mode string
+	api :SDL_RWFromFile, [:string, :string], RWops.ptr, {error: true, filter: OK_WHEN_NOT_NULL}
   ##
-	#
-	api :SDL_RWFromFP, [:pointer, :bool], RWops.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
+	# Load from a file pointer
+	#   *  fp - a file pointer
+  #   *  autoclose - boolean
+	api :SDL_RWFromFP, [:pointer, :bool], RWops.ptr, {error: true, filter: OK_WHEN_NOT_NULL}
   ##
-	#
-	api :SDL_RWFromMem, [:pointer, :count], RWops.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
+	# Load from any pointer in memory
+	#   *  mem - pointer
+	#   *  size - integer
+	api :SDL_RWFromMem, [:pointer, :count], RWops.ptr, {error: true, filter: OK_WHEN_NOT_NULL}
   ##
-	#
-	api :SDL_RWFromConstMem, [:pointer, :count], RWops.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
+	# Load from "constant" memory
+	#   *  mem - constant pointer
+	#   *  size - integer
+	api :SDL_RWFromConstMem, [:pointer, :count], RWops.ptr, {error: true, filter: OK_WHEN_NOT_NULL}
   ##
-	#
-	api :SDL_AllocRW, [], RWops.auto_ptr, {error: true, filter: TRUE_WHEN_NOT_NULL}
+	# Allocate a RWops structure
+	api :SDL_AllocRW, [], RWops.ptr, {error: true, filter: OK_WHEN_NOT_NULL}
   ##
-	#
+	# Release a RWops structure
 	api :SDL_FreeRW, [RWops.by_ref], :void
   ##
-	#
+	# Read 8 bytes
 	api :SDL_ReadU8, [RWops.by_ref], :uint8
   ##
-	#
+	# Read 16 bytes little endian
 	api :SDL_ReadLE16, [RWops.by_ref], :uint16
   ##
-	#
+	# Read 16 bytes big endian
 	api :SDL_ReadBE16, [RWops.by_ref], :uint16
   ##
-	#
+	# Read 32 bytes little endian
 	api :SDL_ReadLE32, [RWops.by_ref], :uint32
   ##
-	#
+	# Read 32 bytes big endian
 	api :SDL_ReadBE32, [RWops.by_ref], :uint32
   ##
-	#
+	# Read 64 bytes little endian
 	api :SDL_ReadLE64, [RWops.by_ref], :uint64
   ##
-	#
+	# Read 32 bytes big endian
 	api :SDL_ReadBE64, [RWops.by_ref], :uint64
   
   ##
-	#
+	# Write 8 bytes
 	api :SDL_WriteU8, [RWops.by_ref, :uint8], :size_t
   ##
-	#
+	# Write 16 bytes little endian
 	api :SDL_WriteLE16, [RWops.by_ref, :uint16], :size_t
   ##
-	#
+	# Write 16 bytes big endian
 	api :SDL_WriteBE16, [RWops.by_ref, :uint16], :size_t
   ##
-	#
+	# Write 32 bytes little endian
 	api :SDL_WriteLE32, [RWops.by_ref, :uint32], :size_t
   ##
-	#
+	# Write 32 bytes big endian
 	api :SDL_WriteBE32, [RWops.by_ref, :uint32], :size_t
   ##
-	#
+	# Write 64 bytes little endian
 	api :SDL_WriteLE64, [RWops.by_ref, :uint64], :size_t
   ##
-	#
+	# Write 64 bytes big endian
 	api :SDL_WriteBE64, [RWops.by_ref, :uint64], :size_t
 end