disp3D 0.2.1 → 1.0.1

data/lib/glut_window.rb

@@ -15,7 +15,7 @@ module Disp3D
 
       GLUT.MouseFunc(method(:mouse).to_proc())
       GLUT.MotionFunc(method(:motion).to_proc())
-      GLUT.PassiveMotionFunc(method(:passive_motion).to_proc())
+      GLUT.PassiveMotionFunc(method(:motion).to_proc())
       super(width, height)
     end
 
@@ -28,34 +28,40 @@ module Disp3D
       GLUT.SwapBuffers
     end
 
-    def reshape(w,h)
-      @camera.reshape(w,h)
+    def idle_process(wait_msec = nil, &block)
+      if(!wait_msec.nil?)
+        new_block = lambda do
+          @lasttime = Time.now if(@lasttime.nil?)
+          interval = Time.now - @lasttime
+          next if( interval < wait_msec/1000.0)
+          yield
+          @lasttime = Time.now
+        end
+        GLUT.IdleFunc(new_block)
+      else
+        GLUT.IdleFunc(block)
+      end
     end
 
+    def start
+      fit
+      GLUT.MainLoop()
+    end
+
+private
     def mouse(button,state,x,y)
       if(state == GLUT::GLUT_UP)
-        @mouse_release_proc.call(self, button, x, y) if( @mouse_release_proc != nil)
+        mouse_release_process(button, x, y)
       elsif(state == GLUT::GLUT_DOWN)
-        @mouse_press_proc.call(self, button, x, y) if( @mouse_press_proc != nil)
+        mouse_press_process(button, x, y)
       end
-      @manipulator.mouse(button,state,x,y)
     end
 
     def motion(x,y)
-      @mouse_move_proc.call(self, x,y) if( @mouse_move_proc != nil)
-      update = @manipulator.motion(x,y)
-      if(update)
+      need_update = mouse_move_process(x, y)
+      if(need_update)
         GLUT.PostRedisplay()
       end
     end
-
-    def passive_motion(x,y)
-      @mouse_move_proc.call(self, x,y) if( @mouse_move_proc != nil)
-    end
-
-    def start
-      fit
-      GLUT.MainLoop()
-    end
   end
 end

data/lib/light.rb

@@ -2,38 +2,21 @@ require 'disp3D'
 
 module Disp3D
   class Light
-    def gl_display()
-      idx = 0
-      GL.Enable(GL::GL_LIGHTING)
-      all_disable = true
-      @enable.each do | enable |
-        if(enable)
-          GL.Enable( @light_id[idx])
-          GL.Lightfv( @light_id[idx], GL::GL_POSITION, @position[idx] )
-          GL.Lightfv( @light_id[idx], GL::GL_DIFFUSE,  @deffuse[idx]  )
-          GL.Lightfv( @light_id[idx], GL::GL_AMBIENT,  @ambient[idx]  )
-          GL.Lightfv( @light_id[idx], GL::GL_SPECULAR, @specular[idx] )
-          all_disable = false
-        end
-      end
-      if(all_disable)
-        GL.Enable(@light_id[0])
-      end
-    end
-
     def initialize()
       @diffuse_default = [0.7, 0.7, 0.7, 1]
       @ambient_default = [0.2, 0.2, 0.2, 1]
       @specular_default = [1, 1, 1, 1]
-      @position_default = [0.0, 0.0, 1.0, 0.0]
+      @position_default = Vector3.new(0.0, 0.0, 1.0)
+      @spot_direction_default = Vector3.new(0.0, 0.0, -1.0)
 
       light_count = 8 # openGL spec
 
       @enable = [false, false, false, false, false, false, false, false]
-      @deffuse = Array.new(light_count, @diffuse_default)
+      @diffuse = Array.new(light_count, @diffuse_default)
       @ambient = Array.new(light_count, @ambient_default)
       @specular = Array.new(light_count, @specular_default)
       @position = Array.new(light_count, @position_default)
+      @spot_direction = Array.new(light_count, @spot_direction_default)
       @light_id = Array.new(light_count)
       @light_id[0] = GL::GL_LIGHT0
       @light_id[1] = GL::GL_LIGHT1
@@ -45,5 +28,36 @@ module Disp3D
       @light_id[7] = GL::GL_LIGHT7
     end
 
+    def gl_display()
+      GL.Enable(GL::GL_LIGHTING)
+      @enable.each_with_index do | enable, idx |
+        if(enable)
+          GL.Enable( @light_id[idx])
+          GL.Lightfv( @light_id[idx], GL::POSITION, [@position[idx].x,@position[idx].y,@position[idx].z] )
+          GL.Lightfv( @light_id[idx], GL::SPOT_DIRECTION, [@spot_direction[idx].x,@spot_direction[idx].y,@spot_direction[idx].z] )
+          GL.Lightfv( @light_id[idx], GL::DIFFUSE,  @diffuse[idx]  )
+          GL.Lightfv( @light_id[idx], GL::AMBIENT,  @ambient[idx]  )
+          GL.Lightfv( @light_id[idx], GL::SPECULAR, @specular[idx] )
+        end
+      end
+      if(!@enable.include?(true))
+        GL.Enable(@light_id[0])
+      end
+    end
+
+    def open(&block)
+      self.instance_eval(&block)
+    end
+
+private
+    def set(hash)
+      Util3D.check_key_arg(hash, :id)
+      target_idx = hash[:id]
+      hash.each do | key, value |
+        next if( key == :id)
+        target_ary = eval "@#{key.to_s}"
+        target_ary[target_idx]=value
+      end
+    end
   end
 end

data/lib/manipulator.rb

@@ -1,4 +1,3 @@
-# -*- coding: cp932 -*-
 require 'disp3D'
 
 include GMath3D
@@ -15,8 +14,6 @@ module Disp3D
       @scalling = false
       @translating = false
       @trackball_size = 0.8
-
-      @compass = Compass.new(camera)
     end
 
     def centering(scene_graph)
@@ -97,10 +94,6 @@ module Disp3D
       return false
     end
 
-    def gl_display_compass
-      @compass.gl_display()
-    end
-
 private
    def set_clicked_point_as_rotation_center(x,y)
      results = @picker.pick(x,y)

data/lib/node/node.rb

@@ -1,90 +1,115 @@
 require 'disp3D'
 
+class Class
+  # use this instead of attr_accessor.
+  # if attribute is changed call Node#update
+  def attr_for_disp(attribute)
+    define_method "#{attribute}=" do |value|
+      instance_variable_set("@#{attribute}", value)
+      update_for_display
+    end
+    define_method attribute do
+      instance_variable_get "@#{attribute}"
+    end
+  end
+end
+
 module Disp3D
   class Node
-    attr_accessor :pre_translate # GMath3D::Vector3
-    attr_accessor :rotate # GMath3D::Quat
-    attr_accessor :post_translate # GMath3D::Vector3
+    attr_for_disp :pre_translate # GMath3D::Vector3
+    attr_for_disp :rotate # GMath3D::Quat
+    attr_for_disp :post_translate # GMath3D::Vector3
 
     attr_reader :name
     attr_reader :instance_id
-
-    attr_accessor :parents # Array of Node
+    attr_reader :parents # Array of Node
 
     def initialize(name = nil)
       Util3D.check_arg_type(Symbol, name, true)
-
-      @name = name
-      @translate = nil
-      @rotate = nil
       @parents = []
       @instance_id = gen_instance_id()
-      Node.add_to_node_name_db(self) if(!name.nil?)
+      @name = name
+      NodeDB.add(self)
     end
 
-    # path id DB
-    def self.init_path_db
-      @path_db = Hash.new
+    def pre_draw
+      GL.PushMatrix()
+      GL.Translate(pre_translate.x, pre_translate.y, pre_translate.z) if(@pre_translate)
+      GL.MultMatrix(@rotate.to_array) if(@rotate)
+      GL.Translate(post_translate.x, post_translate.y, post_translate.z) if(@post_translate)
     end
 
-    def self.add_to_path_db(path_id, node)
-      return @path_db[path_id] = node
+    def post_draw
+      GL.PopMatrix()
     end
 
-    def self.find_node_by_path_id(path_id)
-      return @path_db[path_id]
+    def ancestors
+      rtn_ancestors_ary = []
+      return ancestors_inner(rtn_ancestors_ary)
     end
 
-    # node name DB
-    def self.add_to_node_name_db(node)
-      Util3D.check_arg_type(Node, node)
-      @node_db ||= Hash.new()
-      key = node.name
-      if(!@node_db.key?(key))
-        @node_db[key] = node
-      elsif(@node_db[key].kind_of?(Node))
-        @node_db[key] = [@node_db[key], node]
-      elsif(@node_db[key].kind_of?(Array))
-        @node_db[key].push(node)
+protected
+    def create(hash)
+      Util3D.check_key_arg(hash, :type)
+      geom_arg = hash[:geom]
+      name_arg = hash[:name]
+      clazz = eval "Node" + hash[:type].to_s
+      # node leaf constractor need 2 args
+      if( clazz < Disp3D::NodeLeaf )
+        new_node = clazz.new(geom_arg, name_arg)
+      elsif( clazz <= Disp3D::NodeCollection )
+        new_node = clazz.new(name_arg)
       else
         raise
       end
+      hash.delete(:geom)
+      hash.delete(:type)
+      hash.delete(:name)
+      new_node.update(hash)
+      return new_node
     end
 
-    def self.find_node_by_name(node_name)
-      Util3D.check_arg_type(Symbol, node_name)
-      return @node_db[node_name]
-    end
-
-    def self.delete_from_node_name_db_by_node(node)
-      node_name = node.name
-      if(!node_name.nil?)
-        entry = find_node_by_name(node_name)
-        if(entry == node)
-          @node_db[node_name] = nil
-        elsif(entry.kind_of?(Array))
-          entry.reject!{|item| item == node}
+    # cannnot contains key :type and :name. they cannot be set
+    def update(hash)
+      if(hash.include?(:name))
+        node = NodeDB.find_by_name(hash[:name])
+        hash.delete(:name)
+        if(node.kind_of?(Array))
+          node.each do |item|
+            item.update(hash)
+          end
+        elsif(!node.nil?)
+          node.update(hash)
+        end
+      elsif
+        hash.each do | key, value |
+          next if( key == :type or key ==:name) # cannot change name and type
+          self.send( key.to_s+"=", value)
         end
       end
     end
 
-    def pre_draw
-      GL.PushMatrix()
-      GL.Translate(pre_translate.x, pre_translate.y, pre_translate.z) if(@pre_translate)
-      GL.MultMatrix(@rotate.to_array) if(@rotate)
-      GL.Translate(post_translate.x, post_translate.y, post_translate.z) if(@post_translate)
-    end
+    def delete(node_name)
+      Util3D::check_arg_type(Symbol, node_name)
+      node = NodeDB.find_by_name(node_name)
 
-    def post_draw
-      GL.PopMatrix()
+      if(node.kind_of?(Array))
+        node.each do | node_ele |
+         remove_from_parents(node_ele)
+        end
+      elsif(!node.nil?)
+         remove_from_parents(node)
+      end
+      NodeDB.delete_by_name(node_name)
     end
 
-    def ancestors
-      rtn_ancestors_ary = []
-      return ancestors_inner(rtn_ancestors_ary)
+    def remove_from_parents(node)
+      Util3D::check_arg_type(Node, node)
+      node.parents.each do |parent|
+        parent.remove_child_by_node(node)
+      end
     end
 
-protected
     def box_transform(box)
       box = box.translate(@pre_translate) if(@pre_translate)
       box = box.rotate(@rotate) if(@rotate)
@@ -92,24 +117,6 @@ protected
       return box
     end
 
-    def create(hash)
-      Util3D.check_key_arg(hash, :type)
-      geom = hash[:geom]
-      name = hash[:name]
-      clazz = eval "Node" + hash[:type].to_s
-      # node leaf constractor need 2 args
-      if( clazz < NodeLeaf )
-        new_node = clazz.new(geom, name)
-      else
-        new_node = clazz.new(name)
-      end
-      hash.each do | key, value |
-        next if( key == :geom or key == :type or key ==:name)
-        new_node.send( key.to_s+"=", value)
-      end
-      return new_node
-    end
-
     def ancestors_inner(rtn_ancestors_ary)
       parents.each do |parent|
         if(!rtn_ancestors_ary.include?(parent.instance_id))
@@ -121,48 +128,36 @@ protected
     end
 
 private
-    def remove(path_id)
-      if(path_id.kind_of?(Integer))
-        node = Node.find_node_by_path_id(path_id)
-      else
-        Util3D::raise_argurment_error(path_id)
-      end
-      node.parents.each do |parent|
-        parent.remove_child_by_path_id(path_id)
-      end
+    def gen_instance_id
+      return GL.GenLists(1)
     end
+  end
 
-    def delete(node_name)
-      if( node_name.kind_of?(Node) )
-        node = node_name
-      elsif(node_name.kind_of?(Symbol))
-        node = Node.find_node_by_name(node_name)
+  class NodeDB
+    def self.add(node)
+      Util3D.check_arg_type(Node, node)
+      @node_db ||= Hash.new()
+      key = node.name
+      if(!@node_db.key?(key))
+        @node_db[key] = node
+      elsif(@node_db[key].kind_of?(Node))
+        @node_db[key] = [@node_db[key], node]
+      elsif(@node_db[key].kind_of?(Array))
+        @node_db[key].push(node)
       else
-        Util3D::raise_argurment_error(node_name)
-      end
-      if(node.kind_of?(Array))
-        node.each do | item |
-          self.delete(item)
-        end
-      end
-      if(!node.nil?)
-        node.parents.each do |parent|
-          parent.remove_child_by_node(node)
-        end
-        Node.delete_from_node_name_db_by_node(node)
+        raise
       end
     end
 
-    def gen_instance_id
-      id_adding = GL.GenLists(1)
-      return id_adding
+    def self.find_by_name(node_name)
+      @node_db ||= Hash.new()
+      Util3D.check_arg_type(Symbol, node_name)
+      return @node_db[node_name]
     end
 
-    @@path_id_list = Array.new()
-    def gen_path_id
-      id_adding = @@path_id_list.size
-      @@path_id_list.push(id_adding)
-      return id_adding
+    def self.delete_by_name(node_name)
+      return if @node_db.nil? || node_name.nil?
+      @node_db[node_name] = nil
     end
   end
 end

data/lib/node/node_arrows.rb

@@ -2,7 +2,7 @@ require 'disp3D'
 
 module Disp3D
   class NodeArrows < NodeLeaf
-    attr_accessor :width
+    attr_for_disp :width
 
     def initialize(geom, name = nil)
       Util3D.check_arg_type(Symbol, name, true)

data/lib/node/node_collection.rb

@@ -1,4 +1,3 @@
-
 require 'disp3D'
 
 module Disp3D
@@ -21,14 +20,14 @@ module Disp3D
       end
     end
 
-    def draw
+    def draw currnet_view
       pre_draw()
       @children.each do |key, node|
         if(node.kind_of?(NodeLeaf))
-          Node.add_to_path_db(key, node)
+          NodePathDB.add(key, node)
           GL.LoadName(key)
         end
-        node.draw
+        node.draw currnet_view
       end
       post_draw()
     end
@@ -55,6 +54,14 @@ module Disp3D
       return @children[path_id]
     end
 
+    def child_nodes
+      return @children.values
+    end
+
+    def child_path_id
+      return @children.keys
+    end
+
 protected
     def remove_child_by_path_id(path_id)
       @children.delete(path_id)
@@ -64,25 +71,37 @@ protected
       @children.reject!{|key, value| value == child_node}
     end
 
+    def update_for_display
+      @children.each do |key, node|
+        node.update_for_display
+      end
+    end
 private
     def add_new(node_info, &block)
       if(block_given?)
         create_and_add_node_by_block(node_info, &block)
       elsif(node_info.kind_of?(Hash))
         create_and_add_node(node_info)
+      else
+        Util3D.raise_argurment_error(node_info)
       end
     end
 
-    def create_and_add_node(hash)
-      new_node = create(hash)
-      add_node(new_node)
+    def remove(path_id)
+      if(path_id.kind_of?(Integer))
+        node = NodePathDB.find_by_path_id(path_id)
+      else
+        Util3D::raise_argurment_error(path_id)
+      end
+      node.parents.each do |parent|
+        parent.remove_child_by_path_id(path_id)
+      end
     end
 
-    def create_and_add_node_by_block(hash, &block)
-      hash[:type] = :Collection
-      new_node = create(hash)
-      new_node.instance_eval(&block) if(block_given?)
-      add_node(new_node)
+    def add_node_by_name(node_name)
+      Util3D.check_arg_type(Symbol, node_name)
+      nodes = NodeDB.find_by_name(node_name)
+      add_node(nodes)
     end
 
     def add_node(node)
@@ -102,15 +121,42 @@ private
         node.parents.push(self)
         return new_id
       else
-        raise # invalid Argument
+        Util3D.raise_argurment_error(node)
       end
     end
 
-    def add_node_by_name(node_name)
-      Util3D.check_arg_type(Symbol, node_name)
-      nodes = Node.find_node_by_name(node_name)
-      add_node(nodes)
+    def create_and_add_node(hash)
+      new_node = create(hash)
+      add_node(new_node)
+    end
+
+    def create_and_add_node_by_block(hash, &block)
+      hash[:type] = :Collection
+      new_node = create(hash)
+      new_node.instance_eval(&block) if(block_given?)
+      add_node(new_node)
     end
 
+    @@path_id_list = Array.new()
+    def gen_path_id
+      id_adding = @@path_id_list.size
+      @@path_id_list.push(id_adding)
+      return id_adding
+    end
+  end
+
+  # hold path id and node connectivity
+  class NodePathDB
+    def self.init
+      @path_db = Hash.new
+    end
+
+    def self.add(path_id, node)
+      return @path_db[path_id] = node
+    end
+
+    def self.find_by_path_id(path_id)
+      return @path_db[path_id]
+    end
   end
 end