shattered_ogrerb 0.5.0.1 → 0.5.0.2

data/vendor/ogrerb/samples/grass.rb

@@ -0,0 +1,325 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+include Ogre
+
+GRASS_HEIGHT = 300
+GRASS_WIDTH = 250
+GRASS_MESH_NAME = "grassblades"
+GRASS_MATERIAL = "GrassBlades"
+OFFSET_PARAM = 999
+
+$anim_state = nil
+$static_geom = nil
+
+class GrassListener < ApplicationFrameListener
+
+	def initialize(root, win, cam, scene_manager)
+		super(root, win, cam)
+		@scene_manager = scene_manager
+		@show_bbs = false
+
+		@xinc = Math::PI * 0.4
+		@zinc = Math::PI * 0.55
+		@xpos = Ogre::Math.range_random(-Math::PI, Math::PI)
+		@zpos = Ogre::Math.range_random(-Math::PI, Math::PI)
+		@offset = Vector4.new(0,0,0,0)
+
+		@time_delay = 0.0
+
+	end
+
+	def wave_grass(time_elapsed)
+		# May not be setup yet
+		return if $static_geom.nil?
+
+		@xpos += @xinc * time_elapsed
+		@zpos += @zinc * time_elapsed
+
+		rit = $static_geom.get_region_iterator
+
+		while rit.has_more_elements
+			reg = rit.get_next
+
+			@xpos += reg.get_centre.x * 0.001
+			@zpos += reg.get_centre.z * 0.001
+			@offset.x = Ogre::Math.sin(@xpos) * 0.5
+			@offset.z = Ogre::Math.sin(@zpos) * 0.05
+
+			lod_it = reg.get_lod_iterator
+
+			while lod_it.has_more_elements
+				lod = lod_it.get_next
+				mat_it = lod.get_material_iterator
+				while mat_it.has_more_elements
+					mat = mat_it.get_next
+					geom_it = mat.get_geometry_iterator
+					while geom_it.has_more_elements
+						geom = geom_it.get_next
+						geom.as_renderable.set_custom_parameter(OFFSET_PARAM, @offset)
+					end
+				end
+			end
+		end
+	end
+
+	def frame_started(event)
+		return false unless super
+
+		@time_delay -= event.time_since_last_frame
+
+		if $anim_state
+			$anim_state.add_time(event.time_since_last_frame)
+		end
+
+		if keyboard.key_down?(OIS::KC_B) && time_delay <= 0
+			@time_delay = 1
+			@show_bbs = !@show_bbs
+			@scene_manager.show_bounding_boxes(@show_bbs)
+		end
+
+		wave_grass(event.time_since_last_frame)
+
+		true
+	end
+end
+
+class GrassApplication < Application
+	def create_grass_mesh
+		mesh = MeshManager.instance.create_manual(GRASS_MESH_NAME,
+						ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME)
+		sm = mesh.create_sub_mesh
+		sm.use_shared_vertices = false
+		sm.vertex_data = VertexData.new
+		sm.vertex_data.vertex_start = 0
+		sm.vertex_data.vertex_count = 12 
+
+		decl = sm.vertex_data.vertex_declaration
+		offset = 0
+
+		decl.add_element(0, offset, VET_FLOAT3, VES_POSITION)
+		offset += VertexElement.get_type_size(VET_FLOAT3)
+		decl.add_element(0, offset, VET_FLOAT3, VES_NORMAL)
+		offset += VertexElement.get_type_size(VET_FLOAT3)
+		decl.add_element(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES)
+		offset += VertexElement.get_type_size(VET_FLOAT2)
+
+		vbuf = HardwareBufferManager.instance.create_vertex_buffer(
+						offset, 12, HardwareBuffer::HBU_STATIC_WRITE_ONLY)
+		reals = vbuf.lock(HardwareBuffer::HBL_DISCARD)
+
+		base_vec = Vector3.new(GRASS_WIDTH / 2, 0, 0)
+		vec = Vector3.new(GRASS_WIDTH / 2, 0, 0)
+		rot = Quaternion.new
+		rot.from_angle_axis(Degree.new(60), Vector3.UNIT_Y)
+
+		3.times do |i|
+			x = i * 32
+			# Position
+			reals[x + 0] = -vec.x
+			reals[x + 1] = GRASS_HEIGHT
+			reals[x + 2] = -vec.z
+			# Normal
+			reals[x + 3] = 0
+			reals[x + 4] = 1	
+			reals[x + 5] = 0
+			# UV
+			reals[x + 6] = 0
+			reals[x + 7] = 0
+
+			# Position
+			reals[x + 8] = vec.x
+			reals[x + 9] = GRASS_HEIGHT
+			reals[x + 10] = vec.z
+			# Normal
+			reals[x + 11] = 0
+			reals[x + 12] = 1	
+			reals[x + 13] = 0
+			# UV
+			reals[x + 14] = 1
+			reals[x + 15] = 0
+
+			# Position
+			reals[x + 16] = -vec.x
+			reals[x + 17] = 0
+			reals[x + 18] = -vec.z
+			# Normal
+			reals[x + 19] = 0
+			reals[x + 20] = 1	
+			reals[x + 21] = 0
+			# UV
+			reals[x + 22] = 0
+			reals[x + 23] = 1
+
+			# Position
+			reals[x + 24] = vec.x
+			reals[x + 25] = 0
+			reals[x + 26] = vec.z
+			# Normal
+			reals[x + 27] = 0
+			reals[x + 28] = 1	
+			reals[x + 29] = 0
+			# UV
+			reals[x + 30] = 1
+			reals[x + 31] = 1
+
+			vec = rot * vec
+		end
+
+		vbuf.unlock
+
+		sm.vertex_data.vertex_buffer_binding.set_binding(0, vbuf)
+		sm.index_data.index_count = 6 * 3
+		sm.index_data.index_buffer = HardwareBufferManager.instance.
+			create_index_buffer(HardwareIndexBuffer::IT_16BIT, 6 * 3,
+												HardwareBuffer::HBU_STATIC_WRITE_ONLY)
+		index = sm.index_data.index_buffer.lock(HardwareBuffer::HBL_DISCARD)
+
+		3.times do |i|
+			x = i * 6
+			off = i * 4
+
+			index[x + 0] = 0 + off
+			index[x + 1] = 3 + off
+			index[x + 2] = 1 + off
+
+			index[x + 3] = 0 + off
+			index[x + 4] = 2 + off
+			index[x + 5] = 3 + off
+		end
+
+		sm.index_data.index_buffer.unlock
+
+		sm.set_material_name(GRASS_MATERIAL)
+		mesh.load
+	end
+
+	def setup_lighting
+    scene_manager.set_ambient_light ColourValue.new(0.2, 0.2, 0.2)
+
+		# Point light, movable, reddish
+    @light = scene_manager.create_light("Light2")
+		@light.set_diffuse_colour(@min_light_colour)
+    @light.set_specular_colour(1, 1, 1)
+		@light.set_attenuation(8000, 1, 0.0005, 0)
+
+		@light_node = scene_manager.root_scene_node.create_child_scene_node("MovingLightNode")
+		@light_node.attach_object(@light)
+
+		bbs = scene_manager.create_billboard_set("lightbbs", 1)
+		bbs.set_material_name("Flare")
+		bb = bbs.create_billboard(0, 0, 0, @min_light_colour)
+		@light_node.attach_object(bbs)
+
+		# TODO Controller code
+
+		@light_node.set_position(Vector3.new(300, 250, -300))
+
+		anim = scene_manager.create_animation("LightTrack", 20)
+		# Spline it
+		anim.set_interpolation_mode(Animation::IM_SPLINE)
+		track = anim.create_node_track(0, @light_node)
+
+		key = track.create_node_key_frame(0)
+		key.set_translate(Vector3.new(300,550,-300))
+		key = track.create_node_key_frame(2)#B
+		key.set_translate(Vector3.new(150,600,-250))
+		key = track.create_node_key_frame(4)#C
+		key.set_translate(Vector3.new(-150,650,-100))
+		key = track.create_node_key_frame(6)#D
+		key.set_translate(Vector3.new(-400,500,-200))
+		key = track.create_node_key_frame(8)#E
+		key.set_translate(Vector3.new(-200,500,-400))
+		key = track.create_node_key_frame(10)#F
+		key.set_translate(Vector3.new(-100,450,-200))
+		key = track.create_node_key_frame(12)#G
+		key.set_translate(Vector3.new(-100,400,180))
+		key = track.create_node_key_frame(14)#H
+		key.set_translate(Vector3.new(0,250,600))
+		key = track.create_node_key_frame(16)#I
+		key.set_translate(Vector3.new(100,650,100))
+		key = track.create_node_key_frame(18)#J
+		key.set_translate(Vector3.new(250,600,0))
+		key = track.create_node_key_frame(20)#K == A
+		key.set_translate(Vector3.new(300,550,-300))
+		# Create a new animation state to track this
+		$anim_state = scene_manager.create_animation_state("LightTrack")
+		$anim_state.set_enabled(true)
+	end
+
+  def create_scene
+		@min_light_colour = ColourValue.new(0.5, 0.1, 0.0)
+
+    scene_manager.set_sky_box(true, "SpaceSkyBox")
+
+		setup_lighting
+
+		plane = Plane.new
+		plane.normal = Vector3.UNIT_Y
+		plane.d = 0
+
+		MeshManager.instance.create_plane("MyPlane",
+			ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, plane,
+			14500, 14500, 10, 10, true, 1, 50, 50, Vector3.UNIT_Z)
+
+		plane_ent = scene_manager.create_entity("plane", "MyPlane")
+		plane_ent.set_material_name("GrassFloor")
+		plane_ent.set_cast_shadows(false)
+		scene_manager.root_scene_node.create_child_scene_node.attach_object(plane_ent)
+
+		min_v = Vector3.new(-2000, 0, -2000)
+		max_v = Vector3.new(2000, 0, 2000)
+
+		create_grass_mesh
+
+		e = scene_manager.create_entity("1", GRASS_MESH_NAME)
+
+		s = scene_manager.create_static_geometry("bing")
+		s.set_region_dimensions(Vector3.new(1000, 1000, 1000))
+		s.set_origin(Vector3.new(-500, 500, -500))
+
+		-1950.step(1950, 150) do |x|
+			-1950.step(1950, 150) do |z|
+				pos = Vector3.new(x + Ogre::Math.range_random(-25, 25),
+													0,
+													z + Ogre::Math.range_random(-25, 25))
+				orientation = Quaternion.new
+				orientation.from_angle_axis(
+					Degree.new(Ogre::Math.range_random(0, 359)), Vector3.UNIT_Y)
+				scale = Vector3.new(1, Ogre::Math.range_random(0.85, 1.15), 1)
+				s.add_entity(e, pos, orientation, scale)
+			end
+		end
+
+		s.build
+		$static_geom = s
+
+		# Gots to have the Ogre head
+		m = MeshManager.instance.load("ogrehead.mesh",
+					ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME)
+		src = 0
+		dest = 0
+		ret, src, dest = m.suggest_tangent_vector_build_params(VES_TANGENT)
+		unless ret
+			m.build_tangent_vectors(VES_TANGENT, src, dest)
+		end
+
+		e = scene_manager.create_entity("head", "ogrehead.mesh")
+		e.set_material_name("OffsetMapping/Specular")
+		head_node = scene_manager.root_scene_node.create_child_scene_node
+		head_node.attach_object(e)
+		head_node.set_scale(7, 7, 7)
+		head_node.set_position(0, 200, 0)
+		e.set_normalise_normals(true)
+		camera.move(Vector3.new(0, 350, 0))
+  end
+
+	def create_frame_listener
+		self.frame_listener = GrassListener.new(root, window, camera, scene_manager)
+	end
+end
+
+app = GrassApplication.new
+app.go

data/vendor/ogrerb/samples/lighting.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/ruby -w
 
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
 require 'application'
 include Ogre
 

data/vendor/ogrerb/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/vendor/ogrerb/samples/media/materials/programs/Grass.cg

@@ -0,0 +1,30 @@
+// Vertex program to wave some grass about
+// Simplistic, assumes base of the grass at 0
+void grass_vp(float4 position : POSITION,
+			  float3 normal   : NORMAL,
+			  float2 uv		  : TEXCOORD0,
+			  out float4 oPosition : POSITION,
+			  out float2 oUv	   : TEXCOORD0,
+			  out float4 colour    : COLOR,
+
+			  uniform float4x4 worldViewProj,
+			  uniform float4 ambient,
+			  uniform float4 objSpaceLight,
+			  uniform float4 lightColour,
+			  uniform float4 offset)
+{
+	float4 mypos = position;
+	//offset = float4(0.5, 0, 0, 0);
+	mypos = mypos + offset * mypos.yyyy;
+	oPosition = mul(worldViewProj, mypos);
+
+	oUv = uv;
+	// get vertex light direction (support directional and point)
+	float3 light = normalize(
+		objSpaceLight.xyz -  (position.xyz * objSpaceLight.w));
+	float diffuseFactor = max(dot(normal, light), 0);
+	
+	
+	colour = ambient + diffuseFactor * lightColour;
+}
+

data/vendor/ogrerb/samples/media/materials/programs/OffsetMapping.cg

@@ -0,0 +1,97 @@
+/* Bump mapping with Parallax offset vertex program 
+   In this program, we want to calculate the tangent space light end eye vectors 
+   which will get passed to the fragment program to produce the per-pixel bump map 
+   with parallax offset effect. 
+*/ 
+
+/* Vertex program that moves light and eye vectors into texture tangent space at vertex */ 
+
+void main_vp(float4 position   : POSITION, 
+              float3 normal      : NORMAL, 
+              float2 uv         : TEXCOORD0, 
+              float3 tangent     : TANGENT0, 
+              // outputs 
+              out float4 oPosition    : POSITION, 
+              out float2 oUv          : TEXCOORD0, 
+              out float3 oLightDir    : TEXCOORD1, // tangent space 
+             out float3 oEyeDir       : TEXCOORD2, // tangent space 
+             out float3 oHalfAngle    : TEXCOORD3, // 
+              // parameters 
+              uniform float4 lightPosition, // object space 
+              uniform float3 eyePosition,   // object space 
+              uniform float4x4 worldViewProj) 
+{  
+   // calculate output position 
+   oPosition = mul(worldViewProj, position); 
+
+   // pass the main uvs straight through unchanged 
+   oUv = uv; 
+
+   // calculate tangent space light vector 
+   // Get object space light direction 
+   float3 lightDir = normalize(lightPosition.xyz -  (position * lightPosition.w));
+   float3 eyeDir = eyePosition - position.xyz; 
+    
+   // Calculate the binormal (NB we assume both normal and tangent are 
+   // already normalised) 
+   // NB looks like nvidia cross params are BACKWARDS to what you'd expect 
+   // this equates to NxT, not TxN 
+   float3 binormal = cross(tangent, normal); 
+    
+   // Form a rotation matrix out of the vectors 
+   float3x3 rotation = float3x3(tangent, binormal, normal); 
+    
+   // Transform the light vector according to this matrix 
+   lightDir = normalize(mul(rotation, lightDir)); 
+   eyeDir = normalize(mul(rotation, eyeDir)); 
+
+   oLightDir = lightDir; 
+   oEyeDir = eyeDir; 
+   oHalfAngle = normalize(eyeDir + lightDir); 
+}
+
+// General functions
+
+// Expand a range-compressed vector
+float3 expand(float3 v)
+{
+	return (v - 0.5) * 2;
+}
+
+void main_fp(float2 uv : TEXCOORD0,
+	float3 lightDir : TEXCOORD1,
+	float3 eyeDir : TEXCOORD2,
+	float3 halfAngle : TEXCOORD3,
+	uniform float3 lightDiffuse,
+	uniform float3 lightSpecular,
+	uniform float4 scaleBias,
+	uniform sampler2D normalHeightMap,
+	uniform sampler2D diffuseMap,
+	out float4 oColor : COLOR)
+{
+	// get the height using the tex coords
+	float height = tex2D(normalHeightMap, uv).a;
+
+	// scale and bias factors	
+	float scale = scaleBias.x;
+	float bias = scaleBias.y;
+
+	// calculate displacement	
+	float displacement = (height * scale) + bias;
+	
+	float3 uv2 = float3(uv, 1);
+	
+	// calculate the new tex coord to use for normal and diffuse
+	float2 newTexCoord = ((eyeDir * displacement) + uv2).xy;
+	
+	// get the new normal and diffuse values
+	float3 normal = expand(tex2D(normalHeightMap, newTexCoord).xyz);
+	float3 diffuse = tex2D(diffuseMap, newTexCoord).xyz;
+	
+	float3 specular = pow(saturate(dot(normal, halfAngle)), 32) * lightSpecular;
+	float3 col = diffuse * saturate(dot(normal, lightDir)) * lightDiffuse + specular;
+		
+	oColor = float4(col, 1);
+}
+
+

data/vendor/ogrerb/samples/media/materials/programs/OffsetMapping.hlsl

@@ -0,0 +1,135 @@
+/* Offset mapping including a shadow element and multiple lights in one pass */ 
+void integratedshadows_vp(float4 position   : POSITION, 
+              float3 normal      : NORMAL, 
+              float2 uv         : TEXCOORD0, 
+              float3 tangent     : TANGENT0, 
+              // outputs 
+              out float4 oPosition    : POSITION, 
+              out float2 oUv          : TEXCOORD0, 
+              out float3 oLightDir    : TEXCOORD1, // tangent space 
+             out float3 oEyeDir       : TEXCOORD2, // tangent space 
+			 out float3 oSpotDirection : TEXCOORD3, // tangent space
+              out float3 oLightDir1    : TEXCOORD4, // tangent space 
+              out float3 oSpotDirection1    : TEXCOORD5, // tangent space 
+			 out float4 oShadowUV1 : TEXCOORD6,
+			 out float4 oShadowUV2 : TEXCOORD7,
+              // parameters 
+              uniform float4 lightPosition, // object space 
+              uniform float4 lightPosition1, // object space 
+              uniform float3 eyePosition,   // object space 
+ 			  uniform float3 spotDirection, // object space
+ 			  uniform float3 spotDirection1, // object space
+              uniform float4x4 worldViewProj,
+			  uniform float4x4 worldMatrix,
+			  uniform float4x4 texViewProj1,
+			  uniform float4x4 texViewProj2) 
+{  
+   // calculate output position 
+   oPosition = mul(worldViewProj, position); 
+
+   float4 worldPos = mul(worldMatrix, position);
+   oShadowUV1 = mul(texViewProj1, worldPos);
+   oShadowUV2 = mul(texViewProj2, worldPos);
+   
+   
+
+   // pass the main uvs straight through unchanged 
+   oUv = uv; 
+
+   // calculate tangent space light vector 
+   // Get object space light direction 
+   float3 lightDir = normalize(lightPosition.xyz -  (position * lightPosition.w));
+   float3 lightDir1 = normalize(lightPosition1.xyz -  (position * lightPosition1.w));
+   float3 eyeDir = eyePosition - position.xyz; 
+    
+   // Calculate the binormal (NB we assume both normal and tangent are 
+   // already normalised) 
+   // NB looks like nvidia cross params are BACKWARDS to what you'd expect 
+   // this equates to NxT, not TxN 
+   float3 binormal = cross(tangent, normal); 
+    
+   // Form a rotation matrix out of the vectors 
+   float3x3 rotation = float3x3(tangent, binormal, normal); 
+    
+   // Transform the light vector according to this matrix 
+   lightDir = normalize(mul(rotation, lightDir)); 
+   lightDir1 = normalize(mul(rotation, lightDir1)); 
+   eyeDir = normalize(mul(rotation, eyeDir)); 
+
+   oLightDir = lightDir; 
+   oLightDir1 = lightDir1; 
+   oEyeDir = eyeDir; 
+   oSpotDirection = normalize(mul(rotation, -spotDirection));
+   oSpotDirection1 = normalize(mul(rotation, -spotDirection1));
+}
+
+// Expand a range-compressed vector
+float3 expand(float3 v)
+{
+	return (v - 0.5) * 2;
+}
+
+void integratedshadows_fp(
+	float2 uv : TEXCOORD0,
+	float3 lightDir : TEXCOORD1,
+	float3 eyeDir : TEXCOORD2,
+	float3 spotDir : TEXCOORD3,
+	float3 lightDir1 : TEXCOORD4,
+	float3 spotDir1 : TEXCOORD5,
+	float4 shadowUV1 : TEXCOORD6,
+	float4 shadowUV2 : TEXCOORD7,
+	uniform float3 lightDiffuse,
+	uniform float4 scaleBias,
+    uniform float4 spotParams,
+	uniform float3 lightDiffuse1,
+    uniform float4 spotParams1,
+	uniform sampler2D normalHeightMap : register(s0),
+	uniform sampler2D diffuseMap : register(s1),
+	uniform sampler2D shadowMap1 : register(s2),
+	uniform sampler2D shadowMap2 : register(s3),
+	out float4 oColour : COLOR)
+{
+	// get the height using the tex coords
+	float height = tex2D(normalHeightMap, uv).a;
+
+	// scale and bias factors	
+	float scale = scaleBias.x;
+	float bias = scaleBias.y;
+
+	// calculate displacement	
+	float displacement = (height * scale) + bias;
+	
+	float3 uv2 = float3(uv, 1);
+
+	float3 scaledEyeDir = eyeDir * displacement;
+	
+	// calculate the new tex coord to use for normal and diffuse
+	float2 newTexCoord = (scaledEyeDir + uv2).xy;
+	
+	// get the new normal and diffuse values
+	float3 normal = expand(tex2D(normalHeightMap, newTexCoord).xyz);
+	float3 diffuse = tex2D(diffuseMap, newTexCoord).xyz;
+	
+	float3 col1 = diffuse * saturate(dot(normal, lightDir)) * lightDiffuse;
+	// factor in spotlight angle
+	float rho = saturate(dot(spotDir, lightDir));
+	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
+	float spotFactor = pow(
+		saturate(rho - spotParams.y) / (spotParams.x - spotParams.y), spotParams.z);
+	col1 = col1 * spotFactor;
+	float3 col2 = diffuse * saturate(dot(normal, lightDir1)) * lightDiffuse1;
+	// factor in spotlight angle
+	rho = saturate(dot(spotDir1, lightDir1));
+	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
+	spotFactor = pow(
+		saturate(rho - spotParams1.y) / (spotParams1.x - spotParams1.y), spotParams1.z);
+	col2 = col2 * spotFactor;
+
+	// shadow textures
+	col1 = col1 * tex2Dproj(shadowMap1, shadowUV1);
+	col2 = col2 * tex2Dproj(shadowMap2, shadowUV2);
+
+	oColour = float4(col1 + col2, 1);
+
+}
+