ogre.rb 0.1-i386-mswin32

data/lib/application.rb

@@ -0,0 +1,146 @@
+$:.push('..')
+
+require 'ogre'
+require 'application_frame_listener'
+
+module Ogre
+
+  # Application is a Ruby port of ExampleApplication. It is written so that there's nothing new
+	# to learn here, but you do have to watch out for Ruby version of names 
+	# (createScene vs create_scene).
+  #
+  # All you need to do is define your own createScene. An example Application subclass (sky_plane.rb):
+  #
+  #   require 'ogre'
+  #   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
+	#
+	# Any of the protected methods in this class are free for overriding.
+	class Application
+
+		attr_accessor :root, :frame_listener, :window, :scene_manager, :camera
+
+		def initialize
+			@frame_listener = nil
+			@root = nil
+		end
+
+		# This starts off everything.
+		def go
+			return unless setup
+
+			@root.start_rendering
+
+			destroy_scene
+
+			@frame_listener.shutdown
+		end
+
+		protected
+
+		def setup
+			@root = Root.new("plugins.cfg", "ogre.cfg", "Ogre.log")
+
+			setup_resources
+
+			return unless configure
+
+			choose_scene_manager
+			create_camera
+			create_viewports
+
+			TextureManager.instance.set_default_num_mipmaps 5
+
+			create_resource_listener
+			load_resources
+			create_scene
+			create_frame_listener
+			true
+		end
+
+		# Shows the configuration dialog and initializes our
+		# render window
+		def configure
+			return false unless @root.show_config_dialog
+			@window = @root.initialise(true)
+			true
+		end
+
+		def choose_scene_manager
+			@scene_manager = @root.create_scene_manager(ST_GENERIC, "ExampleSMInstance")
+		end
+
+		def create_camera
+			@camera = @scene_manager.create_camera("PlayerCam")
+
+			@camera.set_position(0, 0, 500)
+			# Look along the -Z axis
+			@camera.look_at(Vector3.new(0, 0, -300))
+			@camera.set_near_clip_distance 5
+		end
+
+		def create_frame_listener
+			@frame_listener = ApplicationFrameListener.new(@root, @window, @camera)
+			@frame_listener.show_debug_overlay(true)
+		end
+
+		def create_scene
+			raise "Please redefine #create_scene in your application"
+		end
+
+		def destroy_scene
+		end
+
+		def create_viewports
+			vp = @window.add_viewport(@camera)
+			vp.set_background_colour ColourValue.new(0,0,0)
+
+			@camera.set_aspect_ratio( (vp.get_actual_width * 1.0) / (vp.get_actual_height * 1.0) )
+		end
+
+		def setup_resources
+			section = "General"
+			File.open("resources.cfg", "r") do |config_file|
+				config_file.each do |line|
+					line.chomp!
+					next if line =~ /^#/ || line.empty?
+					if line =~ /^\[(.+?)\]/
+						section = $1
+						next
+					end
+
+					key, value = line.split("=")
+					ResourceGroupManager.instance.add_resource_location(value, key, section)
+				end
+			end
+		end
+
+		def create_resource_listener
+		end
+
+		def load_resources
+			ResourceGroupManager.instance.initialise_all_resource_groups
+		end
+
+	end
+end

data/lib/application_frame_listener.rb

@@ -0,0 +1,302 @@
+module Ogre
+	# Define a listener for certain window events, such as resizing, closing, 
+	# and changes of focus
+	#
+	# Currently not used 
+	#
+	class ApplicationWindowListener < WindowEventListenerProxy #:nodoc:
+		def initialize(input_manager, window, keyboard, mouse, joy_stick)
+			super(window)
+			@input_manager = input_manager
+			@keyboard = keyboard
+			@mouse = mouse
+			@window = window
+			@joy_stick = joy_stick
+		end
+
+		# Adjust the mouse clipping area when the window has been resized
+		def windowResized(window)
+			width = height = depth = left = top = 0
+			window.getMetrics(width, height, depth, left, top)
+
+			mouse_state = @mouse.getMouseState
+			mouse_state.width = width
+			mouse_state.height = height
+		end
+
+		# Shut everything down nicely when we're done
+		def windowClosed(window)
+			if @window == window
+				if @input_manager
+					@input_manager.destroy_input_object(@mouse)
+					@input_manager.destroy_input_object(@keyboard)
+					@input_manager.destroy_input_object(@joy_stick)
+
+					OIS::InputManager.destroyInputSystem(@input_manager)
+					@input_manager = nil
+				end
+			end
+		end
+	end
+
+  # In the same way Application is the port of ExampleApplication, ApplicationFrameListener
+  # is the Ruby port of ExampleFrameListener. This class gives us a very helpful starting
+  # point for input management and a few Overlays for information. The default ApplicationFrameListener
+  # gives the WASD movement (through OIS), as well as the well-known Ogre overlay showing triangle count, FPS, etc.
+  # 
+  # Usage is just as easy as can be expected:
+  #
+  #   require 'application'
+  #   include Ogre
+  #
+  #   class AppListener < ApplicationFrameListener
+  #
+  #     def frame_started(event)
+  #       return false unless super(event)
+  #         
+  #        ... frame event / input handling ...
+  #       
+  #       true
+  #     end
+  #   end
+  #
+  #   class MyApplication < Application
+  #
+  #     def create_scene
+  #       ...
+  #     end
+  #
+  #     def create_frame_listener
+  #       frame_listener = AppListener.new(root, window, camera)
+  #     end
+  #   end
+  #
+  #   app = MyApplication.new
+  #   app.go
+	#
+	# Do take note of create_frame_listener in the example above. The FrameListener actually takes in
+	# the Root object, instead of the application calling root.addFrameListener. We do this because the process
+	# of using Ruby C++ subclasses in C++ functions doesn't really work, and may not even be possible.
+	# The fix for this is to build a Proxy class in C++ that is given the Root on construction. It then
+	# registers itself with the passed in Root. See OgreProxys for this definition
+  #
+	class ApplicationFrameListener < FrameListenerProxy
+
+		attr_accessor :keyboard, :mouse, :joy_stick, :input_manager, :camera, :window
+
+		def initialize(root, render_window, camera, buffered_keys = false, 
+									 buffered_mouse = false, buffered_joy = false)
+			super(root)
+			@camera = camera
+			@window = render_window
+			@move_speed = 100
+			@rotate_speed = 36
+			@move_scale = 0.0
+			@rot_scale = 0.0
+			@translate_vector = Vector3.ZERO
+			@rot_x = Degree.new(0)
+			@rot_y = Degree.new(0)
+			@debug_text = ""
+
+			@debug_overlay = OverlayManager.instance.get_by_name("Core/DebugOverlay")	
+
+			LogManager.instance.log_message("*** Initializing OIS ***")
+
+			windowHnd = @window.get_custom_attribute_unsigned_long("WINDOW")
+
+			@input_manager = OIS::InputManager.create_input_system({"WINDOW" => "#{windowHnd}"})
+			@keyboard = @input_manager.create_input_object( OIS::OISKeyboard, buffered_keys)
+			@mouse = @input_manager.create_input_object( OIS::OISMouse, buffered_mouse)
+
+			# Most likely won't have a joystick here, so just throw away any exceptions
+			@joy_stick = nil
+			begin
+				@joy_stick = @input_manager.create_input_object( OIS::OISJoyStick, buffered_joy)
+			rescue
+			end
+
+			show_debug_overlay(true)
+
+			# Currently doesn't work, it's the Ruby subclass back into C++ problem
+			#puts "Setting window listener"
+			#@window_event_listener = ApplicationWindowListener.new(@input_manager, @window,
+																														 #@keyboard, @mouse,
+																														 #@joy_stick)
+
+			# Done in proxy constructor
+			# WindowEventUtilities.addWindowEventListener(@window, @window_event_listener)
+		end
+
+		# Ruby doesn't have destructors, just manually call shutdown to clean this up
+		def shutdown
+			#WindowEventUtilities::removeWindowEventListener(@window, @window_event_listener)
+			#@window_event_listener.windowClosed(@window)
+			
+			# Clean up our input objects
+			@input_manager.destroy_input_object(@mouse)
+			@input_manager.destroy_input_object(@keyboard)
+			@input_manager.destroy_input_object(@joy_stick)
+
+			OIS::InputManager.destroy_input_system(@input_manager)
+			@input_manager = nil
+		end
+
+		# Keyboard processing
+		def process_unbuffered_key_input(event)
+			# Start with basic movement, add overlay stuff later
+
+			# Left
+			if @keyboard.key_down?(OIS::KC_A)
+				@translate_vector.x = -@move_scale
+			end
+
+			# Right
+			if @keyboard.key_down?(OIS::KC_D)
+				@translate_vector.x = @move_scale
+			end
+
+			# Forward
+			if @keyboard.key_down?(OIS::KC_UP) || @keyboard.key_down?(OIS::KC_W)
+				@translate_vector.z = -@move_scale
+			end
+
+			# Back
+			if @keyboard.key_down?(OIS::KC_DOWN) || @keyboard.key_down?(OIS::KC_S)
+				@translate_vector.z = @move_scale
+			end
+
+			# Up
+			if @keyboard.key_down?(OIS::KC_PGUP)
+				@translate_vector.y = @move_scale
+			end
+
+			# Down
+			if @keyboard.key_down?(OIS::KC_PGDOWN)
+				@translate_vector.y = -@move_scale
+			end
+
+			# Turn Right
+			if @keyboard.key_down?(OIS::KC_RIGHT)
+				@camera.yaw(-@rot_scale)
+			end
+
+			# Turn Left
+			if @keyboard.key_down?(OIS::KC_LEFT)
+				@camera.yaw(@rot_scale)
+			end
+
+			# Quit
+			if @keyboard.key_down?(OIS::KC_ESCAPE) || @keyboard.key_down?(OIS::KC_Q)
+				return false;
+			end
+
+			# Keep rendering
+			true
+		end
+
+		def process_unbuffered_mouse_input(event)
+			state = @mouse.mouse_state
+
+			if state.button_down?(OIS::MB_Right)
+				@translate_vector.x += state.X.rel * 0.13
+				@translate_vector.y -= state.Y.rel * 0.13
+			else
+				@rot_x = Degree.new(-state.X.rel * 0.13)
+				@rot_y = Degree.new(-state.Y.rel * 0.13)
+			end
+
+			true
+		end
+
+		# Process the movement we've calculated this frame
+		def move_camera
+			@camera.yaw(@rot_x)
+			@camera.pitch(@rot_y)
+			@camera.move_relative(@translate_vector)
+		end
+
+		# Toggle debug overlay if one exists
+		def show_debug_overlay(show)
+			if @debug_overlay
+				if show
+					@debug_overlay.show
+				else
+					@debug_overlay.hide
+				end
+			end
+		end
+
+		# Ogre callback, called at the beginning of every frame
+		def frame_started(event)
+			return false if @window.closed?
+
+			# Need to capture input from each device
+			@keyboard.capture
+			@mouse.capture
+			@joy_stick.capture if @joy_stick
+
+			buffered_joy = @joy_stick.nil? ? true : @joy_stick.buffered
+
+			if !@mouse.buffered || !@keyboard.buffered || !buffered_joy
+				# If this is the first frame, pick a speed
+				if event.time_since_last_frame == 0	
+					@move_scale = 1
+					@rot_scale = 0.1
+				else
+					# ~100 units / second
+					@move_scale = @move_speed * event.time_since_last_frame
+					# ~10 seconds for full rotation
+					@rot_scale = @rotate_speed * event.time_since_last_frame
+				end
+
+				@rot_x = Degree.new 0
+				@rot_y = Degree.new 0
+
+				@translate_vector = Vector3.ZERO
+			end
+
+			if !@keyboard.buffered
+				return false unless process_unbuffered_key_input(event)
+			end
+
+			if !@mouse.buffered
+				return false unless process_unbuffered_mouse_input(event)
+			end
+
+			if !@mouse.buffered || !@keyboard.buffered || !buffered_joy
+				move_camera
+			end
+			
+			# Keep rendering!
+			true
+		end
+
+		def frame_ended(event)
+			update_stats
+			true
+		end
+
+		protected
+
+		def update_stats
+			gui_avg = OverlayManager.instance.get_overlay_element("Core/AverageFps")
+			gui_curr = OverlayManager.instance.get_overlay_element("Core/CurrFps")
+			gui_best = OverlayManager.instance.get_overlay_element("Core/BestFps")
+			gui_worst = OverlayManager.instance.get_overlay_element("Core/WorstFps")
+			gui_tris = OverlayManager.instance.get_overlay_element("Core/NumTris")
+			gui_batches = OverlayManager.instance.get_overlay_element("Core/NumBatches")
+			gui_debug = OverlayManager.instance.get_overlay_element("Core/DebugText")
+
+			stats = @window.get_statistics
+
+			gui_curr.set_caption("Current FPS: #{"%.3f" % stats.last_fps}")
+			gui_avg.set_caption("Average FPS: #{"%.3f" % stats.avg_fps}")
+			gui_best.set_caption("Best FPS: #{"%.3f" % stats.best_fps}")
+			gui_worst.set_caption("Worst FPS: #{"%.3f" % stats.worst_fps}")
+			gui_tris.set_caption("Triangle Count: #{stats.triangle_count}")
+			gui_batches.set_caption("Batch Count: #{stats.batch_count}")
+
+			gui_debug.set_caption("#{@debug_text}")
+		end
+	end
+end

data/lib/application_loading_bar.rb

@@ -0,0 +1,115 @@
+module Ogre
+
+	# From Ogre's ExampleLoadingBar:
+	#
+	# Defines an example loading progress bar which you can use during
+	# startup, level changes etc to display loading progress.
+	#
+	# Basically you just need to create an instance of this class, call start()
+	# before loading and finish() afterwards. You may also need to stop areas of
+	# your scene rendering in between since this method will call
+	# RenderWindow::update() to update the display of the bar - we advise using
+	# SceneManager's 'special case render queues' for this, see
+	# SceneManager::addSpecialCaseRenderQueue for details.
+	#	
+	# This progress bar relies on you having the OgreCore.zip package already
+	# added to a resource group called 'Bootstrap' - this provides the basic
+	# resources required for the progress bar and will be loaded automatically.
+	class ApplicationLoadingBar < ResourceGroupListenerProxy
+
+		def start(window, num_groups_init = 1, num_groups_load = 1, initial_proportion = 0.7)
+			@window = window
+			@num_groups_init = num_groups_init
+			@num_groups_load = num_groups_load
+			@initial_proportion = initial_proportion
+
+			ResourceGroupManager.instance.initialise_resource_group("Bootstrap")
+
+			overlay_mgr = OverlayManager.instance
+			@load_overlay = overlay_mgr.get_by_name("Core/LoadOverlay")
+
+			unless @load_overlay
+				raise "Cannot find loading overlay"
+			end
+			
+			@load_overlay.show
+
+			# Save links the loading text elements
+			@loading_bar_element = overlay_mgr.get_overlay_element("Core/LoadPanel/Bar/Progress")
+			@loading_comment_element = overlay_mgr.get_overlay_element("Core/LoadPanel/Comment")
+			@loading_description_element = overlay_mgr.get_overlay_element("Core/LoadPanel/Description")
+
+			bar = overlay_mgr.get_overlay_element("Core/LoadPanel/Bar")
+			@progress_bar_max_size = bar.get_width
+			@loading_bar_element.set_width(0)
+
+			# See superclass
+			register_as_listener
+		end
+
+		def finish
+			@load_overlay.hide
+
+			# See superclass
+			unregister_as_listener
+		end
+
+		def resource_group_scripting_started(group_name, count)
+			unless @num_groups_init > 0
+				raise "You are initializing groups when you said you would not, failing before causing x / 0 error"
+			end
+
+			@progress_bar_inc = @progress_bar_max_size * @initial_proportion / (count * 1.0)
+			@progress_bar_inc /= @num_groups_init
+
+			@loading_description_element.set_caption("Parsing scripts...")
+			@window.update
+		end
+
+		def script_parse_started(script_name)
+			@loading_comment_element.set_caption(script_name)
+			@window.update
+		end
+
+		def script_parse_ended(script_name)
+			@loading_bar_element.set_width(@loading_bar_element.get_width + @progress_bar_inc)
+			@window.update
+		end
+
+		def resource_group_scripting_ended(group_name)
+		end
+
+		def resource_group_load_started(group_name, count)
+			puts "", "", "Resource group started #{group_name}", "", ""
+			unless @num_groups_load > 0
+				raise "You are initializing groups when you said you would not, failing before causing x / 0 error"
+			end
+
+			@progress_bar_inc = @progress_bar_max_size * (1 - @initial_proportion) / (count * 1.0)
+			@progress_bar_inc /= @num_groups_load
+			@loading_description_element.set_caption("Loading resources...")
+			@window.update
+		end
+
+		def resource_load_started(resource)
+			@loading_comment_element.set_caption(resource.get_name)
+			@window.update
+		end
+
+		def resource_load_ended()
+		end
+
+		def world_geometry_stage_started(description)
+			@loading_comment_element.set_caption(description)
+			@window.update
+		end
+
+		def world_geometry_stage_ended
+			@loading_bar_element.set_width(@loading_bar_element.get_width + @progress_bar_inc)
+			@window.update
+		end
+
+		def resource_group_load_ended(name)
+		end
+	end
+end

data/lib/constants.rb

@@ -0,0 +1,51 @@
+module Ogre
+	class Vector3
+		def self.ZERO
+			Vector3.new(0, 0, 0)
+		end
+
+		def self.UNIT_X
+			Vector3.new(1, 0, 0)
+		end
+
+		def self.UNIT_Y
+			Vector3.new(0, 1, 0)
+		end
+
+		def self.UNIT_Z
+			Vector3.new(0, 0, 1)
+		end
+
+		def self.NEGATIVE_UNIT_X
+			Vector3.new(-1, 0, 0)
+		end
+
+		def self.NEGATIVE_UNIT_Y
+			Vector3.new(0, -1, 0)
+		end
+
+		def self.NEGATIVE_UNIT_Z
+			Vector3.new(0, 0, -1)
+		end
+
+		def self.UNIT_SCALE
+			Vector3.new(1, 1, 1)
+		end
+	end
+
+	class Vector4
+		def self.ZERO
+			Vector4.new(0,0,0,0)
+		end
+	end
+
+	class Quaternion
+		def self.ZERO
+			Quaternion.new(0.0,0.0,0.0,0.0)
+		end
+
+		def self.IDENTITY
+			Quaternion.new(1.0,0.0,0.0,0.0)
+		end
+	end
+end

data/lib/method_fixes.rb

@@ -0,0 +1,42 @@
+module Ogre
+
+	class SubMesh
+		alias_method :use_shared_vertices?, :useSharedVertices
+		alias_method :use_shared_vertices=, :useSharedVertices=
+
+		alias_method :vertex_data, :vertexData	
+		alias_method :vertex_data=, :vertexData=
+
+		alias_method :index_data, :indexData	
+		alias_method :index_data=, :indexData=
+
+		# SubMesh is a friend of Mesh, not a subclass...
+		#alias_method :shared_vertex_data, :sharedVertexData
+		#alias_method :shared_vertex_data=, :sharedVertexData=
+	end
+
+	class VertexData
+		alias_method :vertex_declaration, :vertexDeclaration
+		alias_method :vertex_declaration=, :vertexDeclaration=
+
+		alias_method :vertex_buffer_binding, :vertexBufferBinding
+		alias_method :vertex_buffer_binding=, :vertexBufferBinding=
+
+		alias_method :vertex_start, :vertexStart
+		alias_method :vertex_start=, :vertexStart=
+
+		alias_method :vertex_count, :vertexCount
+		alias_method :vertex_count=, :vertexCount=
+	end
+
+	class IndexData
+		alias_method :index_buffer, :indexBuffer
+		alias_method :index_buffer=, :indexBuffer=
+
+		alias_method :index_start, :indexStart
+		alias_method :index_start=, :indexStart=
+
+		alias_method :index_count, :indexCount
+		alias_method :index_count=, :indexCount=
+	end
+end

data/ogre.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__)+'/platform'
+
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/lib")
+
+# Ruby always looks for .so first, instead of .dll if on windows.
+# So, force .dll on windows environments
+if Platform.windows?
+	require 'lib/ogre.dll'
+	require 'lib/ruby_ois.dll'
+#	require 'lib/navi.dll'
+
+else
+	require 'lib/ogre'
+	require 'lib/ruby_ois'
+end
+
+# Ick, fix this? Doing this because the native OIS binary is infact
+# named OIS.dll, and was causing conflicts on my system.
+module OIS
+  include Ruby_ois
+end
+
+require 'constants'
+require 'method_fixes'

data/platform.rb

@@ -0,0 +1,23 @@
+# Helper functions for determining platform
+
+class Platform
+	def self.mac?
+	  return PLATFORM =~ /darwin/
+	end
+	
+	def self.windows?
+	  return PLATFORM =~ /mswin/
+	end
+	
+	def self.linux?
+		PLATFORM =~ /linux/
+	end
+end
+
+# Used to get around stupid windows STL issues when ruby.h is included first.
+# NOTE: It would better to do this with SWIG, but I could not figure out how.
+def insert_headers(file)
+	contents = File.open(file).read	
+	header = yield+"\n"
+	File.open(file, "w").write(header+contents)
+end