glimr 0.1.0

data/lib/glimr/renderer/shader.rb

@@ -0,0 +1,14 @@
+require 'glimr/renderer/sceneobject'
+
+
+module GlimR
+
+  class Shader < SceneObject
+    
+    def replace!(other)
+      self
+    end
+    
+  end
+
+end

data/lib/glimr/renderer/texture.rb

@@ -0,0 +1,280 @@
+require 'glimr/renderer/sceneobject'
+
+begin
+  require 'sdl'
+  $sdl = true
+rescue LoadError
+  begin
+    require 'imlib2'
+    $imlib = true
+  rescue LoadError
+    begin
+      require 'RMagick'
+      $rmagick = true
+    rescue LoadError
+      warn "Couldn't load any image loading library."
+      warn "Trying to load images will fail."
+      warn "Install one of SDL, Ruby-Imlib2, or RMagick to fix this."
+    end
+  end
+end
+
+module GlimR
+
+
+  # A Texture is a wrapper around an OpenGL texture object.
+  # It generates a texture id when it is first used.
+  #
+  # To load a texture from an image file, use Texture.load(image_filename)
+  # or Texture#load(image_filename).
+  #
+  # The #width and #height of a texture refer to the dimensions of the
+  # loaded image, while the #bound of a texture is the closest containing
+  # power of two for the image dimensions (as in, the texture dimensions
+  # are a power of two square, inside which the image is stamped.)
+  #
+  # The #mode of a texture is GL::TEXTURE_2D. If feeling particularly
+  # adventurous, extend the class to do rectangular textures, non-power-of-two
+  # textures, 1D and 3D textures.
+  #
+  # Uses SDL, Imlib2, or RMagick to load images. If you have none of these,
+  # trying to load texture images will fail.
+  #
+  class Texture < SceneObject
+
+    attr_accessor :width, :height, :mode, :pixels, :bound
+    attr_reader :tex_id, :filename
+
+    def default_config
+      super.merge(
+        :mode => TEXTURE_2D,
+        :width => 0, :height => 0
+      )
+    end
+
+    # Creates a new Texture from the given image filename.
+    def self.load(filename)
+        t = new
+        t.load(filename)
+        t
+    end
+
+    def initialize(*a, &b)
+      @tex_id = []
+      super
+    end
+
+    # The collapsed texture for a texture is the texture itself.
+    def absolute_texture
+      self
+    end
+
+    # Loads the image filename into the texture.
+    def load(filename)
+      if $sdl
+        surf = SDL::Surface.load(filename.to_s)
+        if surf.bpp < 32
+          rmask = 0xff000000
+          gmask = 0x00ff0000
+          bmask = 0x0000ff00
+          amask = 0x000000ff
+          image = SDL::Surface.new(
+              SDL::SWSURFACE|SDL::SRCALPHA,
+              surf.w, surf.h, 32,
+              amask,bmask,gmask,rmask)
+          image.put(surf,0,0)
+        else
+          image = surf
+        end
+        w = image.w
+        h = image.h
+        px = image.pixels
+      elsif $imlib
+        image = Imlib2::Image.load(filename.to_s)
+        w = image.width
+        h = image.height
+        px = image.data.gsub(/(.)(.)(.)(.)/, '\2\3\4\1')
+      elsif $rmagick
+        image = Magick::Image.read(filename.to_s).first
+        w = image.width
+        h = image.height
+        px = image.to_blob{|i|
+          i.format = "RGBA"
+          i.depth = 8
+        }
+      end
+      @filename = filename
+      self.mode = TEXTURE_2D
+      self.width = w.to_i
+      self.height = h.to_i
+      self.pixels = px + ""
+    end
+
+    # Deletes the OpenGL texture object.
+    def finish
+      DeleteTextures(@tex_id)
+      @tex_id.clear
+    end
+
+    # Bind tex_id as the OpenGL texture and upload the texture if it has been changed
+    # since last use.
+    def apply
+      return unless pixels
+      Enable(mode)
+      if not @tex_id[0]
+        @tex_id[0] = GenTextures(1)[0]
+        push_state
+          BindTexture(mode, @tex_id[0])
+          upload_texture
+        pop_state
+      end
+      BindTexture(mode, @tex_id[0])
+      upload_texture if @changed
+    end
+
+    def power_of_two?(n)
+      (n & (n - 1) == 0)
+    end
+
+    def width= w
+      @bound = nil if @width != w
+      @width = w
+    end
+
+    def height= h
+      @bound = nil if @height != h
+      @height = h
+    end
+
+    def pixels= px
+      @changed = true
+      @pixels = px
+    end
+
+    # Pushes GL::TEXTURE_BIT to attrib stack.
+    def push_state
+      PushAttrib(TEXTURE_BIT)
+    end
+
+    # Pops the GL attrib stack.
+    def pop_state
+      PopAttrib()
+    end
+
+    # Returns the smallest power of two that is
+    # larger or equal to the larger of width and height.
+    #
+    def bound
+      b = [width, height].max
+      if not power_of_two?(b)
+        pow = (0..12).find{|i| 2**i > b}
+        b = 2**pow
+      end
+      b
+    end
+
+    # Uploads the texture to OpenGL.
+    # Uses TexImage2D if the texture dimensions have
+    # changed since last upload, otherwise uses TexSubImage2D.
+    #
+    def upload_texture
+      if !@bound
+        @bound = self.bound
+        @bound_pixels = "\000"*(4*@bound*@bound)
+        TexImage2D(
+          mode, 0, 4,
+          @bound, @bound, 0,
+          RGBA,
+          UNSIGNED_BYTE,
+          @bound_pixels
+        )
+      end
+      TexSubImage2D(
+        mode, 0,
+        0, 0, width, height,
+        RGBA,
+        UNSIGNED_BYTE,
+        pixels
+      )
+      TexParameteri(mode, TEXTURE_WRAP_S, CLAMP)
+      TexParameteri(mode, TEXTURE_WRAP_T, CLAMP)
+      TexParameteri(mode, TEXTURE_MIN_FILTER, LINEAR)
+      TexParameteri(mode, TEXTURE_MAG_FILTER, LINEAR)
+      @changed = false
+    end
+
+    # Replace main instance variables with the other's.
+    # Namely: @tex_id, @bound, @bound_pixels, @width, @height, @pixels, @changed, @mode.
+    #
+    # Use this to swap a texture for another when you want to preserve the rest of the state.
+    #
+    # But beware, the current texture is lost unless you copy it somewhere else first.
+    #
+    # E.g.
+    #   t = Texture.load 'foo.jpg'
+    #   backup = Texture.new
+    #   backup.replace! deep_texture_node
+    #   deep_texture_node.replace! t
+    #
+    def replace!(other)
+      @tex_id = other.tex_id
+      @bound = other.instance_variable_get(:@bound)
+      @bound_pixels = other.instance_variable_get(:@bound_pixels)
+      @width = other.instance_variable_get(:@width)
+      @height = other.instance_variable_get(:@height)
+      @pixels = other.instance_variable_get(:@pixels)
+      @changed = other.instance_variable_get(:@changed)
+      @mode = other.instance_variable_get(:@mode)
+      self
+    end
+
+    touching :touch!, :replace!, :pixels=, :width=, :height=, :mode=, :bound=
+
+    def inspect
+      "#<#{self.class.name}:#{hash}:TEXID#@tex_id:FILE:#@filename:MODE#@mode:W#@width:H#@height:B#@bound>"
+    end
+
+  end
+
+
+end
+
+
+
+class String
+
+  def unpremultiply!
+    if MAC_OS_X
+      i = 0
+      while i < size
+        a = self[i+3]
+        a2 = a / 2
+        if a > 0
+          r = self[i]
+          self[i] = (self[i+2] * 255 + a2) / a
+          self[i+1] = (self[i+1] * 255 + a2) / a
+          self[i+2] = (r * 255 + a2) / a
+        end
+        i += 4
+      end
+    else
+      i = 0
+      while i < size
+        r = self[i+1]
+        g = self[i+2]
+        b = self[i+3]
+        a = self[i]
+        if a > 0
+          self[i] = (r * 255 + a / 2) / a
+          self[i+1] = (g * 255 + a / 2) / a
+          self[i+2] = (b * 255 + a / 2) / a
+        end
+        self[i+3] = a
+        i += 4
+      end
+    end
+    self
+  end
+
+end
+

data/lib/glimr/renderer/transform.rb

@@ -0,0 +1,322 @@
+require 'matrix'
+require 'glimr/renderer/sceneobject'
+
+
+class Vector
+
+  # Returns the vector cross product of two vectors.
+  #
+  def cross_product(v)
+    Vector[
+      self[1]*v[2] - self[2]*v[1], 
+      self[2]*v[0] - self[0]*v[2], 
+      self[0]*v[1] - self[1]*v[0]
+    ]
+  end
+  
+  # Normalizes the vector to unit length.
+  #
+  def normalize
+    self * (1.0 / r)
+  end
+
+end
+
+
+module GlimR
+
+  # Transform is a SceneObject that handles OpenGL transformations.
+  #
+  # It has a rotation, scale, position and matrix, These are applied in the
+  # following order: first translate, then scale, then rotate, then multiply by matrix.  
+  # 
+  class Transform < SceneObject
+    
+    attr_accessor :matrix, :collapsed_matrix
+
+    attr_reader :rotation, :scale, :position
+    
+    # Creates a new Transform with position set to [x,y,z].
+    def self.translate(x,y=x,z=0)
+      t = new
+      t.position = [x,y,z]
+      t
+    end
+    
+    # Creates a new Transform with scale set to [x,y,z].
+    def self.scale(x,y=x,z=x)
+      t = new
+      t.scale = [x,y,z]
+      t
+    end
+    
+    # Creates a new Transform with rotation set to r.
+    def self.rotate(r)
+      t = new
+      t.rotation = r
+      t
+    end
+    
+    # Creates a new rotation Transform based on the given angle-axis rotation.
+    def self.rotate_aa(angle_deg, x=0,y=0,z=1)
+      rotate AngleAxis[angle_deg,x,y,z]
+    end
+    
+    # Creates a new rotation Transform based on the given quaternion rotation.
+    def self.rotate_quat(w,x,y,z)
+      rotate Quaternion[w,x,y,z]
+    end
+    
+    def default_config
+      super.merge(
+        :position => [0,0,0],
+        :rotation => AngleAxis[0,0,0,1],
+        :scale => [1,1,1],
+        :changed => true
+      )
+    end
+    
+    # Sets scale to sca.
+    # If sca is a Numeric, sets all dimension scale factors to sca.
+    # If the sca array has only two members, uses 1 for z.
+    #
+    def scale= sca
+      if sca.is_a? Array
+        sca[2] ||= 1
+      elsif sca.is_a? Numeric
+        sca = [sca,sca,sca]
+      end
+      @scale = sca
+    end
+    
+    # Sets position to pos. If the pos array has only two members, uses 0 for z.
+    def position= pos
+      pos[2] ||= 0 if pos.is_a? Array
+      @position = pos
+    end
+    
+    # Sets rotation to rot. If rot is a number, sets the rotation angle to rot.
+    def rotation= rot
+      if rot.is_a? Numeric
+        @rotation = @rotation.to_aa
+        @rotation[0] = rot
+      else
+        @rotation = rot
+      end
+    end
+    
+    def x
+      @position[0]
+    end
+    
+    def y
+      @position[1]
+    end
+    
+    def z
+      @position[2]
+    end
+    
+    def x= nx
+      @position[0] = nx
+    end
+    
+    def y= ny
+      @position[1] = ny
+    end
+    
+    def z= nz
+      @position[2] = nz
+    end
+    
+    def angle
+      @rotation.to_aa[0]
+    end
+    
+    def angle= a
+      self.rotation = a
+    end
+    
+    # Adds the given coordinates to position.
+    def translate(x,y=0,z=0)
+      tl = [x,y,z]
+      tl = x if x.is_a? Array
+      self.position = @position.zip(tl).map{|a,b| a+b}
+    end
+    
+    # Sets transform matrix to m.
+    def matrix= m
+      if @matrix and m.is_a? Array
+        @matrix.replace(m.map{|i|i.to_f})
+      else
+        @matrix = m
+      end
+    end
+
+    # Pushes the OpenGL matrix stack.
+    def push_state
+      PushMatrix()
+    end
+    
+    # Pops OpenGL matrix stack.
+    def pop_state
+      PopMatrix()
+    end
+    
+    # Applies the Transform to the current OpenGL transform matrix.
+    def apply
+      if @collapsed_matrix
+        MultMatrix(@collapsed_matrix)
+      else
+        gl_transform
+      end
+    end
+    
+    # Collapses the transform into a single transform matrix and returns it.
+    def collapse!
+      PushMatrix()
+        LoadIdentity()
+        gl_transform
+        @collapsed_matrix = GetDoublev(MODELVIEW_MATRIX).flatten
+      PopMatrix()
+      @absolute_transform = false
+      @collapsed_matrix
+    end
+    
+    # Apply position, scale, rotation and matrix to OpenGL state.
+    def gl_transform
+      Translate(*position) if @position
+      Scale(*scale) if @scale
+      Rotate(*rotation) if @rotation
+      MultMatrix(*matrix) if @matrix
+    end
+    
+    # Compares two transformations by their transformations.
+    def ===(t)
+      return super unless t.is_a?(Transform)
+      matrix == t.matrix and position == t.position and scale == t.scale and rotation == t.rotation
+    end
+
+    # The absolute transform for a Transform is the parent's absolute transform multiplied with the current transform's collapsed matrix.
+    def absolute_transform
+      return parent.absolute_transform unless (@position or @scale or @rotation or @matrix or @collapsed_matrix)
+      collapse! unless @collapsed_matrix
+      if not (@absolute_transform and @parent_absolute_transform == (parent and (parent.absolute_transform)))
+        @parent_absolute_transform = (parent and (parent.absolute_transform))
+        PushMatrix()
+          LoadMatrix(@parent_absolute_transform) if @parent_absolute_transform
+          MultMatrix(@collapsed_matrix)
+          @absolute_transform = GetDoublev(MODELVIEW_MATRIX)
+        PopMatrix()
+      end
+      @absolute_transform
+    end
+
+    # Clears collapsed matrix.
+    def touch!(*a)
+      super
+      @collapsed_matrix = false
+    end
+    
+    # Clones instance variables as well.
+    def clone(*a)
+      c = super
+      c.instance_variable_set(:@position, @position.clone) if @position
+      c.instance_variable_set(:@scale, @scale.clone) if @scale
+      c.instance_variable_set(:@rotation, @rotation.clone) if @rotation
+      c.instance_variable_set(:@matrix, @matrix.clone) if @matrix
+      c.instance_variable_set(:@collapsed_matrix, @collapsed_matrix.clone) if @collapsed_matrix
+      c
+    end
+    
+    # Replaces ivars with the other's.
+    def replace!(other)
+      @position = other.position
+      @scale = other.scale
+      @rotation = other.rotation
+      @matrix = other.matrix
+      @collapsed_matrix = other.collapsed_matrix
+      @absolute_transform = other.instance_variable_get(:@absolute_transform)
+      @parent_absolute_transform = other.instance_variable_get(:@parent_absolute_transform)
+      self
+    end
+
+    touching :touch!, :replace!, :rotation=, :scale=, :position=, :matrix=, :x=, :y=, :z=, :angle=
+
+    def inspect
+      "#<#{self.class.name}:#{hash}:POS#@position:ROT#@rotation:SCA#@scale:MAT#@matrix>"
+    end
+    
+  end
+
+
+  class Quaternion < Array
+    
+    def self.[](w,x,y,z)
+      aa = new
+      aa.push(w,x,y,z)
+      aa
+    end
+    
+    def normalize
+      self.class[*(Vector[*self] * (1.0 / Vector[*self].r)).to_a]
+    end
+    
+    def to_matrix
+      w,x,y,z = normalize
+      [
+        [1-2*y*y-2*z*z,  2*x*y-2*w*z,  2*z*x+2*w*y, 0],
+        [2*x*y+2*w*z,  1-2*x*x-2*z*z,  2*y*z-2*w*x, 0],
+        [2*z*x-2*w*y,  2*y*z+2*w*x,  1-2*x*x-2*y*y, 0],
+        [0,0,0,1]
+      ].transpose.flatten
+    end
+    
+    def to_aa
+      w,x,y,z = normalize
+      c = w
+      angle = (Math.acos(c) * 2) * (180/Math::PI)
+      s = Math.sqrt( 1 - c*c )
+      s = 1 if (s.abs < 0.0005)      
+      AngleAxis[angle, x/s, y/s, z/s]
+    end
+    
+    def to_quat
+      self
+    end
+    
+  end
+  
+
+  class AngleAxis < Array
+    
+    def self.[](a,x,y,z)
+      aa = new
+      aa.push(a,*normalize(Vector[x,y,z]))
+      aa
+    end
+    
+    def to_quat
+      a,x,y,z = normalize
+      s = Math.sin(a*Math::PI/90)
+      c = Math.cos(a*Math::PI/90)
+      Quaternion[c, x*s, y*s, z*s]
+    end
+
+    def to_aa
+      self
+    end
+
+    def normalize
+      self.class[*self]
+    end
+
+    def self.normalize(v)
+      v = (v * (1.0 / v.r)).to_a if (v.r - 1) > 0.001
+      v.to_a
+    end
+
+  end
+
+
+end