teienlib 0.0.1-x86-linux → 0.0.2-x86-linux

data/lib/teienlib/version.rb

@@ -1,3 +1,3 @@
 module Teienlib
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/sample/hello/box.rb

@@ -0,0 +1,68 @@
+class Box < Bullet::BtMotionState
+  @@cnt = 0
+
+  attr_accessor :id
+
+  def initialize(dynamics_world, scene_mgr, mass, x, y, z, color)
+    super() # needed by Bullet::BtMotionState
+
+    @dynamics_world = dynamics_world
+    @scene_mgr = scene_mgr
+    @x = x
+    @y = y
+    @z = z
+    @color = color
+    @@cnt += 1
+    @id = @@cnt
+    @name = "box_#{@id}"
+
+    # create a physics object.
+    @colObj = Bullet::BtBoxShape.new(Bullet::BtVector3.new(x, y, z))
+    inertia = Bullet::BtVector3.new()
+    @colObj.calculateLocalInertia(mass, inertia)
+    @rigid_body = Bullet::BtRigidBody.new(mass, self, @colObj, inertia)
+    dynamics_world.addRigidBody(@rigid_body)
+
+    # create a view object.
+    gen = Procedural::BoxGenerator.new()
+    gen.setSizeX(x * 2.0).setSizeY(y * 2.0).setSizeZ(z * 2.0)
+    gen.setNumSegX(1).setNumSegY(1).setNumSegZ(1)
+    gen.setUTile(1.0).setVTile(1.0).realizeMesh(@name)
+    @entity = scene_mgr.createEntity(@name)
+    @entity.setCastShadows(true)
+    @entity.setMaterialName("Examples/BumpyMetal")
+    @scene_node = scene_mgr.getRootSceneNode().createChildSceneNode()
+    @scene_node.attachObject(@entity)
+
+    # position/rotation
+    @transform = Bullet::BtTransform.new()
+    @transform.setIdentity()
+  end
+
+  # called through Bullet::BtMotionState when this rigid_body transform is changed 
+  # on bullet simulation step.
+  def setWorldTransform(worldTrans)
+    @transform = Bullet::BtTransform.new(worldTrans)
+    newPos = @transform.getOrigin()
+    newRot = @transform.getRotation()
+    return if (newRot.x.nan?)
+
+    @scene_node.setPosition(newPos.x, newPos.y, newPos.z) 
+    @scene_node.setOrientation(newRot.w, newRot.x, newRot.y, newRot.z)
+  end
+
+  # called by Bullet::BtMotionState
+  def getWorldTransform(worldTrans)
+  end
+
+  def set_position(x, y, z)
+    @scene_node.setPosition(x, y, z)
+    @transform.setOrigin(Bullet::BtVector3.new(x, y, z))
+    @rigid_body.setCenterOfMassTransform(@transform)
+  end
+
+  def apply_impulse(imp, rel = Bullet::BtVector3.new(0, 0, 0))
+    @rigid_body.activate(true)
+    @rigid_body.applyImpulse(imp, rel)
+  end
+end

data/sample/hello/camera_mover.rb

@@ -0,0 +1,190 @@
+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(pos) if @style == CS_FREELOOK
+  end
+
+  def look_at(pos)
+    @camera.lookAt(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(@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
+

data/sample/hello/floor.rb

@@ -0,0 +1,41 @@
+class Floor < Bullet::BtMotionState
+  def initialize(dynamicsWorld, sceneMgr)
+    super()
+
+    x = 10 # width
+    y = 1   # depth
+    z = 10 # height
+    mass = 0.0
+
+    # create a physics object
+    @cshape = Bullet::BtBoxShape.new(Bullet::BtVector3.new(x, 1, z))
+    inertia = Bullet::BtVector3.new()
+    @cshape.calculateLocalInertia(mass, inertia)
+    @rigid_body = Bullet::BtRigidBody.new(mass, self, @cshape, inertia)
+    dynamicsWorld.addRigidBody(@rigid_body)
+
+    # create a floor mesh resource
+    Ogre::MeshManager::getSingleton().createPlane("floor", 
+                                                  Ogre::ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME,
+                                                  Ogre::Plane.new(Ogre::Vector3.UNIT_Y, 0), 
+                                                  x * 2, z * 2, 10, 10, true, 1, 10, 10, 
+                                                  Ogre::Vector3.UNIT_Z)
+    @entity = sceneMgr.createEntity("Floor", "floor")
+    @entity.setMaterialName("Examples/Rockwall")
+    @entity.setCastShadows(false)
+    sceneMgr.getRootSceneNode().attachObject(@entity)
+
+    # set this object's position
+    @transform = Bullet::BtTransform.new()
+    @transform.setIdentity()
+    @transform.setOrigin(Bullet::BtVector3.new(0, -y, 0))
+    @rigid_body.setCenterOfMassTransform(@transform)
+  end
+
+  def setWorldTransform(worldTrans)
+  end
+
+  def getWorldTransform(worldTrans)
+  end
+
+end

data/sample/hello/hello

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+FILE_PATH=`dirname "$0"`
+OGRE_LIB=`ruby -e "require 'OgreConfig'; print OgreConfig.getDepsLibPath"`
+
+LD_LIBRARY_PATH=$OGRE_LIB:$LD_LIBRARY_PATH ruby $FILE_PATH/hello.rb

data/sample/hello/hello.rb

@@ -0,0 +1,300 @@
+
+$LOAD_PATH.push(File.dirname(File.expand_path(__FILE__)) + "/../../lib")
+
+require "Ogre"
+require "OIS"
+require "OgreBites"
+require "Procedural"
+require "Bullet"
+
+require "OgreConfig"
+
+require_relative "ui_listener"
+require_relative "camera_mover"
+require_relative "box"
+require_relative "floor"
+
+class World < Ogre::FrameListener
+  def initialize()
+    super() # needed by Ogre::FrameListener
+
+    @delta_sum = 0
+    @quit = false
+    @info = {}
+    @info["Help"] = 
+      " Use the ESDF keys to move the camera. \n" + 
+      " Use the left mouse button to shot a box. \n" + 
+      " Press Q to quit."
+
+    $file_path = File.dirname(File.expand_path(__FILE__))
+
+    # physics
+    initPhysics()
+
+    # view
+    initView()
+  end
+
+  def initPhysics()
+    # initialize bullet dynamics world.
+    @collision_config = Bullet::BtDefaultCollisionConfiguration.new();
+    @collision_dispatcher = Bullet::BtCollisionDispatcher.new(@collision_config)
+    world_aabb_min = Bullet::BtVector3.new(-3000.0,-500.0, -3000.0)
+    world_aabb_max = Bullet::BtVector3.new(3000.0, 500.0, 3000.0)
+    max_proxies = 1024 * 4
+    @aabb_cache = Bullet::BtAxisSweep3.new(world_aabb_min, world_aabb_max, max_proxies)
+    @solver = Bullet::BtSequentialImpulseConstraintSolver.new();
+    @dynamics_world = Bullet::BtDiscreteDynamicsWorld.new(@collision_dispatcher, @aabb_cache,
+                                                         @solver, @collision_config)
+
+    gravity = Bullet::BtVector3.new(0.0, -9.8, 0.0)
+    @dynamics_world.setGravity(gravity)
+  end
+
+  def initView()
+    # initialize Root
+    @root = Ogre::Root.new("")
+
+    # load Plugins
+    cfg = Ogre::ConfigFile.new
+    cfg.load("#{$file_path}/plugins.cfg")
+    pluginDir = cfg.getSetting("PluginFolder")
+    pluginDir += "/" if (pluginDir.length > 0) && (pluginDir[-1] != '/') 
+    cfg.each_Settings {|secName, keyName, valueName|
+      fullPath = pluginDir + valueName
+      fullPath.sub!("<SystemPluginFolder>", OgreConfig::getPluginFolder)
+      @root.loadPlugin(fullPath) if (keyName == "Plugin")
+    }
+
+    # initialize Resources
+    cfg = Ogre::ConfigFile.new
+    cfg.load("#{$file_path}/resources.cfg")
+    resourceDir = cfg.getSetting("ResourceFolder")
+    resourceDir += "/" if (resourceDir.length > 0) && (resourceDir[-1] != '/')
+    cfg.each_Settings {|secName, keyName, valueName|
+      next if (keyName == "ResourceFolder")
+      fullPath = resourceDir + valueName
+      fullPath.sub!("<SystemResourceFolder>", OgreConfig::getResourceFolder)
+      Ogre::ResourceGroupManager::getSingleton().addResourceLocation(fullPath, 
+                                                                     keyName, 
+                                                                     secName)
+    }
+
+    # create a window to draw.
+    return false unless @root.showConfigDialog()
+    @window = @root.initialise(true, "Sinbad")
+    @root.addFrameListener(self)
+
+    # initialize Managers
+    ## InputManager
+    windowHnd = Ogre::Intp.new
+    @window.getCustomAttribute("WINDOW", windowHnd)
+    windowHndStr = sprintf("%d", windowHnd.value())
+    pl = OIS::ParamList.new
+    pl["WINDOW"] = windowHndStr
+    @inputManager = OIS::InputManager::createInputSystem(pl)
+    @keyboard = @inputManager.createInputObject(OIS::OISKeyboard, true).toKeyboard()
+    @mouse = @inputManager.createInputObject(OIS::OISMouse, true).toMouse()
+
+    ## TrayManager
+    Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Essential")
+    @tray_mgr = OgreBites::SdkTrayManager.new("Base", @window, @mouse);
+    ms = @mouse.getMouseState()
+    ms.width = @window.getWidth()
+    ms.height = @window.getHeight()
+
+    ## SceneMgr
+    @sceneMgr = @root.createSceneManager(Ogre::ST_GENERIC)
+    @sceneMgr.setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE)
+
+    # initialize Listeners
+    @keyListener = KeyListener.new(self)
+    @keyboard.setEventCallback(@keyListener)
+
+    @mouseListener = MouseListener.new(self)
+    @mouse.setEventCallback(@mouseListener)
+
+    @trayListener = TrayListener.new(self)
+    @tray_mgr.setListener(@trayListener)
+
+    # initialize Camera
+    @camera = @sceneMgr.createCamera("FixCamera")
+    # Create one viewport, entire window
+    @vp = @window.addViewport(@camera);
+    @vp.setBackgroundColour(Ogre::ColourValue.new(0, 0, 0))
+    # Alter the camera aspect ratio to match the viewport
+    @camera.setAspectRatio(Float(@vp.getActualWidth()) / Float(@vp.getActualHeight()))
+
+    # load "General" group resources into ResourceGroupManager.
+    @tray_mgr.showLoadingBar(1, 0)
+    Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("General")
+    @tray_mgr.hideLoadingBar()
+    Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5)
+
+    @tray_mgr.showFrameStats(OgreBites::TL_BOTTOMLEFT)
+    @tray_mgr.showLogo(OgreBites::TL_BOTTOMRIGHT)
+    @tray_mgr.hideCursor()
+  end
+
+  def run
+    # set background and some fog
+    @vp.setBackgroundColour(Ogre::ColourValue.new(1.0, 1.0, 0.8))
+    @sceneMgr.setFog(Ogre::FOG_LINEAR, Ogre::ColourValue.new(1.0, 1.0, 0.8), 0, 15, 100)
+
+    # set shadow properties
+    @sceneMgr.setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_MODULATIVE)
+    @sceneMgr.setShadowColour(Ogre::ColourValue.new(0.5, 0.5, 0.5))
+    @sceneMgr.setShadowTextureSize(1024)
+    @sceneMgr.setShadowTextureCount(1)
+
+    # use a small amount of ambient lighting
+    @sceneMgr.setAmbientLight(Ogre::ColourValue.new(0.3, 0.3, 0.3))
+
+    # add a bright light above the scene
+    @light = @sceneMgr.createLight()
+    @light.setType(Ogre::Light::LT_POINT)
+    @light.setPosition(-10, 40, 20)
+    @light.setSpecularColour(Ogre::ColourValue.White)
+
+    @camera_mover = CameraMover.new(@camera)
+    @camera_mover.set_position(Ogre::Vector3.new(20, 10, 20))
+    @camera_mover.look_at(Ogre::Vector3.new(0, 10, 0))
+
+    items = []
+    items.push("Help")
+    @help = @tray_mgr.createParamsPanel(OgreBites::TL_TOPLEFT, "HelpMessage", 100, items)
+    @help.setParamValue(Ogre::UTFString.new("Help"), Ogre::UTFString.new("H / F1"))
+
+    # creates objects
+    @floor = Floor.new(@dynamics_world, @sceneMgr)
+
+    @boxes = []
+    11.times {|x|
+      3.times {|y|
+        box = Box.new(@dynamics_world, @sceneMgr, 1.0, 1, 1, 1, 'blue')
+        box.set_position(-10 + x * 2, 5 + y * 2, 0)
+        @boxes.push(box)
+      }
+    }
+
+    @root.startRendering()
+  end
+
+  def shot_box()
+    cam_pos_ogre = @camera.getPosition()
+    cam_dir_ogre = @camera.getDirection()
+
+    cam_pos = Bullet::BtVector3.new(cam_pos_ogre.x, cam_pos_ogre.y, cam_pos_ogre.z)
+    cam_dir = Bullet::BtVector3.new(cam_dir_ogre.x, cam_dir_ogre.y, cam_dir_ogre.z)
+
+    box = Box.new(@dynamics_world, @sceneMgr, 1.0, 1, 1, 1, 'grey')
+    box_pos = cam_pos + (cam_dir * 5.0)
+    box.set_position(box_pos.x, box_pos.y, box_pos.z)
+    
+    force = cam_dir * Bullet::BtVector3.new(100.0, 100.0, 100.0)
+    box.apply_impulse(force)
+
+    @boxes.push(box)
+  end
+
+  #
+  # Event handlers
+  #
+
+  # implementation of Ogre::FrameListener interface.
+  def frameRenderingQueued(evt)
+    # update bullet(physics)
+    @dynamics_world.stepSimulation(evt.timeSinceLastFrame)
+
+    # update ogre3d(view)
+    @keyboard.capture()
+    @mouse.capture()
+    @tray_mgr.frameRenderingQueued(evt)
+
+    # update model
+    @camera_mover.update(evt.timeSinceLastFrame)
+    
+    @delta_sum += evt.timeSinceLastFrame
+    # create a new box per 3sec.
+    if (@delta_sum > 3.0) 
+      box = Box.new(@dynamics_world, @sceneMgr, 1.0, 1, 1, 1, 'orange')
+      box.set_position(-10 + ((box.id - 1) % 11) * 2, 20, 0)
+      @boxes.push(box)
+      @delta_sum = 0
+    end
+
+    return !@quit
+  end
+
+  def key_pressed(keyEvent)
+    case keyEvent.key 
+    when OIS::KC_ESCAPE
+      @quit =true
+    when OIS::KC_H, OIS::KC_F1
+      if (!@tray_mgr.isDialogVisible() && @info["Help"] != "") 
+        @tray_mgr.showOkDialog(Ogre::UTFString.new("Help"), Ogre::UTFString.new(@info["Help"]))
+      else 
+        @tray_mgr.closeDialog()
+      end
+
+    when OIS::KC_E
+      @camera_mover.move_forward(true)
+    when OIS::KC_D
+      @camera_mover.move_backward(true)
+    when OIS::KC_S
+      @camera_mover.move_left(true)
+    when OIS::KC_F
+      @camera_mover.move_right(true)
+    end
+
+    return true
+  end
+  
+  def key_released(keyEvent)
+    case keyEvent.key
+    when OIS::KC_ESCAPE
+      @quit =true
+    when OIS::KC_E
+      @camera_mover.move_forward(false)
+    when OIS::KC_D
+      @camera_mover.move_backward(false)
+    when OIS::KC_S
+      @camera_mover.move_left(false)
+    when OIS::KC_F
+      @camera_mover.move_right(false)
+    end
+
+    return true
+  end
+  
+  def mouse_moved(mouseEvent)
+    return true if @tray_mgr.injectMouseMove(mouseEvent)
+    @camera_mover.mouse_moved(mouseEvent)
+    return true
+  end
+
+  def mouse_pressed(mouseEvent, mouseButtonID)
+    return true if @tray_mgr.injectMouseDown(mouseEvent, mouseButtonID)
+    @camera_mover.mouse_pressed(mouseEvent, mouseButtonID)
+
+    if (mouseButtonID == OIS::MB_Left)
+      shot_box()
+    end
+
+    return true
+  end
+
+  def mouse_released(mouseEvent, mouseButtonID)
+    return true if @tray_mgr.injectMouseUp(mouseEvent, mouseButtonID)
+    @camera_mover.mouse_released(mouseEvent, mouseButtonID)
+    return true
+  end
+
+  def ok_dialog_closed(name)
+    return true
+  end
+end
+
+
+world = World.new()
+world.run

data/sample/hello/ogre.cfg

@@ -0,0 +1,11 @@
+Render System=OpenGL Rendering Subsystem
+
+[OpenGL Rendering Subsystem]
+Display Frequency=50 Hz
+FSAA=0
+Fixed Pipeline Enabled=Yes
+Full Screen=No
+RTT Preferred Mode=FBO
+VSync=No
+Video Mode=1440 x  900
+sRGB Gamma Conversion=No

data/sample/hello/plugins.cfg

@@ -0,0 +1,17 @@
+# Defines plugins to load
+
+# Define plugin folder
+PluginFolder=<SystemPluginFolder>
+
+# Define plugins
+# Plugin=RenderSystem_Direct3D9
+# Plugin=RenderSystem_Direct3D10
+# Plugin=RenderSystem_Direct3D11
+ Plugin=RenderSystem_GL
+# Plugin=RenderSystem_GLES
+ Plugin=Plugin_ParticleFX
+ Plugin=Plugin_BSPSceneManager
+ Plugin=Plugin_CgProgramManager
+ Plugin=Plugin_PCZSceneManager
+ Plugin=Plugin_OctreeZone
+ Plugin=Plugin_OctreeSceneManager

data/sample/hello/resources.cfg

@@ -0,0 +1,22 @@
+# Resources required by the sample browser and most samples.
+ResourceFolder=<SystemResourceFolder>
+
+[Essential]
+Zip=packs/SdkTrays.zip
+
+# Resource locations to be added to the default path
+[General]
+Zip=packs/skybox.zip
+Zip=packs/Sinbad.zip
+FileSystem=fonts
+FileSystem=models/
+FileSystem=materials/scripts/
+FileSystem=materials/textures/
+FileSystem=materials/textures/nvidia/
+FileSystem=materials/programs/
+FileSystem=particle
+FileSystem=DeferredShadingMedia
+FileSystem=PCZAppMedia
+FileSystem=RTShaderLib
+FileSystem=RTShaderLib/materials
+

data/sample/hello/ui_listener.rb

@@ -0,0 +1,65 @@
+#
+# Key Listener
+#
+class KeyListener < OIS::KeyListener
+  def initialize(listener)
+    super()
+    @listener = listener
+  end
+  
+  def keyPressed(keyEvent)
+    return @listener.key_pressed(keyEvent)
+  end
+  
+  def keyReleased(keyEvent)
+    return @listener.key_released(keyEvent)
+  end
+end
+
+#
+# Mouse Listener
+#
+class MouseListener < OIS::MouseListener
+  def initialize(listener)
+    super()
+    @listener = listener
+  end
+  
+  def mouseMoved(evt)
+    return @listener.mouse_moved(evt)
+  end
+  
+  def mousePressed(mouseEvent, mouseButtonID)
+    return @listener.mouse_pressed(mouseEvent, mouseButtonID)
+  end
+  
+  def mouseReleased(mouseEvent, mouseButtonID)
+    return @listener.mouse_released(mouseEvent, mouseButtonID)
+  end
+end
+
+#
+# Tray Listener
+#
+class TrayListener < OgreBites::SdkTrayListener
+  def initialize(listener)
+    super()
+    @listener = listener
+  end
+
+  def buttonHit(button)
+    @listener.button_hit(button)
+  end
+
+  def itemSelected(menu)
+    @listener.item_selected(menu)
+  end
+
+  def yesNoDialogClosed(name, bl)
+    @listener.yes_no_dialog_closed(name, bl)
+  end
+
+  def okDialogClosed(name)
+    @listener.ok_dialog_closed(name)
+  end
+end

data/teienlib.gemspec

@@ -21,6 +21,9 @@ Gem::Specification.new do |gem|
                           'ext/teienlib/interface/*.i', 
                           'ext/teienlib/interface/Rakefile', 
                           'ext/teienlib/src/*.{cc,h}', 
+                          'sample/hello/*.rb',
+                          'sample/hello/*.cfg',
+                          'sample/hello/hello',
                           'lib/**/*', 
                          ]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: teienlib
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: x86-linux
 authors:
@@ -13,7 +13,7 @@ date: 2012-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-ogre
-  requirement: &82505360 !ruby/object:Gem::Requirement
+  requirement: &76100680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *82505360
+  version_requirements: *76100680
 - !ruby/object:Gem::Dependency
   name: ruby-bullet
-  requirement: &82505070 !ruby/object:Gem::Requirement
+  requirement: &76100330 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *82505070
+  version_requirements: *76100330
 description: An extension library for Teien.
 email:
 - abexsoft@gmail.com
@@ -68,6 +68,15 @@ files:
 - ext/teienlib/src/MeshStrider.h
 - ext/teienlib/src/Vector3D.h
 - ext/teienlib/src/DebugDrawer.h
+- sample/hello/floor.rb
+- sample/hello/ui_listener.rb
+- sample/hello/hello.rb
+- sample/hello/box.rb
+- sample/hello/camera_mover.rb
+- sample/hello/ogre.cfg
+- sample/hello/resources.cfg
+- sample/hello/plugins.cfg
+- sample/hello/hello
 - lib/teienlib/version.rb
 - lib/Teienlib.so
 - lib/teienlib.rb