ashton 0.0.1alpha → 0.0.2alpha

data/ext/ashton/texture.h

@@ -0,0 +1,63 @@
+/*
+ * class Ashton::Texture
+ *
+ *
+ */
+
+
+#ifndef ASHTON_FRAMEBUFFER_H
+#define ASHTON_FRAMEBUFFER_H
+
+#include <math.h>
+
+#include "common.h"
+#include "pixel_cache.h"
+
+#define DRAW_MODE_ALPHA_BLEND "alpha_blend"
+#define DRAW_MODE_ADD "add"
+#define DRAW_MODE_MULTIPLY "multiply"
+#define DRAW_MODE_REPLACE "replace"
+
+typedef struct _texture
+{
+    uint width;
+    uint height;
+
+    GLuint fbo_id;
+    GLuint id;
+
+    VALUE rb_cache; // Value of cache for marking purpose.
+} Texture;
+
+// Create an 'texture' variable which points to our data.
+#define TEXTURE() \
+    Texture* texture; \
+    Data_Get_Struct(self, Texture, texture);
+
+void Init_Ashton_Texture(VALUE module);
+
+// Getters.
+VALUE Ashton_Texture_get_cache(VALUE self);
+VALUE Ashton_Texture_get_width(VALUE self);
+VALUE Ashton_Texture_get_height(VALUE self);
+VALUE Ashton_Texture_get_fbo_id(VALUE self);
+VALUE Ashton_Texture_get_id(VALUE self);
+
+// Creation and destruction.
+VALUE Ashton_Texture_init(VALUE self, VALUE width, VALUE height, VALUE blob);
+
+// Methods.
+VALUE Ashton_Texture_refresh_cache(VALUE self);
+VALUE Ashton_Texture_get_pixel(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_Texture_get_rgba_array(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_Texture_get_red(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_Texture_get_green(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_Texture_get_blue(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_Texture_get_alpha(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_Texture_is_transparent(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_Texture_to_blob(VALUE self);
+VALUE Ashton_Texture_draw(int argc, VALUE argv[], VALUE self);
+VALUE Ashton_Texture_render(VALUE self);
+
+#endif // ASHTON_FRAMEBUFFER_H
+

data/ext/ashton/window.c

@@ -0,0 +1,8 @@
+#include "window.h"
+
+VALUE rb_cWindow;
+
+void Init_Gosu_Window(VALUE module)
+{
+    rb_cWindow = rb_define_class_under(module, "Window", rb_cObject);
+}

data/ext/ashton/window.h

@@ -0,0 +1,16 @@
+/*
+ * class Gosu::Window
+ *
+ *
+ */
+
+
+#ifndef GOSU_WINDOW_H
+#define GOSU_WINDOW_H
+
+#include "common.h"
+
+void Init_Gosu_Window(VALUE module);
+
+#endif // GOSU_WINDOW_H
+

data/lib/ashton.rb

@@ -1,26 +1,38 @@
-require 'opengl'
-require 'gosu'
-
-
-
-module Ashton
-  class Error < RuntimeError; end
-
-  class NotSupportedError < Error; end
-
-  class ShaderError < Error; end
-  class ShaderCompileError < ShaderError; end
-  class ShaderLinkError < ShaderError; end
-  class ShaderUniformError < ShaderError; end
-  class ShaderAttributeError < ShaderError; end
-end
-
-require "ashton/gosu_ext/window"
-require "ashton/gosu_ext/image"
-require "ashton/gosu_ext/color"
-
-require "ashton/version"
-require "ashton/shader"
-require "ashton/post_process"
-require "ashton/framebuffer"
-require "ashton/image_stub"
+require 'opengl'
+require 'gosu'
+
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "ashton/#{$1}/ashton.#{RbConfig::CONFIG['DLEXT']}"
+rescue LoadError
+  require "ashton/ashton.#{RbConfig::CONFIG['DLEXT']}"
+end
+
+module Ashton
+  class Error < StandardError; end
+
+  class NotSupportedError < Error; end
+
+  class ShaderError < Error; end
+  class ShaderCompileError < ShaderError; end
+  class ShaderLinkError < ShaderError; end
+  class ShaderUniformError < ShaderError; end
+  class ShaderAttributeError < ShaderError; end
+  class ShaderLoadError < ShaderError; end
+end
+
+require_relative "ashton/gosu_ext/gosu_module"
+
+require_relative "ashton/mixins/version_checking"
+
+require_relative "ashton/version"
+require_relative "ashton/shader"
+require_relative "ashton/signed_distance_field"
+require_relative "ashton/texture"
+require_relative "ashton/window_buffer"
+require_relative "ashton/image_stub"
+require_relative "ashton/particle_emitter"
+require_relative "ashton/pixel_cache"
+
+require_relative "ashton/lighting/light_source"
+require_relative "ashton/lighting/manager"

data/lib/ashton/gosu_ext/color.rb

@@ -1,12 +1,25 @@
-module Gosu
-  class Color
-    def self.from_opengl(array)
-      rgba *array.map {|c| (c * 255).to_i }
-    end
-
-    # Convert to length 4 array of floats in range 0.0 to 1.0
-    def to_opengl
-      [red / 255.0, green / 255.0, blue / 255.0, alpha / 255.0]
-    end
-  end
+module Gosu
+  class Color
+    # @!method self.from_opengl(rgba_array)
+    #   Convert into an array of floats in range 0.0 to 1.0.
+    #
+    #   @param rgba_array [Array<Float>]
+    #   @return [Gosu::Color]
+
+
+    # @!method to_opengl
+    #   Convert into a length 4 array of floats in range 0.0 to 1.0, which
+    #   can then be passed into OpenGL ruby methods.
+    #
+    #   @example
+    #     color = Gosu::Color.rgba 128, 0, 0, 255 # => [0.502, 0.0, 0.0, 1.0]
+    #     glColor4f *color.to_opengl
+    #
+    #   @return [Array<Float>]
+
+
+    # @!method to_i
+    #   Convert to Gosu-compatible ARGB value (0xAARRGGBB)
+    #   @return [Integer]
+  end
 end

data/lib/ashton/gosu_ext/font.rb

@@ -0,0 +1,58 @@
+module Gosu
+  class Font
+    DEFAULT_DRAW_COLOR = Gosu::Color::WHITE
+
+    alias_method :draw_without_hash, :draw
+    protected :draw_without_hash
+    def draw(*args)
+      args, shader = if args.last.is_a?(Hash)
+                       [args[0..-2], args.last[:shader]]
+                     else
+                       [args, nil]
+                     end
+
+      z = args[3]
+
+      if shader
+        shader.enable z
+        $window.gl z do
+          glActiveTexture GL_TEXTURE0 # Let's make an assumption :)
+          shader.color = args[6].is_a?(Color) ? args[6] : DEFAULT_DRAW_COLOR
+        end
+      end
+
+      begin
+        draw_without_hash *args
+      ensure
+        shader.disable z if shader
+      end
+    end
+
+    alias_method :draw_rel_without_hash, :draw_rel
+    protected :draw_rel_without_hash
+    def draw_rel(*args)
+      args, shader = if args.last.is_a?(Hash)
+                       [args[0..-2], args.last[:shader]]
+                     else
+                       [args, nil]
+                     end
+
+      z = args[3]
+
+      if shader
+        shader.enable z
+        $window.gl z do
+          glActiveTexture GL_TEXTURE0 # Let's make an assumption :)
+          shader.color = args[8].is_a?(Color) ? args[8] : DEFAULT_DRAW_COLOR
+        end
+      end
+
+      begin
+        draw_rel_without_hash *args
+      ensure
+        shader.disable z if shader
+      end
+    end
+
+  end
+end

data/lib/ashton/gosu_ext/gosu_module.rb

@@ -0,0 +1,16 @@
+require_relative "window"
+require_relative "font"
+require_relative "image"
+require_relative "color"
+
+module Gosu
+  class << self
+    alias_method :original_enable_undocumented_retrofication, :enable_undocumented_retrofication
+    protected :original_enable_undocumented_retrofication
+
+    def enable_undocumented_retrofication
+      Ashton::Texture.pixelated = true
+      original_enable_undocumented_retrofication
+    end
+  end
+end

data/lib/ashton/gosu_ext/image.rb

@@ -1,32 +1,96 @@
-module Gosu
-  class Image
-    alias_method :draw_without_hash, :draw
-
-    def draw(*args)
-      if args.last.is_a? Hash
-        shader = args.last[:shader]
-        shader.use do
-          shader.image = self
-          shader.color = args[5].is_a?(Color) ? args[5] : [1, 1, 1, 1]
-          draw_without_hash *args[0...-1]
-        end
-      else
-        draw_without_hash *args
-      end
-    end
-
-    alias_method :draw_rot_without_hash, :draw_rot
-    def draw_rot(*args)
-      if args.last.is_a? Hash
-        shader = args.last[:shader]
-        shader.use do
-          shader.image = self
-          shader.color = args[8].is_a?(Color) ? args[8] : [1, 1, 1, 1]
-          draw_rot_without_hash *args[0...-1]
-        end
-      else
-        draw_rot_without_hash *args
-      end
-    end
-  end
+module Gosu
+  class Image
+    DEFAULT_DRAW_COLOR = Gosu::Color::WHITE
+
+    alias_method :draw_without_hash, :draw
+    protected :draw_without_hash
+    def draw(*args)
+      args, shader = if args.last.is_a?(Hash)
+                       [args[0..-2], args.last[:shader]]
+                     else
+                       [args, nil]
+                     end
+
+      z = args[2]
+
+      if shader
+        shader.enable z
+        $window.gl z do
+          shader.image = self
+          shader.color = args[5].is_a?(Color) ? args[5] : DEFAULT_DRAW_COLOR
+        end
+      end
+
+      begin
+        draw_without_hash *args
+      ensure
+        shader.disable z if shader
+      end
+    end
+
+    alias_method :draw_rot_without_hash, :draw_rot
+    protected :draw_rot_without_hash
+    def draw_rot(*args)
+      args, shader = if args.last.is_a?(Hash)
+                       [args[0..-2], args.last[:shader]]
+                     else
+                       [args, nil]
+                     end
+      z = args[2]
+
+      if shader
+        shader.enable z
+        $window.gl z do
+          shader.image = self
+          shader.color = args[8].is_a?(Color) ? args[8] : DEFAULT_DRAW_COLOR
+        end
+      end
+
+      begin
+        draw_rot_without_hash *args
+      ensure
+        shader.disable z if shader
+      end
+    end
+
+    # Draw a list of centred sprites by position.
+    #
+    # @param points [Array<Array>] Array of [x, y] positions
+    # @param z [Float] Z-order to draw - Ignored if shader is used.
+    # @option options :scale [Float] (1.0) Relative size of the sprites
+    # @option options :shader [Ashton::Shader] Shader to apply to all sprites.
+    #
+    # TODO: Need to use point sprites here, but this is still much faster than individual #draws if using shaders and comparable if not.
+    def draw_as_points(points, z, options = {})
+      color = options[:color] || DEFAULT_DRAW_COLOR
+      scale = options[:scale] || 1.0
+      shader = options[:shader]
+      mode = options[:mode] || :default
+
+      if shader
+        shader.enable z
+        $window.gl z do
+          shader.image = self
+          shader.color = color
+        end
+      end
+
+      begin
+        points.each do |x, y|
+          draw_rot_without_hash x, y, z, 0, 0.5, 0.5, scale, scale, color, mode
+        end
+      ensure
+        shader.disable z if shader
+      end
+    end
+
+    # The cache is a replacement for Texplay's pixel cache system.
+    def cache
+      @cache ||= Ashton::PixelCache.new self
+    end
+
+    def to_texture
+      Ashton::Texture.new self
+    end
+  end
 end

data/lib/ashton/gosu_ext/window.rb

@@ -1,36 +1,79 @@
-# Set the window global, in case it hasn't been set (e.g. by Chingu)
-module Gosu
-  class Window
-    class << self
-      # Used for post-processing effects.
-      attr_accessor :back_buffer
-    end
-
-    alias_method :ashton_initialize, :initialize
-    def initialize(*args, &block)
-      $window = self
-      ashton_initialize *args, &block
-    end
-
-    # TODO: accept multiple shaders.
-    def post_process(shader)
-      raise ArgumentError, "Block required" unless block_given?
-
-      Window.back_buffer ||= Ashton::Framebuffer.new width, height
-
-      buffer = Window.back_buffer
-      buffer.clear
-
-      # allow drawing into the back-buffer.
-      buffer.use do
-        yield
-      end
-
-      # Draw the back-buffer onto the window, utilising the shader.
-      shader.use do
-        shader["in_Texture"] = 0
-        buffer.draw 0, 0
-      end
-    end
-  end
+# Set the window global, in case it hasn't been set (e.g. by Chingu)
+module Gosu
+  class Window
+    class << self
+      WHITE_PIXEL_BLOB = "\xFF" * 4
+
+      # Used for post-processing effects, but could be used by
+      # anyone needing to have a temporary, full-window render buffer.
+      def primary_buffer; @primary_buffer ||= Ashton::WindowBuffer.new end
+
+      # Used for post-processing effects, but could be used by
+      # anyone needing to have a temporary, full-window render buffer.
+      def secondary_buffer; @secondary_buffer ||= Ashton::WindowBuffer.new end
+
+      # An image containing a single white pixel. Useful for drawing effects (rectangle, lines, etc).
+      def pixel
+        @pixel ||= Gosu::Image.new $window, Ashton::ImageStub.new(WHITE_PIXEL_BLOB, 1, 1), true
+      end
+    end
+
+    def pixel; Window.pixel end
+    def primary_buffer; Window.primary_buffer end
+    def secondary_buffer; Window.secondary_buffer end
+
+    alias_method :ashton_initialize, :initialize
+    def initialize(*args, &block)
+      $window = self
+      ashton_initialize *args, &block
+    end
+
+    alias_method :gl_not_liking_nil, :gl
+    protected :gl_not_liking_nil
+    def gl(z = nil, &block)
+      if z
+        gl_not_liking_nil z, &block
+      else
+        gl_not_liking_nil &block
+      end
+    end
+
+    # Full screen post-processing using a fragment shader.
+    #
+    # Variables set for you in the fragment shader:
+    #   uniform sampler2D in_Texture; // Texture containing the screen image.
+    def post_process(*shaders)
+      raise ArgumentError, "Block required" unless block_given?
+      raise TypeError, "Can only process with Shaders" unless shaders.all? {|s| s.is_a? Ashton::Shader }
+
+      # In case no shaders are passed, just run the contents of the block.
+      unless shaders.size > 0
+        yield
+        return
+      end
+
+      buffer1 = primary_buffer
+      buffer1.clear
+
+      # Allow user to draw into a buffer, rather than the window.
+      buffer1.render do
+        yield
+      end
+
+      if shaders.size > 1
+        buffer2 = secondary_buffer # Don't need to clear, since we will :replace.
+
+        # Draw into alternating buffers, applying each shader in turn.
+        shaders[0...-1].each do |shader|
+          buffer1, buffer2 = buffer2, buffer1
+          buffer1.render do
+            buffer2.draw 0, 0, nil, shader: shader, mode: :replace
+          end
+        end
+      end
+
+      # Draw the buffer directly onto the window, utilising the (last) shader.
+      buffer1.draw 0, 0, nil, shader: shaders.last
+    end
+  end
 end