ogre.rb 0.1-i686-linux → 0.2-i686-linux

data/samples/cel_shading.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+include Ogre
+
+CUSTOM_SHININESS = 1
+CUSTOM_DIFFUSE = 2
+CUSTOM_SPECULAR = 3
+
+class CelShadingListener < 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)
+
+		$rot_node.yaw(Degree.new(event.time_since_last_frame * 30))
+
+    true
+  end
+end
+
+class CelShadingApplication < Ogre::Application
+
+  def create_scene
+		caps = root.get_render_system.get_capabilities
+		if !caps.has_capability?(RSC_VERTEX_PROGRAM) || !caps.has_capability?(RSC_FRAGMENT_PROGRAM)
+			raise "Your card does not support vertex or fragmet programs, so we cannot run this demo. Sorry"
+		end
+
+		light = scene_manager.create_light("MainLight")
+		$rot_node = scene_manager.root_scene_node.create_child_scene_node
+		$rot_node.create_child_scene_node(Vector3.new(20, 40, 50)).attach_object(light)
+
+		ent = scene_manager.create_entity("head", "ogrehead.mesh")
+
+		camera.set_position(20, 0, 100)
+		camera.look_at(0,0,0)
+
+		# eyes
+		sub = ent.get_sub_entity(0)
+		sub.set_material_name("CelShading")
+		sub.set_custom_parameter(CUSTOM_SHININESS, Vector4.new(35.0, 0.0, 0.0, 0.0))
+		sub.set_custom_parameter(CUSTOM_DIFFUSE, Vector4.new(1.0, 0.3, 0.3, 1.0))
+		sub.set_custom_parameter(CUSTOM_SPECULAR, Vector4.new(1.0, 0.6, 0.6, 1.0))
+		# skin
+		sub = ent.get_sub_entity(1)
+		sub.set_material_name("CelShading")
+		sub.set_custom_parameter(CUSTOM_SHININESS, Vector4.new(10.0, 0.0, 0.0, 0.0))
+		sub.set_custom_parameter(CUSTOM_DIFFUSE, Vector4.new(0.0, 0.5, 0.0, 1.0))
+		sub.set_custom_parameter(CUSTOM_SPECULAR, Vector4.new(0.3, 0.5, 0.3, 1.0))
+		# earring
+		sub = ent.get_sub_entity(2)
+		sub.set_material_name("CelShading")
+		sub.set_custom_parameter(CUSTOM_SHININESS, Vector4.new(25.0, 0.0, 0.0, 0.0))
+		sub.set_custom_parameter(CUSTOM_DIFFUSE, Vector4.new(1.0, 1.0, 0.0, 1.0))
+		sub.set_custom_parameter(CUSTOM_SPECULAR, Vector4.new(1.0, 1.0, 0.7, 1.0))
+		# teeth
+		sub = ent.get_sub_entity(3)
+		sub.set_material_name("CelShading")
+		sub.set_custom_parameter(CUSTOM_SHININESS, Vector4.new(20.0, 0.0, 0.0, 0.0))
+		sub.set_custom_parameter(CUSTOM_DIFFUSE, Vector4.new(1.0, 1.0, 0.7, 1.0))
+		sub.set_custom_parameter(CUSTOM_SPECULAR, Vector4.new(1.0, 1.0, 1.0, 1.0))
+
+		# Add entity to the root scene node
+		scene_manager.root_scene_node.create_child_scene_node.attach_object(ent)
+
+		window.get_viewport(0).set_background_colour(ColourValue.White)
+  end
+
+  def create_frame_listener
+    self.frame_listener = CelShadingListener.new(root, window, camera, scene_manager)
+  end
+end
+
+app = CelShadingApplication.new
+app.go

data/samples/grass.rb

@@ -74,7 +74,7 @@ class GrassListener < ApplicationFrameListener
 			$anim_state.add_time(event.time_since_last_frame)
 		end
 
-		if keyboard.key_down?(OIS::KC_B) && time_delay <= 0
+		if keyboard.key_down?(OIS::KC_B) && @time_delay <= 0
 			@time_delay = 1
 			@show_bbs = !@show_bbs
 			@scene_manager.show_bounding_boxes(@show_bbs)

data/samples/media/materials/programs/CelShading.cg

@@ -0,0 +1,63 @@
+
+/* Cel shading vertex program for single-pass rendering
+   In this program, we want to calculate the diffuse and specular
+   ramp components, and the edge factor (for doing simple outlining)
+   For the outlining to look good, we need a pretty well curved model.
+*/
+void main_vp(float4 position	: POSITION,
+			 float3 normal		: NORMAL,
+			 // outputs
+			 out float4 oPosition : POSITION,
+			 out float  diffuse		 : TEXCOORD0,
+			 out float  specular	 : TEXCOORD1,
+			 out float  edge		 : TEXCOORD2,
+			 // parameters
+			 uniform float3 lightPosition, // object space
+			 uniform float3 eyePosition,   // object space
+			 uniform float4  shininess,
+			 uniform float4x4 worldViewProj)
+{
+	// calculate output position
+	oPosition = mul(worldViewProj, position);
+
+	// calculate light vector
+	float3 N = normalize(normal);
+	float3 L = normalize(lightPosition - position.xyz);
+	
+	// Calculate diffuse component
+	diffuse = max(dot(N, L) , 0);
+
+	// Calculate specular component
+	float3 E = normalize(eyePosition - position.xyz);
+	float3 H = normalize(L + E);
+	specular = pow(max(dot(N, H), 0), shininess);
+	// Mask off specular if diffuse is 0
+	if (diffuse == 0) specular = 0;
+
+	// Edge detection, dot eye and normal vectors
+	edge = max(dot(N, E), 0);
+}
+
+void main_fp(float diffuseIn 	: TEXCOORD0,
+			 float specularIn	: TEXCOORD1,
+			 float edge		: TEXCOORD2,
+			 
+			 out float4 colour	: COLOR,
+			 
+			 uniform float4 diffuse,
+			 uniform float4 specular,
+			 
+			 uniform sampler1D diffuseRamp,
+			 uniform sampler1D specularRamp,
+			 uniform sampler1D edgeRamp)
+{
+	// Step functions from textures
+	diffuseIn = tex1D(diffuseRamp, diffuseIn).x;
+	specularIn = tex1D(specularRamp, specularIn).x;
+	edge = tex1D(edgeRamp, edge).x;
+
+	colour = edge * ((diffuse * diffuseIn) + 
+					(specular * specularIn));
+}
+			 
+			 

data/samples/media/materials/scripts/CelShading.material

@@ -0,0 +1,68 @@
+// -------------------------------
+// Cel Shading Section
+// -------------------------------
+vertex_program Ogre/CelShadingVP cg
+{
+	source CelShading.cg
+	entry_point main_vp
+	profiles vs_1_1 arbvp1
+
+	default_params
+	{
+		param_named_auto lightPosition light_position_object_space 0
+		param_named_auto eyePosition camera_position_object_space
+		param_named_auto worldViewProj worldviewproj_matrix
+		param_named shininess float 10 
+	}
+}
+
+fragment_program Ogre/CelShadingFP cg
+{
+	source CelShading.cg
+	entry_point main_fp
+	profiles ps_1_1 arbfp1 fp20
+}
+
+
+material CelShading
+{
+	technique
+	{
+		pass
+		{
+			vertex_program_ref Ogre/CelShadingVP
+			{
+				// map shininess from custom renderable param 1
+				param_named_auto shininess custom 1
+			}
+			fragment_program_ref Ogre/CelShadingFP
+			{
+				// map diffuse from custom renderable param 2
+				param_named_auto diffuse custom 2
+				// map specular from custom renderable param 2
+				param_named_auto specular custom 3
+			}
+			texture_unit
+			{
+				texture cel_shading_diffuse.png 1d
+				tex_address_mode clamp
+				filtering none
+			}
+			texture_unit
+			{
+				texture cel_shading_specular.png 1d
+				tex_address_mode clamp
+				filtering none
+				tex_coord_set 1
+			}
+			texture_unit
+			{
+				texture cel_shading_edge.png 1d
+				tex_address_mode clamp
+				filtering none
+				tex_coord_set 2
+			}
+		}
+	}
+	
+}

data/samples/ogre.cfg

@@ -4,5 +4,4 @@ Render System=OpenGL Rendering Subsystem
 FSAA=0
 Full Screen=No
 RTT Preferred Mode=FBO
-Refresh Rate=Not applicable
-Video Mode=1280 x 1024
+Video Mode=800 x 600

data/samples/plugins.cfg

@@ -1,10 +1,11 @@
 # Defines plugins to load
 
 # Define plugin folder
-#PluginFolder=D:\Programming\engines\Ogre1.4.1SDK\bin\release
-PluginFolder=/usr/local/lib/OGRE/
+#PluginFolder=D:\Programming\engines\Ogre1.4.4SDK\bin\release
+PluginFolder=/usr/local/ogre/lib/OGRE/
 
 Plugin=RenderSystem_GL
+#Plugin=RenderSystem_Direct3D9
 Plugin=Plugin_OctreeSceneManager
 Plugin=Plugin_ParticleFX
 Plugin=Plugin_BSPSceneManager

data/test/ogre.cfg

@@ -0,0 +1,10 @@
+Render System=OpenGL Rendering Subsystem
+
+[OpenGL Rendering Subsystem]
+Colour Depth=32
+Display Frequency=N/A
+FSAA=0
+Full Screen=No
+RTT Preferred Mode=FBO
+VSync=No
+Video Mode=1024 x 768

data/{samples/navi → test}/plugins.cfg

@@ -1,10 +1,8 @@
 # Defines plugins to load
 
 # Define plugin folder
-PluginFolder=.
+PluginFolder=D:\Programming\engines\Ogre1.4.4SDK\bin\release
 #PluginFolder=/usr/local/lib/OGRE/
 
 Plugin=RenderSystem_GL
-Plugin=RenderSystem_Direct3D9
-Plugin=Plugin_OctreeSceneManager
-Plugin=Plugin_ParticleFX
+#Plugin=Plugin_ParticleFX

data/test/test_helper.rb

@@ -0,0 +1,67 @@
+$: << File.expand_path( File.dirname(__FILE__) )
+require File.dirname(__FILE__) + "/../ogre"
+require "test/unit"
+
+class Test::Unit::TestCase
+	include Ogre
+
+	# Run through Ogre setup routines so we have access to the system.
+	#
+	# Any test classes that override #setup will need to call super
+	#
+	# I use class variables to make sure only one window pops up instead
+	# of one per test case, which would make things really, really slow.
+	# In the else clause here, do any cleanup you need.
+	def setup
+		@@root ||= nil
+		unless @@root
+			@@log_manager = LogManager.new
+			@@log_manager.create_log("Test.log",true,false,false)
+
+			dir = File.expand_path( File.dirname(__FILE__) )
+			@@root = Root.new "#{dir}/plugins.cfg", "#{dir}/ogre.cfg", "Test.log"
+			@@scene_manager = @@root.create_scene_manager(ST_GENERIC, "test")
+
+			# If needed later
+			#media_path = File.expand_path(File.dirname(__FILE__)+"/media")
+			#ResourceGroupManager.instance.add_resource_location(media_path, "FileSystem", "General")
+
+			# Find a renderer to use
+			renderers = @@root.get_available_renderers
+			@@root.set_render_system(renderers[0])
+
+			@@root.initialise(false)
+
+			# I really, really don't want this! 
+			# but I don't seem to have a choice right now.
+			@@window = @@root.create_render_window("Testing Ogre", 320, 240, false)
+
+			ResourceGroupManager.instance.initialise_all_resource_groups
+		end
+	end
+
+	def teardown
+		@@scene_manager.clear_scene
+	end
+
+	def scene_manager
+		@@scene_manager
+	end
+
+	def window
+		@@window
+	end
+
+
+	# An interesting BDD function
+	def self.should(behave,&block)
+		mname = "test_should_#{behave}"
+		if block
+			define_method mname, &block
+		else
+			define_method mname do 
+				flunk "#{self.class.name.sub(/Test$/,'')} should #{behave}"
+			end
+		end
+	end
+end

data/test/unit/constants_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ConstantsTest < Test::Unit::TestCase
+
+	should "have constantized methods for Vector3" do
+		{	
+			:ZERO => [0, 0, 0],
+			:UNIT_X => [1, 0, 0],
+			:UNIT_Y => [0, 1, 0],
+			:UNIT_Z => [0, 0, 1],
+			:NEGATIVE_UNIT_X => [-1, 0, 0],
+			:NEGATIVE_UNIT_Y => [0, -1, 0],
+			:NEGATIVE_UNIT_Z => [0, 0, -1],
+			:UNIT_SCALE => [1, 1, 1]
+		}.each do |method, expected|
+			vec = Vector3.send(method)
+			assert_equal expected, [vec.x, vec.y, vec.z]
+
+			# And test that we don't destroy the initial data like
+			# Ruby constants like to do
+			vec.x = 10
+			vec.y = 20
+			vec.z = 30
+			vec2 = Vector3.send(method)
+			assert_not_equal [vec2.x, vec2.y, vec2.z], [vec.x, vec.y, vec.z]
+		end
+	end
+
+	should "have constantized methods for Vector4" do
+		{	
+			:ZERO => [0, 0, 0, 0],
+		}.each do |method, expected|
+			vec = Vector4.send(method)
+			assert_equal expected, [vec.x, vec.y, vec.z, vec.w]
+
+			# And test that we don't destroy the initial data like
+			# Ruby constants like to do
+			vec.x = 10
+			vec.y = 20
+			vec.z = 30
+			vec.w = 40
+			vec2 = Vector4.send(method)
+			assert_not_equal [vec2.x, vec2.y, vec2.z, vec2.w], [vec.x, vec.y, vec.z, vec.w]
+		end
+	end
+
+	should "have constantized methods for Quanternion" do
+		{	
+			:ZERO => [0.0, 0.0, 0.0, 0.0],
+			:IDENTITY => [1.0, 0.0, 0.0, 0.0]
+		}.each do |method, expected|
+			quat = Quaternion.send(method)
+			assert_equal expected, [quat.w, quat.x, quat.y, quat.z]
+
+			# And test that we don't destroy the initial data like
+			# Ruby constants like to do
+			quat.x = 10
+			quat.y = 20
+			quat.z = 30
+			quat.w = 40
+			quat2 = Quaternion.send(method)
+			assert_not_equal [quat2.x, quat2.y, quat2.z, quat2.w], [quat.x, quat.y, quat.z, quat.w]
+		end
+	end
+
+end

data/test/unit/frame_stats_proxy_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class FrameStatsProxyTest < Test::Unit::TestCase
+	
+	should "wrap Ogre::FrameStats into our own FrameStatsProxy" do
+		stats = window.get_statistics
+		assert_not_nil stats
+		assert stats.is_a?(FrameStatsProxy)		
+	end
+
+	should "have certain methods for accessing render stats" do
+		stats = FrameStatsProxy.new window
+
+		%w(
+			last_fps
+			avg_fps
+			best_fps
+			worst_fps	
+			best_frame_time
+			worst_frame_time
+			triangle_count
+			batch_count
+		).each do |method|
+			assert stats.respond_to?(method)
+		end
+	end
+
+end

data/test/unit/math_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class MathTest < Test::Unit::TestCase
+
+	should "properly take in Degrees and Radians interchangably" do
+		light = scene_manager.create_light("Testing Light")
+
+		rad = Radian.new(::Math::PI)
+		deg = Degree.new(180)
+
+		# Radians in, Radians out
+		light.set_spotlight_inner_angle(rad)
+		assert_equal rad, light.get_spotlight_inner_angle
+
+		# Degrees in, Radians out
+		light.set_spotlight_inner_angle(deg)
+		assert_in_delta rad.value_radians, 
+			light.get_spotlight_inner_angle.value_radians, 0.0001
+	end
+end

data/test/unit/mesh_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class MeshTest < Test::Unit::TestCase
+	
+	should "have a few new methods" do
+		assert Mesh.instance_methods.include?("shared_vertex_data=")
+		assert Mesh.instance_methods.include?("shared_vertex_data")
+		assert Mesh.instance_methods.include?("suggest_tangent_vector_build_params")
+	end
+
+	should "not have other methods" do
+		assert !Mesh.instance_methods.include?("get_pose_iterator")	
+	end
+
+end

data/test/unit/methods_test.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class MethodsTest < Test::Unit::TestCase
+
+	should "be able to access Singletons through #instance" do
+		assert ResourceGroupManager.respond_to?(:instance)
+		assert MeshManager.respond_to?(:instance)
+		assert MaterialManager.respond_to?(:instance)
+	end
+
+	should "have numerous bang (!) or query (?) methods" do
+		assert Vector3.new.respond_to?(:normalise!)
+		assert RenderWindow.instance_methods.include?("closed?")
+		assert SubMesh.instance_methods.include?("is_mat_initialised?")
+	end
+
+	should "have certain methods" do
+		assert FrameEvent.instance_methods.include?("time_since_last_frame")
+		assert FrameEvent.instance_methods.include?("time_since_last_event")
+	end
+
+	should "be ignoring other methods for various reasons" do
+		assert !AxisAlignedBox.new.respond_to?(:get_corner)
+
+		assert !ResourceGroupManager.instance.respond_to?(:resource_exists)
+
+		assert !BillboardChain.instance_methods.include?(:add_chain_element)
+		assert !BillboardChain.instance_methods.include?(:update_chain_element)
+		assert !BillboardChain.instance_methods.include?(:get_chain_element)
+
+		assert !ConfigFile.instance_methods.include?(:load)
+
+		assert !KeyFrame.instance_methods.include?(:get_post_reference_iterator)
+
+		assert !Node.instance_methods.include?(:get_child_iterator)
+		assert !Node.instance_methods.include?(:set_listener)
+		assert !Node.instance_methods.include?(:get_listener)
+
+		assert !ParticleSystem.instance_methods.include?(:_get_iterator)
+
+		assert !Pass.instance_methods.include?(:set_hash_function)
+		assert !Pass.instance_methods.include?(:get_hash_function)
+
+		assert !PatchMesh.instance_methods.include?(:get_pose_iterator)
+
+		assert !RenderQueue.instance_methods.include?(:set_renderable_listener)
+		assert !RenderQueue.instance_methods.include?(:get_renderable_listener)
+
+		assert !RenderSystem.instance_methods.include?(:add_listener)
+		assert !RenderSystem.instance_methods.include?(:remove_listener)
+		assert !RenderSystem.instance_methods.include?(:register_thread)
+		assert !RenderSystem.instance_methods.include?(:unregister_thread)
+
+		assert !SceneNode.instance_methods.include?(:get_attached_object_iterator)
+
+		assert !TextureUnitState.instance_methods.include?(:add_effect)
+		assert !TextureUnitState.instance_methods.include?(:remove_effect)
+
+		assert !ManualObject.instance_methods.include?(:get_shadow_volume_renderable_iterator)
+	end
+
+	should "have fixed method names related to public instance variables of classes (method_fixes.rb)" do
+		%w(
+			use_shared_vertices?
+			use_shared_vertices=
+			vertex_data
+			vertex_data=
+			index_data
+			index_data=
+		).each do |method|
+			assert SubMesh.new.respond_to?(method)
+		end
+
+		%w(
+			vertex_declaration
+			vertex_declaration=
+			vertex_buffer_binding
+			vertex_buffer_binding=
+			vertex_start
+			vertex_start=
+			vertex_count
+			vertex_count=
+		).each do |method|
+			assert VertexData.new.respond_to?(method)
+		end
+		
+		%w(
+			index_buffer
+			index_buffer=
+			index_start
+			index_start=
+			index_count
+			index_count=
+		).each do |method|
+			assert IndexData.new.respond_to?(method)
+		end
+	end
+end

data/test/unit/movable_object_test.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class MovableObjectTest < Test::Unit::TestCase
+
+  should "be properly cast to their real subclasses on C++ -> Ruby" do
+   	mo = scene_manager.create_movable_object("myThingy", "Light", {}) 
+		assert_equal "myThingy", mo.get_name
+		assert mo.is_a?(Light)
+  end
+
+	should "not have listener methods" do
+   	mo = scene_manager.create_movable_object("myThingy", "Light", {}) 
+
+		assert !mo.respond_to?(:set_listener)
+		assert !mo.respond_to?(:get_listener)
+		assert !mo.respond_to?(:extract_movable_object)
+	end
+
+end

data/test/unit/name_value_pair_list_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class NameValuePairListTest < Test::Unit::TestCase
+
+	should "be able to pass in a Ruby hash into methods expecting NameValuePairList" do
+    trail = scene_manager.create_movable_object("RibbonTrail1", "RibbonTrail",
+              {"numberOfChains" => "2", "maxElements" => "80"}) 
+		assert_equal 80, trail.get_max_chain_elements
+		assert_equal 2, trail.get_number_of_chains
+	end
+
+end

data/test/unit/overlay_element_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class OverlayElementTest < Test::Unit::TestCase
+
+  should "be properly cast to their real subclasses on C++ -> Ruby" do
+		element = OverlayManager.instance.create_overlay_element("Panel", "TestPanel")
+		assert_not_nil element
+		assert element.is_a?(PanelOverlayElement)
+
+		text_element = OverlayManager.instance.create_overlay_element("TextArea", 
+																																"Tester")
+		assert_not_nil text_element
+		assert text_element.is_a?(TextAreaOverlayElement)
+
+		element2 = OverlayManager.instance.get_overlay_element("TestPanel")
+		assert element2.is_a?(PanelOverlayElement)
+		assert_equal element.get_name, element2.get_name
+  end
+
+end

data/test/unit/render_target_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class RenderTargetTest < Test::Unit::TestCase
+	
+	should "have a specially wrapped getCustomAttribute method" do
+		assert window.respond_to?(:get_custom_attribute_unsigned_long)
+		assert !RenderTarget.instance_methods.include?("get_custom_attribute")
+		assert !RenderTarget.instance_methods.include?("_getImpl")
+	end
+
+end

data/test/unit/resource_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class ResourceTest < Test::Unit::TestCase
+
+	def teardown
+		super
+		MeshManager.instance.remove_all
+	end
+
+  should "be properly cast to their real subclasses on C++ -> Ruby" do
+   	mesh = MeshManager.instance.create("TestMesh", "General")
+		assert mesh.is_a?(MeshPtr)
+
+		material = MaterialManager.instance.create("TestMaterial", "General")
+		assert material.is_a?(MaterialPtr)
+  end
+
+	should "not have listener methods" do
+   	mesh = MeshManager.instance.create("TestMesh", "General")
+
+		assert !mesh.respond_to?(:add_listener)
+		assert !mesh.respond_to?(:remove_listener)
+		assert !mesh.respond_to?(:extract_resource)
+	end
+
+end