soby 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 269d82eee352fce114a0120f71fccaab7f25d02a
+  data.tar.gz: 06534754ac6193202a319cabaed39b3b4d9ca93d
+SHA512:
+  metadata.gz: bd29c3af78d994f2d0ed175a37cd272a0f8af53dac5579724b24b958e50f2df3a2de374210ea14a0b0307bc7ec4da919980d54adc93c33600c2235d1ae23ed74
+  data.tar.gz: d2eb41a775fe04d13157045f9550f23069002b6b91eb2467f4334648935aefce550fb18a6112022c44e768187f32b81b418838e0aad0e7fc6ed745f786434974

data/lib/soby/cam.rb

@@ -0,0 +1,103 @@
+
+  class Cam 
+
+    include_package 'processing.core'
+
+    attr_accessor :mat, :angle, :translation, :scale, :pre_translation, :post_translation
+    attr_accessor :quat 
+
+    @@interp = Processing::PMatrix3D.new
+
+    def initialize 
+      @scale = 1
+      @angle = 0;
+      @translation = PVector.new
+      @mat = PMatrix3D.new
+      @pre_translation = PVector.new
+      @post_translation = PVector.new
+
+      @is_computed = false
+    end 
+
+    ## TODO: check modif at
+    def compute_mat
+
+      puts "Warning Camera already computed " if @is_computed
+      return if @is_computed
+
+      @is_computed = true
+
+      @mat.reset
+
+      @mat.translate(@post_translation.x, @post_translation.y)
+      @mat.scale(@scale)
+
+      @mat.translate(@translation.x, @translation.y)
+      @mat.rotate(@angle)
+
+      @mat.translate(@pre_translation.x, @pre_translation.y)
+
+      @mat
+    end
+
+
+
+    # Value = 0 :  self,   value  = 1  : cam2
+    def lerp(cam2, value) 
+
+      complement = 1 - value
+
+      # puts "Value #{value} "
+      # puts "complement #{complement} "
+
+      interp = @@interp
+      interp.reset
+
+      interp.m00 = @mat.m00 * complement + cam2.mat.m00 * value
+      interp.m01 = @mat.m01 * complement + cam2.mat.m01 * value
+      interp.m02 = @mat.m02 * complement + cam2.mat.m02 * value
+      interp.m03 = @mat.m03 * complement + cam2.mat.m03 * value
+
+      interp.m10 = @mat.m10 * complement + cam2.mat.m10 * value
+      interp.m11 = @mat.m11 * complement + cam2.mat.m11 * value
+      interp.m12 = @mat.m12 * complement + cam2.mat.m12 * value
+      interp.m13 = @mat.m13 * complement + cam2.mat.m13 * value
+      
+      interp.m20 = @mat.m20 * complement + cam2.mat.m20 * value
+      interp.m21 = @mat.m21 * complement + cam2.mat.m21 * value
+      interp.m22 = @mat.m22 * complement + cam2.mat.m22 * value
+      interp.m23 = @mat.m23 * complement + cam2.mat.m23 * value
+      
+      interp.m30 = @mat.m30 * complement + cam2.mat.m30 * value
+      interp.m31 = @mat.m31 * complement + cam2.mat.m31 * value
+      interp.m32 = @mat.m32 * complement + cam2.mat.m32 * value
+      interp.m33 = @mat.m33 * complement + cam2.mat.m33 * value
+
+      interp
+
+    end
+
+    private
+    
+    def create_mat4x4(mat) 
+      Matrix4x4.new(mat.m00, mat.m01, mat.m02, mat.m03,\
+                    mat.m10, mat.m11, mat.m12, mat.m13,\
+                    mat.m20, mat.m21, mat.m22, mat.m23,\
+                    mat.m30, mat.m31, mat.m32, mat.m33)
+    end
+
+    def create_pmatrix(mat) 
+      PMatrix3D.new(mat[0][0], mat[0][1], mat[0][2], mat[0][3],\
+                    mat[1][0], mat[1][1], mat[1][2], mat[1][3],\
+                    mat[2][0], mat[2][1], mat[2][2], mat[2][3],\
+                    mat[3][0], mat[3][1], mat[3][2], mat[3][3])
+    end
+
+    def set_pmatrix(mat, pmatrix)
+      pmatrix.set(mat[0][0], mat[0][1], mat[0][2], mat[0][3],\
+                  mat[1][0], mat[1][1], mat[1][2], mat[1][3],\
+                  mat[2][0], mat[2][1], mat[2][2], mat[2][3],\
+                  mat[3][0], mat[3][1], mat[3][2], mat[3][3])
+    end
+  end 
+

data/lib/soby/presentation.rb

@@ -0,0 +1,342 @@
+require 'ostruct'
+require 'base64'
+
+class Presentation 
+
+  include_package 'processing.core'
+
+  include Soby 
+    
+  attr_accessor :geometry, :slides, :pshape, :svg, :transform
+  attr_accessor :width, :height, :matrix, :videos
+  attr_reader  :nb_slides, :debug
+
+  attr_accessor :graphics
+
+  def initialize (app, url)
+    @app = app
+    xml = app.loadXML(url)
+    @pshape = PShapeSVG.new(xml)
+    @svg = Nokogiri::XML(open(url)).children[1];
+
+    @graphics = @app.g
+    build_internal
+
+  end
+
+  def width ; @pshape.getWidth; end
+  def height ; @pshape.getHeight; end
+
+
+  def build_internal 
+
+    # Create the frames.. 
+    @slides = {}
+    @nb_slides = 0
+    @playing_videos = []
+
+    puts "Svg null, look for the error... !"  if @svg == nil
+    return if @svg == nil 
+
+    load_frames
+    load_videos
+    load_animations
+  end
+
+  def draw
+    @graphics.shape pshape, 0, 0
+#    display_videos
+  end
+
+
+  def load_frames
+
+    puts "Loading the frames..."
+    @svg.children.each do |child| 
+      
+      next unless child.name =~ /frame/
+
+      ## ignore if it references nothing. 
+      attr = child.attributes
+      next if attr["refid"] == nil
+
+      slide = Slide.new(child)      
+      
+      # get the element associated with each slide...
+      @svg.search("[id=" + slide.refid + "]").each do |elem|
+
+        case elem.name 
+        when "rect", "image"
+          add_rect_or_image_frame(elem, slide)
+        when "g" 
+          add_group(elem, slide)
+        else 
+          puts "Slide type not supported ! "  + elem.name
+        end # end case
+      end # search
+    end # frame
+  end
+
+  def add_slide(new_slide)
+
+    puts "Add slide, id " << new_slide.title << " numero " << new_slide.sequence
+    @slides[new_slide.sequence] = new_slide
+    @slides[new_slide.title] = new_slide
+    @nb_slides = @nb_slides+1
+  end
+
+
+  def add_rect_or_image_frame(element, slide)
+    id = slide.title
+    refid = slide.refid
+
+    add_slide(slide) 
+
+    # set the geometry &  transformation
+    transform = get_global_transform element
+    @slides[id].set_geometry(element, transform[0])        
+    pshape_element = @pshape.getChild(refid)
+
+    # hide the element
+    if pshape_element == nil 
+      puts "Error: rect or Image  ID:  #{refid} not found. CHECK THE PROCESSING VERSION."
+    else
+      pshape_element.setVisible(!@slides[id].hide) if element.name == "rect"
+    end
+
+    puts "Slide #{id} created from a rect : #{refid}" if element.name == "rect"
+    puts "Slide #{id} created from an image: #{refid}" if element.name == "image"
+  end
+  
+  
+  def add_group(group, slide) 
+    
+    id = slide.title
+    refid = slide.refid
+    add_slide(slide) 
+
+    # TODO: Find the bounding box of any  group..
+    # TODO: Hide the whole group ?
+    surf_max = 0
+    biggest_rect = nil
+    
+    ## biggest_rect surface..
+    group.css("rect").each do |rect|
+      #          (group.css("rect") + group.css("image")).each do |rect|
+      
+      if biggest_rect == nil 
+        biggest_rect = rect
+      end
+      
+      surf_rect = rect.attributes["width"].value.to_i \
+      * rect.attributes["height"].value.to_i
+
+      if(surf_rect > surf_max) 
+        biggest_rect = rect 
+        surf_max = surf_rect
+      end
+    end  # rect.each 
+    
+    rect_id = biggest_rect.attributes["id"].value
+    transform = get_global_transform biggest_rect
+    @slides[id].set_geometry(biggest_rect, transform[0])     
+
+    # The description (code to excute) might be in the group  and not in the rect. 
+    ## TODO: check if it should really be the first ?
+    desc = group.css("desc").first
+    title = group.css("title").first
+
+    if desc != nil 
+      if title == nil || (title.text.match(/animation/) == nil and title.text.match(/video/) == nil)
+        puts "Group Description read #{desc.text}" 
+        
+        @slides[id].description =  desc.text
+      end
+    end
+    
+    e = @pshape.getChild(rect_id)
+    # hide the rect
+    if e == nil 
+      puts "Error: rect ID:  #{rect_id} not found "
+    else
+      @pshape.getChild(rect_id).setVisible(!@slides[id].hide)
+    end 
+
+    puts "Slide #{id} created from a group, and the rectangle: #{rect_id}"
+
+  end
+
+
+
+
+  def load_videos
+    # Load the videos...
+    puts "Loading the videos..."
+
+    @svg.css("rect").each do |rect|
+
+      return if rect.attributes["id"] == nil
+      id = rect.attributes["id"].value       #get the id 
+
+      title = rect.css("title")
+      next if title == nil 
+
+      is_video = title.text.match(/video/) != nil 
+      next unless is_video
+      
+      t = rect.css("desc").text.split("\n")
+      slide_id = t[0]
+      path = t[1]
+
+      puts ("Loading the video : " + path)
+
+      # Get the transformation
+      tr = get_global_transform rect 
+
+      video = MyVideo.new(path, @slides[slide_id], tr[0], tr[1], tr[2]) 
+
+      if  @slides[slide_id] == nil 
+        puts "Error -> The video #{id}  is linked to the slide #{slide_id} which is not found !" 
+      else 
+
+        @slides[slide_id].add_video(video)
+        puts "Video #{id} loaded with  #{slide_id}"
+      end
+
+      # Hide the rect, and ... TODO replace it with a special object
+      #      @pshape.getChild(id).setVisible(false)
+    end
+  end
+
+
+
+  def load_animations
+
+    puts "Loading the animations..."
+
+    @svg.css("*").each do |elem|
+
+      valid = false
+      elem.children.each do |child|
+        valid = true if child.name == "title" && child.text.match(/animation/)
+      end
+
+      next unless valid
+
+      id = elem.attributes["id"].value
+
+      # Get the animation information 
+      t = elem.css("desc").text.split("\n")
+
+      # 1. which slide
+      # 2. when 
+      slide_id = t[0]
+      anim_id = t[1].to_i
+
+      animation = OpenStruct.new
+      animation.pshape_elem = @pshape.getChild(id)
+
+      puts "Animation found on slide #{slide_id} with element #{animation.pshape_elem}"
+
+      if  @slides[slide_id] == nil 
+        puts "Error -> The animation #{id}  is linked to the slide #{slide_id} which is not found !" 
+      else 
+        # add the animation
+        @slides[slide_id].add_animation(anim_id, animation)
+        
+        # hide the group !
+        animation.pshape_elem.setVisible(false) unless animation.pshape_elem == nil
+        puts "Animation #{id} loaded with  #{slide_id}"
+      end
+    end
+
+  end
+
+  def display_videos
+    if not @app.is_moving 
+
+      slide_no = @app.current_slide_no
+
+      # # Display the videos
+      if slide_no > 0 and  @slides[slide_no].has_videos? 
+        
+
+        # draw the object
+        @graphics.imageMode(Processing::App::CORNER)
+        
+        @slides[slide_no].videos.each do |my_video| 
+          @graphics.push_matrix
+          @graphics.modelview.apply(my_video.matrix)
+          
+          # when the video is loaded it is saved... so that the memory can
+          # hopefully be freed
+          @playing_videos << my_video if my_video.play 
+
+#          my_video.video.read if my_video.video.available?           
+#          my_video.video.read
+          @graphics.image(my_video.video, 0, 0, my_video.width, my_video.height)
+
+          
+          @graphics.pop_matrix
+        end # videos.each
+        
+      else  # has_videos
+
+        ## no video, free some memory 
+        @playing_videos.each do |my_video|
+          puts "Saving memory. "
+          my_video.video.stop
+          my_video.video = nil 
+          System.gc
+        end
+        @playing_videos =  []
+      end 
+    end
+  end
+
+
+
+  class MyVideo
+
+    include_package 'processing.video'
+    include_package 'processing.video.Movie'
+    include_package 'org.gestreamer.elements'
+
+    attr_reader :matrix, :width, :height, :slide
+    attr_accessor :video
+    
+    def initialize(path, slide, matrix, width, height) 
+      @path = path
+      @width = width
+      @height = height
+      @matrix = matrix
+      @slide = slide
+    end
+    
+    def play 
+      if @video == nil 
+
+        absolute_path = $app.sketchPath "" << @path
+
+        puts ("loading the video : " + absolute_path)
+        vid = Movie.new($app, absolute_path)
+
+#        vid = Movie.new($app, @path)
+        puts "Loaded " 
+        puts vid, vid.width, vid.height
+        vid.play
+        @video = vid
+        true 
+      else 
+        false
+      end
+    end
+    
+  end
+
+
+  def to_s 
+    "Slides #{@slides.size}" 
+  end
+
+end 

data/lib/soby/slide.rb

@@ -0,0 +1,166 @@
+class Slide 
+
+  attr_accessor :next, :previous, :refid, :sequence, :hide, :matrix, :description
+  attr_reader :x, :y, :width, :height, :transform, :title ,:id
+
+  # transition states 
+  attr_reader :transition_duration_ms, :timeout_ms, :timeout_enable, :transition_profile
+  attr_reader :videos, :animations
+
+
+  def initialize (element)
+
+    attr = element.attributes
+
+    ## Zoom & Path -> not used...
+    # @transition_path_hide = attr["transition-path-hide"].value
+    # @transition_zoom_percent = attr["transition-zoom-percent"].value
+
+    #Not always set ! We use the title instead
+    #    @id = attr["id"].value
+
+    @transition_profile = attr["transition-profile"].value
+    @transition_duration_ms = attr["transition-duration-ms"].value.to_f
+    @timeout_ms = attr["timeout-ms"].value.to_f
+    @timeout_enable = attr["timeout-enable"].value  == "true"
+    #    @show_in_frame_list = attr["show-in-frame-list"].value
+
+    @clip = attr["clip"].value
+    @hide = attr["hide"].value == "true"
+    @sequence = attr["sequence"].value.to_i
+    @title = attr["title"].value
+    @refid = attr["refid"].value
+
+    init_transition_profile
+
+    @videos = []
+    @animations = []
+    @current_animation = 0
+  end
+
+  def is_hidden?
+    @hide
+ end 
+
+
+  def init_transition_profile
+    case @transition_profile
+    when "linear" 
+      @transition = Proc.new { |x| x } 
+    when "accelerate" 
+      @transition = Proc.new { |x| x**3 } 
+    when "strong-accelerate"
+      @transition = Proc.new { |x| x**5 } 
+    when "decelerate" 
+      @transition = Proc.new { |x| 1 - Math.pow(1 - x, 3) } 
+    when "strong-decelerate" 
+      @transition = Proc.new { |x| 1 - Math.pow(1 - x, 5) } 
+    when "accelerate-decelerate" 
+      @transition = Proc.new { |x|   
+        xs = x <= 0.5 ? x : 1 - x
+        y = Math.pow(2 * xs, 3) / 2
+        x <= 0.5 ? y : 1 - y
+      }
+    when "strong-decelerate-accelerate"
+      @transition = Proc.new { |x| 
+        xs = x <= 0.5 ? x : 1 - x
+        y = Math.pow(2 * xs, 5) / 2
+        x <= 0.5 ? y : 1 - y 
+      }
+    when  "immediate-beginning"
+      @transition = Proc.new { |x| 1 }
+    when  "immediate-end"
+      @transition = Proc.new { |x| x === 1 ? 1 : 0}
+    when "immediate-middle" 
+      @transition = Proc.new { |x| x >= 0.5 ? 1 : 0}
+      
+    else 
+      @transition = Proc.new {|x| x }
+    end
+  end
+
+
+  def add_video (video)
+    @videos << video
+  end
+
+  def has_videos?() 
+    @videos.size() != 0 
+  end 
+
+
+  def add_animation (id, animation) 
+    @animations[id] = animation
+  end
+
+  def has_next_animation?() 
+    return false if @animations.size == 0 
+    return @current_animation < @animations.size
+  end 
+
+  def next_animation 
+    @current_animation = @current_animation + 1
+    @animations[@current_animation -1]
+  end
+
+  def has_previous_animation?() 
+    return false if @animations.size == 0 
+    return @current_animation > 0
+  end 
+
+  def previous_animation 
+    @current_animation = @current_animation - 1
+    @animations[@current_animation]
+  end
+
+
+  def set_geometry (element, matrix)
+
+    @matrix = matrix
+    attr = element.attributes
+
+    #    @label = attr["label"].value
+    #    @id = attr["id"].value
+    @x = attr["x"].value.to_f
+    @y = attr["y"].value.to_f
+    @width = attr["width"].value.to_f
+    @height = attr["height"].value.to_f
+    
+    @description = element.css("desc").text if element.css("desc").size > 0
+    @title = element.css("title").text if element.css("title").size > 0
+
+    ## TODO : check if title != animation and video 
+
+    # Animation & Video are not ruby Code !
+    if @title != nil 
+      if  @title.match(/animation/) or @title.match(/video/) 
+        @description = nil
+      end
+    end
+    
+    #eval @description if @description
+  end
+
+  def transition x 
+    @transition.call x 
+  end
+
+
+  def to_s 
+    ["id ",@id.to_s ," ",
+     "transition_path_hide ",@transition_path_hide.to_s ," ",
+     "transition_profile ",@transition_profile.to_s ," ",
+     "transition_zoom_percent ",@transition_zoom_percent.to_s ," ",
+     "transition_duration_ms ",@transition_duration_ms.to_s ," ",
+     "timeout_ms ",@timeout_ms.to_s ," ",
+     "timeout_enable ",@timeout_enable.to_s ," ",
+     "show_in_frame_list ",@show_in_frame_list.to_s ," ",
+     "clip ",@clip.to_s ," ",
+     "hide ",@hide.to_s ," ",
+     "sequence ",@sequence.to_s ," ",
+     "title ",@title.to_s ," ",
+     "refid ",@refid.to_s ," " ].join
+  end
+end
+
+

data/lib/soby/transforms.rb

@@ -0,0 +1,53 @@
+
+module Soby 
+
+  include_package 'processing.core'
+
+  def read_transform (text)
+    if(text.match("matrix"))
+      text = text.split(/[,\(]/)  # split with  , or  (
+      return PMatrix2D.new(text[1].to_f, text[3].to_f, text[5].to_f, \
+                           text[2].to_f, text[4].to_f, text[6].to_f)   if(text.size == 7)
+    end
+    
+    if(text.match("translate")) 
+      text = text.split(/[,\(]/)  
+      return PMatrix2D.new(1, 0, text[1].to_f, 0, 1, text[2].to_f)   
+    end
+  end
+
+
+  def get_global_transform element
+    e = element
+    global_transform = PMatrix3D.new
+
+    attr = e.attributes
+
+    global_transform.translate(attr["x"].value.to_f, attr["y"].value.to_f)
+
+    while  e.class != Nokogiri::XML::Document do 
+      t = e.attribute("transform")
+      if (t != nil) 
+        tr = read_transform(t.value)
+        global_transform.preApply(tr)
+      end
+      e = e.parent
+    end
+    
+    [global_transform , attr["width"].value.to_f, attr["height"].value.to_f]
+  end
+
+  def get_angle (mat)
+    Math.atan2(mat.m01, mat.m00) 
+  end
+
+
+  def create_mat4x4(mat) 
+    Matrix4x4.new(mat.m00, mat.m01, mat.m02, mat.m03,\
+                  mat.m10, mat.m11, mat.m12, mat.m13,\
+                  mat.m20, mat.m21, mat.m22, mat.m23,\
+                  mat.m30, mat.m31, mat.m32, mat.m33)
+  end
+
+
+end

data/lib/soby.rb

@@ -0,0 +1,403 @@
+# -*- coding: utf-8 -*-
+
+require 'nokogiri'  # for XML.
+require 'ruby-processing' 
+require 'java' 
+
+# For the other files, we need to load the libraries 
+Processing::App::load_library 'video', 'toxiclibscore'
+
+require_relative 'soby/transforms'
+require_relative 'soby/presentation'
+require_relative 'soby/slide'
+require_relative 'soby/cam' 
+
+class SobyPlayer < Processing::App
+
+  include_package 'processing.core'
+  include_package 'toxi.geom'
+
+  import 'toxi.geom.Matrix4x4'
+
+  attr_accessor :prez, :prev_cam, :next_cam, :slides
+  attr_reader :is_moving, :current_slide_no
+
+#  attr_accessor :background_max_color, :background_min_color, :background_constrain
+  attr_accessor :cam
+
+  
+  def running? () @is_running  end
+
+  TRANSITION_DURATION = 1000
+
+  # no Border  
+  def init 
+    super
+    removeFrameBorder
+  end
+  
+  def removeFrameBorder
+    frame.removeNotify
+    frame.setUndecorated true
+    frame.addNotify
+  end 
+
+
+  def setup 
+    @ready = false
+    size 1024, 768, OPENGL
+
+## Some bugs with this. 
+## frame.setResizable true  if frame != nil 
+
+    init_player
+
+    @custom_setup_done = true
+    @ready = true
+  end 
+
+  def ready?
+    @ready
+  end
+
+  def init_player 
+    @prez = nil
+    @current_slide_no = 0
+    @is_running = false
+    init_cameras
+  end
+
+  def init_cameras
+    # current camera matrix 
+    @cam = PMatrix3D.new
+
+    # Cameras for movement. 
+    @prev_cam = Cam.new
+    @next_cam = Cam.new
+    @is_moving = false
+    @current_ratio = 0
+  end
+
+
+  ## To be overriden by the Presentation Code. 
+  def custom_setup
+
+  end
+
+  def custom_pre_draw
+    background(255)
+  end
+
+  def custom_post_draw
+
+  end
+
+
+  def draw 
+
+    if not @custom_setup_done 
+      custom_setup
+      @custom_setup_done = true
+    end
+
+    custom_pre_draw
+
+    smooth(8)
+
+    shapeMode(CORNER)
+    imageMode(CORNER)
+
+    if(running?)
+      
+      push_matrix
+
+      update_cam
+      self.g.modelview.apply(@cam)
+      @prez.draw
+      @prez.display_videos
+      pop_matrix
+
+      run_slide_code 
+      display_slide_number 
+    end
+
+    custom_post_draw
+  end
+
+  def run_slide_code 
+    translate 0, 0, 1
+    if not @is_moving and @current_slide_no != 0
+      desc = @prez.slides[@current_slide_no].description
+      if(desc != nil)
+        #          puts "EVAL #{desc}" 
+        eval desc
+      end 
+    end
+  end
+
+
+  def display_slide_number 
+    # Slide number
+    push_matrix
+    translate(@width - 40, @height - 45)
+    fill(30)
+    strokeWeight(3)
+    stroke(190)
+    ellipseMode(CENTER)
+    ellipse(18, 22, 35, 35)
+    fill(255)
+    noStroke 
+    textSize(20)
+    text(@current_slide_no.to_s, 10, 30)
+    pop_matrix
+  end
+
+  alias :default_display_slide_number :display_slide_number 
+
+
+  def key_pressed
+
+    if key == 'g' 
+      puts "Garbage"
+      Java::JavaLang::System.gc 
+    end 
+
+    return if @prez == nil
+
+    if keyCode == LEFT 
+      prev_slide
+    end
+
+    if keyCode == RIGHT
+      next_slide
+    end
+    
+    #    puts "slide #{@current_slide_no} "
+  end
+
+  def mouse_dragged
+    if not @is_moving 
+      tr = PMatrix3D.new 
+      tr.translate(mouse_x - pmouse_x, mouse_y - pmouse_y)
+      
+      @cam.preApply(tr)
+      @next_cam.mat.preApply(tr)
+    end
+  end
+
+  def mouseWheel(event) 
+    e = event.getAmount()
+    if not @is_moving 
+      tr = PMatrix3D.new 
+      tr.translate(mouse_x, mouse_y) 
+      tr.scale(e < 0 ?  1.05 :  1 / 1.05)
+      tr.translate(-mouse_x, -mouse_y) 
+      @cam.preApply(tr)
+    end
+  end
+
+
+  def set_prez (prez)
+    #    PShape.loadedImages.clear 
+    @prez = prez
+    @slides = prez.slides
+    goto_slide 0
+    @is_running = true
+    @prez_middle = PVector.new(@prez.width / 2.0, @prez.height / 2.0)
+
+    puts "Presentation size " 
+    puts @prez.width
+    puts @prez.height
+
+    @custom_setup_done = false
+  end
+
+  def compute_view(view, slide_number)
+    #    view = createGraphics(@width, @height, P3D)
+    #    @next_view = createGraphics(@width, @height)
+    view.beginDraw
+
+    cam = slide_view slide_number
+    view.g.modelview.apply(cam)
+    view.shapeMode(CORNER)
+    view.shape(@prez.pshape, 0, 0)
+    view.endDraw
+
+    view 
+  end
+
+
+  def next_slide
+    is_last_slide = @current_slide_no >= @prez.nb_slides 
+    is_slide_zero = current_slide_no == 0
+
+    # Gloal view
+    if is_slide_zero
+      goto_slide(@current_slide_no + 1)
+      return 
+    end
+
+    # animation
+    if @slides[@current_slide_no].has_next_animation?
+      puts "Animation Next " 
+      anim = @slides[@current_slide_no].next_animation
+      anim.pshape_elem.setVisible(true)
+    else
+      goto_slide(@current_slide_no + 1) unless is_last_slide
+    end
+
+  end
+
+  def prev_slide
+    return if @current_slide_no <= 0
+
+    if current_slide_no == 0 
+      goto_slide(@current_slide_no - 1) 
+      return 
+    end
+
+    if @slides[@current_slide_no].has_previous_animation?
+      puts "Animation Previous " 
+      anim = @slides[@current_slide_no].previous_animation
+      anim.pshape_elem.setVisible(false)
+    else
+      goto_slide(@current_slide_no - 1)   
+    end
+
+  end
+
+  def goto_slide (next_slide)
+
+    current_slide = @current_slide_no 
+
+    use_global_view =  next_slide == 0 || next_slide > @prez.slides.size 
+
+    cam = global_view if use_global_view
+    cam = slide_view(next_slide)  if next_slide > 0   
+
+    # previous next is now old. 
+    @prev_cam = @next_cam
+    @prev_cam.mat.set(@cam)
+    @next_cam = cam
+
+    @current_slide_no = next_slide
+
+    if use_global_view
+      @transition_duration = TRANSITION_DURATION.to_f
+    else
+      @transition_duration = @slides[@current_slide_no].transition_duration_ms
+    end
+
+    @transition_start_time = millis
+    @is_moving = true  
+    @current_ratio = 0
+
+    ## trigger the slide_change function (user defined)
+    slide_change
+  end
+
+  def slide_change
+
+  end
+
+
+  def update_cam 
+
+    return unless @is_moving
+    return if @slides.size == 0
+
+    elapsed_time = millis - @transition_start_time
+    @current_ratio = elapsed_time.to_f / @transition_duration.to_f
+
+    @current_ratio = @slides[@current_slide_no].transition @current_ratio unless @current_slide_no == 0
+
+    if @current_ratio > 1  && @is_moving 
+      @is_moving = false
+      @cam = @prev_cam.lerp(@next_cam, 1)
+
+      # save a copy 
+      @prev_cam.mat = @cam.get
+      return
+    end
+
+    #    puts @current_ratio
+    @cam = @prev_cam.lerp(@next_cam, @current_ratio)
+
+  end  
+
+  def slide_view (slide_no)
+
+    if slide_no > @prez.slides.size 
+      puts "No more slides" 
+      return
+    end
+
+    return if @prez.slides[slide_no] == nil 
+
+    puts "slide view..." << slide_no.to_s
+
+    # check slide number
+    w = @prez.slides[slide_no].width
+    h = @prez.slides[slide_no].height
+    x = @prez.slides[slide_no].x
+    y = @prez.slides[slide_no].y
+
+    sc1 = @width.to_f / w.to_f
+    sc2 = @height.to_f / h.to_f
+
+    # scale 
+    sc = [sc1, sc2].min
+
+
+    # translate 
+    dx = ((@width / sc) - w) * 0.5
+    dy = ((@height / sc) - h) * 0.5
+
+    cam = Cam.new
+
+    m = PMatrix3D.new 
+    m.apply @prez.slides[slide_no].matrix
+    m.invert
+
+    # Scale
+    tr = PMatrix3D.new 
+    tr.scale(sc)
+    m.preApply(tr)
+    m.translate(dx, dy)
+
+    # center
+    cam.mat = m
+    cam
+
+  end
+
+
+  def global_view 
+    # ortho(left, right, bottom, top)
+    # frustum(left, right, bottom, top, near, far)
+    
+    my_scale = find_scale
+
+    # centering
+    dx = ((@width / my_scale) - @prez.width) * 0.5
+    dy = ((@height / my_scale) - @prez.height) * 0.5
+
+    cam = Cam.new 
+    cam.scale = my_scale
+    # Not necessary : display from the center...
+    cam.post_translation.set(dx, dy)
+    cam.compute_mat
+    cam
+  end
+
+  def find_scale
+    sc1 = @width / @prez.width
+    sc2 = @height / @prez.height
+    return [sc1, sc2].min
+  end
+  private :find_scale
+
+
+end
+
+

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: soby
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jeremy Laviole
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: ruby-processing
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.6.7
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.6.7
+  prerelease: false
+  type: :runtime
+description: Based on Sozi, it works plays presentation using Ruby-processing.
+email: poqudrof@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/soby.rb
+- lib/soby/cam.rb
+- lib/soby/slide.rb
+- lib/soby/presentation.rb
+- lib/soby/transforms.rb
+homepage: https://github.com/poqudrof/Soby
+licenses:
+- LGPL
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: Sozi player !
+test_files: []