teien 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in teien.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 abexsoft@gmail.com
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,34 @@
+# Teien
+
+Teien will be a platform to make 3D world easily with Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'teien'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby-ogre
+    $ gem install ruby-bullet
+    $ gem install teienlib
+    $ gem install pkg/teien-<version>.gem
+
+## Usage
+
+Run a sample application.
+
+     $ /var/lib/gems/1.9.1/gems/teien-<version>/sample/standalone/hello_garden/run
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/teien

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+# This script is a environment setting helper on the startup.
+# 1. set a LD_LIBRARY_PATH(or PATH) value for dynamic libraries.
+# 2. restart with above value.
+# 3. set a LOAD_PATH value for ruby libraries.
+
+if (ARGV[0] == "-h" || ARGV[0] == "--help")
+  puts "Usage: teien file"
+  exit
+end
+
+#
+# require this file directly at first line, unless you set 
+# RUBYLIB and LD_LIBRARY_PATH. (check sample code)
+#
+require 'rbconfig'
+require 'OgreConfig'
+
+$topDir = File.dirname(File.dirname(File.expand_path(__FILE__)))
+libPath  = $topDir  + "/lib"
+extPath  = OgreConfig::getDepsLibPath
+
+# needed by dynamic library.
+if (/mingw/ =~ RUBY_PLATFORM)
+  ldLibPath = extPath + ";" + OgreConfig::getLib + ";" + libPath
+  if (ENV["PATH"] == nil)
+    ENV["PATH"] =  ldLibPath
+    exec("ruby #{$0} #{ARGV.join(" ")}")
+  elsif (!ENV["PATH"].include?(ldLibPath))
+    ENV["PATH"] = ldLibPath + ";" +ENV["PATH"]
+    exec("ruby #{$0} #{ARGV.join(" ")}")
+  end
+else
+  ldLibPath = extPath + ":" + libPath
+  if (ENV["LD_LIBRARY_PATH"] == nil)
+    ENV["LD_LIBRARY_PATH"] = ldLibPath
+    exec($0, *ARGV)
+  elsif(!ENV["LD_LIBRARY_PATH"].include?(ldLibPath))
+    ENV["LD_LIBRARY_PATH"] = ldLibPath + ":" + ENV["LD_LIBRARY_PATH"]
+    exec($0, *ARGV)
+  end
+end
+
+$LOAD_PATH.push(libPath)
+$LOAD_PATH.push("./")
+
+load ARGV[0]
+

data/lib/teien/animation_operator.rb

@@ -0,0 +1,142 @@
+class AnimationOperator
+  BL_MODE_SWITCH = 0      # stop current animation and start next animation.
+  BL_MODE_CONCURRENT = 1  # cross fade, blend current animation out while blending next animation in.
+  BL_MODE_FIRSTFRAME = 2  # blend current animation to first frame of next animation, when done, start next animation.
+
+  def initialize(entity)
+    @entity = entity
+    @state = nil
+    @nextState = nil
+    @mode = BL_MODE_CONCURRENT
+    @duration = 0.2
+    @timeLeft = 0
+    @complete = false
+    @loop = false
+
+#    @blender = Ogrelet::AnimationBlender.new(entity)
+  end
+
+  def init(name, loop)
+    initializeAllAnimations()
+    play(name, loop)
+  end
+
+  def initializeAllAnimations()
+    set = @entity.getAllAnimationStates()
+    set.each_AnimationState {|state|
+      state.setEnabled(false)
+      state.setWeight(0)
+      state.setTimePosition(0)
+    }
+  end
+
+  def setEnabled(bl)
+#    @blender.getSource().setEnabled(bl)
+  end
+
+  def setBlendingMode(mode)
+    @mode = mode
+  end
+
+  def setBlengingDuration(duration)
+    @duration = duration
+  end
+
+  def play(name, loop)
+    @loop = loop
+
+    unless @state
+      @state = @entity.getAnimationState(name)
+      @state.setEnabled(true)
+      @state.setWeight(1)
+      @state.setTimePosition(0)
+      @state.setLoop(loop)
+      return
+    end
+
+    case @mode
+    when BL_MODE_SWITCH
+      @state.setEnabled(false)
+      @state = @entity.getAnimationState(name)
+      @state.setEnabled(true)
+      @state.setWeight(1)
+      @state.setTimePosition(0)
+      @timeLeft = 0
+    else
+      newState = @entity.getAnimationState(name)
+      if @timeLeft > 0
+        if newState.getAnimationName == @nextState.getAnimationName
+          return
+        elsif newState.getAnimationName == @state.getAnimationName
+          # going back to the source state
+          @state = @nextState
+          @nextState = newState
+          @timeLeft = @duration - @timeLeft
+        else
+          if @timeLeft < @duration * 0.5
+            # simply replace the target with this one
+            @nextState.setEnabled(false)
+            @nextState.setWeight(0)
+          else
+            # old target becomes new source
+            @state.setEnabled(false)
+            @state.setWeight(0)
+            @state = @nextState
+          end
+
+          @nextState = newState
+          @nextState.setEnabled(true)
+          @nextState.setWeight( 1.0 - @timeLeft / @duration )
+          @nextState.setTimePosition(0)
+        end
+      else
+        return if newState.getAnimationName == @state.getAnimationName
+                  
+        # assert( target == 0, "target should be 0 when not blending" )
+        # @state.setEnabled(true)
+        # @state.setWeight(1)
+        # mTransition = transition;
+        @timeLeft = @duration
+        @nextState = newState
+        @nextState.setEnabled(true)
+        @nextState.setWeight(0)
+        @nextState.setTimePosition(0)
+      end
+    end
+#    @blender.blend(name, Ogrelet::AnimationBlender::BlendWhileAnimating, 0.2, loop)
+  end
+
+  def addTime(delta)
+    if @state
+      if @timeLeft > 0
+        @timeLeft -= delta
+        
+        if @timeLeft < 0
+          @state.setEnabled(false)
+          @state.setWeight(0)
+          @state = @nextState
+          @state.setEnabled(true)
+          @state.setWeight(1)
+          @nextState = nil
+        else
+          # still blending, advance weights
+          @state.setWeight(@timeLeft / @duration)
+          @nextState.setWeight(1.0 - @timeLeft / @duration)
+          if(@mode  == BL_MODE_CONCURRENT)
+            @nextState.addTime(delta)
+          end
+        end
+      end
+      
+      if @state.getTimePosition() >= @state.getLength()
+        @complete = true
+      else
+        @complete = false
+      end
+
+      @state.addTime(delta)
+      @state.setLoop(@loop)
+    end
+    #    @blender.addTime(delta)
+  end
+end

data/lib/teien/camera.rb

@@ -0,0 +1,25 @@
+require 'teien/camera_mover'
+
+module Teien
+
+class Camera
+    def initialize(cam)
+      # Ogre::Camera
+      @camera = cam
+      @mover = CameraMover.new(cam)
+    end
+
+    def get_mover()
+      return @mover
+    end
+
+    def get_position
+      return Vector3D.to_self(@camera.getPosition())
+    end
+
+    def get_direction
+      return Vector3D.to_self(@camera.getDirection())
+    end
+end
+
+end

data/lib/teien/camera_mover.rb

@@ -0,0 +1,193 @@
+module Teien
+
+class CameraMover
+  CS_FREELOOK = 0
+  CS_ORBIT = 1
+  CS_MANUAL = 2
+  CS_TPS = 3
+
+  CAM_HEIGHT = 5.0
+
+  attr_accessor :height
+  attr_accessor :camera_pivot
+  attr_accessor :camera
+
+  def initialize(cam)
+    @camera = cam
+    @camera.setPosition(0, 0, 0)
+    @camera.setNearClipDistance(0.1)
+
+    @style = CS_FREELOOK
+
+    # CS_FREELOOK, CS_ORBIT, CS_MANUAL
+    @sdk_camera_man = OgreBites::SdkCameraMan.new(@camera)
+    @evt_frame = Ogre::FrameEvent.new
+
+    # CS_TPS
+    @height = CAM_HEIGHT
+    @camera_pivot = cam.getSceneManager().getRootSceneNode().createChildSceneNode()
+    @camera_goal = @camera_pivot.createChildSceneNode(Ogre::Vector3.new(0, 0, 5))
+
+    @camera_pivot.setFixedYawAxis(true)
+    @camera_goal.setFixedYawAxis(true)
+
+    @pivot_pitch = 0
+
+  end
+
+  def set_style(style)
+    @style = style
+    case @style
+    when CS_FREELOOK
+      @sdk_camera_man.setStyle(OgreBites::CS_FREELOOK)
+    when CS_ORBIT
+      @sdk_camera_man.setStyle(OgreBites::CS_ORBIT)
+    else  # CS_MANUAL, CS_TPS
+      @sdk_camera_man.setStyle(OgreBites::CS_MANUAL)
+    end
+  end
+
+  def set_target(target)
+    @target = target
+    if @style == CS_TPS
+      @camera.setAutoTracking(false)
+      @camera.moveRelative(Ogre::Vector3.new(0, 0, 0))
+      update_camera(1.0)
+    else
+      @sdk_camera_man.setTarget(target.pivotSceneNode)
+    end
+  end
+
+  def set_position(pos)
+    @camera.setPosition(Vector3D.to_ogre(pos)) if @style == CS_FREELOOK
+  end
+
+  def look_at(pos)
+    @camera.lookAt(Vector3D.to_ogre(pos)) if @style == CS_FREELOOK
+  end
+
+  def set_yaw_pitch_dist(yaw, pitch, dist)
+    @sdk_camera_man.setYawPitchDist(yaw, pitch, dist) if @style == CS_ORBIT
+  end
+
+  def move_forward(bl)
+    evt = OIS::KeyEvent.new(nil, OIS::KC_W, 0)
+    if bl
+      @sdk_camera_man.injectKeyDown(evt)
+    else
+      @sdk_camera_man.injectKeyUp(evt)
+    end
+  end
+
+  def move_backward(bl)
+    evt = OIS::KeyEvent.new(nil, OIS::KC_S, 0)
+    if bl
+      @sdk_camera_man.injectKeyDown(evt)
+    else
+      @sdk_camera_man.injectKeyUp(evt)
+    end
+  end
+
+  def move_left(bl)
+    evt = OIS::KeyEvent.new(nil, OIS::KC_A, 0)
+    if bl
+      @sdk_camera_man.injectKeyDown(evt)
+    else
+      @sdk_camera_man.injectKeyUp(evt)
+    end
+  end
+
+  def move_right(bl)
+    evt = OIS::KeyEvent.new(nil, OIS::KC_D, 0)
+    if bl
+      @sdk_camera_man.injectKeyDown(evt)
+    else
+      @sdk_camera_man.injectKeyUp(evt)
+    end
+  end
+
+
+  def update(delta)
+    if (@style == CS_TPS)
+      update_camera(delta)
+    else
+      @evt_frame.timeSinceLastFrame = delta
+      @sdk_camera_man.frameRenderingQueued(@evt_frame)
+    end
+  end
+
+  #
+  # This method moves this camera position to the goal position smoothly.
+  # In general, should be called in the frameRenderingQueued handler.
+  #
+  def update_camera(deltaTime)
+    # place the camera pivot roughly at the character's shoulder
+    @camera_pivot.setPosition(Vector3D::to_ogre(@target.get_position()) + Ogre::Vector3.UNIT_Y * @height)
+    # move the camera smoothly to the goal
+    goalOffset = @camera_goal._getDerivedPosition() - @camera.getPosition()
+    @camera.move(goalOffset * deltaTime * 9.0)
+    # always look at the pivot
+    @camera.lookAt(@camera_pivot._getDerivedPosition())
+  end
+
+  def mouse_moved(evt)
+    if @style == CS_TPS
+
+      # deal with a warp.
+      if evt.state.X.rel.abs > 300
+        #puts "#{evt.state.X.rel}, #{evt.state.X.abs}"
+        return true
+      end
+
+      update_camera_goal(-0.05 * evt.state.X.rel, 
+                         -0.05 * evt.state.Y.rel, 
+                         -0.0005 * evt.state.Z.rel)
+    else
+      @sdk_camera_man.injectMouseMove(evt)      
+    end    
+    return true
+  end
+
+  #
+  # This method updates the goal position, which this camera should be placed finally.
+  # In general, should be called when the mouse is moved.
+  # *deltaYaw*::_float_, degree value.
+  # *deltaPitch*::_float_, degree value.
+  # *deltaZoom*::_float_, zoom 
+  #
+  def update_camera_goal(deltaYaw, deltaPitch, deltaZoom)
+
+    @camera_pivot.yaw(Ogre::Radian.new(Ogre::Degree.new(deltaYaw)), Ogre::Node::TS_WORLD);
+
+    # bound the pitch
+    if (!(@pivot_pitch + deltaPitch > 25 && deltaPitch > 0) &&
+        !(@pivot_pitch + deltaPitch < -60 && deltaPitch < 0))
+      @camera_pivot.pitch(Ogre::Radian.new(Ogre::Degree.new(deltaPitch)), Ogre::Node::TS_LOCAL)
+      @pivot_pitch += deltaPitch;
+    end
+    dist = @camera_goal._getDerivedPosition().distance(@camera_pivot._getDerivedPosition())
+    distChange = deltaZoom * dist;
+
+#    puts "dist: #{dist}:#{distChange}"
+
+    # bound the zoom
+    if (!(dist + distChange < 8 && distChange < 0) &&
+        !(dist + distChange > 25 && distChange > 0))
+
+      @camera_goal.translate(Ogre::Vector3.new(0, 0, distChange), Ogre::Node::TS_LOCAL)
+    end
+  end
+
+  def mouse_pressed(mouseEvent, mouseButtonID)
+    @sdk_camera_man.injectMouseDown(mouseEvent, mouseButtonID) if @style == CS_ORBIT
+    return true
+  end
+
+  def mouse_released(mouseEvent, mouseButtonID)
+    @sdk_camera_man.injectMouseUp(mouseEvent, mouseButtonID) if @style == CS_ORBIT
+    return true
+  end
+  
+end
+
+end

data/lib/teien/garden.rb

@@ -0,0 +1,203 @@
+require "teien/garden_object.rb"
+require "teien/light_object.rb"
+require "teien/object_factory.rb"
+require "teien/view.rb"
+#require "teien/server_view.rb"
+require "teien/physics.rb"
+require "teien/user_interface.rb"
+#require "teien/server_user_interface.rb"
+
+module Teien
+
+# This is a top object of 3D world.
+class Garden
+  attr_accessor :view
+  attr_accessor :physics
+  attr_accessor :resources_cfg
+  attr_accessor :plugins_cfg
+  attr_accessor :objects
+  attr_accessor :object_factory
+  attr_accessor :is_server
+
+  #
+  # _script_klass_:: : set a user define class.
+  # 
+  def initialize(script_klass)
+    @view = nil
+    @physics = nil
+    @script_klass = script_klass
+
+    @resources_cfg = nil
+    @plugins_cfg = nil
+    @objects = {}
+    @object_num = 0
+
+    @object_factory = ObjectFactory.new(self)
+
+    @is_server = false
+    @debug_draw = false
+    @quit = false
+  end
+
+  #
+  # set a title name on the window title bar.
+  #
+  # _title_ :: : set a name(String).
+  #
+  def set_window_title(title)
+    @view.window_title = title unless @is_server
+  end
+  
+  #
+  # set the gravity of the world.
+  #
+  # _grav_ :: : set a vector(Vector3D) as the gravity.
+  #
+  def set_gravity(grav)
+    @physics.set_gravity(grav)
+  end
+
+  #
+  # set the ambient light of the world.
+  #
+  # _color_:: : set a color(Color).
+  #
+  def set_ambient_light(color)
+    @view.scene_mgr.setAmbientLight(color)
+  end
+
+  def set_sky_dome(enable, materialName, curvature = 10, tiling = 8, distance = 4000)
+    @view.scene_mgr.setSkyDome(enable, materialName, curvature, tiling, distance)
+  end
+
+  def set_debug_draw(bl)
+    if (bl)
+      @debug_draw = bl
+      @debug_drawer = Ogrelet::DebugDrawer.new(@view.scene_mgr)
+      @physics.dynamicsWorld.setDebugDrawer(@debug_drawer)
+    end      
+  end
+
+  def create_user_interface()
+    if @is_server
+      return ServerUserInterface.new(@view)
+    else
+      return UserInterface.new(@view)
+    end
+  end
+
+  def create_object(name, objectInfo, physicsInfo)
+    return @object_factory.create_object(name, objectInfo, physicsInfo)
+  end
+
+  def create_light(name)
+    return LightObject.new(self, name)
+  end
+
+  def add_object(obj, collision_filter = nil)
+    if (@objects[obj.name] == nil)
+      if (obj.rigid_body != nil)
+        if (collision_filter)
+          @physics.add_rigid_body(obj.rigid_body, collision_filter) 
+        else
+          @physics.add_rigid_body(obj.rigid_body) 
+        end
+      end
+      @objects[obj.name] = obj
+      obj.id = @object_num
+      @object_num += 1
+    else
+      raise RuntimeError, "There is a object with the same name (#{obj.name})"
+    end
+  end
+
+  def check_collision(objectA, objectB)
+    result = @physics.contact_pair_test(objectA.rigid_body, objectB.rigid_body)
+    return result.isCollided
+  end
+
+  def setup()
+    if @is_server
+      @view = ServerView.new(self)
+    else
+      @view = View.new(self)
+    end
+
+    @physics = Physics.new(self)
+    @script = @script_klass.new(self)
+
+    if @view.setup()
+      @view.start(@script)
+      @view.prepare_render_loop()
+
+      @physics.setup()
+      @script.setup()
+
+      return true
+    else
+      return false
+    end
+  end
+
+  #
+  # mainloop
+  #
+  def run()
+    return false unless setup()
+
+    last_time = Time.now.to_f
+    while !@quit
+      now_time = Time.now.to_f
+      delta = now_time - last_time
+      last_time = now_time
+      break unless update(delta)
+    end
+    
+    finalize()
+
+    return true
+  end
+
+  
+  def update(delta)
+    @physics.dynamics_world.debugDrawWorld() if @debug_draw
+
+    return @view.update(delta)
+  end
+
+  # called from view.update()
+  # This function is divided from update() by the purpose of an optimization, 
+  # which archives to run in parallel with GPU process.
+  def updateInFrameRenderingQueued(delta)
+    return false unless @physics.update(delta)
+      
+    @objects.each_value {|obj|
+      obj.update(delta)
+    }
+
+    return @script.update(delta)
+  end
+
+  def clean_up()
+    @physics.finalize()
+    @objects = {}
+    @view.stop()
+  end
+
+  # called by Garden class.
+  # clear all managers.
+  def finalize()
+    @physics.finalize()
+    @view.root.saveConfig()
+    @view.finalize()
+    @objects = {}
+  end
+  
+
+  # quit the current running garden.
+  def quit()
+    @quit = true
+  end
+end
+
+end # module