ruby-sfml 3.0.0.0

data/lib/sfml/graphics/render_window.rb

@@ -0,0 +1,154 @@
+module SFML
+  # The main drawing surface. Wraps sfRenderWindow.
+  #
+  #   window = SFML::RenderWindow.new(800, 600, "Hello")
+  #
+  #   while window.open?
+  #     window.each_event do |event|
+  #       case event
+  #       in {type: :closed}                     then window.close
+  #       in {type: :key_pressed, code: :escape} then window.close
+  #       end
+  #     end
+  #
+  #     window.clear(SFML::Color.cornflower_blue)
+  #     window.display
+  #   end
+  class RenderWindow
+    include Graphics::RenderTarget
+    CSFML_PREFIX = :sfRenderWindow
+
+    DEFAULT_STYLE = C::Window::Style::DEFAULT
+
+    # The first form takes (width, height, title, **opts).
+    # The second form takes (video_mode, title, **opts) for full control.
+    #
+    # Options:
+    #   style:      bitmask of SFML::C::Window::Style constants
+    #   fullscreen: true to use sfFullscreen state instead of sfWindowed
+    #   framerate:  cap to N FPS via sfRenderWindow_setFramerateLimit
+    #   vsync:      enable vertical sync
+    def initialize(*args, **opts)
+      mode, title = parse_args(args)
+      style = opts.fetch(:style, DEFAULT_STYLE)
+      state = opts[:fullscreen] ? :fullscreen : :windowed
+
+      ptr = C::Graphics.sfRenderWindow_create(
+        mode.to_native,
+        title.to_s,
+        style,
+        C::Window::State[state],
+        nil,
+      )
+      raise Error, "sfRenderWindow_create returned NULL" if ptr.null?
+
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfRenderWindow_destroy))
+      @event_buffer = C::Window::Event.new
+
+      self.framerate_limit = opts[:framerate] if opts[:framerate]
+      self.vsync = opts[:vsync]               unless opts[:vsync].nil?
+    end
+
+    def open?
+      C::Graphics.sfRenderWindow_isOpen(@handle)
+    end
+
+    def close
+      C::Graphics.sfRenderWindow_close(@handle)
+      self
+    end
+
+    # Returns the next pending Event or nil if the queue is empty.
+    def poll_event
+      return nil unless C::Graphics.sfRenderWindow_pollEvent(@handle, @event_buffer)
+      Event.from_native(@event_buffer)
+    end
+
+    # Yields every pending event for this frame, then returns. Without a block
+    # returns an Enumerator.
+    def each_event
+      return enum_for(:each_event) unless block_given?
+      while (event = poll_event)
+        yield event
+      end
+      self
+    end
+
+    def title=(value)
+      C::Graphics.sfRenderWindow_setTitle(@handle, value.to_s)
+    end
+
+    # Apply a SFML::Cursor as the visible mouse pointer over this
+    # window. Keeps a Ruby reference so the Cursor object's lifetime
+    # spans at least until the next assignment.
+    def cursor=(cursor)
+      raise ArgumentError, "RenderWindow#cursor= requires a SFML::Cursor" unless cursor.is_a?(Cursor)
+      C::Graphics.sfRenderWindow_setMouseCursor(@handle, cursor.handle)
+      @cursor = cursor
+    end
+
+    # Toggle the OS mouse pointer's visibility while it's over the window.
+    def cursor_visible=(visible)
+      C::Graphics.sfRenderWindow_setMouseCursorVisible(@handle, visible ? true : false)
+    end
+
+    # Lock the mouse pointer inside the window's client area while
+    # focused — useful for FPS-style games or when dragging widgets
+    # that need pixel-precise input.
+    def cursor_grabbed=(grabbed)
+      C::Graphics.sfRenderWindow_setMouseCursorGrabbed(@handle, grabbed ? true : false)
+    end
+
+    def framerate_limit=(value)
+      C::Graphics.sfRenderWindow_setFramerateLimit(@handle, Integer(value))
+    end
+
+    def vsync=(enabled)
+      C::Graphics.sfRenderWindow_setVerticalSyncEnabled(@handle, enabled ? true : false)
+    end
+
+    def size
+      v = C::Graphics.sfRenderWindow_getSize(@handle)
+      Vector2.new(v[:x], v[:y])
+    end
+
+    # Convenience driver loop. Yields the per-frame delta (SFML::Time) and
+    # auto-pumps events + display. The block is responsible for #clear and
+    # any drawing.
+    #
+    #   window.run do |dt, events|
+    #     events.each { |e| ... }
+    #     window.clear(...)
+    #     window.draw(...)
+    #   end
+    def run
+      clock = Clock.new
+      while open?
+        dt = clock.restart
+        events = each_event.to_a
+        yield dt, events
+        display
+      end
+      self
+    end
+
+    attr_reader :handle # :nodoc:
+
+    private
+
+    def parse_args(args)
+      case args.length
+      when 2
+        # (video_mode, title)
+        [args[0], args[1]]
+      when 3
+        # (width, height, title)
+        [VideoMode.new(args[0], args[1]), args[2]]
+      else
+        raise ArgumentError,
+              "RenderWindow.new takes either (video_mode, title) or " \
+              "(width, height, title), got #{args.length} positional arg(s)"
+      end
+    end
+  end
+end

data/lib/sfml/graphics/shader.rb

@@ -0,0 +1,132 @@
+module SFML
+  # A GLSL shader. Build one from a vertex and/or fragment source (either
+  # a file path or a literal source string), then set uniforms with
+  # bracket assignment and pass it to draw via the `shader:` kwarg:
+  #
+  #   shader = SFML::Shader.from_source(fragment: <<~GLSL)
+  #     uniform sampler2D texture;
+  #     uniform float time;
+  #     void main() {
+  #       vec2 uv = gl_TexCoord[0].xy;
+  #       uv.x += sin(uv.y * 20.0 + time * 3.0) * 0.02;
+  #       gl_FragColor = texture2D(texture, uv) * gl_Color;
+  #     }
+  #   GLSL
+  #
+  #   shader[:time] = clock.elapsed.as_seconds
+  #   window.draw(sprite, shader: shader)
+  #
+  # Uniform types are inferred from the Ruby value:
+  #   Float / Integer / Numeric  → float (uniform float)
+  #   true / false               → bool
+  #   SFML::Vector2              → vec2
+  #   SFML::Vector3              → vec3
+  #   SFML::Color                → vec4 (normalised RGBA)
+  #   SFML::Texture              → sampler2D
+  #   :current_texture (Symbol)  → sampler2D bound to the drawable's own texture
+  #   [a, b]                     → vec2     (floats)
+  #   [a, b, c]                  → vec3
+  #   [a, b, c, d]               → vec4
+  #
+  # Need an int / bvec / matrix / array uniform? Use the explicit setters
+  # (#set_int, #set_ivec2, etc.) — they exist for completeness.
+  class Shader
+    # Class-level: is GLSL available on the current GPU at all?
+    def self.available?
+      C::Graphics.sfShader_isAvailable
+    end
+
+    def self.geometry_available?
+      C::Graphics.sfShader_isGeometryAvailable
+    end
+
+    # Build a shader from one or more source files. Any of vertex /
+    # geometry / fragment may be omitted; at least one must be present.
+    def self.from_file(vertex: nil, geometry: nil, fragment: nil)
+      _check_at_least_one(vertex, geometry, fragment)
+      ptr = C::Graphics.sfShader_createFromFile(
+        vertex&.to_s, geometry&.to_s, fragment&.to_s,
+      )
+      raise Error, "sfShader_createFromFile failed (compile error or missing file?)" if ptr.null?
+      _wrap(ptr)
+    end
+
+    # Build a shader directly from GLSL source strings.
+    def self.from_source(vertex: nil, geometry: nil, fragment: nil)
+      _check_at_least_one(vertex, geometry, fragment)
+      ptr = C::Graphics.sfShader_createFromMemory(vertex, geometry, fragment)
+      raise Error, "sfShader_createFromMemory failed (GLSL compile error?)" if ptr.null?
+      _wrap(ptr)
+    end
+
+    # Set a uniform by name. Dispatches to the right CSFML setter based
+    # on the Ruby value's type — see the class-level docs for the table.
+    def []=(name, value)
+      n = name.to_s
+      case value
+      when true, false
+        C::Graphics.sfShader_setBoolUniform(@handle, n, value)
+      when Integer
+        C::Graphics.sfShader_setFloatUniform(@handle, n, value.to_f)
+      when Numeric
+        C::Graphics.sfShader_setFloatUniform(@handle, n, value.to_f)
+      when Vector2
+        v = C::System::Vector2f.new
+        v[:x] = value.x.to_f; v[:y] = value.y.to_f
+        C::Graphics.sfShader_setVec2Uniform(@handle, n, v)
+      when Vector3
+        v = C::System::Vector3f.new
+        v[:x] = value.x.to_f; v[:y] = value.y.to_f; v[:z] = value.z.to_f
+        C::Graphics.sfShader_setVec3Uniform(@handle, n, v)
+      when Color
+        C::Graphics.sfShader_setColorUniform(@handle, n, value.to_native)
+      when Texture
+        C::Graphics.sfShader_setTextureUniform(@handle, n, value.handle)
+      when :current_texture
+        C::Graphics.sfShader_setCurrentTextureUniform(@handle, n)
+      when Array
+        case value.length
+        when 2 then self[name] = Vector2.new(*value)
+        when 3 then self[name] = Vector3.new(*value)
+        when 4
+          v = C::Graphics::GlslVec4.new
+          v[:x] = value[0].to_f; v[:y] = value[1].to_f
+          v[:z] = value[2].to_f; v[:w] = value[3].to_f
+          C::Graphics.sfShader_setVec4Uniform(@handle, n, v)
+        else
+          raise ArgumentError, "Shader uniform array must be length 2, 3, or 4 (got #{value.length})"
+        end
+      else
+        raise ArgumentError,
+              "Shader uniform value must be Numeric, Vector2/3, Color, Texture, " \
+              "Array of 2-4 numbers, or :current_texture (got #{value.class})"
+      end
+    end
+
+    # Explicit integer setters when a uniform really is `uniform int n`.
+    def set_int(name, value)
+      C::Graphics.sfShader_setIntUniform(@handle, name.to_s, Integer(value))
+    end
+
+    def set_ivec2(name, x, y)
+      v = C::System::Vector2i.new
+      v[:x] = Integer(x); v[:y] = Integer(y)
+      C::Graphics.sfShader_setIvec2Uniform(@handle, name.to_s, v)
+    end
+
+    attr_reader :handle # :nodoc:
+
+    # @!visibility private
+    def self._wrap(ptr)
+      shader = allocate
+      shader.instance_variable_set(:@handle, FFI::AutoPointer.new(ptr, C::Graphics.method(:sfShader_destroy)))
+      shader
+    end
+
+    # @!visibility private
+    def self._check_at_least_one(*sources)
+      return unless sources.compact.empty?
+      raise ArgumentError, "Shader needs at least one of vertex:, geometry:, fragment:"
+    end
+  end
+end

data/lib/sfml/graphics/sprite.rb

@@ -0,0 +1,75 @@
+module SFML
+  # A textured rectangle. SFML 3 requires a Texture at construction time
+  # (no default-constructible Sprite anymore), so we keep the texture
+  # reference alive inside the Ruby Sprite to prevent the GC from freeing
+  # the GPU resource while it's still being drawn.
+  #
+  #   tex    = SFML::Texture.load("hero.png")
+  #   sprite = SFML::Sprite.new(tex, position: [100, 100])
+  #   window.draw(sprite)
+  class Sprite
+    include Graphics::Transformable
+    CSFML_PREFIX = :sfSprite
+
+    def initialize(texture, **opts)
+      raise ArgumentError, "Sprite requires a SFML::Texture" unless texture.is_a?(Texture)
+
+      ptr = C::Graphics.sfSprite_create(texture.handle)
+      raise Error, "sfSprite_create returned NULL" if ptr.null?
+      @handle  = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfSprite_destroy))
+      @texture = texture # keep alive for GC
+
+      self.color    = opts[:color]    if opts.key?(:color)
+      self.position = opts[:position] if opts.key?(:position)
+      self.origin   = opts[:origin]   if opts.key?(:origin)
+      self.rotation = opts[:rotation] if opts.key?(:rotation)
+      self.scale    = opts[:scale]    if opts.key?(:scale)
+    end
+
+    attr_reader :texture
+
+    def texture=(new_texture)
+      raise ArgumentError, "Sprite#texture= requires a SFML::Texture" unless new_texture.is_a?(Texture)
+      C::Graphics.sfSprite_setTexture(@handle, new_texture.handle, false)
+      @texture = new_texture
+    end
+
+    def color = Color.from_native(C::Graphics.sfSprite_getColor(@handle))
+
+    def color=(c)
+      C::Graphics.sfSprite_setColor(@handle, c.to_native)
+    end
+
+    # Sub-region of the texture this sprite shows. Returns a SFML::Rect
+    # of integer pixel coordinates. Use it for sprite-sheet animation:
+    #
+    #   sprite.texture_rect = SFML::Rect.new([frame * 32, 0], [32, 32])
+    def texture_rect
+      Rect.from_native(C::Graphics.sfSprite_getTextureRect(@handle))
+    end
+
+    def texture_rect=(rect)
+      raise ArgumentError, "Sprite#texture_rect= requires a SFML::Rect" unless rect.is_a?(Rect)
+      native = C::Graphics::IntRect.new
+      native[:position][:x] = Integer(rect.x)
+      native[:position][:y] = Integer(rect.y)
+      native[:size][:x]     = Integer(rect.width)
+      native[:size][:y]     = Integer(rect.height)
+      C::Graphics.sfSprite_setTextureRect(@handle, native)
+    end
+
+    def local_bounds
+      Rect.from_native(C::Graphics.sfSprite_getLocalBounds(@handle))
+    end
+
+    def global_bounds
+      Rect.from_native(C::Graphics.sfSprite_getGlobalBounds(@handle))
+    end
+
+    def draw_on(target, states_ptr = nil) # :nodoc:
+      target._draw_native(:Sprite, @handle, states_ptr)
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/graphics/text.rb

@@ -0,0 +1,144 @@
+module SFML
+  # Drawable rendered text. Like Sprite, requires a Font at construction time
+  # in SFML 3, and we hold a Ruby reference to it to keep the GPU resource
+  # alive while the Text object is in use.
+  #
+  #   font = SFML::Font.find("DejaVuSans")
+  #   score = SFML::Text.new(font, "0 : 0",
+  #     character_size: 48,
+  #     fill_color: SFML::Color.white,
+  #     position: [400, 30],
+  #     style: %i[bold])
+  #   window.draw(score)
+  #   score.string = "1 : 0"  # mutate freely after construction
+  class Text
+    include Graphics::Transformable
+    CSFML_PREFIX = :sfText
+
+    STYLES = {
+      regular:        0,
+      bold:           1 << 0,
+      italic:         1 << 1,
+      underlined:     1 << 2,
+      strike_through: 1 << 3,
+    }.freeze
+
+    def initialize(font, string = "", **opts)
+      raise ArgumentError, "Text requires a SFML::Font" unless font.is_a?(Font)
+
+      ptr = C::Graphics.sfText_create(font.handle)
+      raise Error, "sfText_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfText_destroy))
+      @font   = font # keep alive for GC
+
+      self.string             = string
+      self.character_size     = opts[:character_size]    if opts.key?(:character_size)
+      self.fill_color         = opts[:fill_color]        if opts.key?(:fill_color)
+      self.outline_color      = opts[:outline_color]     if opts.key?(:outline_color)
+      self.outline_thickness  = opts[:outline_thickness] if opts.key?(:outline_thickness)
+      self.style              = opts[:style]             if opts.key?(:style)
+      self.position           = opts[:position]          if opts.key?(:position)
+      self.origin             = opts[:origin]            if opts.key?(:origin)
+      self.rotation           = opts[:rotation]          if opts.key?(:rotation)
+      self.scale              = opts[:scale]             if opts.key?(:scale)
+    end
+
+    attr_reader :font
+
+    def font=(new_font)
+      raise ArgumentError, "Text#font= requires a SFML::Font" unless new_font.is_a?(Font)
+      C::Graphics.sfText_setFont(@handle, new_font.handle)
+      @font = new_font
+    end
+
+    # Read the current string back as Ruby UTF-8. CSFML returns a pointer
+    # to a null-terminated sfChar32 (UTF-32) array; we walk it until the
+    # zero terminator and pack the codepoints back into a UTF-8 String.
+    def string
+      ptr = C::Graphics.sfText_getUnicodeString(@handle)
+      return "" if ptr.null?
+
+      codepoints = []
+      offset = 0
+      loop do
+        cp = ptr.get_uint32(offset)
+        break if cp.zero?
+        codepoints << cp
+        offset += 4
+      end
+      codepoints.pack("U*")
+    end
+
+    def string=(value)
+      str = value.to_s.encode("UTF-8")
+      cps = str.unpack("U*")  # array of integer codepoints
+      buf = FFI::MemoryPointer.new(:uint32, cps.length + 1)
+      buf.write_array_of_uint32(cps + [0])
+      C::Graphics.sfText_setUnicodeString(@handle, buf)
+    end
+
+    def character_size = C::Graphics.sfText_getCharacterSize(@handle)
+
+    def character_size=(value)
+      C::Graphics.sfText_setCharacterSize(@handle, Integer(value))
+    end
+
+    def fill_color = Color.from_native(C::Graphics.sfText_getFillColor(@handle))
+
+    def fill_color=(c)
+      C::Graphics.sfText_setFillColor(@handle, c.to_native)
+    end
+
+    def outline_color = Color.from_native(C::Graphics.sfText_getOutlineColor(@handle))
+
+    def outline_color=(c)
+      C::Graphics.sfText_setOutlineColor(@handle, c.to_native)
+    end
+
+    def outline_thickness = C::Graphics.sfText_getOutlineThickness(@handle)
+
+    def outline_thickness=(t)
+      C::Graphics.sfText_setOutlineThickness(@handle, t.to_f)
+    end
+
+    # Returns an Array of style symbols, e.g. [:bold, :italic].
+    def style
+      bits = C::Graphics.sfText_getStyle(@handle)
+      return [:regular] if bits.zero?
+      STYLES.each_with_object([]) do |(name, value), acc|
+        acc << name if value != 0 && (bits & value) != 0
+      end
+    end
+
+    # Accepts a single Symbol, an Array of Symbols, or a raw integer bitmask.
+    def style=(value)
+      bits = case value
+             when Integer then value
+             when Symbol  then STYLES.fetch(value)
+             when Array
+               value.reduce(0) { |acc, sym| acc | STYLES.fetch(sym) }
+             else
+               raise ArgumentError, "Text#style= expects Symbol, Array, or Integer; got #{value.class}"
+             end
+      C::Graphics.sfText_setStyle(@handle, bits)
+    end
+
+    # Bounding box of the text in its own (untransformed) coordinate system.
+    # Use this to centre or align glyphs precisely:
+    #   text.origin = [text.local_bounds.width / 2, 0]
+    def local_bounds
+      Rect.from_native(C::Graphics.sfText_getLocalBounds(@handle))
+    end
+
+    # Bounding box after applying the Text's transform (position/scale/rotation).
+    def global_bounds
+      Rect.from_native(C::Graphics.sfText_getGlobalBounds(@handle))
+    end
+
+    def draw_on(target, states_ptr = nil) # :nodoc:
+      target._draw_native(:Text, @handle, states_ptr)
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/graphics/texture.rb

@@ -0,0 +1,79 @@
+module SFML
+  # A 2D image stored on the GPU. Used by Sprite (and shapes) to draw textured
+  # geometry. Build one with .load:
+  #
+  #   tex = SFML::Texture.load("assets/hero.png")
+  #   tex = SFML::Texture.load("assets/tile.png", smooth: true, repeated: true)
+  class Texture
+    def self.load(path, smooth: false, repeated: false)
+      ptr = C::Graphics.sfTexture_createFromFile(path.to_s, nil)
+      raise Error, "Could not load texture from #{path.inspect}" if ptr.null?
+
+      tex = allocate
+      tex.send(:_take_ownership, ptr)
+      tex.smooth   = smooth
+      tex.repeated = repeated
+      tex
+    end
+
+    # Upload a CPU-side SFML::Image to the GPU as a new Texture. Keeps
+    # the RGBA byte order and dimensions of the source image.
+    def self.from_image(image, smooth: false, repeated: false)
+      raise ArgumentError, "Texture.from_image needs a SFML::Image" unless image.is_a?(Image)
+
+      ptr = C::Graphics.sfTexture_createFromImage(image.handle, nil)
+      raise Error, "sfTexture_createFromImage returned NULL" if ptr.null?
+
+      tex = allocate
+      tex.send(:_take_ownership, ptr)
+      tex.smooth   = smooth
+      tex.repeated = repeated
+      tex
+    end
+
+    # Re-upload an Image's pixels to this texture in place. The image
+    # must match the texture's size — use this for animated procedural
+    # textures (paint-buffer style) without re-allocating GPU memory.
+    def update(image)
+      raise ArgumentError, "Texture#update needs a SFML::Image" unless image.is_a?(Image)
+      offset = C::System::Vector2u.new
+      offset[:x] = 0; offset[:y] = 0
+      C::Graphics.sfTexture_updateFromImage(@handle, image.handle, offset)
+      self
+    end
+
+    # Read the texture back from the GPU into a fresh SFML::Image. Slow
+    # — useful for screenshots or post-processing inspection.
+    def to_image
+      ptr = C::Graphics.sfTexture_copyToImage(@handle)
+      raise Error, "sfTexture_copyToImage returned NULL" if ptr.null?
+      img = Image.allocate
+      img.send(:_take_ownership, ptr)
+      img
+    end
+
+    def size
+      Vector2.from_native(C::Graphics.sfTexture_getSize(@handle))
+    end
+
+    def smooth?  = C::Graphics.sfTexture_isSmooth(@handle)
+
+    def smooth=(value)
+      C::Graphics.sfTexture_setSmooth(@handle, !!value)
+    end
+
+    def repeated? = C::Graphics.sfTexture_isRepeated(@handle)
+
+    def repeated=(value)
+      C::Graphics.sfTexture_setRepeated(@handle, !!value)
+    end
+
+    attr_reader :handle # :nodoc:
+
+    private
+
+    def _take_ownership(ptr)
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfTexture_destroy))
+    end
+  end
+end