disp3D 0.1.0 → 0.1.1

data/lib/disp3D.rb

@@ -5,14 +5,30 @@ require 'gmath3D'
 require 'opengl'
 require 'glut'
 
-require 'view'
+require 'util'
+require 'dsl'
+require 'stl'
+
+require 'gl_view'
+
+require 'glut_window'
+
 require 'camera'
+require 'light'
 require 'manipulator'
+require 'picker'
+require 'picked_result'
 require 'scene_graph'
+
 require 'node'
 require 'node_collection'
+require 'node_leaf'
 
 require 'node_tea_pod'
-require 'node_lines'
-require 'node_points'
+require 'node_text'
 
+require 'node_points'
+require 'node_lines'
+require 'node_polylines'
+require 'node_tris'
+require 'node_arrows'

data/lib/dsl.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+require 'disp3D'
+
+module Disp3D
+  # SDLは３次元ビューに対して操作を行うための、ミニ言語である。
+  # 基本的にユーザーはこのインターフェースによって、３次元ビューに対して操作する
+  class GLView
+    # 表示要素に対する操作
+    # (例)
+    # 括弧内は入れても入れなくてもよい
+    # Create Point named point1 [0,0,0]
+    # Create Points named points [[0,0,1], [1,0,1], [1,2,1]]
+    # Create Line named line1 from[0,0,0] to[1,2,0]
+    # Create Plane named plane1 base[0,0,0] normal[0,0,1]
+    # Create Polyline named polyline1 (vertices) [[1,2,1], [1,4,3], [1,2,4]]
+    # →これによって、geometryの要素を作成する
+  end
+end

data/lib/gl_view.rb

@@ -0,0 +1,80 @@
+require 'disp3D'
+
+module Disp3D
+  # GLView class hold primary object for 3D displaying like camera, scene_graph.
+  # User never use this class
+  # Use QtWidgetGL class (in Qt Application)
+  # Use GLWindow class (in GLUT Window)
+  class GLView
+    attr_reader :world_scene_graph
+    attr_reader :camera
+    attr_reader :manipulator
+    attr_reader :light
+    attr_reader :picker
+
+    attr_reader :mouse_move_proc
+    attr_reader :mouse_press_proc
+    attr_reader :mouse_release_proc
+
+    attr_accessor :bk_color
+
+    def initialize(width, height)
+      GL.Enable(GL::GL_DEPTH_TEST)
+
+      GL.FrontFace(GL::GL_CW)
+
+      GL.Enable(GL::GL_AUTO_NORMAL)
+      GL.Enable(GL::GL_NORMALIZE)
+
+      GL.Enable(GL::GL_DEPTH_TEST)
+      GL.DepthFunc(GL::GL_LESS)
+
+      GL.Enable(GL::BLEND)
+      GL.BlendFunc(GL::GL_SRC_ALPHA, GL::GL_ONE_MINUS_SRC_ALPHA)
+
+      @light = Light.new()
+      @camera = Camera.new()
+      @manipulator = Manipulator.new(@camera, width, height)
+      @world_scene_graph = SceneGraph.new()
+      @picker = Picker.new(self)
+      @bk_color = [0.28,0.23,0.55,1]
+
+      @mouse_move_proc = nil
+    end
+
+    def display()
+      GL.ClearColor(@bk_color[0],@bk_color[1],@bk_color[2],@bk_color[3])
+      GL.Clear(GL::GL_COLOR_BUFFER_BIT | GL::GL_DEPTH_BUFFER_BIT)
+
+      @light.display() if(@light)
+
+      @camera.display() if(@camera)
+      @world_scene_graph.display() if(@world_scene_graph)
+    end
+
+    def centering
+      center_pos =  @world_scene_graph.bounding_box.center * -1 # TODO refactaring vector3.rb
+      @manipulator.centering(center_pos)
+    end
+
+    def fit
+      centering
+      length = @world_scene_graph.bounding_box.length # TODO refactaring box.rb
+      orth_length = Math.sqrt( length[0]*length[0] + length[1]*length[1] + length[2]*length[2] )
+      @manipulator.fit(orth_length/2.0)
+    end
+
+    def set_mouse_move(proc)
+      @mouse_move_proc = proc
+    end
+
+    def set_mouse_press(proc)
+      @mouse_press_proc = proc
+    end
+
+    def set_mouse_release(proc)
+      @mouse_release_proc = proc
+    end
+
+  end
+end

data/lib/glut_window.rb

@@ -0,0 +1,60 @@
+require 'disp3D'
+
+module Disp3D
+  class GLUTWindow < GLView
+    def initialize(width, height)
+      x = 100
+      y = 100
+      GLUT.InitWindowPosition(x, y)
+      GLUT.InitWindowSize(width, height)
+      GLUT.Init
+      GLUT.InitDisplayMode(GLUT::GLUT_DOUBLE | GLUT::GLUT_RGB | GLUT::GLUT_DEPTH)
+      GLUT.CreateWindow("Disp3D view test")
+      GLUT.DisplayFunc(method(:display).to_proc())
+      GLUT.ReshapeFunc(method(:reshape).to_proc())
+
+      GLUT.MouseFunc(method(:mouse).to_proc())
+      GLUT.MotionFunc(method(:motion).to_proc())
+      GLUT.PassiveMotionFunc(method(:passive_motion).to_proc())
+
+      super(width, height)
+    end
+
+    def display
+      super
+      GLUT.SwapBuffers()
+    end
+
+    def reshape(w,h)
+      @camera.reshape(w,h)
+    end
+
+    def mouse(button,state,x,y)
+      if(state == GLUT::GLUT_UP)
+        @mouse_release_proc.call(self, button, x, y) if( @mouse_release_proc != nil)
+      elsif(state == GLUT::GLUT_DOWN)
+        @mouse_press_proc.call(self, button, x, y) if( @mouse_press_proc != nil)
+      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)
+        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

@@ -0,0 +1,49 @@
+require 'disp3D'
+
+module Disp3D
+  class Light
+    LIGHT_POSITION_1 = [0.25, 1.0, 0.25]
+
+    def 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
+      GL.Enable(GL::GL_LIGHT0) if(all_disable)
+    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.25, 1.0, 0.25]
+
+      light_count = 8 # openGL spec
+
+      @enable = [true, false, false, false, false, false, false, false]
+      @deffuse = 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)
+      @light_id = Array.new(light_count)
+      @light_id[0] = GL::GL_LIGHT0
+      @light_id[1] = GL::GL_LIGHT1
+      @light_id[2] = GL::GL_LIGHT2
+      @light_id[3] = GL::GL_LIGHT3
+      @light_id[4] = GL::GL_LIGHT4
+      @light_id[5] = GL::GL_LIGHT5
+      @light_id[6] = GL::GL_LIGHT6
+      @light_id[7] = GL::GL_LIGHT7
+    end
+
+  end
+end

data/lib/manipulator.rb

@@ -1,41 +1,112 @@
 require 'disp3D'
 
+include GMath3D
 module Disp3D
   class Manipulator
+    def initialize(camera, w, h)
+      @camera = camera
+      @start_x = 0
+      @start_y = 0
+      reset_size(w, h)
+
+      @moving = false
+      @scalling = false
+      @translating = false
+      @trackball_size = 0.8
+    end
+
+    def reset_size(width, height)
+      @width = width
+      @height = height
+    end
+
     def mouse(button,state,x,y)
-      if button == GLUT::GLUT_LEFT_BUTTON && state == GLUT::GLUT_DOWN then
+      if (state == GLUT::GLUT_DOWN &&
+          ((button == GLUT::GLUT_RIGHT_BUTTON && @moving == true) ||
+          (button == GLUT::GLUT_LEFT_BUTTON && @scalling == true) ))
+        # pushed left and right at the same time
+        @translating = true
+        @start_x = x
+        @start_y = y
+      elsif (button == GLUT::GLUT_RIGHT_BUTTON && state == GLUT::GLUT_DOWN)
+        @scalling = true
+        @start_y = y
+      elsif ( button == GLUT::GLUT_LEFT_BUTTON && state == GLUT::GLUT_DOWN )
+        @moving = true
         @start_x = x
         @start_y = y
-        @drag_flg = true
-      elsif state == GLUT::GLUT_UP then
-        @drag_flg = false
+      elsif ( button == GLUT::GLUT_RIGHT_BUTTON && state == GLUT::GLUT_UP )
+        @scalling = false
+        @translating = false
+      elsif ( button == GLUT::GLUT_LEFT_BUTTON && state == GLUT::GLUT_UP )
+        @moving = false
+        @translating = false
       end
     end
 
+    # return true if should be redisplay
     def motion(x,y)
-      if @drag_flg then
-        dx = x - @start_x
-        dy = y - @start_y
+      if( @translating )
+        delta_x = 2*((@start_x - x).to_f/@width)
+        delta_y = 2*((@start_y - y).to_f/@height)
+        @start_x = x
+        @start_y = y
 
-        @camera.rotY += dx
-        @camera.rotY = @camera.rotY % 360
+        @camera.translate.x -= delta_x
+        @camera.translate.y += delta_y
+        return true
+      elsif ( @scalling )
+        @camera.scale *= (1.0+(@start_y - y).to_f/@height)
+        @start_y = y
+        return true
+      elsif ( @moving )
+        @lastquat =trackball(
+                   (2.0 * @start_x - @width) / @width,
+                   (@height - 2.0 * @start_y) / @height,
+                   (2.0 * x - @width) / @width,
+                   (@height - 2.0 * y) / @height)
+        @start_x = x
+        @start_y = y
+        @camera.rotation = @lastquat * @camera.rotation if( @lastquat )
+        return true
+      end
+      return false
+    end
 
-        @camera.rotX += dy
-        @camera.rotX = @camera.rotX % 360
+    def project_to_sphere(r, x, y)
+      d = Math.sqrt(x*x + y*y)
+      if (d < r * Math.sqrt(2)/2) # inside sphere
+        z = Math.sqrt(r*r - d*d)
+      else
+        t = r / Math.sqrt(2)
+        z = t*t / d
       end
-      @start_x = x
-      @start_y = y
-      GLUT.PostRedisplay()
+      return z
     end
 
-    def initialize(camera)
-      @camera = camera
-      @start_x = 0
-      @start_y = 0
-      @drag_flg = false
+    def trackball(p1x, p1y, p2x, p2y)
+      if( p1x == p2x && p1y == p2y)
+        return Quat.new(0,0,0,1)
+      end
+      p1 = Vector3.new( p1x, p1y, project_to_sphere(@trackball_size, p1x, p1y))
+      p2 = Vector3.new( p2x, p2y, project_to_sphere(@trackball_size, p2x, p2y))
+      a = p1.cross(p2)
+      d = p1 - p2
+      t = d.length / (2*@trackball_size)
+      t = 1 if( t > 1)
+      t = -1 if( t < -1 )
+      phi = 2*Math.asin(t)
+      a = a.normalize
+      return Quat.from_axis(a, phi)
+    end
+
+    def centering(center_pos)
+      return if center_pos == nil
+      @camera.translate = center_pos
+    end
 
-      GLUT.MouseFunc(method(:mouse).to_proc())
-      GLUT.MotionFunc(method(:motion).to_proc())
+    def fit(radius)
+      @camera.fit(radius, @width, @height)
     end
   end
 end

data/lib/node.rb

@@ -2,16 +2,22 @@ require 'disp3D'
 
 module Disp3D
   class Node
-    attr_accessor :geom
-
     attr_accessor :translate
 
-    attr_accessor :color
+    @@named_nodes = nil
+    def initialize(geometry)
+      @translate = nil
+    end
 
-    def pre_draw
-      GL.Color(@color[0], @color[1], @color[2]) if(@color && @color.size == 3)
-      GL.Color(@color[0], @color[1], @color[2], @color[3]) if(@color && @color.size == 4)
+    def self.init_node_list
+      @@named_nodes = Hash.new
+    end
 
+    def self.from_id(id)
+      return @@named_nodes[id]
+    end
+
+    def pre_draw
       GL.PushMatrix()
       GL.Translate(translate[0], translate[1], translate[2]) if(@translate)
     end
@@ -20,9 +26,9 @@ module Disp3D
       GL.PopMatrix()
     end
 
-    def initialize(geometry)
-      @geom = geometry
-      @color = [1.0, 1.0, 1.0]
+    def box
+      # should be implimented in child class
+      raise
     end
   end
 end

data/lib/node_arrows.rb

@@ -0,0 +1,68 @@
+require 'disp3D'
+
+module Disp3D
+  class NodeArrows < NodeLeaf
+    attr_accessor :width
+
+protected
+    def draw_element
+      if(@geom)
+        GL.ShadeModel(GL::FLAT)
+        GL.LineWidth(@width) if(@width)
+        GL.Begin(GL::LINES)
+        if(@geom.kind_of?(GMath3D::FiniteLine))
+          draw_element_inner(@geom)
+        elsif(@geom.kind_of?(Array))
+          @geom.each do |line|
+            draw_element_inner(line)
+          end
+        end
+        GL.End()
+      end
+    end
+
+    def draw_element_inner(line)
+      start_point = line.start_point
+      end_point = line.end_point
+
+      GL.Vertex( start_point.x, start_point.y, start_point.z )
+      GL.Vertex( end_point.x, end_point.y, end_point.z )
+
+      # draw arrow head!
+      head_angle = 15.0 ;
+      head_ratio = 0.2 ;
+
+      vector = line.direction
+      orh = vector.arbitrary_orthogonal
+      orh2 = vector.cross(orh)
+      orh2 = orh2.normalize
+
+      body_length = vector.length
+      orh_length = body_length*Math.tan(head_angle*Math::PI/180.0)
+
+      head_vec1 = Vector3.new( -vector.x + orh.x*orh_length, -vector.y + orh.y*orh_length, -vector.z + orh.z*orh_length )
+      head_vec2 = Vector3.new( -vector.x + orh2.x*orh_length, -vector.y + orh2.y*orh_length, -vector.z + orh2.z*orh_length )
+      head_vec3 = Vector3.new( -vector.x - orh.x*orh_length, -vector.y - orh.y*orh_length, -vector.z - orh.z*orh_length )
+      head_vec4 = Vector3.new( -vector.x - orh2.x*orh_length, -vector.y - orh2.y*orh_length, -vector.z - orh2.z*orh_length )
+
+      head_bases = Array.new(4)
+      head_bases[0] = Vector3.new( end_point.x + head_vec1.x*head_ratio, end_point.y + head_vec1.y*head_ratio, end_point.z + head_vec1.z*head_ratio )
+      head_bases[1] = Vector3.new( end_point.x + head_vec2.x*head_ratio, end_point.y + head_vec2.y*head_ratio, end_point.z + head_vec2.z*head_ratio )
+      head_bases[2] = Vector3.new( end_point.x + head_vec3.x*head_ratio, end_point.y + head_vec3.y*head_ratio, end_point.z + head_vec3.z*head_ratio )
+      head_bases[3] = Vector3.new( end_point.x + head_vec4.x*head_ratio, end_point.y + head_vec4.y*head_ratio, end_point.z + head_vec4.z*head_ratio )
+
+      head_bases.each do | head_base |
+        GL.Vertex( head_base.x, head_base.y, head_base.z )
+        GL.Vertex( end_point.x, end_point.y, end_point.z )
+      end
+
+      arrow_size_minus = head_bases.size - 1
+      arrow_size_minus.times do |i|
+        GL.Vertex( head_bases[i  ].x, head_bases[i  ].y, head_bases[i  ].z )
+        GL.Vertex( head_bases[i+1].x, head_bases[i+1].y, head_bases[i+1].z )
+      end
+      GL.Vertex( head_bases[arrow_size_minus].x, head_bases[arrow_size_minus].y, head_bases[arrow_size_minus].z )
+      GL.Vertex( head_bases[0].x, head_bases[0].y, head_bases[0].z )
+    end
+  end
+end