Flastar » in english

Tutorial Realtime raycast in Alternativa3D

Flastar — Sun, 11 Dec 2011 22:45:21 +0000

Hi! In this lesson I’ll show you how to create your own realtime raycast with reflect and refract using GPU in Alternativa3D 8.17.0.

Demo 1 – Only Reflect

Demo 2 – RefractionIndex = 6 and mix-value between reflect and refract equals 0.2

Demo 3 – RefractionIndex = 1 and mix-value between reflect and refract equals 0.5

Before start, I recommend you to read my previous article Environment and Refraction in Alternativa3D.

I achived this effect by setRenderToTexture Context3D method. This method is really useful for creating:
1) Shadow maps
2) Postprocessing
3) Reflections

When you use this technique you must set optimizeForRenderToTexture property = true for draw target textures.
At first lets create CubeMap Alternativa3D resource:

package {
	import alternativa.engine3d.alternativa3d;
	import alternativa.engine3d.resources.TextureResource;
 
	import flash.display3D.Context3D;
	import flash.display3D.Context3DTextureFormat;
 
	use namespace alternativa3d;
	public class CubeMapResource extends TextureResource {
		private var _size : Number;
 
		public function CubeMapResource(size : Number) {
			_size = size;
		}
 
		override public function upload(context3D : Context3D) : void {
			if (_texture != null) _texture.dispose();
			_texture = context3D.createCubeTexture(_size, Context3DTextureFormat.BGRA, true);
		}
	}
}

Then we optimize material from previous tutorial:

package {
	import alternativa.engine3d.alternativa3d;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.core.DrawUnit;
	import alternativa.engine3d.core.Light3D;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.RenderPriority;
	import alternativa.engine3d.core.Transform3D;
	import alternativa.engine3d.core.VertexAttributes;
	import alternativa.engine3d.materials.A3DUtils;
	import alternativa.engine3d.materials.Material;
	import alternativa.engine3d.materials.ShaderProgram;
	import alternativa.engine3d.objects.Surface;
	import alternativa.engine3d.resources.Geometry;
	import alternativa.engine3d.resources.TextureResource;
 
	import avmplus.getQualifiedClassName;
 
	import com.adobe.utils.AGALMiniAssembler;
 
	import flash.display3D.Context3DProgramType;
	import flash.display3D.VertexBuffer3D;
	import flash.utils.Dictionary;
	import flash.utils.getDefinitionByName;
 
	use namespace alternativa3d;
	public class ReflectRefractMaterial extends Material {
		alternativa3d var _cubeTexture : TextureResource;
		private var _vertexShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
		private var _fragmentShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
		private var program : ShaderProgram;
		public var reflectionPower: Number = 0.5;
		private var refractionIndex : Number = 6;
		private var alpha : Number = 1;
		private var rotatedObject:Object3D;
		public function ReflectRefractMaterial(cubeTexture : TextureResource = null) {
			_cubeTexture = cubeTexture;
			program = new ShaderProgram(null, null);
			_vertexShaderAssembler.assemble(Context3DProgramType.VERTEX,
			"mov vt0, va1\n"+
			"m33 vt0.xyz, vt0.xyz, vc6\n"+
			"sub vt1, vc4, va0\n"+
			"m33 vt1.xyz, vt1.xyz, vc6\n"+
			"dp3 vt2, vt1, vt0\n"+
			"add vt2, vt2, vt2\n"+
			"mul vt2, vt0, vt2\n"+
			"sub vt2, vt1, vt2\n"+
			"neg vt2, vt2\n"+
			"nrm vt2.xyz, vt2.xyz\n"+
			"mov v0, vt2\n"+
			"dp3 vt3, vt1, vt0\n"+
			"mul vt3, vt3, vt0\n"+
			"sub vt3, vt3, vt1\n"+
			"mul vt3, vt3, vc5.y\n"+
			"dp3 vt4, vt1, vt0\n"+
			"mul vt4, vt4, vt4\n"+
			"sub vt4, vc5.x, vt4\n"+
			"mul vt4, vc5.z, vt4\n"+
			"sub vt4, vc5.x, vt4\n"+
			"sqt vt4, vt4\n"+
			"mul vt4, vt4, vt0\n"+
			"sub vt4, vt3, vt4\n"+
			"nrm vt4.xyz, vt4.xyz\n"+
			"mov v1, vt4\n"+
			"m44 op, va0, vc0");
 
			_fragmentShaderAssembler.assemble(Context3DProgramType.FRAGMENT,
			"mov ft4.xyz, v0.yzx\n"+
			"neg ft4.z, ft4.z\n"+
			"m33 ft4.xyz, ft4.xyz, fc1\n"+
			"tex ft0,ft4.xyz,fs0 \n"+
			"mov ft5.xyz, v1.yzx\n"+
			"neg ft5.z, ft5.z\n"+
			"m33 ft5.xyz, ft5.xyz, fc1\n"+
			"tex ft1,ft5.xyz,fs0 \n"+
			"sub ft3, ft0, ft1\n"+
			"mul ft3, ft3, fc0\n"+
			"add ft3, ft3, ft1\n"+
			"mov ft3.w, fc0.w\n"+
			"mov oc, ft3"
			);
 
			rotatedObject = new Object3D();
			rotatedObject.rotationY = -Math.PI/2;
			rotatedObject.composeTransforms();
			Main.instance.rootContainer.addChild(rotatedObject);
		}
		alternativa3d override function fillResources(resources : Dictionary, resourceType : Class) : void {
			if (_cubeTexture != null && A3DUtils.checkParent(getDefinitionByName(getQualifiedClassName(_cubeTexture)) as Class, resourceType)) {
				resources[_cubeTexture] = true;
			}
			program.program = Main.instance.stage.stage3Ds[0].context3D.createProgram();
			program.program.upload(_vertexShaderAssembler.agalcode, _fragmentShaderAssembler.agalcode);
		}
 
		override alternativa3d function collectDraws(camera : Camera3D, surface : Surface, geometry : Geometry, lights : Vector.<Light3D>, lightsLength : int, objectRenderPriority : int = -1) : void {
			var object : Object3D = surface.object;
			var positionBuffer : VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.POSITION);
			var normalsBuffer : VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.NORMAL);
			var drawUnit : DrawUnit = camera.renderer.createDrawUnit(object, program.program, geometry._indexBuffer, surface.indexBegin, surface.numTriangles, program);
			drawUnit.setVertexBufferAt(0, positionBuffer, 0, "float3");
			drawUnit.setVertexBufferAt(1, normalsBuffer, 5, "float3");
			drawUnit.setProjectionConstants(camera, 0, object.localToCameraTransform);
			var cameraToLocalTransform : Transform3D = object.cameraToLocalTransform;
			drawUnit.setVertexConstantsFromNumbers(4, cameraToLocalTransform.d, cameraToLocalTransform.h, cameraToLocalTransform.l);
			var refraction:Number = refractionIndex/1000;
			drawUnit.setVertexConstantsFromNumbers(5, 1, refraction, refraction*refraction, 1);
			var globalTransform : Transform3D = new Transform3D();
			globalTransform.copy(object.localToCameraTransform);
			globalTransform.append(camera.localToGlobalTransform);
			drawUnit.setVertexConstantsFromTransform(6, globalTransform);
			drawUnit.setFragmentConstantsFromNumbers(0,reflectionPower,reflectionPower,reflectionPower,alpha);
			drawUnit.setFragmentConstantsFromTransform(1, rotatedObject.inverseTransform);
			drawUnit.setTextureAt(0, _cubeTexture._texture);
			camera.renderer.addDrawUnit(drawUnit, objectRenderPriority >= 0 ? objectRenderPriority : RenderPriority.OPAQUE);
		}
	}
}

WARNING!!! To calculate localToGlobal transform you need to transform from localToCamera and then from cameraToGlobal, because object localToGlobal is native Transform3D inside Alternativa3D engine.

Let’s do main class of project.
Method for creating sample sphere with ReflectRefractMaterial:

private var objects : Vector.<Mesh> = new Vector.<Mesh>();
private var objectsMaterials : Vector.<ReflectRefractMaterial> = new Vector.<ReflectRefractMaterial>();
 
public function createSphere(radius : Number = 120, reflectionPower : Number = 0.5) : void {
	var sphere : GeoSphere = new GeoSphere(radius, 6);
	var sphereMaterial : ReflectRefractMaterial = new ReflectRefractMaterial(new CubeMapResource(xneg_sky.width));
	sphereMaterial.reflectionPower = reflectionPower;
	sphere.setMaterialToAllSurfaces(sphereMaterial);
	rootContainer.addChild(sphere);
	objects.push(sphere);
	objectsMaterials.push(sphereMaterial);
}

Embed images and create skybox:

[Embed(source="03.jpg")]
private var xnegJpgClass_sky : Class;
public var xneg_sky : BitmapData;
[Embed(source="06.jpg")]
private var xposJpgClass_sky : Class;
public var xpos_sky : BitmapData;
[Embed(source="01.jpg")]
private var ynegJpgClass_sky : Class;
public var yneg_sky : BitmapData;
[Embed(source="05.jpg")]
private var yposJpgClass_sky : Class;
public var ypos_sky : BitmapData;
[Embed(source="04.jpg")]
private var znegJpgClass_sky : Class;
public var zneg_sky : BitmapData;
[Embed(source="02.jpg")]
private var zposJpgClass_sky : Class;
public var zpos_sky : BitmapData;
 
private function setupScene() : void {
	xneg_sky = (new xnegJpgClass_sky() as Bitmap).bitmapData;
	xpos_sky = (new xposJpgClass_sky() as Bitmap).bitmapData;
	yneg_sky = (new ynegJpgClass_sky() as Bitmap).bitmapData;
	ypos_sky = (new yposJpgClass_sky() as Bitmap).bitmapData;
	zneg_sky = (new znegJpgClass_sky() as Bitmap).bitmapData;
	zpos_sky = (new zposJpgClass_sky() as Bitmap).bitmapData;
	createSphere(180, 0.2);
	createSphere(180, 0.2);
	createSphere(180, 0.2);
	skyBox = new SkyBox(10000, new TextureMaterial(new BitmapTextureResource(xneg_sky)), new TextureMaterial(new BitmapTextureResource(xpos_sky)), new TextureMaterial(new BitmapTextureResource(yneg_sky)), new TextureMaterial(new BitmapTextureResource(ypos_sky)), new TextureMaterial(new BitmapTextureResource(zneg_sky)), new TextureMaterial(new BitmapTextureResource(zpos_sky)));
	rootContainer.addChild(skyBox);
}

Create method which render cubeMap for every object. But here are not all simple. Let’s do that by steps:
1) Set position of skybox at object position
2) Set camera position to default pos
3) Calculate fov, scaleX, scaleY properties for camera. Thanks to Ivan Dembicki for help.
4) And then, for all 6 sides render scene from different views.

private function calculateCubeMapForSphere(sphere : Mesh, sphereMaterial : ReflectRefractMaterial) : void {
	skyBox.x = sphere.x;
	skyBox.y = sphere.y;
	skyBox.z = sphere.z;
	camera.x = sphere.x;
	camera.y = sphere.y;
	camera.z = sphere.z;
	var viewSizeX : Number = stage.stageWidth / 2;
	var viewSizeY : Number = stage.stageHeight / 2;
	camera.fov = Math.atan(Math.sqrt(viewSizeX * viewSizeX + viewSizeY * viewSizeY) / camera.focalLength) * 2;
	camera.scaleX = camera.focalLength / stage.stageWidth * 2;
	camera.scaleY = camera.focalLength / stage.stageHeight * 2;
	lookAt(camera.x - 1, camera.y, camera.z);
	stage3D.context3D.setRenderToTexture(sphereMaterial._cubeTexture._texture, false, 0, 0);
	camera.render(stage3D);
 
	lookAt(camera.x + 1, camera.y, camera.z);
	stage3D.context3D.setRenderToTexture(sphereMaterial._cubeTexture._texture, false, 0, 1);
	camera.render(stage3D);
 
	lookAt(camera.x, camera.y - 1, camera.z);
	stage3D.context3D.setRenderToTexture(sphereMaterial._cubeTexture._texture, false, 0, 4);
	camera.render(stage3D);
 
	lookAt(camera.x, camera.y + 1, camera.z);
	stage3D.context3D.setRenderToTexture(sphereMaterial._cubeTexture._texture, false, 0, 5);
	camera.render(stage3D);
 
	lookAt(camera.x, camera.y, camera.z + 1);
	camera.rotationZ = Math.PI;
 
	stage3D.context3D.setRenderToTexture(sphereMaterial._cubeTexture._texture, false, 0, 2);
	camera.render(stage3D);
 
	lookAt(camera.x, camera.y, camera.z - 1);
	camera.rotationZ = Math.PI;
	stage3D.context3D.setRenderToTexture(sphereMaterial._cubeTexture._texture, false, 0, 3);
	camera.render(stage3D);
}

lookAt method:

public function lookAt(x : Number, y : Number, z : Number) : void {
	var dx : Number = x - camera.x;
	var dy : Number = y - camera.y;
	var dz : Number = z - camera.z;
	camera.rotationX = Math.atan2(dz, Math.sqrt(dx * dx + dy * dy)) - Math.PI / 2;
	camera.rotationY = 0;
	camera.rotationZ = -Math.atan2(dx, dy);
}

onEnterFrame method:

private var angle : Number = 0.01;
private var radius : Number = 400;
private var anim:Boolean = true;
private function onEnterFrame(e : Event) : void {
	//Rotate spheres
	var length : Number = objects.length;
	var step : Number = 0;
	var i : int;
	var mesh : Mesh;
	for (i = 0; i < length; i++) {
		mesh = objects[i] as Mesh;
		mesh.x = Math.cos(angle + step) * radius;
		mesh.y = Math.sin(angle + step) * radius;
		step += Math.PI * 2 / length;
	}
	if(anim) angle += 0.005;
	//Store camera propetrties
	var cameraX : Number = camera.x;
	var cameraY : Number = camera.y;
	var cameraZ : Number = camera.z;
	var cameraRotationX : Number = camera.rotationX;
	var cameraRotationY : Number = camera.rotationY;
	var cameraRotationZ : Number = camera.rotationZ;
	rootContainer.addChild(camera);
	//Render cube maps
	for (i = 0; i < length; i++) {
		mesh = objects[i] as Mesh;
		calculateCubeMapForSphere(mesh, objectsMaterials[i] as ReflectRefractMaterial);
	}
	//set render back
	stage3D.context3D.setRenderToBackBuffer();
	camera.scaleX = 1;
	camera.scaleY = 1;
	cameraContainer.addChild(camera);
	camera.x = cameraX;
	camera.y = cameraY;
	camera.z = cameraZ;
	camera.rotationX = cameraRotationX;
	camera.rotationY = cameraRotationY;
	camera.rotationZ = cameraRotationZ;
	camera.fov = 1.5707963267948966;
	camera.composeTransforms();
	skyBox.x = 0;
	skyBox.y = 0;
	skyBox.z = 0;
	//render
	camera.render(stage3D);
}

That’s all! Thanks for reading! If you have any questions please contact me.

Realtime raycast in Alternativa3D

Flastar — Mon, 05 Dec 2011 22:09:52 +0000

Reflect + Refract

(en) Environment and Refraction in Alternativa3D

Flastar — Sun, 04 Dec 2011 19:53:13 +0000

In this lesson I’ll show you how to create your own environment and refract material in Alternativa3D 8.17.0.

Cube Texture

Molehill supports cube mapping. Cube mapping is a method of environment mapping that uses a six-sided cube as the map shape. The environment is projected onto the six faces of a cube and stored as six square textures, or unfolded into six regions of a single texture. For create new cube-map you need to call createCubeTexture method of created instance of Context3D. For upload each side of cube in cubemap you need to use uploadFromBitmapData method of CubeTexture instance. This method uploads each mip-level.

Environment

For calculating Environment I need to know: vertex normal, object local-space camera position, object local to global matrix. Environment vector calculated by this formula:

V – View Vector = camera position – vertex position, N – Normal

package {
	import alternativa.engine3d.alternativa3d;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.core.DrawUnit;
	import alternativa.engine3d.core.Light3D;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.RenderPriority;
	import alternativa.engine3d.core.Transform3D;
	import alternativa.engine3d.core.VertexAttributes;
	import alternativa.engine3d.materials.A3DUtils;
	import alternativa.engine3d.materials.Material;
	import alternativa.engine3d.materials.ShaderProgram;
	import alternativa.engine3d.objects.Surface;
	import alternativa.engine3d.resources.Geometry;
	import alternativa.engine3d.resources.TextureResource;
 
	import avmplus.getQualifiedClassName;
 
	import com.adobe.utils.AGALMiniAssembler;
 
	import flash.display3D.Context3DProgramType;
	import flash.display3D.VertexBuffer3D;
	import flash.utils.Dictionary;
	import flash.utils.getDefinitionByName;
 
	use namespace alternativa3d;
	public class MyGlassMaterial extends Material {
		alternativa3d var _cubeTexture : TextureResource;
		//vertex shader
		private var _vertexShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
		//fragment shader
		private var _fragmentShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
		private var program : ShaderProgram;
 
		public function MyGlassMaterial(cubeTexture : TextureResource = null) {
			_cubeTexture = cubeTexture;
			program = new ShaderProgram(null, null);
			_vertexShaderAssembler.assemble(Context3DProgramType.VERTEX,
			//vertex normal
			"mov vt0, va1\n"+
			//normal from local to global
			"m33 vt0.xyz, vt0.xyz, vc5\n"+
			//viewVec
			"sub vt1, vc4, va0\n"+
			//viewVec from local to global
			"m33 vt1.xyz, vt1.xyz, vc5\n"+
			// r = V - 2(V.N)*N
			"dp3 vt2, vt1, vt0\n"+
			"add vt2, vt2, vt2\n"+
			"mul vt2, vt0, vt2\n"+
			"sub vt2, vt1, vt2\n"+
			"neg vt2, vt2\n"+
			"nrm vt2.xyz, vt2.xyz\n"+
			//send to fragment shader
			"mov v0, vt2\n"+
			//project vertex
			"m44 op, va0, vc0");
 
			_fragmentShaderAssembler.assemble(Context3DProgramType.FRAGMENT,
			//get cubemap color
			"tex ft0,v0.xyz,fs0 \n"+
			//output color
			"mov oc, ft0"
			);
		}
		alternativa3d override function fillResources(resources : Dictionary, resourceType : Class) : void {
			//fill cubeTexture
			if (_cubeTexture != null &amp;&amp; A3DUtils.checkParent(getDefinitionByName(getQualifiedClassName(_cubeTexture)) as Class, resourceType)) {
				resources[_cubeTexture] = true;
			}
			//upload program
			program.program = Main.instance.stage.stage3Ds[0].context3D.createProgram();
			program.program.upload(_vertexShaderAssembler.agalcode, _fragmentShaderAssembler.agalcode);
		}
 
		//draw each surface of object
		override alternativa3d function collectDraws(camera : Camera3D, surface : Surface, geometry : Geometry, lights : Vector., lightsLength : int, objectRenderPriority : int = -1) : void {
			//get link to object
			var object : Object3D = surface.object;
			//positionBuffer 
			var positionBuffer : VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.POSITION);
			//normalsBuffer 
			var normalsBuffer : VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.NORMAL);
 
			var drawUnit : DrawUnit = camera.renderer.createDrawUnit(object, program.program, geometry._indexBuffer, surface.indexBegin, surface.numTriangles, program);
			//setting buffers
			//point types float3,float3 and offsets 0,5
			drawUnit.setVertexBufferAt(0, positionBuffer, 0, "float3");
			drawUnit.setVertexBufferAt(1, normalsBuffer, 5, "float3");
			//project matrix
			drawUnit.setProjectionConstants(camera, 0, object.localToCameraTransform);
			//local-space camera position
			var cameraToLocalTransform : Transform3D = object.cameraToLocalTransform;
			drawUnit.setVertexConstantsFromNumbers(4, cameraToLocalTransform.d, cameraToLocalTransform.h, cameraToLocalTransform.l);
			//calculating local to global transform
			var globalTransform : Transform3D = new Transform3D();
			globalTransform.copy(object.localToCameraTransform);
			globalTransform.append(camera.localToGlobalTransform);
			//send this transform
			drawUnit.setVertexConstantsFromTransform(5, globalTransform);
			//set cubemap texture		
			drawUnit.setTextureAt(0, _cubeTexture._texture);
			//add surface to draw
			camera.renderer.addDrawUnit(drawUnit, objectRenderPriority &gt;= 0 ? objectRenderPriority:RenderPriority.OPAQUE);
		}
	}
}

Refraction

For refraction ray I used Shell’s law.
Source formula:

Changing n1/n2 by Refraction Index we calculate next formula:

package {
	import alternativa.engine3d.alternativa3d;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.core.DrawUnit;
	import alternativa.engine3d.core.Light3D;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.RenderPriority;
	import alternativa.engine3d.core.Transform3D;
	import alternativa.engine3d.core.VertexAttributes;
	import alternativa.engine3d.materials.A3DUtils;
	import alternativa.engine3d.materials.Material;
	import alternativa.engine3d.materials.ShaderProgram;
	import alternativa.engine3d.objects.Surface;
	import alternativa.engine3d.resources.Geometry;
	import alternativa.engine3d.resources.TextureResource;
 
	import avmplus.getQualifiedClassName;
 
	import com.adobe.utils.AGALMiniAssembler;
 
	import flash.display3D.Context3DBlendFactor;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.VertexBuffer3D;
	import flash.utils.Dictionary;
	import flash.utils.getDefinitionByName;
 
	use namespace alternativa3d;
	public class MyGlassMaterial extends Material {
		alternativa3d var _cubeTexture : TextureResource;
		//vertex shader
		private var _vertexShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
		//fragment shader
		private var _fragmentShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
		private var program : ShaderProgram;
		public var reflectionPower: Number = 0.4;
		public var refractionIndex : Number = 0.01;
		public var alpha : Number = 0.8;
 
		public function MyGlassMaterial(cubeTexture : TextureResource = null) {
			_cubeTexture = cubeTexture;
			program = new ShaderProgram(null, null);
			_vertexShaderAssembler.assemble(Context3DProgramType.VERTEX,
			//vertex normal
			"mov vt0, va1\n"+
			//normal from local to global
			"m33 vt0.xyz, vt0.xyz, vc5\n"+
			//viewVec
			"sub vt1, vc4, va0\n"+
			//viewVec from local to global
			"m33 vt1.xyz, vt1.xyz, vc5\n"+
			// r = V - 2(V.N)*N
			"dp3 vt2, vt1, vt0\n"+
			"add vt2, vt2, vt2\n"+
			"mul vt2, vt0, vt2\n"+
			"sub vt2, vt1, vt2\n"+
			"neg vt2, vt2\n"+
			"nrm vt2.xyz, vt2.xyz\n"+
			//send to fragment shader
			"mov v0, vt2\n"+
			//REFR_IND*(V.N)*N-V) - SQRT(1-REFR_IND^2(1-(V.N)^2))*N
			//(V.N)
			"dp3 vt3, vt1, vt0\n"+
			//(V.N)*N
			"mul vt3, vt3, vt0\n"+
			//(V.N)*N-V
			"sub vt3, vt3, vt1\n"+
			//REFR_IND*(V.N)*N-V)
			"mul vt3, vt3, vc5.y\n"+
			//V.N
			"dp3 vt4, vt1, vt0\n"+
			//(V.N)^2
			"mul vt4, vt4, vt4\n"+
			//(1-(V.N)^2)
			"sub vt4, vc5.x, vt4\n"+
			//REFR_IND^2(1-(V.N)^2)
			"mul vt4, vc5.z, vt4\n"+
			//1-REFR_IND^2(1-(V.N)^2)
			"sub vt4, vc5.x, vt4\n"+
			//SQRT(1-REFR_IND^2(1-(V.N)^2))
			"sqt vt4, vt4\n"+
			//SQRT(1-REFR_IND^2(1-(V.N)^2))*N
			"mul vt4, vt4, vt0\n"+
			//REFR_IND*(V.N)*N-V) - SQRT(1-REFR_IND^2(1-(V.N)^2))*N
			"sub vt4, vt3, vt4\n"+
			//normalize
			"nrm vt4.xyz, vt4.xyz\n"+
			"mov v1, vt4\n"+
			//project vertex
			"m44 op, va0, vc0");
 
			_fragmentShaderAssembler.assemble(Context3DProgramType.FRAGMENT,
			//environment
			"tex ft0,v0.xyz,fs0 \n"+
			//refract
			"tex ft1,v1.xyz,fs0 \n"+
			//mix them
			"sub ft3, ft0, ft1\n"+
			"mul ft3, ft3, fc0\n"+
			"add ft3, ft3, ft1\n"+
			//alpha
			"mov ft3.w, fc0.w\n"+
			//output color
			"mov oc, ft3"
			);
		}
		//переопределяем метод заливки ресурсов в видео-карту
		alternativa3d override function fillResources(resources : Dictionary, resourceType : Class) : void {
			//fill cubeTexture
			if (_cubeTexture != null &amp;&amp; A3DUtils.checkParent(getDefinitionByName(getQualifiedClassName(_cubeTexture)) as Class, resourceType)) {
				resources[_cubeTexture] = true;
			}
			//upload program
			program.program = Main.instance.stage.stage3Ds[0].context3D.createProgram();
			program.program.upload(_vertexShaderAssembler.agalcode, _fragmentShaderAssembler.agalcode);
		}
 
		//draw each surface of object
		override alternativa3d function collectDraws(camera : Camera3D, surface : Surface, geometry : Geometry, lights : Vector.<Light3D>, lightsLength : int, objectRenderPriority : int = -1) : void {
			//draw each surface of object
		override alternativa3d function collectDraws(camera : Camera3D, surface : Surface, geometry : Geometry, lights : Vector., lightsLength : int, objectRenderPriority : int = -1) : void {
			//get link to object
			var object : Object3D = surface.object;
			//positionBuffer 
			var positionBuffer : VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.POSITION);
			//normalsBuffer 
			var normalsBuffer : VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.NORMAL);
 
			var drawUnit : DrawUnit = camera.renderer.createDrawUnit(object, program.program, geometry._indexBuffer, surface.indexBegin, surface.numTriangles, program);
			//setting buffers
			//point types float3,float3 and offsets 0,5
			drawUnit.setVertexBufferAt(0, positionBuffer, 0, "float3");
			drawUnit.setVertexBufferAt(1, normalsBuffer, 5, "float3");
			//project matrix
			drawUnit.setProjectionConstants(camera, 0, object.localToCameraTransform);
			//local-space camera position
			var cameraToLocalTransform : Transform3D = object.cameraToLocalTransform;
			drawUnit.setVertexConstantsFromNumbers(4, cameraToLocalTransform.d, cameraToLocalTransform.h, cameraToLocalTransform.l);
			//send to vertex shader 1, refractionIndex и refractionIndex^2 
			drawUnit.setVertexConstantsFromNumbers(5, 1, refractionIndex, refractionIndex*refractionIndex, 1);
			//calculating local to global transform
			var globalTransform : Transform3D = new Transform3D();
			globalTransform.copy(object.localToCameraTransform);
			globalTransform.append(camera.localToGlobalTransform);
			//send this transform
			drawUnit.setVertexConstantsFromTransform(6, globalTransform);
			//mix color
drawUnit.setFragmentConstantsFromNumbers(0,reflectionPower,reflectionPower,reflectionPower,alpha);
			//set cubemap texture	
			drawUnit.setTextureAt(0, _cubeTexture._texture);
			//add surface to draw
			camera.renderer.addDrawUnit(drawUnit, objectRenderPriority >= 0 ? objectRenderPriority : RenderPriority.TRANSPARENT_SORT);
			drawUnit.blendSource = Context3DBlendFactor.SOURCE_ALPHA;
			drawUnit.blendDestination = Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA;
		}
	}
}

(en) Alternativa3D 8.17 Custom materials, shaders and intersectionRay

Flastar — Mon, 31 Oct 2011 00:43:16 +0000

In this lesson I’ll show you how to create custom materials and shaders with Alternativa3D 8.17.0.
(clickable)

When you develop molehill-projects, often arise situtations when you need more features in Alternativa3D, and standard materials do not enough. For example, we have loaded character model and onClick event we want to highlight this model little greeny.
We have two solutions:
1) Upload two textures in video-card and change them every time when model was clicked. First texture is diffuse texture. Second is little greeny diffuse texture. But, This is expensive way, because we must save links on every surface or find them in every onClick event, to setup new material.
2) Create custom material with color and colorAlpha properties. And every mouse click, set colorAlpha custom material property.

Find mouse coordinates in 3D space

Alternativa3D have default opportunity to detect mouse coordinates in 3D-space.

container.addEventListener(MouseEvent3D.MOUSE_MOVE, goMouseMove);
function goMouseMove(event:MouseEvent3D):void {
	var mouseX:Number = event.localX;
	var mouseY:Number = event.localY;
	var mouseZ:Number = event.localZ;
}

But, there are one problem. I can do that only on MouseEvent3D. In this lesson I need to detect mouse coordinates onEnterFrame. Include altearnativa3d namespace and write this function:

import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
...
//ray center
private var localOrigin:Vector3D = new Vector3D();
//ray directions
private var localDirection:Vector3D = new Vector3D();
public function calculateMouseInObjectSpace(obj:Object3D):Vector3D {
	//camera has calculateRay method
	//which calculates center and direction of ray
	camera.calculateRay(localOrigin, localDirection, stage.mouseX, stage.mouseY);
	//compose object matrix
	obj.composeTransforms();
	//append parents matrices
	var root:Object3D = obj;
	while (root.parent != null) {
		root = root.parent;
		root.composeTransforms();
		obj.transform.append(root.transform);
	}
	//do invert matrix, to translate ray in object local space
	obj.transform.invert();
	var ox:Number = localOrigin.x;
	var oy:Number = localOrigin.y;
	var oz:Number = localOrigin.z;
	var dx:Number = localDirection.x;
	var dy:Number = localDirection.y;
	var dz:Number = localDirection.z;
	//translate center of ray in local space
	localOrigin.x = obj.transform.a * ox + obj.transform.b * oy + obj.transform.c * oz + obj.transform.d;
	localOrigin.y = obj.transform.e * ox + obj.transform.f * oy + obj.transform.g * oz + obj.transform.h;
	localOrigin.z = obj.transform.i * ox + obj.transform.j * oy + obj.transform.k * oz + obj.transform.l;
	//translate direction of ray in local space
	localDirection.x = obj.transform.a * dx + obj.transform.b * dy + obj.transform.c * dz;
	localDirection.y = obj.transform.e * dx + obj.transform.f * dy + obj.transform.g * dz;
	localDirection.z = obj.transform.i * dx + obj.transform.j * dy + obj.transform.k * dz;
	//we have center and direction in local space
	//now we can call intersectRay method
	//which returns result of intersection
	var data:RayIntersectionData = obj.intersectRay(localOrigin, localDirection);
	if (data) {
		return data.point;
	}
	return null;
}

Now we have function which finds mouse coordinates in local space of object.

Creating custom material and shaders

Now we create custom material with custom shader to emulate light.
Material properties:

Two textures for different effects by div, sub, add, mul them.
alpha
mousePos – mouse position on 3D-space
intensivity – light intensity

The description of all process occurs in code comments.

package {
	import alternativa.engine3d.alternativa3d;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.core.DrawUnit;
	import alternativa.engine3d.core.Light3D;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.RenderPriority;
	import alternativa.engine3d.core.VertexAttributes;
	import alternativa.engine3d.materials.A3DUtils;
	import alternativa.engine3d.materials.Material;
	import alternativa.engine3d.materials.ShaderProgram;
	import alternativa.engine3d.objects.Surface;
	import alternativa.engine3d.resources.Geometry;
	import alternativa.engine3d.resources.TextureResource;
 
	import avmplus.getQualifiedClassName;
 
	import com.adobe.utils.AGALMiniAssembler;
 
	import flash.display3D.Context3D;
	import flash.display3D.Context3DProgramType;
	import flash.display3D.VertexBuffer3D;
	import flash.geom.Vector3D;
	import flash.utils.Dictionary;
	import flash.utils.getDefinitionByName;
 
	use namespace alternativa3d;
	public class CustomMaterial extends Material {
		//first texture
		public var diffuseMap:TextureResource;
		//second texture
		public var dynamicMap:TextureResource;
		//alpha
		public var alpha:Number = 1;
		//mouse position
		public var mousePos:Vector3D = new Vector3D();
		//vertex shader
		private var _vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
		//fragments
		private var _fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
		private var program:ShaderProgram;
		//context for uploading resources
		private var context:Context3D;
		public var intensivity:Number;
		//constructor
		public function CustomMaterial(diffuseMap:TextureResource, dynamicMap:TextureResource, context:Context3D) {
			this.diffuseMap = diffuseMap;
			this.dynamicMap = dynamicMap;
			this.context = context;
			program = new ShaderProgram(null, null);
			//vertex shader
			_vertexShaderAssembler.assemble(Context3DProgramType.VERTEX, 
				//project vertex position
				"m44 vt0, va0, vc0\n" + 
				//send UV-coordinates in fragment shader
				"mov v0, va1\n" +
				//send vertex-coordinates in fragment shader
				"mov v1, va0\n"+
				//Output Position = projected vertex position
				"mov op, vt0\n"
			);
			_fragmentShaderAssembler.assemble(Context3DProgramType.FRAGMENT, 
				//load texture №1
				"tex ft0, v0, fs0 <2D, repeat, linear, miplinear>\n" + 
				//load texture №2
				"tex ft1, v0, fs1 <2D, repeat, linear, miplinear>\n" +
				//alpha 
				"mov ft0.w, fc0.w\n" +
				//there are we calculating distance from mouse to vertex
				//(x-mouseX) 
				"sub ft2.x, v1.x, fc1.x\n" + 
				//(x-mouseX)*(x-mouseX) 
				"mul ft2.x, ft2.x, ft2.x\n" + 
				//(y-mouseY)
				"sub ft2.y, v1.y, fc1.y\n" + 
				//(y-mouseY)*(y-mouseY)
				"mul ft2.y, ft2.y, ft2.y\n" +
				//(z-mouseZ) 
				"sub ft2.z, v1.z, fc1.z\n" + 
				//(z-mouseZ)*(z-mouseZ)
				"mul ft2.z, ft2.z, ft2.z\n" + 
				//(x-mouseX)*(x-mouseX) + (y-mouseY)*(y-mouseY)
				"add ft2.w, ft2.x, ft2.y\n" + 
				//(x-mouseX)*(x-mouseX) + (y-mouseY)*(y-mouseY) + (z-mouseZ)*(z-mouseZ)
				"add ft2.w, ft2.w, ft2.z\n" + 
				//res = sqrt((x-mouseX)*(x-mouseX) + (y-mouseY)*(y-mouseY) + (z-mouseZ)*(z-mouseZ))
				"sqt ft2.w, ft2.w\n" + 
				//res/intensivity
				"div ft3.x, ft2.w, fc1.w\n" +
				//reciprocal
				"rcp ft3.x, ft3.x\n" +
				//mul RED texture channel
				"mul ft0.x, ft0.x, ft3.x\n" + 
				//mul GREEN texture channel
				"mul ft0.y, ft0.y, ft3.x\n" + 
				//mul BLUE texture channel
				"mul ft0.z, ft0.z, ft3.x\n" + 
				//mul texture №1 on texture №2
				"mul ft0, ft0, ft1\n" + 
				//output result
				"mov oc, ft0"
			);
		}
		//override fillResources method
		override alternativa3d function fillResources(resources:Dictionary, resourceType:Class):void {
			super.fillResources(resources, resourceType);
			//texture №1
			if (diffuseMap != null && A3DUtils.checkParent(getDefinitionByName(getQualifiedClassName(diffuseMap)) as Class, resourceType)) {
				resources[diffuseMap] = true;
			}
			//texture №2
			if (dynamicMap != null && A3DUtils.checkParent(getDefinitionByName(getQualifiedClassName(dynamicMap)) as Class, resourceType)) {
				resources[dynamicMap] = true;
			}
			//shader program
			program.program = context.createProgram();
			program.program.upload(_vertexShaderAssembler.agalcode, _fragmentShaderAssembler.agalcode);
		}
 
		//surface draw
		override alternativa3d function collectDraws(camera:Camera3D, surface:Surface, geometry:Geometry, lights:Vector.<Light3D>, lightsLength:int, objectRenderPriority:int = -1):void {
			//get link to object
			var object:Object3D = surface.object;
			//get buffer with positions
			var positionBuffer:VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.POSITION);
			//get buffer with UVs
			var uvBuffer:VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.TEXCOORDS[0]);
 
			var drawUnit:DrawUnit = camera.renderer.createDrawUnit(object, program.program, geometry._indexBuffer, surface.indexBegin, surface.numTriangles, program);
			//upload buffers with float3 and float2 formats
			drawUnit.setVertexBufferAt(0, positionBuffer, 0, "float3");
			drawUnit.setVertexBufferAt(1, uvBuffer, 3, "float2");
			//set project matrix
			drawUnit.setProjectionConstants(camera, 0, object.localToCameraTransform);
 
			//send alpha		
			drawUnit.setFragmentConstantsFromNumbers(0, 0, 0, 0, alpha);
			//send mouse position and intensivity
			drawUnit.setFragmentConstantsFromNumbers(1, mousePos.x, mousePos.y, mousePos.z, intensivity);
 
			//set first texture
			drawUnit.setTextureAt(0, diffuseMap._texture);
			//set second texture
			drawUnit.setTextureAt(1, dynamicMap._texture);
			//add surface to draw
			camera.renderer.addDrawUnit(drawUnit, objectRenderPriority >= 0 ? objectRenderPriority:RenderPriority.OPAQUE);
		}
	}
}

Download source code
P.S. Sorry for my English. This is my first article in English. Thx for reading. Cheers!