ruby-sfml 3.0.0.0

data/lib/sfml/graphics/convex_shape.rb

@@ -0,0 +1,82 @@
+module SFML
+  # An arbitrary convex polygon. Define its outline by listing points in
+  # order (clockwise or counter-clockwise — just stay consistent). The
+  # shape must remain convex — drawing a non-convex point set produces
+  # visual artifacts (CSFML doesn't validate).
+  #
+  #   star = SFML::ConvexShape.new(
+  #     points: [[60, 0], [80, 40], [120, 50], [90, 80],
+  #              [100, 120], [60, 95], [20, 120], [30, 80],
+  #              [0, 50], [40, 40]],
+  #     fill_color: SFML::Color.yellow,
+  #   )
+  #   window.draw(star)
+  class ConvexShape
+    include Graphics::Transformable
+    CSFML_PREFIX = :sfConvexShape
+
+    def initialize(points: nil, **opts)
+      ptr = C::Graphics.sfConvexShape_create
+      raise Error, "sfConvexShape_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfConvexShape_destroy))
+
+      self.points = points if points
+      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.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
+
+    def point_count = C::Graphics.sfConvexShape_getPointCount(@handle)
+
+    # Returns the polygon vertices as an Array of Vector2.
+    def points
+      n = point_count
+      (0...n).map do |i|
+        Vector2.from_native(C::Graphics.sfConvexShape_getPoint(@handle, i))
+      end
+    end
+
+    # Replace every point. Accepts a list of [x, y] arrays or Vector2s.
+    def points=(list)
+      C::Graphics.sfConvexShape_setPointCount(@handle, list.length)
+      list.each_with_index do |pt, i|
+        vec = pt.is_a?(Vector2) ? pt : Vector2.new(*pt)
+        C::Graphics.sfConvexShape_setPoint(@handle, i, vec.to_native_f)
+      end
+    end
+
+    # Mutate a single vertex by index.
+    def set_point(index, point)
+      vec = point.is_a?(Vector2) ? point : Vector2.new(*point)
+      C::Graphics.sfConvexShape_setPoint(@handle, Integer(index), vec.to_native_f)
+    end
+
+    def fill_color = Color.from_native(C::Graphics.sfConvexShape_getFillColor(@handle))
+
+    def fill_color=(c)
+      C::Graphics.sfConvexShape_setFillColor(@handle, c.to_native)
+    end
+
+    def outline_color = Color.from_native(C::Graphics.sfConvexShape_getOutlineColor(@handle))
+
+    def outline_color=(c)
+      C::Graphics.sfConvexShape_setOutlineColor(@handle, c.to_native)
+    end
+
+    def outline_thickness = C::Graphics.sfConvexShape_getOutlineThickness(@handle)
+
+    def outline_thickness=(t)
+      C::Graphics.sfConvexShape_setOutlineThickness(@handle, t.to_f)
+    end
+
+    def draw_on(target, states_ptr = nil) # :nodoc:
+      target._draw_native(:ConvexShape, @handle, states_ptr)
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/graphics/font.rb

@@ -0,0 +1,67 @@
+module SFML
+  # A typeface loaded from a TTF/OTF file.
+  #
+  #   font = SFML::Font.default                                                # bundled DejaVu Sans
+  #   font = SFML::Font.load("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf")
+  #   font = SFML::Font.find("DejaVuSans")                                     # search common locations
+  class Font
+    SEARCH_PATHS = [
+      "/usr/share/fonts",
+      "/usr/local/share/fonts",
+      "/Library/Fonts",
+      "/System/Library/Fonts",
+      File.expand_path("~/Library/Fonts"),
+      "C:/Windows/Fonts",
+    ].freeze
+
+    # Path to the font ruby-sfml ships with: DejaVu Sans (Bitstream Vera
+    # license, redistributable). See lib/sfml/assets/fonts/DejaVuSans.LICENSE.txt.
+    DEFAULT_PATH = File.expand_path("../assets/fonts/DejaVuSans.ttf", __dir__).freeze
+
+    def self.load(path)
+      ptr = C::Graphics.sfFont_createFromFile(path.to_s)
+      raise Error, "Could not load font from #{path.inspect}" if ptr.null?
+
+      font = allocate
+      font.send(:_take_ownership, ptr)
+      font
+    end
+
+    # The default font bundled with ruby-sfml. Use this when you don't
+    # care which typeface as long as you can render text — examples,
+    # debug HUDs, prototypes. Memoized so subsequent calls return the
+    # same Font instance.
+    def self.default
+      @default ||= load(DEFAULT_PATH)
+    end
+
+    # Look up a font on disk by basename (with or without extension). Useful
+    # for examples that should "just run" — production code should ship its
+    # own font files. Returns nil if nothing is found.
+    def self.find(name)
+      target = name.to_s.downcase.sub(/\.(ttf|otf)\z/, "")
+      SEARCH_PATHS.each do |dir|
+        next unless File.directory?(dir)
+        match = Dir.glob(File.join(dir, "**", "*.{ttf,otf}")).find do |path|
+          File.basename(path).downcase.sub(/\.(ttf|otf)\z/, "") == target
+        end
+        return load(match) if match
+      end
+      nil
+    end
+
+    def smooth?       = C::Graphics.sfFont_isSmooth(@handle)
+
+    def smooth=(value)
+      C::Graphics.sfFont_setSmooth(@handle, !!value)
+    end
+
+    attr_reader :handle # :nodoc:
+
+    private
+
+    def _take_ownership(ptr)
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfFont_destroy))
+    end
+  end
+end

data/lib/sfml/graphics/image.rb

@@ -0,0 +1,125 @@
+module SFML
+  # CPU-side bitmap. Lives in main memory and supports per-pixel reads /
+  # writes — handy for procedural generation, screenshots, masks, and
+  # anything that needs to inspect or modify pixel data before upload.
+  #
+  #   img = SFML::Image.new(800, 600, fill: SFML::Color.cornflower_blue)
+  #   img = SFML::Image.load("assets/hero.png")
+  #
+  #   img[10, 20] = SFML::Color.red
+  #   img[10, 20]                       #=> Color(255, 0, 0, 255)
+  #
+  #   img.flip_vertically
+  #   img.save("out.png")
+  #
+  # Convert to a GPU-side texture for drawing:
+  #
+  #   tex = SFML::Texture.from_image(img)
+  #   sprite = SFML::Sprite.new(tex)
+  class Image
+    # Create a blank image of the given size. With `fill:` it's filled
+    # with that colour; without, with transparent black.
+    def initialize(width, height, fill: nil)
+      size = C::System::Vector2u.new
+      size[:x] = Integer(width)
+      size[:y] = Integer(height)
+
+      ptr = if fill
+              C::Graphics.sfImage_createFromColor(size, fill.to_native)
+            else
+              C::Graphics.sfImage_create(size)
+            end
+      raise Error, "sfImage_create returned NULL" if ptr.null?
+      _take_ownership(ptr)
+    end
+
+    def self.load(path)
+      ptr = C::Graphics.sfImage_createFromFile(path.to_s)
+      raise Error, "Could not load image from #{path.inspect}" if ptr.null?
+      img = allocate
+      img.send(:_take_ownership, ptr)
+      img
+    end
+
+    # Build an image from a raw RGBA byte string. `pixels` must be
+    # exactly width*height*4 bytes, row-major from the top-left.
+    def self.from_pixels(width, height, pixels)
+      expected = Integer(width) * Integer(height) * 4
+      raise ArgumentError, "expected #{expected} bytes, got #{pixels.bytesize}" if pixels.bytesize != expected
+
+      buf = FFI::MemoryPointer.new(:uint8, expected)
+      buf.write_bytes(pixels)
+
+      size = C::System::Vector2u.new
+      size[:x] = Integer(width)
+      size[:y] = Integer(height)
+      ptr = C::Graphics.sfImage_createFromPixels(size, buf)
+      raise Error, "sfImage_createFromPixels returned NULL" if ptr.null?
+
+      img = allocate
+      img.send(:_take_ownership, ptr)
+      img
+    end
+
+    def size
+      Vector2.from_native(C::Graphics.sfImage_getSize(@handle))
+    end
+
+    def width  = size.x
+    def height = size.y
+
+    # Read the colour of a single pixel.
+    def [](x, y)
+      coord = C::System::Vector2u.new
+      coord[:x] = Integer(x); coord[:y] = Integer(y)
+      Color.from_native(C::Graphics.sfImage_getPixel(@handle, coord))
+    end
+
+    # Write a single pixel.
+    def []=(x, y, color)
+      coord = C::System::Vector2u.new
+      coord[:x] = Integer(x); coord[:y] = Integer(y)
+      C::Graphics.sfImage_setPixel(@handle, coord, color.to_native)
+    end
+
+    # Write the entire pixel buffer back as a Ruby String. Useful for
+    # piping to image-processing libraries or writing custom file formats.
+    # Format: width*height*4 bytes, RGBA, row-major from top-left.
+    def pixels
+      ptr = C::Graphics.sfImage_getPixelsPtr(@handle)
+      ptr.read_bytes(width * height * 4)
+    end
+
+    def save(path)
+      ok = C::Graphics.sfImage_saveToFile(@handle, path.to_s)
+      raise Error, "Could not save image to #{path.inspect}" unless ok
+      path
+    end
+
+    # Replace any pixel matching `color` with that colour at `alpha`
+    # opacity — typical use is to turn a fixed background colour
+    # transparent: img.mask_color!(SFML::Color.magenta, alpha: 0).
+    def mask_color!(color, alpha: 0)
+      C::Graphics.sfImage_createMaskFromColor(@handle, color.to_native, Integer(alpha))
+      self
+    end
+
+    def flip_horizontally
+      C::Graphics.sfImage_flipHorizontally(@handle)
+      self
+    end
+
+    def flip_vertically
+      C::Graphics.sfImage_flipVertically(@handle)
+      self
+    end
+
+    attr_reader :handle # :nodoc:
+
+    private
+
+    def _take_ownership(ptr)
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfImage_destroy))
+    end
+  end
+end

data/lib/sfml/graphics/rectangle_shape.rb

@@ -0,0 +1,62 @@
+module SFML
+  # An axis-aligned filled rectangle.
+  #
+  #   wall = SFML::RectangleShape.new(
+  #     size: [200, 40],
+  #     position: [100, 500],
+  #     fill_color: SFML::Color["#444"],
+  #   )
+  #   window.draw(wall)
+  class RectangleShape
+    include Graphics::Transformable
+    CSFML_PREFIX = :sfRectangleShape
+
+    def initialize(size:, **opts)
+      ptr = C::Graphics.sfRectangleShape_create
+      raise Error, "sfRectangleShape_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfRectangleShape_destroy))
+
+      self.size = 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.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
+
+    def size
+      Vector2.from_native(C::Graphics.sfRectangleShape_getSize(@handle))
+    end
+
+    def size=(value)
+      vec = value.is_a?(Vector2) ? value : Vector2.new(*value)
+      C::Graphics.sfRectangleShape_setSize(@handle, vec.to_native_f)
+    end
+
+    def fill_color = Color.from_native(C::Graphics.sfRectangleShape_getFillColor(@handle))
+
+    def fill_color=(c)
+      C::Graphics.sfRectangleShape_setFillColor(@handle, c.to_native)
+    end
+
+    def outline_color = Color.from_native(C::Graphics.sfRectangleShape_getOutlineColor(@handle))
+
+    def outline_color=(c)
+      C::Graphics.sfRectangleShape_setOutlineColor(@handle, c.to_native)
+    end
+
+    def outline_thickness = C::Graphics.sfRectangleShape_getOutlineThickness(@handle)
+
+    def outline_thickness=(t)
+      C::Graphics.sfRectangleShape_setOutlineThickness(@handle, t.to_f)
+    end
+
+    def draw_on(target, states_ptr = nil) # :nodoc:
+      target._draw_native(:RectangleShape, @handle, states_ptr)
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/graphics/render_states.rb

@@ -0,0 +1,56 @@
+module SFML
+  # The state passed alongside a draw call: blend mode, texture, shader,
+  # transform, coordinate type. You rarely instantiate this directly —
+  # `window.draw(...)` accepts `blend_mode:`, `texture:`, etc. shortcuts
+  # that build a RenderStates internally. Construct one yourself when
+  # you need to keep the same combination across many draws:
+  #
+  #   states = SFML::RenderStates.new(
+  #     blend_mode: SFML::BlendMode::ADD,
+  #     texture:    glow_texture,
+  #   )
+  #   window.draw(va,    render_states: states)
+  #   window.draw(other, render_states: states)
+  #
+  # All fields default to the CSFML `sfRenderStates_default` value.
+  class RenderStates
+    COORDINATE_TYPES = %i[normalized pixels].freeze
+    COORDINATE_INDEX = COORDINATE_TYPES.each_with_index.to_h.freeze
+
+    attr_reader :blend_mode, :texture, :shader, :coordinate_type
+
+    def initialize(blend_mode: nil, texture: nil, shader: nil, coordinate_type: :normalized)
+      @blend_mode      = blend_mode
+      @texture         = texture
+      @shader          = shader   # placeholder until SFML::Shader lands in the next P1 step
+      @coordinate_type = coordinate_type
+      raise ArgumentError, "unknown coordinate_type: #{coordinate_type.inspect}" unless COORDINATE_INDEX.key?(coordinate_type)
+      freeze
+    end
+
+    # @!visibility private
+    # Allocate and populate a sfRenderStates buffer. Returns an
+    # FFI::MemoryPointer ready to pass as the `const sfRenderStates*`
+    # argument of a CSFML draw function.
+    def to_native_pointer
+      buffer = C::Graphics::RenderStates.new
+      # Start from the CSFML default so we get sane stencil + transform.
+      C::Graphics.sfRenderStates_default.pointer.read_bytes(C::Graphics::RenderStates.size)
+        .then { |bytes| buffer.pointer.write_bytes(bytes) }
+
+      @blend_mode&.populate(buffer[:blend_mode])
+      buffer[:coordinate_type] = COORDINATE_INDEX[@coordinate_type]
+      buffer[:texture] = @texture ? @texture.handle : nil
+      buffer[:shader]  = @shader  ? @shader.handle  : nil
+      buffer.pointer
+    end
+
+    # Convenience: build a RenderStates from the same shortcut kwargs
+    # that RenderTarget#draw accepts. Returns nil if no opts given (so
+    # the draw call uses the CSFML default without allocating anything).
+    def self.from_draw_opts(opts)
+      return nil if opts.empty?
+      new(**opts)
+    end
+  end
+end

data/lib/sfml/graphics/render_target.rb

@@ -0,0 +1,146 @@
+module SFML
+  module Graphics
+    # Shared behaviour between SFML::RenderWindow and SFML::RenderTexture.
+    # The two CSFML APIs are near-mirrors of each other (sfRenderWindow_*
+    # vs sfRenderTexture_*), so the Ruby side dispatches by the includer's
+    # CSFML_PREFIX constant. Adding a new render target only takes:
+    #
+    #   class NewTarget
+    #     include Graphics::RenderTarget
+    #     CSFML_PREFIX = :sfNewTarget
+    #     ...
+    #   end
+    #
+    # Drawables call `target._draw_native(:CircleShape, handle)` to dispatch
+    # through the right CSFML draw function for whichever target they're
+    # being rendered to.
+    module RenderTarget
+      def clear(color = Color::BLACK)
+        _csfml(:clear, @handle, color.to_native)
+        self
+      end
+
+      def display
+        _csfml(:display, @handle)
+        self
+      end
+
+      # Polymorphic draw: any drawable with a #draw_on(target, [states])
+      # method. Built-in drawables call back into target._draw_native.
+      #
+      # Pass shortcut kwargs to apply render states without instantiating
+      # SFML::RenderStates yourself:
+      #
+      #   window.draw(va,    texture: tile_texture)
+      #   window.draw(glow,  blend_mode: SFML::BlendMode::ADD)
+      #   window.draw(thing, texture: tex, blend_mode: SFML::BlendMode::ADD)
+      #
+      # Or pass a pre-built object for re-use across calls:
+      #
+      #   window.draw(thing, render_states: shared_states)
+      def draw(drawable, render_states: nil, **opts)
+        states     = render_states || RenderStates.from_draw_opts(opts)
+        states_ptr = states&.to_native_pointer
+        drawable.draw_on(self, states_ptr)
+        self
+      end
+
+      # @!visibility private
+      # Invoke the right CSFML draw function for this target + drawable
+      # kind. `kind` is the suffix after `draw`: e.g. :CircleShape →
+      # sfRenderWindow_drawCircleShape on a window, sfRenderTexture_drawCircleShape
+      # on a texture. `states_ptr` may be nil for default render states.
+      def _draw_native(kind, drawable_handle, states_ptr = nil)
+        C::Graphics.public_send(
+          :"#{self.class::CSFML_PREFIX}_draw#{kind}",
+          @handle, drawable_handle, states_ptr,
+        )
+      end
+
+      # Draw a one-shot batch of vertices without allocating a
+      # SFML::VertexArray. Useful for tight inner loops (a few dozen
+      # primitives per frame, where the VertexArray's per-object
+      # bookkeeping is itself the cost).
+      #
+      #   window.draw_primitives(
+      #     [SFML::Vertex.new([0, 0], color: SFML::Color.red),
+      #      SFML::Vertex.new([100, 0], color: SFML::Color.green),
+      #      SFML::Vertex.new([50, 80], color: SFML::Color.blue)],
+      #     :triangles,
+      #   )
+      #
+      # Accepts the same render-states kwargs as #draw.
+      def draw_primitives(vertices, primitive_type = :points, render_states: nil, **opts)
+        type_code = VertexArray::PRIMITIVE_INDEX.fetch(primitive_type) do
+          raise ArgumentError, "Unknown primitive type: #{primitive_type.inspect}"
+        end
+
+        # Pack the vertex array into a contiguous buffer.
+        n   = vertices.length
+        buf = FFI::MemoryPointer.new(C::Graphics::Vertex, n)
+        vertices.each_with_index do |v, i|
+          slot = C::Graphics::Vertex.new(buf + i * C::Graphics::Vertex.size)
+          slot[:position][:x]   = v.position.x.to_f
+          slot[:position][:y]   = v.position.y.to_f
+          slot[:color][:r]      = v.color.r
+          slot[:color][:g]      = v.color.g
+          slot[:color][:b]      = v.color.b
+          slot[:color][:a]      = v.color.a
+          slot[:tex_coords][:x] = v.tex_coords.x.to_f
+          slot[:tex_coords][:y] = v.tex_coords.y.to_f
+        end
+
+        states     = render_states || RenderStates.from_draw_opts(opts)
+        states_ptr = states&.to_native_pointer
+
+        C::Graphics.public_send(
+          :"#{self.class::CSFML_PREFIX}_drawPrimitives",
+          @handle, buf, n, type_code, states_ptr,
+        )
+        self
+      end
+
+      def view=(value)
+        raise ArgumentError, "#{self.class}#view= requires a SFML::View" unless value.is_a?(View)
+        _csfml(:setView, @handle, value.handle)
+        @view = value
+      end
+
+      def view
+        View.from_borrowed(_csfml(:getView, @handle))
+      end
+
+      # The default 1:1 view that matches the target's pixel size.
+      # Memoised — see the comment in render_window.rb for why.
+      def default_view
+        @default_view ||= View.from_borrowed(_csfml(:getDefaultView, @handle))
+      end
+
+      def map_pixel_to_coords(pixel, view: nil)
+        vec = C::System::Vector2i.new
+        px, py = pixel.is_a?(Vector2) ? [pixel.x, pixel.y] : pixel
+        vec[:x] = Integer(px); vec[:y] = Integer(py)
+
+        v_handle = view ? view.handle : _csfml(:getView, @handle)
+        result = _csfml(:mapPixelToCoords, @handle, vec, v_handle)
+        Vector2.new(result[:x], result[:y])
+      end
+
+      def map_coords_to_pixel(coord, view: nil)
+        vec = C::System::Vector2f.new
+        cx, cy = coord.is_a?(Vector2) ? [coord.x, coord.y] : coord
+        vec[:x] = cx.to_f; vec[:y] = cy.to_f
+
+        v_handle = view ? view.handle : _csfml(:getView, @handle)
+        result = _csfml(:mapCoordsToPixel, @handle, vec, v_handle)
+        Vector2.new(result[:x], result[:y])
+      end
+
+      private
+
+      def _csfml(suffix, *args)
+        C::Graphics.public_send(:"#{self.class::CSFML_PREFIX}_#{suffix}", *args)
+      end
+    end
+  end
+end

data/lib/sfml/graphics/render_texture.rb

@@ -0,0 +1,72 @@
+module SFML
+  # Off-screen rendering target. Anything you can draw on a RenderWindow
+  # — sprites, shapes, text, vertex arrays — you can also draw on a
+  # RenderTexture and then use its #texture as a Sprite source. Typical
+  # uses: minimaps, post-processing, motion-blur trails, custom UIs that
+  # composite multiple layers.
+  #
+  #   rt = SFML::RenderTexture.new(400, 300)
+  #   rt.clear(SFML::Color.cornflower_blue)
+  #   rt.draw(sprite)
+  #   rt.draw(text)
+  #   rt.display
+  #
+  #   sprite = SFML::Sprite.new(rt.texture)
+  #   window.draw(sprite)
+  #
+  # Note: rt.texture returns a *borrowed* reference owned by the
+  # RenderTexture. Keep the RenderTexture alive for as long as anything
+  # uses its texture.
+  class RenderTexture
+    include Graphics::RenderTarget
+    CSFML_PREFIX = :sfRenderTexture
+
+    def initialize(width, height, smooth: false, repeated: false)
+      size = C::System::Vector2u.new
+      size[:x] = Integer(width)
+      size[:y] = Integer(height)
+
+      ptr = C::Graphics.sfRenderTexture_create(size, nil)
+      raise Error, "sfRenderTexture_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfRenderTexture_destroy))
+
+      self.smooth   = smooth
+      self.repeated = repeated
+    end
+
+    def size
+      v = C::Graphics.sfRenderTexture_getSize(@handle)
+      Vector2.new(v[:x], v[:y])
+    end
+
+    def smooth?  = C::Graphics.sfRenderTexture_isSmooth(@handle)
+
+    def smooth=(value)
+      C::Graphics.sfRenderTexture_setSmooth(@handle, !!value)
+    end
+
+    def repeated? = C::Graphics.sfRenderTexture_isRepeated(@handle)
+
+    def repeated=(value)
+      C::Graphics.sfRenderTexture_setRepeated(@handle, !!value)
+    end
+
+    # The Texture this RenderTexture is rendering into. Borrowed — its
+    # lifetime is bounded by `self`. Memoised so repeated calls return
+    # the same Ruby wrapper.
+    def texture
+      @texture ||= begin
+        ptr = C::Graphics.sfRenderTexture_getTexture(@handle)
+        raise Error, "sfRenderTexture_getTexture returned NULL" if ptr.null?
+        # Borrowed — RenderTexture owns the underlying sf::Texture, so
+        # we wrap with a raw pointer (no AutoPointer / no destructor).
+        # Sprite.new(@texture) will still get a valid handle through it.
+        tex = Texture.allocate
+        tex.instance_variable_set(:@handle, ptr)
+        tex
+      end
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end