ashton 0.0.1alpha → 0.0.2alpha

data/lib/ashton/{post_process/noise.frag → shaders/static.frag}

@@ -1,27 +1,25 @@
-#version 110
-
-// Rather poor quality noise generation, but better than nothing and sort of looks like TV static a bit.
-
-uniform sampler2D in_Texture;
-
-uniform int in_WindowWidth; // Not used.
-uniform int in_WindowHeight; // Not used.
-
-uniform float in_Intensity;
-uniform float in_T;
-
-varying vec2 var_TexCoord;
-
-float rand(vec2 co) {
-	return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
-}
-
-void main() {
-	vec4 color = texture2D(in_Texture, var_TexCoord);
-	
-	vec4 influence = min(color, 1.0 - color);
-	
-	float noise = 1.0 - 2.0 * rand(var_TexCoord + float(in_T));
-	
-    gl_FragColor = color + in_Intensity * influence * noise;
-}
+#version 110
+
+#include <rand>
+
+// Rather poor quality noise generation, but better than nothing and sort of looks like TV static a bit.
+
+uniform sampler2D in_Texture;
+
+uniform int in_WindowWidth; // Not used.
+uniform int in_WindowHeight; // Not used.
+
+uniform float in_Intensity;
+uniform float in_T;
+
+varying vec2 var_TexCoord;
+
+void main() {
+	vec4 color = texture2D(in_Texture, var_TexCoord);
+	
+	vec4 influence = min(color, 1.0 - color);
+	
+	float noise = 1.0 - 2.0 * rand(var_TexCoord + float(in_T));
+	
+    gl_FragColor = color + in_Intensity * influence * noise;
+}

data/lib/ashton/shaders/stencil.frag

@@ -0,0 +1,27 @@
+#version 110
+
+// Use a stencil texture to selectively draw. Drawing of the image will occur
+// where the stencil is transparent (or only where the stencil is opaque if
+// inverted).
+//
+// Partial transparency in the stencil will allow the image to be drawn
+// partially too.
+
+varying vec4 var_Color;
+varying vec2 var_TexCoord0; // The texture/image to draw.
+varying vec2 var_TexCoord1; // The stencil (multitexture).
+
+uniform sampler2D in_Texture0; // The texture/image to draw.
+uniform sampler2D in_Texture1; // The stencil (multitexture).
+uniform bool in_Inverted; // true to draw in opaque areas / false to draw in transparent areas.
+ 
+void main()
+{
+  vec4 texColor = texture2D(in_Texture0, var_TexCoord0);
+  vec4 maskColor = texture2D(in_Texture1, var_TexCoord1);
+
+  // Only draw the texture where the stencil is transparent (unless inverted).
+  float mask_alpha = in_Inverted ? (1.0 - maskColor.a) : maskColor.a;
+
+  gl_FragColor = vec4(texColor.r, texColor.g, texColor.b, texColor.a - mask_alpha);
+}

data/lib/ashton/shaders/tv_screen.frag

@@ -0,0 +1,23 @@
+#version 110
+
+uniform sampler2D in_Texture;
+
+uniform float in_ColumnWidth; // In pixels.
+uniform int in_WindowWidth;
+uniform int in_WindowHeight; // Not used in this shader.
+
+varying vec2 var_TexCoord;
+
+void main()
+{
+    vec3 color = texture2D(in_Texture, var_TexCoord).rgb;
+
+    gl_FragColor = vec4(color * 0.25, 1.0);
+
+    float column_index = var_TexCoord.x * float(in_WindowWidth) / in_ColumnWidth;
+
+    int c = int(mod(column_index, 3.0));
+    if(c == 0) { gl_FragColor.r = color.r; }
+    else if(c == 1) { gl_FragColor.g = color.g; }
+    else if(c == 2) { gl_FragColor.b = color.b; }
+}

data/lib/ashton/signed_distance_field.rb

@@ -0,0 +1,151 @@
+module Ashton
+  class SignedDistanceField
+    ZERO_DISTANCE = 128 # color channel containing 0 => -128, 128 => 0, 129 => +1, 255 => +128
+
+    attr_reader :width, :height
+
+    # Creates a Signed Distance Field based on a given image.
+    # When drawing into the SDF, drawing should ONLY have alpha of 0 (clear) or 255 (solid)
+    #
+    # @param width [Integer]
+    # @param height [Integer]
+    # @param max_distance [Integer] Maximum distance to measure.
+    # @option options :step_size [Integer] (1) pixels to step out.
+    # @option options :scale [Integer] (1) Scale relative to the image.
+    def initialize(width, height, max_distance, options = {}, &block)
+      options = {
+         scale: 1,
+         step_size: 1,
+      }.merge! options
+
+      @width, @height = width, height
+      @scale = options[:scale].to_f
+
+      @shader = Shader.new fragment: :signed_distance_field, uniforms: {
+          max_distance: max_distance.ceil,
+          step_size: options[:step_size].floor, # One pixel.
+          texture_size: [width, height].map(&:to_f),
+      }
+
+      @field = Texture.new (width / @scale).ceil, (height / @scale).ceil
+      @mask = Texture.new @field.width, @field.height
+
+      if block_given?
+        render_field &block
+      else
+        @field.clear color: Gosu::Color.rgb(*([ZERO_DISTANCE + max_distance] * 3))
+      end
+    end
+
+    # Is the position clear for a given radius around it.
+    def position_clear?(x, y, radius)
+      sample_distance(x, y) >= radius
+    end
+
+    # If positive, distance, in pixels, to the nearest opaque pixel.
+    # If negative, distance in pixels to the nearest transparent pixel.
+    def sample_distance(x, y)
+      x = [[x, width - 1].min, 0].max
+      y = [[y, height - 1].min, 0].max
+      # Could be checking any of red/blue/green.
+      @field.red((x / @scale).round, (y / @scale).round) - ZERO_DISTANCE
+    end
+
+    # Gets the gradient of the field at a given point.
+    # @return [Float, Float] gradient_x, gradient_y
+    def sample_gradient(x, y)
+      d0 = sample_distance x, y - 1
+      d1 = sample_distance x - 1, y
+      d2 = sample_distance x + 1, y
+      d3 = sample_distance x, y + 1
+
+      [(d2 - d1) / @scale, (d3 - d0) / @scale]
+    end
+
+    # Get the normal at a given point.
+    # @return [Float, Float] normal_x, normal_y
+    def sample_normal(x, y)
+      gradient_x, gradient_y = sample_gradient x, y
+      length = Gosu::distance 0, 0, gradient_x, gradient_y
+      if length == 0
+        [0, 0] # This could be NaN in edge cases.
+      else
+        [gradient_x / length, gradient_y / length]
+      end
+    end
+
+    # Does the point x1, x2 have line of sight to x2, y2 (that is, no solid in the way).
+    def line_of_sight?(x1, y1, x2, y2)
+      !line_of_sight_blocked_at(x1, y1, x2, y2)
+    end
+
+    # Returns blocking position, else nil if line of sight isn't blocked.
+    def line_of_sight_blocked_at(x1, y1, x2, y2)
+      distance_to_travel = Gosu::distance x1, y1, x2, y2
+      distance_x, distance_y = x2 - x1, y2 - y1
+      distance_travelled = 0
+      x, y = x1, y1
+
+      loop do
+        distance = sample_distance x, y
+
+        # Blocked?
+        return [x, y] if distance <= 0
+
+        distance_travelled += distance
+
+        # Got to destination in the clear.
+        return nil if distance_travelled >= distance_to_travel
+
+        lerp = distance_travelled.fdiv distance_to_travel
+        x = x1 + distance_x * lerp
+        y = y1 + distance_y * lerp
+      end
+    end
+
+    # Update the SDF should the image have changed.
+    # Draw the mask in the passed block.
+    def render_field
+      raise ArgumentError, "Block required" unless block_given?
+
+      @mask.render do
+        @mask.clear
+        $window.scale 1.0 / @scale do
+          yield self
+        end
+      end
+
+      @shader.enable do
+        @field.render do
+          @mask.draw 0, 0, 0
+        end
+      end
+
+      nil
+    end
+
+    # Draw the field, usually for debugging purposes.
+    # @see Ashton::Texture#draw
+    def draw(x, y, z, options = {})
+      options = {
+          mode: :add,
+      }.merge! options
+
+      $window.scale @scale do
+        @field.draw x, y, z, options
+      end
+
+      nil
+    end
+
+    # Convert into a nested array of sample values.
+    # @return [Array<Array<Integer>>]
+    def to_a
+      width.times.map do |x|
+        height.times.map do |y|
+          sample_distance x, y
+        end
+      end
+    end
+  end
+end

data/lib/ashton/texture.rb

@@ -0,0 +1,186 @@
+module Ashton
+  class Texture
+    include Mixins::VersionChecking
+
+    DEFAULT_DRAW_COLOR = Gosu::Color::WHITE
+    VALID_DRAW_MODES = [:alpha_blend, :add, :multiply, :replace]
+
+    class << self
+      # [Boolean] Whether or not to pixelate (rather than smooth) on #draw
+      attr_writer :pixelated
+      # [Boolean] Whether or not to pixelate (rather than smooth) on #draw. Set true when Gosu::enable_undocumented_retrofication called.
+      def pixelated?; @pixelated end
+    end
+    self.pixelated = false
+
+    # [Boolean] Is this texture being rendered to currently?
+    def rendering?; @rendering end
+
+    # @overload initialize(image)
+    #   Create a texture from a Gosu::Image
+    #
+    #   @see Image#to_texture
+    #   @param image [Gosu::Image]
+    #
+    # @overload initialize(blob, width, height)
+    #   Create a texture from a binary blob.
+    #
+    #   @param blob [String]
+    #   @param width [Integer]
+    #   @param height [Integer]
+    #
+    # @overload initialize(width, height)
+    #   Create a blank (transparent) texture.
+    #
+    #   @param width [Integer]
+    #   @param height [Integer]
+    def initialize(*args)
+      case args.size
+        when 1
+          # Create from Gosu::Image
+          image = args[0]
+          raise TypeError, "Expected Gosu::Image" unless image.is_a? Gosu::Image
+          initialize_ image.width, image.height, nil
+
+          render do
+            # TODO: Ideally we'd draw the image in replacement mode, but Gosu doesn't support that.
+            $window.gl do
+              info = image.gl_tex_info
+              glEnable GL_TEXTURE_2D
+              glBindTexture GL_TEXTURE_2D, info.tex_name
+              glEnable GL_BLEND
+              glBlendFunc GL_ONE, GL_ZERO
+
+              glBegin GL_QUADS do
+                glTexCoord2d info.left, info.top
+                glVertex2d 0, height # BL
+
+                glTexCoord2d info.left, info.bottom
+                glVertex2d 0, 0 # TL
+
+                glTexCoord2d info.right, info.bottom
+                glVertex2d width, 0 # TR
+
+                glTexCoord2d info.right, info.top
+                glVertex2d width, height # BR
+              end
+            end
+          end
+
+        when 2
+          # Create blank image.
+          width, height = *args
+          initialize_ width, height, nil
+          clear
+
+        when 3
+          # Create from blob - create a Gosu image first.
+          blob, width, height = *args
+          raise ArgumentError, "Blob data is not of expected size" if blob.length != width * height * 4
+          initialize_ width, height, blob
+
+        else
+          raise ArgumentError, "Expected 1, 2 or 3 parameters."
+      end
+
+      @rendering = false
+    end
+
+    public
+    # Clears the buffer, optionally to a specific color.
+    #
+    # @option options :color [Gosu::Color, Array<Float>] (transparent)
+    def clear(options = {})
+      options = {
+          color: [0.0, 0.0, 0.0, 0.0],
+      }.merge! options
+
+      color = options[:color]
+      color = color.to_opengl if color.is_a? Gosu::Color
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, fbo_id unless rendering?
+
+      glDisable GL_BLEND # Need to replace the alpha too.
+      glClearColor *color
+      glClear GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+      glEnable GL_BLEND
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, 0 unless rendering?
+
+      nil
+    end
+
+    public
+    # Enable the texture to use (e.g. to draw or convert it).
+    def render
+      raise ArgumentError, "Block required" unless block_given?
+      raise Error, "Can't nest rendering" if rendering?
+
+      $window.flush # Ensure that any drawing _before_ the render block is drawn to screen, rather than into the buffer.
+
+      render_
+
+      @rendering = true
+
+      # Project onto the texture itself, using Gosu (inverted) coordinates.
+      glPushMatrix
+      glMatrixMode GL_PROJECTION
+      glLoadIdentity
+      glViewport 0, 0, width, height
+      glOrtho 0, width, height, 0, -1, 1
+
+      begin
+        yield self
+      ensure
+        $window.flush # Force all the drawing to draw now!
+        glBindFramebufferEXT GL_FRAMEBUFFER_EXT, 0
+
+        @rendering = false
+
+        glPopMatrix
+
+        cache.refresh # Force lazy reloading of the cache.
+      end
+
+      self
+    end
+
+    # @!method draw(x, y, z, options = {})
+    #   Draw the Texture.
+    #
+    #   This is not as versatile as converting the Texture into a Gosu::Image and then
+    #   drawing it, but it is many times faster, so use it when you are updating the buffer
+    #   every frame, rather than just composing an image.
+    #
+    #   Drawing in Gosu orientation will be flipped in standard OpenGL and visa versa.
+    #
+    #   @param x [Number] Top left corner x.
+    #   @param y [Number] Top left corner y.
+    #   @param z [Number] Z-order (can be nil to draw immediately)
+    #
+    #   @option options :shader [Ashton::Shader] Shader to apply to drawing.
+    #   @option options :color [Gosu::Color] (Gosu::Color::WHITE) Color to apply to the drawing.
+    #   @option options :mode [Symbol] (:alpha_blend) :alpha_blend, :add, :multiply, :replace
+    #   @option options :multitexture [Texture] A texture to be used in a multi-texturing shader.
+    #   @option options :pixelated [Boolean] (true if Gosu::enable_undocumented_retrofication ever called) Pixelate, rather than smooth, when zoomed out.
+
+    public
+    # Convert the current contents of the buffer into a Gosu::Image
+    #
+    # @option options :caching [Boolean] (true) TexPlay behaviour.
+    # @option options :tileable [Boolean] (false) Standard Gosu behaviour.
+    # @option options :rect [Array<Integer>] ([0, 0, width, height]) Rectangular area of buffer to use to create the image [x, y, w, h]
+    def to_image(*args)
+      cache.to_image *args
+    end
+
+    def dup
+      # Create a new texture and draw self into it.
+      new_texture = Texture.new width, height
+      new_texture.render do
+        draw 0, 0, 0, mode: :replace
+      end
+      new_texture
+    end
+  end
+end

data/lib/ashton/version.rb

@@ -1,3 +1,3 @@
-module Ashton
-  VERSION = "0.0.1alpha"
+module Ashton
+  VERSION = "0.0.2alpha"
 end