ogre.rb 0.1-i686-linux

data/samples/render_to_texture.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+include Ogre
+
+class RenderToTextureListener < ApplicationFrameListener
+  def initialize(root, window, cam, reflect_cam, plane)
+    super(root, window, cam)
+    @reflect_cam = reflect_cam
+    @plane = plane
+
+  end
+
+  def frame_started(event)
+    return false unless super(event)
+
+		#GC.start
+
+    # Update reflection camera
+    @reflect_cam.set_orientation(camera.get_orientation)
+    @reflect_cam.set_position(camera.get_position)
+
+    # Rotate the plane
+    @plane.yaw(Degree.new(30 * event.time_since_last_frame), Node::TS_PARENT)
+
+    true
+  end
+end
+
+# Is this class really needed? Not using and the demo looks fine
+class RTTRenderTargetListener < RenderTargetListener
+  def initialize(plane_entity)
+    super()
+    @plane = plane_entity
+  end
+
+  def pre_render_target_update(event)
+    @plane.set_visible(false)
+  end
+
+  def post_render_target_update(event)
+    @plane.set_visible(true)
+  end
+end
+
+class RenderToTextureApplication < Application
+
+  def create_scene
+    scene_manager.set_ambient_light(Ogre::ColourValue.new(0.2, 0.2, 0.2))
+    scene_manager.set_sky_box(true, "MorningSkyBox")
+
+    light = scene_manager.create_light("MainLight")
+    light.set_type(Light::LT_DIRECTIONAL)
+
+    dir = Vector3.new(0.5, -1, 0)
+    dir.normalise!
+
+    light.set_direction(dir)
+    light.set_diffuse_colour(1.0, 1.0, 0.8)
+    light.set_specular_colour(1.0, 1.0, 1.0)
+
+    @plane = MovablePlane.new("ReflectPlane")
+    @plane.d = 0
+    @plane.normal = Vector3.UNIT_Y
+
+    MeshManager.instance.create_plane("ReflectionPlane",
+      ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME,
+      @plane, 2000, 2000,
+      1, 1, true, 1, 1, 1, Vector3.UNIT_Z) 
+
+    @plane_entity = scene_manager.create_entity("Plane", "ReflectionPlane")
+
+    knot_entity = scene_manager.create_entity("Knot", "knot.mesh")
+    knot_entity.set_material_name("TextureEffect2")
+
+    ogre_head = scene_manager.create_entity("Head", "ogrehead.mesh")
+
+    root = scene_manager.root_scene_node
+
+    # Setting up the plane in the scene
+    @plane_node = root.create_child_scene_node
+    @plane_node.attach_object(@plane_entity)
+    @plane_node.attach_object(@plane)
+    @plane_node.translate(0, -10, 0)
+
+    # Tilt cause it's cool
+    @plane_node.roll(Degree.new(5))
+
+    root.create_child_scene_node("Head").attach_object(ogre_head)
+
+    texture = TextureManager.instance.create_manual("RttTex",
+                ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D,
+                512, 512, 1, -1, PF_R8G8B8, TU_RENDERTARGET)
+
+    target = texture.get_buffer.get_render_target
+
+    @reflect_cam = scene_manager.create_camera("ReflectCam")
+    @reflect_cam.set_near_clip_distance(camera.get_near_clip_distance)
+    @reflect_cam.set_far_clip_distance(camera.get_far_clip_distance)
+
+		# Make sure these are floats, otherwise we get a much smaller aspect ratio than expected
+    @reflect_cam.set_aspect_ratio(
+     	window.get_viewport(0).get_actual_width * 1.0 / window.get_viewport(0).get_actual_height * 1.0)
+
+    viewport = target.add_viewport(@reflect_cam)
+    viewport.set_clear_every_frame(true)
+    viewport.set_background_colour(ColourValue.Black)
+
+    mat = MaterialManager.instance.create("RttMat",
+            ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME)
+
+
+    mat.get_technique(0).get_pass(0).create_texture_unit_state("RustedMetal.jpg")
+    tex_unit_state = mat.get_technique(0).get_pass(0).create_texture_unit_state("RttTex")
+    tex_unit_state.set_colour_operation_ex(LBX_BLEND_MANUAL, LBS_TEXTURE, LBS_CURRENT,
+                                        ColourValue.White, ColourValue.White, 0.25)
+
+    tex_unit_state.set_texture_addressing_mode(TextureUnitState::TAM_CLAMP)
+    tex_unit_state.set_projective_texturing(true, @reflect_cam)
+
+    #puts "", "Registering our listener"
+    #@rt_listener = RTTRenderTargetListener.new(@plane_entity)
+    #target.add_listener(@rt_listener)
+    
+    @reflect_cam.enable_reflection(@plane)
+    @reflect_cam.enable_custom_near_clip_plane(@plane)
+
+    @plane_entity.set_material_name("RttMat")
+
+    # Create some knots
+    clone_ent = nil
+    10.times do |i|
+      node = scene_manager.create_scene_node
+      pos = Vector3.new
+      pos.x = Ogre::Math.symmetric_random * 750.0
+      pos.y = Ogre::Math.symmetric_random * 100.0 + 25
+      pos.z = Ogre::Math.symmetric_random * 750.0
+
+      node.set_position(pos)
+      root.add_child(node)
+
+      # Clone it
+      clone_name = "Knot#{i}"
+      clone_ent = knot_entity.clone(clone_name)
+      node.attach_object(clone_ent)
+    end
+
+    camera.set_position(-50, 100, 500)
+    camera.look_at(0, 0, 0)
+  end
+
+  def create_frame_listener
+    self.frame_listener = RenderToTextureListener.new(root, window, camera, 
+																											@reflect_cam, @plane_node)
+  end
+end
+
+app = RenderToTextureApplication.new
+app.go

data/samples/resources.cfg

@@ -0,0 +1,16 @@
+[Bootstrap]
+Zip=./media/packs/OgreCore.zip
+
+[General]
+FileSystem=./media/
+FileSystem=./media/materials
+FileSystem=./media/materials/textures
+FileSystem=./media/materials/scripts
+FileSystem=./media/materials/programs
+FileSystem=./media/models
+FileSystem=./media/particles
+FileSystem=./media/overlays
+Zip=./media/packs/skybox.zip
+Zip=./media/packs/dragon.zip
+Zip=./media/packs/cubemap.zip
+Zip=./media/packs/cubemapsJS.zip

data/samples/sky_box.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+include Ogre
+
+$thrusters = nil
+
+class SkyBoxListener < ApplicationFrameListener
+  attr_accessor :default_dimensions, :default_velocity
+  def initialize(*args)
+    super
+    @default_dimensions = 25.0
+    @default_velocity = 50.0
+  end    
+
+  def frame_started(evt)
+    return false unless super(evt)
+
+    if keyboard.key_down?( OIS::KC_N ) 
+      $thrusters.set_default_dimensions( @default_dimensions + 0.25, @default_dimensions + 0.25 )
+      @default_dimensions += 0.25
+    end
+
+    if keyboard.key_down?( OIS::KC_M ) 
+      $thrusters.set_default_dimensions( @default_dimensions - 0.25, @default_dimensions - 0.25 )
+      @default_dimensions -= 0.25
+    end
+
+    if keyboard.key_down?( OIS::KC_H ) 
+      $thrusters.get_emitter( 0 ).set_particle_velocity( @default_velocity + 1 )
+      $thrusters.get_emitter( 1 ).set_particle_velocity( @default_velocity + 1 )
+      @default_velocity += 1            
+    end
+
+    if keyboard.key_down?( OIS::KC_J ) && !( @default_velocity < 0.0 ) 
+      $thrusters.get_emitter( 0 ).set_particle_velocity( @default_velocity - 1 )
+      $thrusters.get_emitter( 1 ).set_particle_velocity( @default_velocity - 1 )
+      @default_velocity -= 1            
+    end
+
+    true
+  end
+end
+
+class SkyBoxApplication < Application
+
+  def create_scene
+    scene_manager.set_ambient_light ColourValue.new(0.5, 0.5, 0.5)
+
+    # Create a skybox
+    scene_manager.set_sky_box(true, "SpaceSkyBox", 50 )
+
+    # Create a light
+    l = scene_manager.create_light("MainLight")
+    l.set_position(20,80,50)
+
+    # Also add a nice starship in
+    ent = scene_manager.create_entity( "razor", "razor.mesh" )
+
+    scene_manager.root_scene_node.attach_object( ent )
+
+    $thrusters = scene_manager.create_particle_system( "ParticleSys1", 200 )
+
+    $thrusters.set_material_name("Flare")
+    $thrusters.set_default_dimensions( 25, 25 )
+
+    emitter1 = $thrusters.add_emitter( "Point" )
+    emitter2 = $thrusters.add_emitter( "Point" )
+
+    # Thruster 1
+    emitter1.set_angle( Radian.new(0.05) )
+    emitter1.set_time_to_live( 0.2 )
+    emitter1.set_emission_rate( 70 )
+
+    emitter1.set_particle_velocity( 50 )
+
+    emitter1.set_direction(- Vector3.UNIT_Z)
+    emitter1.set_colour( ColourValue.White, ColourValue.Red)        
+
+    # Thruster 2
+    emitter2.set_angle( Radian.new(0.05) )
+    emitter2.set_time_to_live( 0.2 )
+    emitter2.set_emission_rate( 70 )
+
+    emitter2.set_particle_velocity( 50 )
+
+    emitter2.set_direction( -Vector3.UNIT_Z )
+    emitter2.set_colour( ColourValue.White, ColourValue.Red )
+
+    # Set the position of the $thrusters
+    emitter1.set_position( Vector3.new( 5.7, 0.0, 0.0 ) )
+    emitter2.set_position( Vector3.new( -18.0, 0.0, 0.0 ) )
+
+    node = scene_manager.root_scene_node.create_child_scene_node( Vector3.new( 0.0, 6.5, -67.0 ) )
+    node.attach_object($thrusters)
+  end
+
+  def create_frame_listener
+    self.frame_listener = SkyBoxListener.new(root, window, camera)
+    #root.addFrameListener(self.frame_listener)
+  end
+end
+
+app = SkyBoxApplication.new
+app.go

data/samples/sky_dome.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+include Ogre
+
+class SkyDomeListener < ApplicationFrameListener
+  def initialize(root, window, camera, scene_manager)
+    super(root, window, camera)
+    @scene_manager = scene_manager
+    @curvature = 1
+    @tiling = 15
+
+    @time_delay = 0
+  end
+
+  def frame_started(event)
+    return false unless super(event)
+
+    update_sky = false
+
+    if keyboard.key_down?(OIS::KC_H) && @time_delay <= 0
+      @curvature += 1
+      @time_delay = 0.1
+      update_sky = true
+    elsif keyboard.key_down?(OIS::KC_G) && @time_delay <= 0
+      @curvature -= 1
+      @time_delay = 0.1
+      update_sky = true
+    elsif keyboard.key_down?(OIS::KC_U) && @time_delay <= 0
+      @tiling += 1
+      @time_delay = 0.1
+      update_sky = true
+    elsif keyboard.key_down?(OIS::KC_Y) && @time_delay <= 0
+      @tiling -= 1
+      @time_delay = 0.1
+      update_sky = true
+    end
+
+    if @time_delay > 0
+      @time_delay -= event.time_since_last_frame
+    end
+
+    if update_sky
+			puts "Updating sky with #@curvature and #@tiling"
+      @scene_manager.set_sky_dome(true, "CloudySky", @curvature, @tiling)
+    end
+
+    true
+  end
+end
+
+class SkyDomeApplication < Ogre::Application
+
+  def create_scene
+    scene_manager.set_ambient_light ColourValue.new(0.5, 0.5, 0.5)
+    scene_manager.set_sky_dome(true, "CloudySky", 5, 8)
+
+    light = scene_manager.create_light("MainLight")
+    light.set_position Vector3.new(20, 80, 50)
+
+    p = Plane.new
+    p.normal = Vector3.UNIT_Y
+    p.d = 200
+
+    MeshManager.instance.create_plane("FloorPlane", 
+      ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, p, 2000, 2000, 1, 1, true,
+      1, 5, 5, Vector3.UNIT_Z)
+      
+    entity = scene_manager.create_entity("floor", "FloorPlane")
+    entity.set_material_name "RustySteel"
+
+    scene_manager.root_scene_node.attach_object(entity)
+
+    entity = scene_manager.create_entity("head", "ogrehead.mesh")
+    scene_manager.root_scene_node.attach_object(entity)
+  end
+
+  def create_frame_listener
+    self.frame_listener = SkyDomeListener.new(root, window, camera, scene_manager)
+  end
+end
+
+app = SkyDomeApplication.new
+app.go

data/samples/sky_plane.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+
+include Ogre
+
+class SkyPlaneApplication < Application
+  def create_scene
+    scene_manager.set_ambient_light ColourValue.new(0.5, 0.5, 0.5)
+  
+    plane = Plane.new
+    plane.d = 5000
+    plane.normal = -Vector3.UNIT_Y
+    scene_manager.set_sky_plane(true, plane, "SpaceSkyPlane", 10000, 3)
+
+    light = scene_manager.create_light("MainLight")
+    light.set_position(20, 80, 50)
+
+    dragon = scene_manager.create_entity("dragon", "dragon.mesh")
+    scene_manager.root_scene_node.attach_object(dragon)
+  end
+end
+
+app = SkyPlaneApplication.new
+app.go

data/samples/smoke.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+
+class ParticleApplication < Ogre::Application
+
+  def create_scene
+    scene_manager.set_ambient_light Ogre::ColourValue.new(0.5, 0.5, 0.5)
+    scene_manager.set_sky_dome(true, "CloudySky", 5, 8)
+
+    @fountain = scene_manager.root_scene_node.create_child_scene_node;
+
+    @particle_system = scene_manager.create_particle_system("fountain1", "Smoke")
+    node = @fountain.create_child_scene_node
+    node.attach_object(@particle_system)
+  end
+
+end
+
+app = ParticleApplication.new
+app.go