ray 0.1.1 → 0.2.0

data/lib/ray/effect/black_and_white.rb

@@ -0,0 +1,38 @@
+module Ray
+  class Effect
+    # A black and white effect. It considers the grayscale level of the image,
+    # and sets pixels that are darker than a given value to black, and the
+    # others to white.
+    class BlackAndWhite < Effect
+      effect_name :black_and_white
+      attribute   :ratio, :vec3
+      attribute   :value, :float
+
+      # @param [Ray::Vector3] ratio Default ratio to compute grayscale
+      # @param [Float] value Minimal grayscale level of white pixels
+      def initialize(value = 0.5, ratio = [0.299, 0.587, 0.114])
+        @ratio = ratio
+        @value = value
+      end
+
+      # @return [Ray::Vector3] ratio
+      attr_accessor :ratio
+
+      def defaults
+        {:ratio => @ratio, :value => @value}
+      end
+
+      def code
+        return <<code
+vec4 do_black_and_white(ray_black_and_white args, vec4 color) {
+  float gray = dot(color.rgb, args.ratio);
+  if (gray > args.value)
+    return vec4(1, 1, 1, color.a);
+  else
+    return vec4(0, 0, 0, color.a);
+}
+code
+      end
+    end
+  end
+end

data/lib/ray/effect/color_inversion.rb

@@ -0,0 +1,16 @@
+module Ray
+  class Effect
+    # An effect to invert the color of a pixel. This preserves the alpha component.
+    class ColorInversion < Effect
+      effect_name :color_inversion
+
+      def code
+        return <<code
+vec4 do_color_inversion(ray_color_inversion args, vec4 color) {
+  return vec4(vec3(1, 1, 1) - color.rgb, color.a);
+}
+code
+      end
+    end
+  end
+end

data/lib/ray/effect/generator.rb

@@ -0,0 +1,145 @@
+module Ray
+  class Effect
+    class Generator
+      include Enumerable
+
+      # @param [Integer] version GLSL version to use
+      # @yield Yields itself if a block is given
+      def initialize(version = 110)
+        @effects = []
+        @version = version
+
+        if version >= 130
+          @input = <<-input
+in vec4 var_Color;
+in vec2 var_TexCoord;
+input
+        else
+          @input = <<-input
+varying vec4 var_Color;
+varying vec2 var_TexCoord;
+input
+        end
+
+        @uniforms = <<-uniforms
+uniform sampler2D in_Texture;
+uniform bool in_TextureEnabled;
+uniforms
+
+        @color = "color"
+
+        @default = <<-default
+  /* Apply default value */
+  vec4 color;
+  if (in_TextureEnabled)
+    color = texture#{"2D" if version<130}(in_Texture, var_TexCoord) * var_Color;
+  else
+    color = var_Color;
+default
+
+        yield self if block_given?
+      end
+
+      # @param [Array<Ray:::Effect>] effects effects to add to the generator
+      def push(*effects)
+        @effects.concat effects
+        self
+      end
+
+      alias << push
+
+      def each(&block)
+        @effects.each(&block)
+      end
+
+      # @return [Array<Ray::Effect>] All of the effects used by the generator
+      attr_reader :effects
+      alias to_a effects
+
+      # @return [Integer] GLSL version number
+      attr_reader :version
+
+      # @return [String] Code defining GLSL input (with varying or in, depending
+      #   on the GLSL version).
+      attr_accessor :input
+
+      # @return [String] Code defining uniforms
+      attr_accessor :uniforms
+
+      # @return [String] Name of the variable containing the
+      #   color once the default code is run. "color" by default.
+      attr_accessor :color
+
+      # @return [String] Code to ste the default color. It should apply
+      #   texturing, for example.
+      attr_accessor :default
+
+      # @return [String] code of the pixel shader
+      def code
+        str  = "#version #@version\n"
+        str << "\n"
+
+        str << input    << "\n"
+        str << uniforms << "\n"
+
+
+        str << "out vec4 out_FragColor;\n" if version >= 130
+        str << "\n"
+
+        str << "/* Headers */\n"
+        each do |effect|
+          str << effect.header << "\n"
+        end
+        str << "\n"
+
+        str << "/* Structs */\n\n"
+        each do |effect|
+          str << effect.struct << "\n"
+        end
+
+        str << "/* Effects parameters */\n"
+        each do |effect|
+          str << "uniform ray_#{effect.name} #{effect.name};\n"
+        end
+        str << "\n"
+
+        str << "/* Functions */\n"
+        each do |effect|
+          str << effect.code << "\n"
+        end
+
+        str << "void main() {\n"
+        str << default << "\n"
+
+        each do |effect|
+          str << "  if (#{effect.name}.enabled)\n"
+          str << "    #@color = do_#{effect.name}(#{effect.name}, #@color);\n"
+          str << "\n"
+        end
+
+        if version >= 130
+          str << "  out_FragColor = #@color;\n"
+        else
+          str << "  gl_FragColor = #@color;\n"
+        end
+
+        str << "}\n"
+      end
+
+      # Generates a shader
+      # @param [Ray::Shader] shader Shader to compile and apply defaults to
+      # @return [Ray::Shader] shader
+      def build(shader = Ray::Shader.new)
+        shader.compile :frag => StringIO.new(code)
+        apply_defaults shader
+        shader
+      end
+
+      # Apply generator defaults to a shader
+      # @param [Ray::Shader] shader Shader to apply defaults to
+      def apply_defaults(shader)
+        each { |effect| effect.apply_defaults(shader) }
+      end
+    end
+  end
+end

data/lib/ray/effect/grayscale.rb

@@ -0,0 +1,32 @@
+module Ray
+  class Effect
+    # A grayscale effect. To accomplish it, it computes the dot product of the
+    # color by a ratio, and assigns the result to red, green, and blue
+    # components. Alpha component is preserved.
+    class Grayscale < Effect
+      effect_name :grayscale
+      attribute   :ratio, :vec3
+
+      # @param [Ray::Vector3] ratio Default ratio
+      def initialize(ratio = [0.299, 0.587, 0.114])
+        @ratio = ratio
+      end
+
+      # @return [Ray::Vector3] ratio
+      attr_accessor :ratio
+
+      def defaults
+        {:ratio => @ratio}
+      end
+
+      def code
+        return <<code
+vec4 do_grayscale(ray_grayscale args, vec4 color) {
+  float gray = dot(color.rgb, args.ratio);
+  return vec4(gray, gray, gray, color.a);
+}
+code
+      end
+    end
+  end
+end

data/lib/ray/game.rb

@@ -120,11 +120,31 @@ module Ray
       @game_scenes.push(scene_name, *args)
     end
 
-    # Pops the last scene.
+    # Pops the last scene
     def pop_scene
       @game_scenes.pop
     end
 
+    # Pops scenes while a condition is true
+    #
+    # @yield [scene] To determine if a scene must be popped.
+    # @yieldparam [Ray::Scene] scene The scene that will be popped
+    # @yieldreturn [Boolean] True to pop the next scene
+    def pop_scene_while
+      while yield scenes.current
+        scenes.current.pop_scene # ensure exit is set to false
+      end
+    end
+
+    # Pops scenes until a condition is met
+    #
+    # @yield (see #pop_scene_while)
+    # @yieldparam scene (see #pop_scene_while)
+    # @yieldreturn [Boolean] False to pop the next scene
+    def pop_scene_until
+      pop_scene_while { |o| !yield(o) }
+    end
+
     # Registers a new scene with a given name. the block will be passed
     # to klass.new.
     #
@@ -136,6 +156,7 @@ module Ray
       scene.game         = self
       scene.event_runner = event_runner
       scene.window       = @game_window
+      scene.name         = name
     end
 
     # @return [Ray::Scene] scene register for a given name
@@ -183,14 +204,17 @@ module Ray
       @game_scenes.clear
     end
 
+    # @return [Ray::String]
     def title
       @game_title
     end
 
+    # @return [Ray::SceneList]
     def scenes
       @game_scenes
     end
 
+    # @return [Ray::Window]
     def window
       @game_window
     end
@@ -210,10 +234,6 @@ module Ray
         scene.event_runner = runner
       end
     end
-
-    def inspect
-      "game(#{title.inspect})"
-    end
   end
 
   # (see Ray::Game#initialize)

data/lib/ray/gl/vertex.rb

@@ -1,15 +1,51 @@
 module Ray
   module GL
     class Vertex
+      include Ray::PP
+
       @vertex_classes = {0 => Ray::Vertex}
 
+      class Instance
+        include Ray::PP
+
+        @instance_classes = {}
+
+        class << self
+          attr_reader :instance_classes
+        end
+
+        def self.layout
+          @vertex_instance_layout
+        end
+
+        def to_s
+          pairs = []
+          self.class.layout.each do |key, _, _, per_instance|
+            pairs << "#{key}=#{send(key)}" if per_instance
+          end
+
+          "#<#{self.class} #{pairs.join " "}>"
+        end
+
+        def pretty_print(q)
+          attr = []
+          self.class.layout.each do |key, _, _, per_instance|
+            attr << key if per_instance
+          end
+
+          pretty_print_attributes q, attr
+        end
+      end
+
       # Creates a new Vertex class with a custom layout. Layout is an array of
-      # arrays, where each row contains 3 elements:
+      # arrays, where each row contains 3 or 4 elements:
       #
       # 1. Attribute name in Ruby
       # 2. Attribute name in GLSL shaders
       # 3. Attribute type, one of the following symbols: float, int, ubyte,
       #    bool, color, vector2, vector3.
+      # 4. Whether the attribute is only accessibel on a per-instance basis (as
+      #    opposed to per-vertex, which is the default)
       #
       # Getters and setters are created for all of the attributes.
       #
@@ -23,10 +59,13 @@ module Ray
       #     [:bool,    "in_Bool",     :bool],
       #     [:color,   "in_Color",    :color],
       #     [:vector2, "in_Vector2",  :vector2],
-      #     [:vector3, "in_Vector3",  :vector3]
+      #     [:vector3, "in_Vector3",  :vector3],
+      #
+      #     # per-instance data
+      #     [:instance_color, "magic", :color, true]
       #   ]
       def self.make(layout)
-        layout.each do |_, _, type|
+        layout.each do |_, _, type, _|
           unless TypeMap.has_key? type
             raise ArgumentError, "unknown type in a vertex: #{type.inspect}"
           end
@@ -40,6 +79,20 @@ module Ray
           @vertex_type_size   = Vertex.size(vtype)
           @vertex_type_layout = layout
 
+          if layout.any? { |_, _, _, per_instance| per_instance }
+            const_set :Instance, Class.new(Ray::GL::Vertex::Instance) {
+              @vertex_instance_type_id = vtype
+              @vertex_instance_size    = Vertex.instance_size(vtype)
+              @vertex_instance_layout  = layout
+
+              class << self
+                undef instance_classes
+              end
+
+              Vertex.define_layout self, layout, vtype, true
+            }
+          end
+
           class << self
             undef make
             undef make_type
@@ -47,18 +100,51 @@ module Ray
             undef offset_of
           end
 
+          Vertex.define_layout self, layout, vtype, false
+        end
+
+        if @vertex_classes[vtype].const_defined? :Instance
+          Instance.instance_classes[vtype] = @vertex_classes[vtype]::Instance
+        end
+
+        @vertex_classes[vtype]
+      end
+
+      def self.layout
+        @vertex_type_layout
+      end
+
+      def self.default_for(type)
+        case type
+        when :float, :int, :ubyte then 0
+        when :bool                then true
+        when :vector2             then Ray::Vector2[0, 0]
+        when :vector3             then Ray::Vector3[0, 0, 0]
+        when :color               then Ray::Color.white
+        end
+      end
+
+      def self.define_layout(on, layout, vtype, instance = false)
+        argument_layout = layout.reject do |_, _, _, per_instance|
+          per_instance ^ instance
+        end
+
+        on.class_eval do
           define_method :initialize do |*args|
             if args.size > layout.size
-              raise ArgumentError, "wrong number of arguments: %d for %d",
-                args.size, layout.size
+              msg = "wrong number of arguments: #{args.size} for" <<
+                " #{layout.size}"
+              raise ArgumentError, msg
             end
 
-            layout.each_with_index do |(attr, _, type), i|
-              send("#{attr}=", args[i] || default_for(type))
+            argument_layout.each_with_index do |(attr, _, type, _), i|
+              send("#{attr}=", args[i] || Vertex.default_for(type))
             end
           end
 
-          layout.each_with_index do |(attr, _, type), i|
+          layout.each_with_index do |(attr, _, type, per_instance), i|
+            next if per_instance ^ instance
+
             offset = Vertex.offset_of(vtype, i)
 
             # Faster than define_method.
@@ -77,29 +163,22 @@ module Ray
         end
       end
 
-      def self.layout
-        @vertex_type_layout
-      end
-
       def to_s
-        "#<#{self.class} #{pairs}>"
-      end
+        pairs = []
+        self.class.layout.each do |key, _, _, per_instance|
+          pairs << "#{key}=#{send(key)}" unless per_instance
+        end
 
-      def pairs
-        self.class.layout.map { |key, _, _|
-          "#{key}=#{send(key)}"
-        }.join " "
+        "#<#{self.class} #{pairs.join " "}>"
       end
 
-      private
-      def default_for(type)
-        case type
-        when :float, :int, :ubyte then 0
-        when :bool                then true
-        when :vector2             then Ray::Vector2[0, 0]
-        when :vector3             then Ray::Vector3[0, 0, 0]
-        when :color               then Ray::Color.white
+      def pretty_print(q)
+        attr = []
+        self.class.layout.each do |key, _, _, per_instance|
+          attr << key unless per_instance
         end
+
+        pretty_print_attributes q, attr
       end
     end
   end