bvh 1.0.0 → 1.0.1

data/lib/bvh/exporter.rb

@@ -1,86 +1,86 @@
-class Bvh
-  class Exporter
-    attr_reader :filename
-    attr_reader :source
-
-    def initialize(file)
-      @filename = file
-    end
-
-    def export(bvh)
-      #raise "File exists" if File.exist?(filename)
-      unless bvh.frame_count == 0
-        raise ArgumentError, "Frame time is 0; this would result in infinite FPS!" if bvh.frame_time == 0
-        raise ArgumentError, "Frame time is #{bvh.frame_time}! Should be a positive number." if bvh.frame_time < 0
-      end
-      @bvh = bvh
-      File.open(filename, "w+") do |file|
-        @file = file
-        file.puts "HIERARCHY"
-        bvh.skeletons.each { |skel| export_skeleton(skel) }
-        export_motion(bvh.motion)
-        file.puts # end with a blank line
-      end
-    end
-
-    private
-    attr_reader :bvh, :file
-
-    # export HIERARCHY data
-    def export_skeleton(skele)
-      export_root skele.root
-    end
-
-    # export ROOT node and its joints
-    def export_root(root)
-      file.puts "ROOT #{root.name}"
-      file.puts "{"
-      export_bone_data(root)
-      file.puts "}"
-    end
-
-    # export JOINT node, or End Site if joint has no joints
-    # level defines number of preceding tab stops
-    def export_joint(bone, level = 1)
-      tabs = "\t"*level
-      header = if bone.end_site? then "End Site"
-      else "JOINT #{bone.name}" 
-      end
-      file.puts "#{tabs}#{header}"
-      file.puts "#{tabs}{"
-      export_bone_data(bone, level)
-      file.puts "#{tabs}}"
-    end
-
-    # exports bone data, regardless of type, including its joints
-    # level defines number of preceding tab stops
-    def export_bone_data(bone, level = 0)
-      level += 1 # we're within a node, so it's one more tab than expected
-      tabs = "\t"*level
-      file.puts "#{tabs}OFFSET\t #{bone.offset.collect { |i| "%.6f" % i }.join("\t ")}"
-      if bone.channels.length > 0
-        chans = bone.channels.join(" ")
-        file.puts("#{tabs}CHANNELS #{bone.channels.length} #{chans}")
-      end
-      bone.joints.each { |joint| export_joint(joint, level) }
-    end
-
-    # export MOTION data
-    def export_motion(motion)
-      file.puts "MOTION"
-      file.puts "Frames: #{motion.frame_count}"
-      file.puts "Frame Time: #{motion.frame_time}"
-      motion.frames.each do |frame|
-        line = ""
-        # chan.bone.channels vs. chan.channels to maintain order
-        frame.channel_data.each do |channel_data|
-          channel_data.bone.channels.each do |i|
-            chan = "%.6f" % channel_data[i]
-            line = "#{line}#{chan}\t"
-          end
-        end
-        file.puts line.strip
-      end
-    end
-  end
-end
+class Bvh
+  class Exporter
+    attr_reader :filename
+    attr_reader :source
+
+    def initialize(file)
+      @filename = file
+    end
+
+    def export(bvh)
+      #raise "File exists" if File.exist?(filename)
+      unless bvh.frame_count == 0
+        raise ArgumentError, "Frame time is 0; this would result in infinite FPS!" if bvh.frame_time == 0
+        raise ArgumentError, "Frame time is #{bvh.frame_time}! Should be a positive number." if bvh.frame_time < 0
+      end
+      @bvh = bvh
+      File.open(filename, "w+") do |file|
+        @file = file
+        file.puts "HIERARCHY"
+        bvh.skeletons.each { |skel| export_skeleton(skel) }
+        export_motion(bvh.motion)
+        file.puts # end with a blank line
+      end
+    end
+
+    private
+    attr_reader :bvh, :file
+
+    # export HIERARCHY data
+    def export_skeleton(skele)
+      export_root skele.root
+    end
+
+    # export ROOT node and its joints
+    def export_root(root)
+      file.puts "ROOT #{root.name}"
+      file.puts "{"
+      export_bone_data(root)
+      file.puts "}"
+    end
+
+    # export JOINT node, or End Site if joint has no joints
+    # level defines number of preceding tab stops
+    def export_joint(bone, level = 1)
+      tabs = "\t"*level
+      header = if bone.end_site? then "End Site"
+      else "JOINT #{bone.name}" 
+      end
+      file.puts "#{tabs}#{header}"
+      file.puts "#{tabs}{"
+      export_bone_data(bone, level)
+      file.puts "#{tabs}}"
+    end
+
+    # exports bone data, regardless of type, including its joints
+    # level defines number of preceding tab stops
+    def export_bone_data(bone, level = 0)
+      level += 1 # we're within a node, so it's one more tab than expected
+      tabs = "\t"*level
+      file.puts "#{tabs}OFFSET\t #{bone.offset.collect { |i| "%.6f" % i }.join("\t ")}"
+      if bone.channels.length > 0
+        chans = bone.channels.join(" ")
+        file.puts("#{tabs}CHANNELS #{bone.channels.length} #{chans}")
+      end
+      bone.joints.each { |joint| export_joint(joint, level) }
+    end
+
+    # export MOTION data
+    def export_motion(motion)
+      file.puts "MOTION"
+      file.puts "Frames: #{motion.frame_count}"
+      file.puts "Frame Time: #{motion.frame_time}"
+      motion.frames.each do |frame|
+        line = ""
+        # chan.bone.channels vs. chan.channels to maintain order
+        frame.channel_data.each do |channel_data|
+          channel_data.bone.channels.each do |i|
+            chan = "%.6f" % channel_data[i]
+            line = "#{line}#{chan}\t"
+          end
+        end
+        file.puts line.strip
+      end
+    end
+  end
+end

data/lib/bvh/matrix.rb

@@ -1,19 +1,19 @@
-require 'matrix'
-
-# This adds a few methods to the default Ruby Matrix implementation.
-class Matrix
-  # Sets row "i", column "j", to the value "x".
-  def []=(i,j,x)
-    @rows[i][j] = x
-  end
-
-  # Turns this matrix into an identity matrix, erasing all previous values.
-  def load_identity!
-    row_size.times do |r|
-      column_size.times do |c|
-        self[r, c] = (r == c ? 1 : 0)
-      end
-    end
-    self
-  end
-end
+require 'matrix'
+
+# This adds a few methods to the default Ruby Matrix implementation.
+class Matrix
+  # Sets row "i", column "j", to the value "x".
+  def []=(i,j,x)
+    @rows[i][j] = x
+  end
+
+  # Turns this matrix into an identity matrix, erasing all previous values.
+  def load_identity!
+    row_size.times do |r|
+      column_size.times do |c|
+        self[r, c] = (r == c ? 1 : 0)
+      end
+    end
+    self
+  end
+end

data/lib/bvh/motion.rb

@@ -1,79 +1,79 @@
-class Bvh
-  class Motion
-    # The amount of time that passes for each frame. Most BVH files have this set to 0.0333, or 30 frames per second.
-    # The following calculations might also be useful to you:
-    #    frame_time = 1 / frames_per_second   # =>  0.0333 = 1 / 30
-    #    frames_per_second = 1 / frame_time   # =>  30 = 1 / 0.0333
-    attr_accessor :frame_time
-
-    # The array of frames in this animation. You can modify this directly if you wish.
-    attr_reader :frames
-
-    # Returns the frames per second calculated by (1 / frame_time)
-    def frames_per_second; 1 / frame_time; end
-
-    # Assigns the frame_time by calculating it from (1 / frames_per_second)
-    def frames_per_second=(a); self.frame_time = 1 / a; end
-
-    def initialize
-      @frames = []
-    end
-
-    # Returns the number of frames in this animation.
-    def frame_count
-      frames.length
-    end
-
-    # Adds the specified frame or frames to the end of this animation.
-    def add_frame(*frames)
-      self.frames.concat frames.flatten
-    end
-
-    # Creates a single frame that is an exact copy of the last frame in this animation.
-    def create_frame
-      frames.last.copy
-    end
-
-    # Creates N frames via #create_frame.
-    def create_frames(n)
-      r = []
-      n.times { r << create_frame }
-      r
-    end
-
-    # Creates enough frames to fill the specified number of seconds, adds them to the animation, and returns self.
-    #
-    # target_frame is the state at which the animation should be in upon reaching the final frame of the alotted time.
-    # If it contains data that is different from the last frame in this animation, then the result will be an
-    # interpolation between the two over the course of the alotted time.
-    #
-    # You can use this method to specify key points in the animation, and produce a fluid result.
-    def add_time(seconds, target_frame = frames.last)
-      raise "Can't calculate frames from seconds: frame_time is zero!" if frame_time == 0
-      num_frames = (seconds / frame_time).to_i
-      return self if num_frames == 0
-
-      # buf holds the amount to change each frame
-      buf = (frames.last - target_frame) / num_frames.to_f
-
-      num_frames.times do |i|
-        if i == (num_frames-1) then add_frame(target_frame.copy) # last iteration, last frame... we can cheat.
-        else add_frame(create_frame + buf) # create_frame clones the last frame, and buf moves it closer to target
-        end
-      end
-
-      self
-    end
-
-    # Chops the specified amount of time off of the end of this animation and then returns self.
-    def truncate_time(seconds)
-      raise "Can't calculate frames from seconds: frame_time is zero!" if frame_time == 0
-      num_frames = (seconds / frame_time).to_i
-      return self if num_frames == 0
-      frames[-1..-num_frames].each { |i| frames.delete i }
-      self
-    end
-
-    alias add_frames add_frame
-  end
-end
+class Bvh
+  class Motion
+    # The amount of time that passes for each frame. Most BVH files have this set to 0.0333, or 30 frames per second.
+    # The following calculations might also be useful to you:
+    #    frame_time = 1 / frames_per_second   # =>  0.0333 = 1 / 30
+    #    frames_per_second = 1 / frame_time   # =>  30 = 1 / 0.0333
+    attr_accessor :frame_time
+
+    # The array of frames in this animation. You can modify this directly if you wish.
+    attr_reader :frames
+
+    # Returns the frames per second calculated by (1 / frame_time)
+    def frames_per_second; 1 / frame_time; end
+
+    # Assigns the frame_time by calculating it from (1 / frames_per_second)
+    def frames_per_second=(a); self.frame_time = 1 / a; end
+
+    def initialize
+      @frames = []
+    end
+
+    # Returns the number of frames in this animation.
+    def frame_count
+      frames.length
+    end
+
+    # Adds the specified frame or frames to the end of this animation.
+    def add_frame(*frames)
+      self.frames.concat frames.flatten
+    end
+
+    # Creates a single frame that is an exact copy of the last frame in this animation.
+    def create_frame
+      frames.last.copy
+    end
+
+    # Creates N frames via #create_frame.
+    def create_frames(n)
+      r = []
+      n.times { r << create_frame }
+      r
+    end
+
+    # Creates enough frames to fill the specified number of seconds, adds them to the animation, and returns self.
+    #
+    # target_frame is the state at which the animation should be in upon reaching the final frame of the alotted time.
+    # If it contains data that is different from the last frame in this animation, then the result will be an
+    # interpolation between the two over the course of the alotted time.
+    #
+    # You can use this method to specify key points in the animation, and produce a fluid result.
+    def add_time(seconds, target_frame = frames.last)
+      raise "Can't calculate frames from seconds: frame_time is zero!" if frame_time == 0
+      num_frames = (seconds / frame_time).to_i
+      return self if num_frames == 0
+
+      # buf holds the amount to change each frame
+      buf = (frames.last - target_frame) / num_frames.to_f
+
+      num_frames.times do |i|
+        if i == (num_frames-1) then add_frame(target_frame.copy) # last iteration, last frame... we can cheat.
+        else add_frame(create_frame + buf) # create_frame clones the last frame, and buf moves it closer to target
+        end
+      end
+
+      self
+    end
+
+    # Chops the specified amount of time off of the end of this animation and then returns self.
+    def truncate_time(seconds)
+      raise "Can't calculate frames from seconds: frame_time is zero!" if frame_time == 0
+      num_frames = (seconds / frame_time).to_i
+      return self if num_frames == 0
+      frames[-1..-num_frames].each { |i| frames.delete i }
+      self
+    end
+
+    alias add_frames add_frame
+  end
+end

data/lib/bvh/motion/channel_data.rb

@@ -1,147 +1,147 @@
-class Bvh
-  class Motion
-    class ChannelData < Hash
-      # The bone that is related to this channel data.
-      attr_reader :bone
-
-      def initialize(bone, *args, &block)
-        @bone = bone
-        super(*args, &block)
-      end
-
-      # call-seq:
-      #   channel_data + channel_data  => new_channel_data
-      #   channel_data - channel_data  => new_channel_data
-      #   channel_data / channel_data  => new_channel_data
-      #   channel_data * channel_data  => new_channel_data
-      #   channel_data + number => new_channel_data
-      #   channel_data - number => new_channel_data
-      #   channel_data / number => new_channel_data
-      #   channel_data * number => new_channel_data
-      #
-      # Performs arithmetic on this frame with the target. The second operand may be either a number or another
-      # ChannelData. If the target is a number, then that number is added to, subtracted from, multiplied with, or
-      # divided against each channel of this ChannelData.
-      #
-      # If the target is another ChannelData, the arithmetic looks something like this:
-      #   return_value['Xposition'] = channel_data_one['Xposition'] * channel_data_two['Xposition']
-      #   return_value['Yposition'] = channel_data_one['Yposition'] * channel_data_two['Yposition']
-      #   return_value['Zposition'] = channel_data_one['Zposition'] * channel_data_two['Zposition']
-      #   . . .
-      #
-      # Both objects must contain the same number of channels, and must also reference the same bone.
-      #
-      # Returns a new instance of ChannelData containing the result.
-      #
-      def arithmetic_proc(target)
-        # Fooled you again! I metaprogrammed it to save some typing!
-      end
-      undef arithmetic_proc
-
-      [:+, :-, :/, :*].each do |operator|
-        define_method operator do |target|
-          ret = ChannelData.new(bone)
-          if target.kind_of?(ChannelData)
-            target.each { |key, value| ret[key] = 0.send(operator, value) }
-            self.each do |key, value|
-              ret[key] = value.send(operator, 0)
-              ret[key] = value.send(operator, target[key]) if target.key?(key)
-            end
-          else
-            self.each { |key, value| ret[key] = value.send(operator, target) }
-          end
-          ret
-        end
-      end
-
-      # Sets the specified channel to a value of theta, and then returns self.
-      def set_channel(channel, theta)
-        channel = channel.to_s if channel.kind_of? Symbol
-        raise "Channel not found: #{channel} (expected one of #{self.keys.inspect})" unless self.keys.include? channel
-        self[channel] = theta
-      end
-
-      # Retrieves and returns the specified channel datum, raising an error if its key is not found.
-      # If the channel key is a symbol, it is converted to a string before the lookup is performed.
-      def get_channel(channel)
-        channel = channel.to_s if channel.kind_of?(Symbol)
-        raise "Channel not found: #{channel} (expected one of #{self.keys.inspect})" unless self.keys.include?(channel)
-        self[channel]
-      end
-
-      # Modifies the specified channel datum, resulting in a rotation around the specified channel.
-      def rotate!(channel, theta)
-        theta = get_channel(channel)+theta
-        # this doesn't really have an effect, but may help keep the file from getting junked.
-        if theta >= 360 then theta %= 360
-        elsif theta <= -360 then theta %= -360
-        end
-        set_channel(channel, theta)
-      end
-
-      # Adds x, y and z to the X, Y and Z position channels, resulting in a "movement" or translation.
-      def translate!(x, y, z)
-        set_channel('Xposition', get_channel('Xposition')+x)
-        set_channel('Yposition', get_channel('Yposition')+y)
-        set_channel('Zposition', get_channel('Zposition')+z)
-      end
-
-      # Returns the transform matrix for this bone's channel data. See also
-      # Frame#relative_transform_matrix and Frame#absolute_transform_matrix.
-      #
-      # The resultant matrix needs to be multiplied against the parent bone's transform matrix in order
-      # to be accurate to worldspace. Otherwise it's only accurate in local space. If you're not sure what
-      # that means, then use Frame#absolute_transform_matrix instead.
-      def relative_transform_matrix()
-        # theta is retrieved from the set of numbers loaded from the BVH file, or is supplied directly
-        #
-        # R is the matrix calculated for a rotation of theta degrees around the vector V
-        #    This is performed on right, view and up vectors, multiplying the three matrices together
-        #    to construct the rotation matrix for this bone. Since the calculations are done in world
-        #    space, the right, up and view vectors are [1,0,0]; [0,1,0]; [0,0,1], respectively. No reason
-        #    we couldn't attach a Camera object to this bone and figure it out that way, but it'd actually
-        #    be more work to create and maintain the camera than to just calculate the matrix. Obviously,
-        #    the resultant matrix needs to be multiplied against the parent bone's rotation matrix in order
-        #    to be accurate to worldspace. Otherwise it's only accurate in local space.
-        #
-        # R = [tx^2 + c,  txy - sz,  txz + sy,  0]
-        #     [txy + sz,  ty^2 + c,  tyz - sx,  0]
-        #     [txz - sy,  tyz + sx,  tz^2 + c,  0]
-        #     [       0,         0,         0,  1]
-        #
-        # where c = cos theta,
-        #       s = sin theta,
-        #       t = 1 - c
-        # [x,y,z] = a unit vector on the axis of rotation
-
-        # bone.channels.each so that we don't lose order of operation
-        r = Matrix.identity(4)
-        bone.channels.each do |chan|
-          v = nil
-          case chan
-            when 'Xrotation' then v = [1,0,0] # right vector
-            when 'Yrotation' then v = [0,1,0] # up vector
-            when 'Zrotation' then v = [0,0,1] # view vector
-            else next # ignore nonrotational values. To my knowledge, this includes only position values.
-          end
-          theta = self[chan]
-          x, y, z = v
-          c, s, t = Math.cos(theta), Math.sin(theta), 1 - Math.cos(theta)
-          mat = Matrix.identity(4)
-          mat[0,0], mat[0,1], mat[0,2] = t*(x**2) + c, t*x*y - s*z, t*x*z + s*y
-          mat[1,0], mat[1,1], mat[1,2] = t*x*y + s*z, t*(y**2) + c, t*y*z - s*x
-          mat[2,0], mat[2,1], mat[2,2] = t*x*z - s*y, t*y*z + s*x, t*(z**2) + c
-          r *= mat
-        end
-
-        # Finally, the last row is simply set to the translation and/or bone offset.
-        r[0,3] = bone.offset[0] + (self.key?("Xposition") ? self['Xposition'] : 0)
-        r[1,3] = bone.offset[1] + (self.key?("Yposition") ? self['Yposition'] : 0)
-        r[2,3] = bone.offset[2] + (self.key?("Zposition") ? self['Zposition'] : 0)
-        r
-      end
-
-      alias local_transform_matrix relative_transform_matrix
-    end
-  end
-end
+class Bvh
+  class Motion
+    class ChannelData < Hash
+      # The bone that is related to this channel data.
+      attr_reader :bone
+
+      def initialize(bone, *args, &block)
+        @bone = bone
+        super(*args, &block)
+      end
+
+      # call-seq:
+      #   channel_data + channel_data  => new_channel_data
+      #   channel_data - channel_data  => new_channel_data
+      #   channel_data / channel_data  => new_channel_data
+      #   channel_data * channel_data  => new_channel_data
+      #   channel_data + number => new_channel_data
+      #   channel_data - number => new_channel_data
+      #   channel_data / number => new_channel_data
+      #   channel_data * number => new_channel_data
+      #
+      # Performs arithmetic on this frame with the target. The second operand may be either a number or another
+      # ChannelData. If the target is a number, then that number is added to, subtracted from, multiplied with, or
+      # divided against each channel of this ChannelData.
+      #
+      # If the target is another ChannelData, the arithmetic looks something like this:
+      #   return_value['Xposition'] = channel_data_one['Xposition'] * channel_data_two['Xposition']
+      #   return_value['Yposition'] = channel_data_one['Yposition'] * channel_data_two['Yposition']
+      #   return_value['Zposition'] = channel_data_one['Zposition'] * channel_data_two['Zposition']
+      #   . . .
+      #
+      # Both objects must contain the same number of channels, and must also reference the same bone.
+      #
+      # Returns a new instance of ChannelData containing the result.
+      #
+      def arithmetic_proc(target)
+        # Fooled you again! I metaprogrammed it to save some typing!
+      end
+      undef arithmetic_proc
+
+      [:+, :-, :/, :*].each do |operator|
+        define_method operator do |target|
+          ret = ChannelData.new(bone)
+          if target.kind_of?(ChannelData)
+            target.each { |key, value| ret[key] = 0.send(operator, value) }
+            self.each do |key, value|
+              ret[key] = value.send(operator, 0)
+              ret[key] = value.send(operator, target[key]) if target.key?(key)
+            end
+          else
+            self.each { |key, value| ret[key] = value.send(operator, target) }
+          end
+          ret
+        end
+      end
+
+      # Sets the specified channel to a value of theta, and then returns self.
+      def set_channel(channel, theta)
+        channel = channel.to_s if channel.kind_of? Symbol
+        raise "Channel not found: #{channel} (expected one of #{self.keys.inspect})" unless self.keys.include? channel
+        self[channel] = theta
+      end
+
+      # Retrieves and returns the specified channel datum, raising an error if its key is not found.
+      # If the channel key is a symbol, it is converted to a string before the lookup is performed.
+      def get_channel(channel)
+        channel = channel.to_s if channel.kind_of?(Symbol)
+        raise "Channel not found: #{channel} (expected one of #{self.keys.inspect})" unless self.keys.include?(channel)
+        self[channel]
+      end
+
+      # Modifies the specified channel datum, resulting in a rotation around the specified channel.
+      def rotate!(channel, theta)
+        theta = get_channel(channel)+theta
+        # this doesn't really have an effect, but may help keep the file from getting junked.
+        if theta >= 360 then theta %= 360
+        elsif theta <= -360 then theta %= -360
+        end
+        set_channel(channel, theta)
+      end
+
+      # Adds x, y and z to the X, Y and Z position channels, resulting in a "movement" or translation.
+      def translate!(x, y, z)
+        set_channel('Xposition', get_channel('Xposition')+x)
+        set_channel('Yposition', get_channel('Yposition')+y)
+        set_channel('Zposition', get_channel('Zposition')+z)
+      end
+
+      # Returns the transform matrix for this bone's channel data. See also
+      # Frame#relative_transform_matrix and Frame#absolute_transform_matrix.
+      #
+      # The resultant matrix needs to be multiplied against the parent bone's transform matrix in order
+      # to be accurate to worldspace. Otherwise it's only accurate in local space. If you're not sure what
+      # that means, then use Frame#absolute_transform_matrix instead.
+      def relative_transform_matrix()
+        # theta is retrieved from the set of numbers loaded from the BVH file, or is supplied directly
+        #
+        # R is the matrix calculated for a rotation of theta degrees around the vector V
+        #    This is performed on right, view and up vectors, multiplying the three matrices together
+        #    to construct the rotation matrix for this bone. Since the calculations are done in world
+        #    space, the right, up and view vectors are [1,0,0]; [0,1,0]; [0,0,1], respectively. No reason
+        #    we couldn't attach a Camera object to this bone and figure it out that way, but it'd actually
+        #    be more work to create and maintain the camera than to just calculate the matrix. Obviously,
+        #    the resultant matrix needs to be multiplied against the parent bone's rotation matrix in order
+        #    to be accurate to worldspace. Otherwise it's only accurate in local space.
+        #
+        # R = [tx^2 + c,  txy - sz,  txz + sy,  0]
+        #     [txy + sz,  ty^2 + c,  tyz - sx,  0]
+        #     [txz - sy,  tyz + sx,  tz^2 + c,  0]
+        #     [       0,         0,         0,  1]
+        #
+        # where c = cos theta,
+        #       s = sin theta,
+        #       t = 1 - c
+        # [x,y,z] = a unit vector on the axis of rotation
+
+        # bone.channels.each so that we don't lose order of operation
+        r = Matrix.identity(4)
+        bone.channels.each do |chan|
+          v = nil
+          case chan
+            when 'Xrotation' then v = [1,0,0] # right vector
+            when 'Yrotation' then v = [0,1,0] # up vector
+            when 'Zrotation' then v = [0,0,1] # view vector
+            else next # ignore nonrotational values. To my knowledge, this includes only position values.
+          end
+          theta = self[chan]
+          x, y, z = v
+          c, s, t = Math.cos(theta), Math.sin(theta), 1 - Math.cos(theta)
+          mat = Matrix.identity(4)
+          mat[0,0], mat[0,1], mat[0,2] = t*(x**2) + c, t*x*y - s*z, t*x*z + s*y
+          mat[1,0], mat[1,1], mat[1,2] = t*x*y + s*z, t*(y**2) + c, t*y*z - s*x
+          mat[2,0], mat[2,1], mat[2,2] = t*x*z - s*y, t*y*z + s*x, t*(z**2) + c
+          r *= mat
+        end
+
+        # Finally, the last row is simply set to the translation and/or bone offset.
+        r[0,3] = bone.offset[0] + (self.key?("Xposition") ? self['Xposition'] : 0)
+        r[1,3] = bone.offset[1] + (self.key?("Yposition") ? self['Yposition'] : 0)
+        r[2,3] = bone.offset[2] + (self.key?("Zposition") ? self['Zposition'] : 0)
+        r
+      end
+
+      alias local_transform_matrix relative_transform_matrix
+    end
+  end
+end