ogre.rb 0.1-i386-mswin32

data/samples/work/cube_mapping.rb

@@ -0,0 +1,686 @@
+#!/usr/bin/ruby -w
+
+require 'application'
+include Ogre
+include OIS
+
+# This is a pretty much verbatim copy of the CubeMapping demo.
+# Will this work in Ruby? I really don't know. There's a LOT of
+# pointer arithmetic happening in the original.
+
+# Perlin Noise data and algorithms
+class Perlin
+ 	P = [
+	151,160,137,91,90,15,
+	131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
+	190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
+	88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
+	77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
+	102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
+	135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
+	5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
+	223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
+	129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
+	251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
+	49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
+	138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,
+
+	151,160,137,91,90,15,
+	131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
+	190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
+	88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
+	77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
+	102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
+	135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
+	5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
+	223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
+	129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
+	251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
+	49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
+	138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
+	]
+
+	class << self
+
+		def lerp(t, a, b)
+			a + t * (b - a)
+		end
+
+		def fade(t)
+			t*t*t*t*(t*(t*6-15)+10) 
+		end
+
+		# Convert Low 4 bits of hash code into
+		# 12 gradient directions
+		def grad(hash, x, y, z)
+			hash ||= 0
+			h = hash & 15
+			u = h < 8 || h == 12 || h == 13 ? x : y
+			v = h < 4 || h == 12 || h == 13 ? y : z
+
+			((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v)
+		end
+
+		# This is copied almost verbatim from CubeMapping demo
+		def noise3(x, y, z)
+			_x = x.floor & 225
+			_y = y.floor & 255
+			_z = z.floor & 255	
+
+			x -= x.floor
+			y -= y.floor
+			z -= z.floor
+
+			u = fade(x)
+			v = fade(y)
+			w = fade(z)
+
+			a = P[_x] + _y
+			aa = P[a] + _z
+			ab = P[a + 1] + _z
+			b = P[_x + 1]
+			ba = P[b] + _z
+			bb = P[b + 1] + _z
+
+			# Oh snap!
+			return lerp(w, 
+									lerp(v, 
+											 lerp(u, 
+														grad(P[aa], x, y, z), # And add
+														grad(P[ba], x - 1, y, z)), # Blended
+												lerp(u, 
+														grad(P[ab], a, y - 1, z), # Results
+														grad(P[bb], x - 1, y - 1, z))), # From 8
+									lerp(v,
+											 lerp(u,
+														grad(P[aa + 1], x, y, z - 1), # Corners
+														grad(P[ba + a], x - 1, y, z - 1)), # Of Cube
+											 lerp(u,
+														grad(P[ab + 1], x, y - 1, z - 1),
+														grad(P[bb + 1], x - 1, y - 1, z - 1))))
+										
+		end
+	end
+end
+
+ENTITY_NAME = "CubeMappedEntity"
+MESH_NAME = "CubeMappedMesh"
+
+MATERIAL_NAME = "SceneCubeMap2"
+SKYBOX_MATERIAL = "SceneSkyBox2"
+
+class CubeMappingListener < ApplicationFrameListener
+	def initialize(root, win, cam, scene_manager, object_node)
+		super(root, win, cam)
+
+		@scene_manager = scene_manager
+		@object_node = object_node
+
+		@tm = 0
+		@timeout_delay = 0
+		@displacement = 0.1
+		@density = 50.0
+		@time_density = 5.0
+		@object_entity = 0
+		@cloned_materials = []
+		@cloned_mesh = nil
+
+		@noise_on = false
+		@current_cube_map_index = 0
+		@current_lbx_index = 0
+		@current_mesh_index = 0
+
+		@material = MaterialManager.instance.get_by_name(MATERIAL_NAME)
+
+		raise "Cannot find material #{MATERIAL_NAME}" unless @material
+
+		#puts "\tReading config"
+		read_config
+
+		#puts "\tSetting object"
+		set_object
+
+		#puts "\tSetting material blending"
+		set_material_blending
+
+		#puts "\tSetting cube map"
+		set_cube_map
+
+		#puts "\tSetting noise to On"
+		set_noise_on
+
+		#puts "\tUpdate Info displacement"
+		update_info_displacement
+
+		#puts "\tUpdate info density"
+		update_info_density
+
+		#puts "\tUpdate info time density"
+		update_info_time_density
+	end
+
+	def frame_started(event)
+		return false unless super(event)
+
+		@tm += event.time_since_last_frame / @time_density
+
+		update_noise if @noise_on
+
+		@object_node.yaw(Degree.new(20 * event.time_since_last_frame))
+		
+		true
+	end
+
+	def adjust_range(value_key, key_plus, key_minus, min_val, max_val, change, func)
+		value = instance_variable_get("@#{value_key}")	
+		if keyboard.key_down?(key_plus)
+			value += change
+			if value >= max_val
+				value = max_val
+			end
+			instance_variable_set("@#{value_key}", value)
+			send(func)
+		end
+
+		if keyboard.key_down?(key_minus)
+			value -= change
+			if value <= min_val
+				value = min_val
+			end
+			instance_variable_set("@#{value_key}", value)
+			send(func)
+		end
+
+	end
+
+	def switch_value(key, time_delay, code)
+		if keyboard.key_down?(key) && @timeout_delay == 0
+			@timeout_delay = time_delay
+			code.call
+		end
+	end
+
+	def process_unbuffered_key_input(event)
+
+		ret = super(event)
+
+		change_speed = event.time_since_last_frame
+
+		if keyboard.key_down?(KC_LSHIFT) || keyboard.key_down?(KC_RSHIFT)
+			change_speed += 10.0
+		end
+
+		if keyboard.key_down?(KC_LCONTROL)
+			change_speed /= 10.0
+		end
+
+		adjust_range(:displacement, OIS::KC_2, OIS::KC_1, 2, 2, 0.1 * change_speed, :update_info_displacement)
+		adjust_range(:density, OIS::KC_4, OIS::KC_3, 0.1, 500, 10.0 * change_speed, :update_info_density)
+		adjust_range(:time_density, OIS::KC_6, OIS::KC_5, 1, 10, 1.0 * change_speed, :update_info_time_density)
+
+		@timeout_delay -= event.time_since_last_frame
+		@timeout_delay = 0 if @timeout_delay <= 0
+
+		switch_value(OIS::KC_O, 0.5, proc { @current_mesh_index += 1; set_object})
+		switch_value(OIS::KC_N, 0.5, proc { @noise_on = !@noise_on; set_noise_on})
+		switch_value(OIS::KC_M, 0.5, proc { @current_lbx_index += 1; set_material_blending})
+		switch_value(OIS::KC_C, 0.5, proc { @current_cube_map_index += 1; set_cube_map})
+		switch_value(OIS::KC_SPACE, 0.5, proc { go_random })
+
+		ret
+	end
+
+	private
+
+	def read_config
+		cfg = ConfigFile.new
+		cfg.load("media.cfg")
+		@available_meshes = cfg.get_multi_setting("Mesh")
+		@available_cube_maps = cfg.get_multi_setting("CubeMap")
+	end
+
+	def random_from(a, b)
+		(rand() & 65535) / 65536.0 * (b-a) + a
+	end
+
+	def go_random
+		@displacement = random_from(0.0, 1.0)
+		update_info_displacement
+
+		@density = random_from(1.0, 300.0)
+		update_info_density
+
+		@time_density = random_from(1.0, 10.0)
+		update_info_time_density
+	end
+
+	def update_info_displacement
+		OverlayManager.instance.get_overlay_element("CubeMapping/Displacement").set_caption("[1/2] Displacement: #{@displacement}")
+	end
+
+	def update_info_density
+		OverlayManager.instance.get_overlay_element("CubeMapping/Density").set_caption("[3/4] Noise density: #{@density}")
+	end
+
+	def update_info_time_density
+		OverlayManager.instance.get_overlay_element("CubeMapping/TimeDensity").set_caption("[5/6] Time density: #{@time_density}")
+	end
+
+	def set_object
+		@current_mesh_index %= @available_meshes.size
+		mesh_name = @available_meshes[@current_mesh_index]
+
+		puts "Switching to object #{mesh_name}"
+
+		prepare_entity(mesh_name)
+
+		puts "Taking care of overlay"
+		OverlayManager.instance.get_overlay_element("CubeMapping/Object").set_caption("[O] Object: #{mesh_name}")
+	end
+
+	def set_noise_on
+		OverlayManager.instance.get_overlay_element("CubeMapping/Noise").set_caption("[N] Noise: #{@noise_on ? 'on' : 'off'}")
+	end
+
+	def set_cube_map
+		@current_cube_map_index %= @available_cube_maps.size
+		cube_map_name = @available_cube_maps[@current_cube_map_index]
+
+		pass = @material.get_technique(0).get_pass(0)
+
+		pass.get_texture_unit_state(0).get_num_frames.times do |i|
+			old_tex_name = pass.get_texture_unit_state(0).get_frame_texture_name(i)
+			old_tex = TextureManager.instance.get_by_name(old_tex_name)
+			TextureManager.instance.remove(old_tex_name)
+		end
+		pass.get_texture_unit_state(0).set_cubic_texture_name(cube_map_name, true)
+
+		mat2 = MaterialManager.instance.get_by_name(SKYBOX_MATERIAL)
+		pass2 = mat2.get_technique(0).get_pass(0)
+
+		pass2.get_texture_unit_state(0).get_num_frames.times do |i|
+			old_tex_name = pass2.get_texture_unit_state(0).get_frame_texture_name(i)
+			old_tex = TextureManager.instance.get_by_name(old_tex_name)
+			TextureManager.instance.remove(old_tex_name)
+		end
+		pass2.get_texture_unit_state(0).set_cubic_texture_name(cube_map_name, true)
+
+		# FIXME UG! Causing Problem
+		#@scene_manager.set_sky_box(true, SKYBOX_MATERIAL)	
+
+		prepare_entity(@available_meshes[@current_mesh_index])
+		OverlayManager.instance.get_overlay_element("CubeMapping/CubeMap").set_caption("[C] CubeMap: #{cube_map_name}")
+	end
+
+	def set_material_blending
+		lbx_name = ""
+		@current_lbx_index %= 5
+		case @current_lbx_index
+		when 0
+			@current_lbx = LBX_ADD; 
+			lbx_name = "ADD"
+		when 1
+			@current_lbx = LBX_MODULATE; 
+			lbx_name = "MODULATE"
+		when 2
+			@current_lbx = LBX_MODULATE_X2; 
+			lbx_name = "MODULATE X2"
+		when 3
+			@current_lbx = LBX_MODULATE_X4; 
+			lbx_name = "MODULATE X4"
+		when 4
+			@current_lbx = LBX_SOURCE1; 
+			lbx_name = "SOURCE1"
+		when 5
+			@current_lbx = LBX_SOURCE2; 
+			lbx_name = "SOURCE2"
+		end
+
+		# Reset entities, materials, etc
+		prepare_entity(@available_meshes[@current_mesh_index])
+		OverlayManager.instance.get_overlay_element("CubeMapping/Material").set_caption("[M] Material blend: " + lbx_name)
+	end
+
+	def prepare_entity(mesh_name)
+		clear_entity if @object_entity
+
+		@original_mesh = MeshManager.instance.get_by_name(mesh_name)
+
+		if !@original_mesh
+			@original_mesh = MeshManager.instance.load(mesh_name,
+												ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME)
+			if !@original_mesh
+				raise "Can't find the mesh #{mesh_name}"
+			end
+		end
+
+		prepare_cloned_mesh
+
+		@object_entity = @scene_manager.create_entity(ENTITY_NAME, MESH_NAME)
+		@object_entity.set_material_name(@material.get_name)
+		pass = @material.get_technique(0).get_pass(0)
+
+		# Go through subentities and set materials
+		num = @cloned_mesh.get_num_sub_meshes
+		num.times do |m|
+			sub_mesh = @cloned_mesh.get_sub_mesh(m)
+			sub_entity = @object_entity.get_sub_entity(m)
+
+			if sub_mesh.is_mat_initialised?
+				mat_name = sub_mesh.get_material_name
+				sub_mat = MaterialManager.instance.get_by_name(mat_name)
+
+				unless sub_mat
+					sub_mat.load
+					cloned = sub_mat.clone("CubeMapTempMaterial##{m}")
+					cloned_pass = cloned.get_technique(0).get_pass(0)
+
+					# the knot, it needs to scroll!
+					if mesh_name == "knot.mesh"
+						cloned_pass.get_num_texture_unit_states.times do |tl|
+							tlayer = cloned_pass.get_texture_unit_state(tl)
+							tlayer.set_scroll_animation(1.0, 0)
+						end
+					end
+
+					# Layers
+					pass.get_num_texture_unit_states.times do |tl|
+						org_tl = pass.get_texture_unit_state(tl)
+						new_tl = cloned_pass.create_texture_unit_state(org_tl.get_texture_name)
+						# Um, *new_tl = *org_tl ?
+						new_tl = org_tl
+						new_tl.set_colour_operation_ex(@current_lbx)
+					end
+
+					sub_entity.set_material_name(cloned.get_name)
+					@cloned_materials << cloned
+				end
+			end	
+		end
+
+		@object_node.attach_object(@object_entity)
+
+		if @noise_on
+			update_noise
+		end
+	end
+
+	def prepare_cloned_mesh
+		@cloned_mesh = MeshManager.instance.create_manual(MESH_NAME,
+										ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME)
+		@cloned_mesh._set_bounds(@original_mesh.get_bounds)
+		@cloned_mesh._set_bounding_sphere_radius(@original_mesh.get_bounding_sphere_radius)
+
+		@cloned_mesh.shared_vertex_data = prepare_vertex_data(@original_mesh.shared_vertex_data)
+
+		@original_mesh.get_num_sub_meshes.times do |sm|
+			org_sm = @original_mesh.get_sub_mesh(sm)
+			new_sm = @cloned_mesh.create_sub_mesh
+
+			if org_sm.is_mat_initialised?
+				new_sm.set_material_name(org_sm.get_material_name)
+			end
+
+			new_sm.use_shared_vertices = org_sm.use_shared_vertices?
+			# Vertex data
+			new_sm.vertex_data = prepare_vertex_data(org_sm.vertex_data)
+			# Reuse index
+			new_sm.index_data.index_buffer = org_sm.index_data.index_buffer
+			new_sm.index_data.index_start = org_sm.index_data.index_start
+			new_sm.index_data.index_count = org_sm.index_data.index_count
+		end
+	end
+
+	def prepare_vertex_data(org_vd)
+		return nil unless org_vd
+
+		# Hacky bit: reorganise vertex buffers to a buffer-per-element
+		# Since this demo was written a while back to assume that
+		# Really this demo should be replaced with a vertex program noise
+		# distortion, but left the software for now since it's nice for older
+		# card owners
+		new_decl = org_vd.vertex_declaration.clone
+		elems = new_decl.get_elements
+		buff = 0
+		elems.each do |elem|
+			new_decl.modify_element(buff, buff, 0, elem.get_type, elem.get_semantic, elem.get_index)
+			buff += 1
+		end
+
+		org_vd.reorganise_buffers(new_decl)
+
+		new_vd = VertexData.new
+		# Copy that which does not change
+		new_vd.vertex_count = org_vd.vertex_count
+		new_vd.vertex_start = org_vd.vertex_start
+		# Now copy vertex buffers, looking in the declarations
+		new_vdecl = new_vd.vertex_declaration
+		new_vbind = new_vd.vertex_buffer_binding
+
+		org_vel = org_vd.vertex_declaration.get_elements
+		org_vel.each do |veli|
+			ves = veli.get_semantic
+			source = veli.get_source
+
+			org_buf = org_vd.vertex_buffer_binding.get_buffer(source)
+
+			# Check usage of new buffer
+			dynamic = false
+			case ves
+			when [VES_NORMAL, VES_POSITION]
+				dynamic = true
+			else
+				dynamic = false
+			end
+
+			if dynamic
+				new_buf = HardwareBufferManager.instance.create_vertex_buffer(
+										org_buff.get_vertex_size, org_buff.get_num_vertices,
+										HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE,
+										true)
+				new_buff.copy_data(org_buff, 0, 0, org_buff.get_size_in_bytes, true)
+				new_vbind.set_binding(source, new_buf)
+			else
+				new_vbind.set_binding(source, org_buf)
+			end
+
+			# Add element for declaration
+			new_vdecl.add_element(source, veli.get_offset, veli.get_type,
+														ves, veli.get_index)
+		end
+
+		new_vd
+	end
+
+	def clear_entity
+		@cloned_materials.each do |cm|
+			MaterialManager.instance.remove(cm.get_handle)
+		end
+
+		@cloned_materials.clear
+
+		@object_node.detach_all_objects
+		@scene_manager.destroy_entity(ENTITY_NAME)
+
+		MeshManager.instance.remove(@cloned_mesh.get_handle) if @cloned_mesh
+
+		@object_entity = nil
+	end
+
+	def update_noise
+		shared_normals = nil
+		normals = nil
+
+		@cloned_mesh.get_num_sub_meshes.times do |m|
+			sub_mesh = @cloned_mesh.get_sub_mesh(m)
+			org_sub_mesh = @original_mesh.get_sub_mesh(m)
+
+			if sub_mesh.use_shared_vertices?
+				if !shared_normals
+					shared_normals = normals_get_cleared(@cloned_mesh.shared_vertex_data)
+				end
+
+				update_vertex_data_noise_and_normals(
+					@cloned_mesh.shared_vertex_data,
+					@original_mesh.shared_vertex_data,
+					sub_mesh.index_data,
+					shared_normals)
+			else
+				normals = normals_get_cleared(sub_mesh.vertex_data)
+
+				update_vertex_data_noise_and_normals(
+					sub_mesh.vertex_data,
+					org_sub_mesh.vertex_data,
+					sub_mesh.index_data,
+					normals)
+				normals_save_normalized(sub_mesh.vertex_data, normals)
+			end
+		end
+
+		if shared_normals
+			normals_save_normalized(@cloned_mesh.shared_vertex_data, shared_normals)
+		end
+	end
+
+	def normals_get_cleared(vertex_data)
+		norm_ve = vertex_data.vertex_declaration.find_element_by_semantic(VES_NORMAL)
+		norm_hvb = vertex_data.vertex_buffer_binding.get_buffer(norm_ve.get_source)
+		normals = norm_hvb.lock(vertex_data.vertex_declaration, HardwareBuffer::HBL_DISCARD)
+		# FIXME Um, memset?
+		normals
+	end
+
+	def normals_save_normalized(vertex_data, normals)
+		norm_ve = vertex_data.vertex_declaration.find_element_by_semantic(VES_NORMAL)
+		norm_hvb = vertex_data.vertex_buffer_binding.get_buffer(norm_ve.get_source)
+		i = 0
+		num_verts = norm_hvb.get_num_vertices
+		while i < num_verts
+			n = Vector3.new(normals[0], normals[1], normals[2])
+			n.normalise!
+
+			normals[0] = n.x
+			normals[1] = n.y
+			normals[2] = n.z
+			i += 3
+		end
+		norm_hvb.unlock
+	end
+
+	def update_vertex_data_noise_and_normals(dst_data, org_data, index_data, normals)
+		# Find destination vertex buffer
+		dst_ve_pos = dst_data.vertex_declaration.find_element_by_semantic(VES_POSITION)
+		dst_hvb_pos = dst_data.vertex_buffer_binding.get_buffer(dst_ve_pos.get_source)
+
+		# Find source vertex buffer
+		org_ve_pos = org_data.vertex_declaration.find_element_by_semantic(VES_POSITION)
+		org_hvb_pos = org_data.vertex_buffer_binding.get_buffer(org_ve_pos.get_source)
+
+		# Lock buffers
+		dst_data_pos = dst_hvb_pos.lock(dst_data.vertex_declaration, HardwareBuffer::HBL_DISCARD)
+		org_data_pos = org_hvb_pos.lock(org_data.vertex_declaration, HardwareBuffer::HBL_READ_ONLY)
+
+		# Noise!
+		num_verts = org_hvb_pos.get_num_vertices
+		i = 0
+		while i < num_verts
+			org_data = org_data_pos.get_float(i, VES_POSITION, 3)
+			n = 1 + @displacement * Perlin.noise3(
+																org_data[0] / @density + @tm,
+																org_data[1] / @density + @tm,
+																org_data[2] / @density + @tm)
+			dst_data_pos.set_float(i, VES_POSITION, org_data[0] * n,
+																							org_data[1] * n,
+																							org_data[2] * n)
+			i += 3
+		end
+
+		# Unlock original position buffer
+		org_hvb_pos.unlock
+
+		# Calculate normals
+		index_hb = index_data.index_buffer
+		vertex_indicies = index_hb.lock(HardwareBuffer::HBL_READ_ONLY)
+		num_faces = index_data.index_count / 3
+		i = 0
+		while i < num_faces
+			p0 = vertex_indicies[0]
+			p1 = vertex_indicies[1]
+			p2 = vertex_indicies[2]
+
+			dst_data = dst_data_pos.get_float(3 * p0, VES_POSITION, 3)
+			v0 = Vector3.new(dst_data[0], dst_data[1], dst_data[2])
+
+			dst_data = dst_data_pos.get_float(3 * p1, VES_POSITION, 3)
+			v1 = Vector3.new(dst_data[0], dst_data[1], dst_data[2])
+
+			dst_data = dst_data_pos.get_float(3 * p2, VES_POSITION, 3)
+			v2 = Vector3.new(dst_data[0], dst_data[1], dst_data[2])
+
+			diff1 = v1 - v2
+			diff2 = v1 - v0
+			vn = diff1.cross_product(diff2)
+
+			normals.set_float(3 * p0, VES_POSITION, 
+												normals.get_float(3 * p0, VES_POSITION, 1)[0] + vn.x,
+												normals.get_float(3 * p0 + 1, VES_POSITION, 1)[0] + vn.y,
+												normals.get_float(3 * p0 + 2, VES_POSITION, 1)[0] + vn.z
+											 )
+			#normals[3 * p0] += vn.x
+			#normals[3 * p0 + 1] += vn.y
+			#normals[3 * p0 + 2] += vn.z
+
+			normals.set_float(3 * p0, VES_POSITION, 
+												normals.get_float(3 * p1, VES_POSITION, 1)[0] + vn.x,
+												normals.get_float(3 * p1 + 1, VES_POSITION, 1)[0] + vn.y,
+												normals.get_float(3 * p1 + 2, VES_POSITION, 1)[0] + vn.z
+											 )
+			#normals[3 * p1] += vn.x
+			#normals[3 * p1 + 1] += vn.y
+			#normals[3 * p1 + 2] += vn.z
+
+			normals.set_float(3 * p2, VES_POSITION, 
+												normals.get_float(3 * p2, VES_POSITION, 1)[0] + vn.x,
+												normals.get_float(3 * p2 + 1, VES_POSITION, 1)[0] + vn.y,
+												normals.get_float(3 * p2 + 2, VES_POSITION, 1)[0] + vn.z
+											 )
+			#normals[3 * p2] += fn.x
+			#normals[3 * p2 + 1] += fn.y
+			#normals[3 * p2 + 2] += fn.z
+
+			i += 3
+		end
+
+		index_hb.unlock
+
+		dst_hvb_pos.unlock
+	end
+
+end
+
+class CubeMappingApplication < Application
+  def create_scene
+		# Make sure cube mapping is supported
+		if !root.get_render_system.get_capabilities.has_capability?(RSC_CUBEMAPPING)
+			raise "Your card does not support cube mapping, so we cannot run this demo. Sorry"
+		end
+
+		scene_manager.set_ambient_light(ColourValue.new(0.5, 0.5, 0.5))
+		scene_manager.set_sky_box(true, SKYBOX_MATERIAL)
+
+		l = scene_manager.create_light("MainLight")
+		l.set_position(20, 80, 50)
+
+		@object_node = scene_manager.root_scene_node.create_child_scene_node
+
+		overlay = OverlayManager.instance.get_by_name("CubeMappingOverlay")
+		overlay.show
+  end
+
+	def create_frame_listener
+		self.frame_listener = CubeMappingListener.new(root, window, camera, scene_manager, @object_node)
+	end
+end
+
+app = CubeMappingApplication.new
+app.go