ogre.rb 0.1-i386-mswin32

data/samples/lighting.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/ruby -w
+
+$: << File.dirname(__FILE__) + "/.."
+require 'ogre'
+require 'application'
+include Ogre
+
+$animation_state_list = []
+
+class LightingListener < ApplicationFrameListener
+  def frame_started(event)
+    return false unless super(event)
+
+    $animation_state_list.each do |anim|
+      anim.add_time(event.time_since_last_frame)
+    end
+
+    true
+  end
+end
+
+class LightingApplication < Application
+
+  def create_scene
+    scene_manager.set_ambient_light ColourValue.new(0.5, 0.5, 0.5)
+    scene_manager.set_sky_box(true, "SpaceSkyBox")
+    head = scene_manager.create_entity("head", "ogrehead.mesh")
+
+    scene_manager.root_scene_node.attach_object(head)
+
+    ## Set up light ribbons
+    dir = Vector3.new(-1, -1, 0.5)
+    dir.normalise!
+
+    l = scene_manager.create_light("light1")
+    l.set_type Light::LT_DIRECTIONAL
+    l.set_direction dir
+
+    trail = scene_manager.create_movable_object("RibbonTrail1", "RibbonTrail",
+              {"numberOfChains" => "2", "maxElements" => "80"}) 
+    trail.set_material_name "LightRibbonTrail"
+    trail.set_trail_length 400
+
+    puts trail
+
+    scene_manager.root_scene_node.create_child_scene_node.attach_object(trail)
+
+		anim_node = scene_manager.root_scene_node.create_child_scene_node
+		anim_node.set_position Vector3.new(50,30,0)
+		anim = scene_manager.create_animation("an1", 14)
+		anim.set_interpolation_mode Animation::IM_SPLINE
+		track = anim.create_node_track(1, anim_node)
+		kf = track.create_node_key_frame(0)
+		kf.set_translate Vector3.new(50,30,0)
+		kf = track.create_node_key_frame(2)
+		kf.set_translate Vector3.new(100, -30, 0)
+		kf = track.create_node_key_frame(4)
+		kf.set_translate Vector3.new(120, -100, 150)
+		kf = track.create_node_key_frame(6)
+		kf.set_translate Vector3.new(30, -100, 50)
+		kf = track.create_node_key_frame(8)
+		kf.set_translate Vector3.new(-50, 30, -50)
+		kf = track.create_node_key_frame(10)
+		kf.set_translate Vector3.new(-150, -20, -100)
+		kf = track.create_node_key_frame(12)
+		kf.set_translate Vector3.new(-50, -30, 0)
+		kf = track.create_node_key_frame(14)
+		kf.set_translate Vector3.new(50,30,0)
+
+    anim_state = scene_manager.create_animation_state("an1")
+    anim_state.set_enabled true
+    $animation_state_list << anim_state
+
+		trail.set_initial_colour(0, 1.0, 0.8, 0)
+		trail.set_colour_change(0, 0.5, 0.5, 0.5, 0.5)
+		trail.set_initial_width(0, 5)
+		trail.add_node(anim_node)
+
+		# Add light
+		l2 = scene_manager.create_light("l2")
+		l2.set_diffuse_colour trail.get_initial_colour(0)
+		anim_node.attach_object(l2)
+
+		# Add billboard
+		bbs = scene_manager.create_billboard_set("bb", 1)
+		bbs.create_billboard(Vector3.ZERO, trail.get_initial_colour(0))
+		bbs.set_material_name "Flare"
+		anim_node.attach_object(bbs)
+
+		anim_node = scene_manager.root_scene_node.create_child_scene_node
+		anim_node.set_position Vector3.new(-50,100,0)
+		anim = scene_manager.create_animation("an2", 10)
+		anim.set_interpolation_mode Animation::IM_SPLINE
+		track = anim.create_node_track(1, anim_node)
+		kf = track.create_node_key_frame(0)
+		kf.set_translate Vector3.new(-50,100,0)
+		kf = track.create_node_key_frame(2)
+		kf.set_translate Vector3.new(-100, 150, -30)
+		kf = track.create_node_key_frame(4)
+		kf.set_translate Vector3.new(-200, 0, 40)
+		kf = track.create_node_key_frame(6)
+		kf.set_translate Vector3.new(0, -150, 70)
+		kf = track.create_node_key_frame(8)
+		kf.set_translate Vector3.new(50, 0, 30)
+		kf = track.create_node_key_frame(10)
+		kf.set_translate Vector3.new(-50,100,0)
+
+		anim_state = scene_manager.create_animation_state("an2")
+		anim_state.set_enabled true
+		$animation_state_list << anim_state
+
+		trail.set_initial_colour(1, 0.0, 1.0, 0.4)
+		trail.set_colour_change(1, 0.5, 0.5, 0.5, 0.5)
+		trail.set_initial_width(1, 5)
+		trail.add_node(anim_node)
+
+
+		# Add light
+		l2 = scene_manager.create_light("l3")
+		l2.set_diffuse_colour trail.get_initial_colour(1)
+		anim_node.attach_object(l2)
+
+		# Add billboard
+		bbs = scene_manager.create_billboard_set("bb2", 1)
+		bbs.create_billboard(Vector3.ZERO, trail.get_initial_colour(1))
+		bbs.set_material_name "Flare"
+		anim_node.attach_object(bbs)
+
+  end
+
+  def create_frame_listener
+    self.frame_listener = LightingListener.new(root, window, camera)
+    #root.addFrameListener(self.frame_listener)
+  end
+end
+
+app = LightingApplication.new
+app.go

data/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/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/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);
+
+}
+

data/samples/media/materials/programs/OffsetMappingFp.glsl

@@ -0,0 +1,69 @@
+uniform vec4 lightDiffuse;
+uniform vec4 scaleBias;
+uniform vec4 spotParams;
+uniform vec4 lightDiffuse1;
+uniform vec4 spotParams1;
+
+uniform sampler2D normalHeightMap;
+uniform sampler2D diffuseMap;
+uniform sampler2D shadowMap1;
+uniform sampler2D shadowMap2;
+
+
+
+varying vec3 tangentEyeDir;
+varying vec3 tangentLightDir[2];
+varying vec3 tangentSpotDir[2];
+varying vec4 shadowUV[2];
+
+
+// Expand a range-compressed vector
+vec3 expand(vec3 v)
+{
+	return (v - 0.5) * 2.0;
+}
+
+
+void main()
+{
+	// get the height using the tex coords
+	float height = texture2D(normalHeightMap, gl_TexCoord[0].xy).a;
+	// scale and bias factors	
+	float scale = scaleBias.x;
+	float bias = scaleBias.y;
+
+	// calculate displacement	
+	float displacement = (height * scale) + bias;
+	//float displacement = (height * 0.04) - 0.02;
+	
+	vec3 scaledEyeDir = tangentEyeDir * displacement;
+	
+	// calculate the new tex coord to use for normal and diffuse
+	vec2 newTexCoord = (scaledEyeDir + gl_TexCoord[0].xyz).xy;
+	
+	// get the new normal and diffuse values
+	vec3 normal = expand(texture2D(normalHeightMap, newTexCoord).xyz);
+	vec4 diffuse = texture2D(diffuseMap, newTexCoord);
+	
+	vec4 col1 = diffuse * clamp(dot(normal, tangentLightDir[0]),0.0,1.0) * lightDiffuse;
+	// factor in spotlight angle
+	float rho = clamp(dot(tangentSpotDir[0], tangentLightDir[0]),0.0,1.0);
+	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
+	float spotFactor = pow(
+		clamp(rho - spotParams.y,0.0,1.0) / (spotParams.x - spotParams.y), spotParams.z);
+	col1 = col1 * spotFactor;
+	vec4 col2 = diffuse * clamp(dot(normal, tangentLightDir[1]),0.0,1.0) * lightDiffuse1;
+	// factor in spotlight angle
+	rho = clamp(dot(tangentSpotDir[1], tangentLightDir[1]),0.0,1.0);
+	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
+	spotFactor = pow(
+		clamp(rho - spotParams1.y,0.0,1.0) / (spotParams1.x - spotParams1.y), spotParams1.z);
+	col2 = col2 * spotFactor;
+
+	// shadow textures
+	col1 = col1 * texture2DProj(shadowMap1, shadowUV[0]);
+	col2 = col2 * texture2DProj(shadowMap2, shadowUV[1]);
+
+	gl_FragColor = col1 + col2;
+
+}

data/samples/media/materials/programs/OffsetMappingVp.glsl

@@ -0,0 +1,54 @@
+attribute vec3 tangent;
+
+uniform vec4 lightPosition; // object space 
+uniform vec4 lightPosition1; // object space 
+uniform vec4 eyePosition;   // object space 
+uniform vec4 spotDirection; // object space
+uniform vec4 spotDirection1; // object space
+uniform mat4 worldViewProj; // not actually used but here for compat with HLSL
+uniform mat4 worldMatrix;
+uniform mat4 texViewProj1;
+uniform mat4 texViewProj2;
+
+
+varying vec3 tangentEyeDir;
+varying vec3 tangentLightDir[2];
+varying vec3 tangentSpotDir[2];
+varying vec4 shadowUV[2];
+
+void main()
+{
+	gl_Position = ftransform();
+
+	vec4 worldPos = worldMatrix * gl_Vertex;
+
+	shadowUV[0] = texViewProj1 * worldPos;
+	shadowUV[1] = texViewProj2 * worldPos;
+
+	// pass the main uvs straight through unchanged 
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+
+	// calculate tangent space light vector 
+	// Get object space light direction 
+    vec3 lightDir = normalize(lightPosition.xyz -  (gl_Vertex.xyz * lightPosition.w));
+	vec3 lightDir1 = normalize(lightPosition1.xyz -  (gl_Vertex.xyz * lightPosition1.w));
+	
+	vec3 eyeDir = (eyePosition - gl_Vertex).xyz; 
+
+	// Calculate the binormal (NB we assume both normal and tangent are 
+	// already normalised) 
+	vec3 binormal = cross(gl_Normal, tangent); 
+
+	// Form a rotation matrix out of the vectors 
+	mat3 rotation = mat3(tangent, binormal, gl_Normal); 
+    
+	// Transform the light vector according to this matrix 
+	tangentLightDir[0] = normalize(rotation * lightDir); 
+	tangentLightDir[1] = normalize(rotation * lightDir1); 
+	// Invert the Y on the eye dir since we'll be using this to alter UVs and
+	// GL has Y inverted
+	tangentEyeDir = normalize(rotation * eyeDir) * vec3(1, -1, 1); 
+
+	tangentSpotDir[0] = normalize(rotation * -spotDirection.xyz);
+	tangentSpotDir[1] = normalize(rotation * -spotDirection1.xyz);	
+}

data/samples/media/materials/programs/OffsetMapping_specular.asm

@@ -0,0 +1,44 @@
+// Pixel Shader for doing bump mapping with parallax plus diffuse and specular lighting by nfz 
+
+// uv               TEXCOORD0 
+// lightDir            TEXCOORD1 
+// eyeDir            TEXCOORD2 
+// half               TEXCOORD3 
+
+// lightDiffuse         c0 
+// lightSpecular      c1 
+// Parallax scale and bias c2 
+// normal/height map   texunit 0 - height map in alpha channel 
+// diffuse texture      texunit 1 
+
+ps.1.4 
+
+
+texld r0, t0               // get height 
+texcrd r2.xyz, t0            // get uv coordinates 
+texcrd r3.xyz, t2            // get eyedir vector 
+
+
+mad r0.xyz, r0.a, c2.x, c2.y   // displacement = height * scale + bias 
+mad r2.xyz, r3, r0, r2         // newtexcoord = eyedir * displacement + uv 
+
+phase 
+
+texld r0, r2.xyz            // get normal N using newtexcoord 
+texld r1, r2.xyz            // get diffuse texture using newtexcoord 
+texcrd r4.xyz, t1            // get lightdir vector 
+texcrd r5.xyz, t3            // get half angle vector 
+
+dp3_sat r5.rgb, r0_bx2, r5         // N dot H - spec calc 
+dp3_sat r4.rgb, r0_bx2, r4         // N dot L - diffuse calc 
++ mul r5.a, r5.r, r5.r 
+mul r0.rgb, r4, r1            // colour = diffusetex * N dot L 
++ mul r5.a, r5.a, r5.a 
+
+mul r5.rgb, r5.a, r5.a          
+mul r5.rgb, r5, r5          
+mul r5.rgb, r5, r5          
+mul r5.rgb, r5, c1            // specular = (N dot H)^32 * specularlight 
+
+mad r0.rgb, r0, c0, r5         // colour = diffusetex * (N dot L)* diffuselight + specular 
++ mov r0.a, c2.b 

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

@@ -0,0 +1,17 @@
+material CloudySky
+{
+	technique
+	{
+		pass
+		{
+			lighting off
+			depth_write off
+
+			texture_unit
+			{
+				texture clouds.jpg
+				scroll_anim 0.15 0
+			}
+		}
+	}
+}

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

@@ -0,0 +1,34 @@
+material SceneSkyBox2
+{
+	technique
+	{
+		pass
+		{
+			lighting off
+			depth_write off
+
+			texture_unit
+			{
+				cubic_texture cubescene_fr.jpg cubescene_bk.jpg cubescene_lf.jpg cubescene_rt.jpg cubescene_up.jpg cubescene_dn.jpg separateUV
+				tex_address_mode clamp
+			}
+		}
+	}
+}
+material SceneCubeMap2
+{
+	technique
+	{
+		pass
+		{
+			lighting off
+
+			texture_unit
+			{
+				cubic_texture cubescene.jpg combinedUVW
+				tex_address_mode clamp
+				env_map cubic_reflection
+			}
+		}
+	}
+}

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

@@ -0,0 +1,17 @@
+material Flare
+{
+	technique
+	{
+		pass
+		{
+			lighting off
+			scene_blend add
+			depth_write off
+
+			texture_unit
+			{
+				texture flare.png
+			}
+		}
+	}
+}