disp3D 0.2.1 → 1.0.1

data/lib/node/node_cone.rb

@@ -0,0 +1,49 @@
+require 'disp3D'
+
+module Disp3D
+  class NodeCone < NodeLeaf
+    attr_for_disp :radius
+    attr_for_disp :height
+    attr_for_disp :base_point
+    attr_for_disp :direction
+
+    def initialize(geom=nil, name=nil)
+      super
+      @radius = 1.0
+      @height = 3.0
+      @slices = 10
+      @stacks = 10
+      @base_point = Vector3.new()
+      @direction = Vector3.new(0,0,1)
+    end
+
+    def box
+      rtn_box = Box.new(Vector3.new(-@radius,-@radius,0), Vector3.new(@radius,@radius,@height))
+      rtn_box = box_transform(rtn_box)
+      rot = calc_rotate_from_direction
+      rtn_box = rtn_box.rotate(rot) if(!rot.nil?)
+      rtn_box = rtn_box.translate(@base_point)
+      return rtn_box
+    end
+
+protected
+    def draw_element
+      GL.PushMatrix()
+      rot = calc_rotate_from_direction
+      GL.Translate(@base_point.x, @base_point.y, @base_point.z) if(@base_point)
+      GL.MultMatrix(rot.to_array) if(!rot.nil?)
+      draw_color
+      GLUT.SolidCone(@radius, @height, @slices, @stacks)
+      GL.PopMatrix()
+    end
+
+private
+    def calc_rotate_from_direction
+      return nil if(@direction.length < 1e-2)
+      base_direction = Vector3.new(0,0,1)
+      angle = base_direction.angle(@direction)
+      axis = base_direction.cross(@direction)
+      rotate = Quat.from_axis(axis, angle)
+    end
+  end
+end

data/lib/node/node_coord.rb

@@ -2,26 +2,41 @@ require 'disp3D'
 
 module Disp3D
   class NodeCoord < NodeCollection
-    def initialize(base_position = Vector3.new(), length = 1)
-      super()
+    attr_for_disp :length
+    attr_for_disp :base_position
+
+    def initialize(name = nil, base_position = Vector3.new(), length = 1)
+      super(name)
       @length = length
       @base_position = base_position
       @x_color = [1,0,0,1]
       @y_color = [0,1,0,1]
       @z_color = [0,0,1,1]
 
+      @x_node = NodeArrows.new(geom[0])
+      @y_node = NodeArrows.new(geom[1])
+      @z_node = NodeArrows.new(geom[2])
+      @x_node.colors = @x_color
+      @y_node.colors = @y_color
+      @z_node.colors = @z_color
+      add(@x_node)
+      add(@y_node)
+      add(@z_node)
+    end
+
+    def update_for_display
+      @x_node.geom = geom[0]
+      @y_node.geom = geom[1]
+      @z_node.geom = geom[2]
+      super
+    end
+
+private
+    def geom
       x_geom = FiniteLine.new(@base_position, @base_position + Vector3.new(@length,0,0))
       y_geom = FiniteLine.new(@base_position, @base_position + Vector3.new(0,@length,0))
       z_geom = FiniteLine.new(@base_position, @base_position + Vector3.new(0,0,@length))
-      x_node = NodeArrows.new(x_geom)
-      y_node = NodeArrows.new(y_geom)
-      z_node = NodeArrows.new(z_geom)
-      x_node.colors = @x_color
-      y_node.colors = @y_color
-      z_node.colors = @z_color
-      add(x_node)
-      add(y_node)
-      add(z_node)
+      return [x_geom, y_geom, z_geom]
     end
   end
 end

data/lib/node/node_leaf.rb

@@ -3,9 +3,10 @@ require 'disp3D'
 
 module Disp3D
   class NodeLeaf < Node
-    attr_accessor :material_color
-    attr_accessor :colors
-    attr_accessor :shininess
+    attr_for_disp :material_color
+    attr_for_disp :colors
+    attr_for_disp :shininess
+    attr_for_disp :geom
 
     def initialize(geometry = nil, name = nil)
       Util3D.check_arg_type(Symbol, name, true)
@@ -17,11 +18,11 @@ module Disp3D
       @shininess = nil
       @shininess_default = 32.0
 
-      @list_created = false
+      @dislay_list_created = nil
     end
 
-    def draw
-      draw_inner(self.method(:draw_element))
+    def draw currnet_view
+      draw_inner(self.method(:draw_element), currnet_view)
     end
 
     def box
@@ -38,8 +39,12 @@ module Disp3D
       return box_transform(rtn_box)
     end
 
+    def update_for_display
+      @dislay_list_created = nil
+    end
+
 protected
-    def draw_inner(draw_element)
+    def draw_inner(draw_element, current_view)
       # colors���ݒ肳��Ă�����A�������D��I�ɕ\������B���̍ہA���C�e�B���O�̓I�t�ɂ���K�v������
       if(@colors.nil?)
         GL.Enable(GL::GL_LIGHTING)
@@ -58,15 +63,16 @@ protected
         GL.Disable(GL::GL_LIGHTING)
       end
 
-      if(@list_created == false)
-        @list_created = true
-        GL.NewList(@instance_id, GL::COMPILE_AND_EXECUTE)
+      if(@dislay_list_created.nil? || @dislay_list_created[current_view] == nil)
+        @dislay_list_created ||= Hash.new()
+        @dislay_list_created[current_view] = true
+        GL.NewList(self.instance_id, GL::COMPILE_AND_EXECUTE)
         pre_draw  # matrix manipulation
         draw_element.call
         post_draw # matrix manipulation
         GL.EndList()
       else
-        GL.CallList(@instance_id)
+        GL.CallList(self.instance_id)
       end
     end
 

data/lib/node/node_lines.rb

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

data/lib/node/node_points.rb

@@ -2,7 +2,7 @@ require 'disp3D'
 
 module Disp3D
   class NodePoints < NodeLeaf
-    attr_accessor :size
+    attr_for_disp :size
 
     def initialize(geom, name = nil)
       Util3D.check_arg_type(Symbol, name, true)
@@ -16,6 +16,7 @@ protected
       if(@geom)
         GL.PointSize(@size)
         draw_color
+        GL.Enable(GL::POINT_SMOOTH)
         GL.Begin(GL::POINTS)
         if(@geom.kind_of?(GMath3D::Vector3))
           GL.Vertex( @geom.x, @geom.y, @geom.z )

data/lib/node/node_polylines.rb

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

data/lib/node/node_rectangle.rb

@@ -3,18 +3,23 @@ require 'disp3D'
 module Disp3D
   class NodeRectangle < NodeLeaf
     # texture_image should be rmagick image
-    def initialize(geom, name = nil, texture_image = nil)
+    def initialize(geom, name = nil)
       Util3D.check_arg_type(Symbol, name, true)
       Util3D.check_arg_type(GMath3D::Rectangle, geom, false, false) #Array is not allowed
-      super(geom, name)
-      @image = texture_image
-      initialize_texture
+      super
     end
 
     def box
       return @geom.box
     end
 
+    def image=(texture_image)
+      Util3D.check_arg_type(Magick::Image, texture_image, true)
+      @image = texture_image
+      initialize_texture
+      update_for_display
+    end
+
 protected
     def draw_element
       if(@geom && @geom.kind_of?(GMath3D::Rectangle))

data/lib/node/node_sphere.rb

@@ -0,0 +1,28 @@
+require 'disp3D'
+
+module Disp3D
+  class NodeSphere < NodeLeaf
+    attr_for_disp :radius
+    attr_for_disp :center
+
+    def initialize(geom=nil, name=nil)
+      super
+      @radius = 1.0
+      @center = Vector3.new()
+      @slices = 10
+      @stacks = 10
+    end
+
+    def box
+      rtn_box = Box.new(Vector3.new(-@radius,-@radius,-@radius)+@center, Vector3.new(@radius,@radius,@radius)+@center)
+      return box_transform(rtn_box)
+    end
+
+protected
+    def draw_element
+      draw_color
+      GL.Translate(@center.x, @center.y, @center.z) if(@center)
+      GLUT.SolidSphere(@radius, @slices, @stacks)
+    end
+  end
+end

data/lib/node/node_tea_pod.rb

@@ -2,11 +2,11 @@ require 'disp3D'
 
 module Disp3D
   class NodeTeaPod < NodeLeaf
-    attr_accessor :size
+    attr_for_disp :size
 
-    def initialize(geom = nil, name = nil, size)
-      super(geom, name)
-      @size = size
+    def initialize(geom=nil, name=nil)
+      super
+      @size = 1.0
     end
 
     def box

data/lib/node/node_text.rb

@@ -2,8 +2,8 @@ require 'disp3D'
 
 module Disp3D
   class NodeText < NodeLeaf
-    attr_accessor :text
-    attr_accessor :position
+    attr_for_disp :text
+    attr_for_disp :position
 
     def initialize(position, name = nil, text = nil)
       Util3D.check_arg_type(Vector3, position)

data/lib/node/node_tris.rb

@@ -2,7 +2,7 @@ require 'disp3D'
 
 module Disp3D
   class NodeTris < NodeLeaf
-    attr_accessor :normal_mode
+    attr_for_disp :normal_mode
 
     NORMAL_EACH_FACE = 0
     NORMAL_EACH_VERTEX = 1

data/lib/node/node_workplane.rb

@@ -2,13 +2,15 @@ require 'disp3D'
 
 module Disp3D
   class NodeWorkplane < NodeLeaf
-    attr_accessor :length
+    attr_for_disp :length
+    attr_for_disp :grid
 
     def initialize(geom, name = nil)
       Util3D.check_arg_type(Symbol, name, true)
       Util3D.check_arg_type(GMath3D::Plane, geom, false)
       super
       @length = 1000
+      @grid = nil
     end
 
     def box
@@ -25,12 +27,42 @@ protected
           GL.Vertex( vertex.x, vertex.y, vertex.z )
         end
         GL.End()
+
+        GL.Color(0,0,0,1)
+        GL.LineWidth(3)
+        if(!@grid.nil?)
+          line_vertices_ary = grid_lines_vertices
+          GL.Begin(GL::LINES)
+          line_vertices_ary.each do |vertex|
+            GL.Vertex( vertex.x, vertex.y, vertex.z )
+          end
+          GL.End()
+        end
       else
         raise
       end
     end
 
 private
+    def grid_lines_vertices
+      count = (@length/@grid) + 1
+      u_vec = @geom.normal
+      u_vec = @geom.normal.arbitrary_orthogonal
+      v_vec = @geom.normal.cross(u_vec)
+      vertices = Array.new(count*4)
+      count.times.each do |idx|
+        point_tmp = @geom.base_point + u_vec * @grid * (idx - count/2)
+        vertices[2*idx] = point_tmp + v_vec * @length/2.0
+        vertices[2*idx+1] = point_tmp - v_vec * @length/2.0
+      end
+      count.times.each do |idx|
+        point_tmp = @geom.base_point + v_vec * @grid * (idx - count/2)
+        vertices[2*idx+2*count] = point_tmp + u_vec * @length/2.0
+        vertices[2*idx+2*count+1] = point_tmp - u_vec * @length/2.0
+      end
+      return vertices
+    end
+
     def calc_vertices
       tan_vec1 = @geom.normal.arbitrary_orthogonal
       tan_vec2 = @geom.normal.cross(tan_vec1)

data/lib/picker.rb

@@ -2,12 +2,106 @@ require 'disp3D'
 
 module Disp3D
   class Picker
+    attr_reader :pick_mode
+    attr_accessor :max_select_count
+
+    # pick modes
+    NONE = 0
+    POINT_PICK = 1
+    LINE_PICK = 2
+    RECT_PICK = 3
+
     def initialize(view)
       @view = view
       @max_select_count = 100
+      @pick_mode = NONE
+    end
+
+    def point_pick(x,y)
+      pick(x, y)
+    end
+
+    def post_picked(&block)
+      @post_pick_process = block
+    end
+
+    def start_point_pick(&block)
+      @pick_mode = POINT_PICK
+      post_picked(&block) if(block_given?)
+    end
+
+    def start_line_pick(&block)
+      @pick_mode = LINE_PICK
+      post_picked(&block) if(block_given?)
+    end
+
+    def start_rect_pick(&block)
+      @pick_mode = RECT_PICK
+      post_picked(&block) if(block_given?)
+    end
+
+    def end_pick
+      @pick_mode = NONE
+    end
+
+    # users donot need to use this.
+    def mouse(button,state,x,y)
+      return if(@pick_mode == NONE)
+      if(button == GLUT::GLUT_LEFT_BUTTON && state == GLUT::GLUT_DOWN)
+        if(@pick_mode == POINT_PICK)
+          picked_result = point_pick(x,y)
+          @post_pick_process.call(picked_result) if(!@post_pick_process.nil?)
+          return
+        elsif(@pick_mode == LINE_PICK)
+          @line_start_result = point_pick(x,y)
+        end
+        @last_pos = Vector3.new(x, y)
+        @rubber_band = false
+      elsif(button == GLUT::GLUT_LEFT_BUTTON && state == GLUT::GLUT_UP)
+        if(@pick_mode == LINE_PICK)
+          draw_rubber_band(FiniteLine.new(@last_pos, @save_pos)) # delete rubber band
+          line_end_result =  pick(x, y)
+          @post_pick_process.call(@line_start_result, line_end_result) if(!@post_pick_process.nil?)
+          @line_start_result = nil
+        elsif(@pick_mode == RECT_PICK)
+          draw_rubber_band(Box.new(@last_pos, @save_pos)) # delete rubber band
+          pick_x = (x + @last_pos.x)/2
+          pick_y = (y + @last_pos.y)/2
+          width  = (x - @last_pos.x).abs
+          height = (y - @last_pos.y).abs
+          picked_result = pick(pick_x, pick_y, width, height)
+          @post_pick_process.call(picked_result) if(!@post_pick_process.nil?)
+        end
+        @save_pos = nil
+        @last_pos = nil
+        @rubber_band = false
+      end
+    end
+
+    # users donot need to use this.
+    # return if picking process is in progress?
+    def motion(x,y)
+      return false if(@pick_mode == NONE || @last_pos.nil?)
+      if(@pick_mode == LINE_PICK)
+        if(@rubber_band)
+          draw_rubber_band([FiniteLine.new(@last_pos, @save_pos), FiniteLine.new(@last_pos, Vector3.new(x,y))])
+        else
+          draw_rubber_band(FiniteLine.new(@last_pos, Vector3.new(x,y)))
+        end
+      elsif(@pick_mode == RECT_PICK)
+        if(@rubber_band)
+          draw_rubber_band([Box.new(@last_pos, @save_pos), Box.new(@last_pos, Vector3.new(x,y))])
+        else
+          draw_rubber_band(Box.new(@last_pos, Vector3.new(x,y)))
+        end
+      end
+      @save_pos = Vector3.new(x, y)
+      @rubber_band=true
+      return true
     end
 
-    def pick(x,y)
+private
+    def pick(x, y, width = 1, height = 1)
       vp = GL.GetIntegerv(GL::VIEWPORT)
 
       selection = GL.SelectBuffer(@max_select_count)
@@ -19,7 +113,7 @@ module Disp3D
       GL.PushMatrix()
       GL.LoadIdentity()
 
-      GLU.PickMatrix(x, vp[3] - y - 1, 1, 1, vp)
+      GLU.PickMatrix(x, vp[3] - y - 1, width, height, vp)
       @view.camera.set_screen(vp[2], vp[3])
 
       GL.MatrixMode(GL::MODELVIEW)
@@ -47,7 +141,7 @@ module Disp3D
         node_info = Array.new()
         count.times do | j |
           path_id = data[4*i+3 + j]
-          picked_node = Node.find_node_by_path_id(path_id)
+          picked_node = NodePathDB.find_by_path_id(path_id)
           if (picked_node != nil)
             parent_node = picked_node.parents.find {|parent| parent.include?(path_id) }
             picked_node_info = PathInfo.new(picked_node, parent_node, path_id)
@@ -58,5 +152,65 @@ module Disp3D
       end
       return picked_result
     end
+
+    def pre_rubber_band_process
+      dmy,dmy, w,h = GL.GetIntegerv(GL::VIEWPORT)
+      @view.camera.set_projection_for_camera_scene
+      GL.MatrixMode(GL::GL_MODELVIEW)
+      GL.PushMatrix()
+      GL.LoadIdentity()
+      GLU.LookAt(0, 0, 1, 0, 0, 0, 0, 1, 0)
+
+      GL.Enable(GL::COLOR_LOGIC_OP)
+      GL.LogicOp(GL::INVERT)
+      GL.DrawBuffer( GL::FRONT )
+
+      GL.LineWidth(2)
+
+      return w,h
+    end
+
+    def post_rubber_band_process
+      GL.Flush()
+
+      GL.Disable(GL::COLOR_LOGIC_OP)
+      GL.LogicOp(GL::COPY)
+
+      GL.PopMatrix()
+    end
+
+    # [Input]
+    #  _elemnets_ should be FiniteLine or Box or Array of them.
+    def draw_rubber_band(elements)
+      w,h = pre_rubber_band_process
+      draw_rubber_band_lines_inner(elements, w, h)
+      post_rubber_band_process
+    end
+
+    def screen_to_rubberband( vec, w , h )
+      [-w/2 + vec.x, h/2 - vec.y - 1]
+    end
+
+    def draw_rubber_band_lines_inner(elements, w, h)
+      return if(elements.nil?)
+      if(elements.kind_of?(FiniteLine))
+        GL.Begin(GL::LINES)
+        GL.Vertex(screen_to_rubberband( elements.start_point, w, h ))
+        GL.Vertex(screen_to_rubberband( elements.end_point, w, h  ))
+        GL.End()
+      elsif(elements.kind_of?(Box))
+        box = elements
+        lines = Array.new(4)
+        lines[0] = FiniteLine.new(Vector3.new(box.min_point.x, box.min_point.y), Vector3.new(box.max_point.x, box.min_point.y))
+        lines[1] = FiniteLine.new(Vector3.new(box.max_point.x, box.min_point.y), Vector3.new(box.max_point.x, box.max_point.y))
+        lines[2] = FiniteLine.new(Vector3.new(box.max_point.x, box.max_point.y), Vector3.new(box.min_point.x, box.max_point.y))
+        lines[3] = FiniteLine.new(Vector3.new(box.min_point.x, box.max_point.y), Vector3.new(box.min_point.x, box.min_point.y))
+        draw_rubber_band_lines_inner(lines, w, h)
+      elsif(elements.kind_of?(Array))
+        elements.each do |item|
+          draw_rubber_band_lines_inner(item, w, h)
+        end
+      end
+    end
   end
 end