mov vt0, va0
mov vt0, va1
mov vt0, va2
mov vt0, va3
mov vt0, va4

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);
       }
   }
}

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 <cube,clamp,linear>\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 <cube,clamp,linear>\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);
        }
   }
}

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(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);
}

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);
}

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);
}

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);
}

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 && 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 >= 0 ? objectRenderPriority:RenderPriority.OPAQUE);
       }
   }
}

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 <cube,clamp,linear>\n"+
            //refract
           "tex ft1,v1.xyz,fs0 <cube,clamp,linear>\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;
        }
   }
}

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;
       //вершинный шейдер
       private var _vertexShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
       //фрагментный шейдер
       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,
            //нормаль вершины
         "mov vt0, va1\n"+
          //переводим из локального в глобальное пространство
         "m33 vt0.xyz, vt0.xyz, vc5\n"+
         //в локальном пространстве рассчитываем view vec = позиция камеры - позиция вершины.
           "sub vt1, vc4, va0\n"+
         //переводим viewVec из локального в глобальное пространство
         "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"+
          //отправляем фрагментному шейдеру
          "mov v0, vt2\n"+
           //прогоняем позицию вершины через матрицу проекции
           "m44 op, va0, vc0");
 
            _fragmentShaderAssembler.assemble(Context3DProgramType.FRAGMENT,
            //получаем цвет по лучу из кубической текстуры
            "tex ft0,v0.xyz,fs0 \n"+
           //отправляем результат
           "mov oc, ft0"
           );
      }
       //переопределяем метод заливки ресурсов в видео-карту
      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., 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);
            //для вершинного шейдера загружаем буфер позиции и нормалей
           //при этом указываем их формат float3, float3 и смещения 0,5
           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 globalTransform : Transform3D = new Transform3D();
          globalTransform.copy(object.localToCameraTransform);
            globalTransform.append(camera.localToGlobalTransform);
          //передаем полученную матрицу
          drawUnit.setVertexConstantsFromTransform(5, globalTransform);
           //устанавливаем кубическую текстуру          
            drawUnit.setTextureAt(0, _cubeTexture._texture);
            //добавляем сурфейс на отрисовку
         camera.renderer.addDrawUnit(drawUnit, objectRenderPriority >= 0 ? objectRenderPriority:RenderPriority.OPAQUE);
       }
   }
}

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;
       //вершинный шейдер
       private var _vertexShaderAssembler : AGALMiniAssembler = new AGALMiniAssembler();
       //фрагментный шейдер
       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,
            //нормаль вершины
         "mov vt0, va1\n"+
          //переводим из локального в глобальное пространство
         "m33 vt0.xyz, vt0.xyz, vc6\n"+
         //в локальном пространстве рассчитываем view vec = позиция камеры - позиция вершины.
           "sub vt1, vc4, va0\n"+
         //переводим viewVec из локального в глобальное пространство
         "m33 vt1.xyz, vt1.xyz, vc6\n"+
         // r = - (V - 2(V.N)*N) = 2(V.N)*N - V
          "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"+
           //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"+
         //нормализируем результат
         "nrm vt4.xyz, vt4.xyz\n"+
          "mov v1, vt4\n"+
           //прогоняем позицию вершины через матрицу проекции
           "m44 op, va0, vc0");
 
            _fragmentShaderAssembler.assemble(Context3DProgramType.FRAGMENT,
            //отражение
            "tex ft0,v0.xyz,fs0 <cube,clamp,linear>\n"+
            //преломление
            "tex ft1,v1.xyz,fs0 <cube,clamp,linear>\n"+
            //смешиваем
            "sub ft3, ft0, ft1\n"+
         "mul ft3, ft3, fc0\n"+
         "add ft3, ft3, ft1\n"+
         //alpha
         "mov ft3.w, fc0.w\n"+
          //отправляем результат
           "mov oc, ft3"
           );
      }
       //переопределяем метод заливки ресурсов в видео-карту
      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);
            //для вершинного шейдера загружаем буфер позиции и нормалей
           //при этом указываем их формат float3, float3 и смещения 0,5
           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);
            //передаем 1, refractionIndex и refractionIndex^2 
         drawUnit.setVertexConstantsFromNumbers(5, 1, refractionIndex, refractionIndex*refractionIndex, 1);
          //рассчитываем матрицу перевода из локального в глобальное пространсво
         var globalTransform : Transform3D = new Transform3D();
          globalTransform.copy(object.localToCameraTransform);
            globalTransform.append(camera.localToGlobalTransform);
          //передаем полученную матрицу
          drawUnit.setVertexConstantsFromTransform(6, globalTransform);
           //mix color
         drawUnit.setFragmentConstantsFromNumbers(0,reflectionPower,reflectionPower,reflectionPower,alpha);
          //устанавливаем кубическую текстуру
          drawUnit.setTextureAt(0, _cubeTexture._texture);
            //добавляем сурфейс на отрисовку
         camera.renderer.addDrawUnit(drawUnit, objectRenderPriority >= 0 ? objectRenderPriority : RenderPriority.TRANSPARENT_SORT);
          drawUnit.blendSource = Context3DBlendFactor.SOURCE_ALPHA;
           drawUnit.blendDestination = Context3DBlendFactor.ONE_MINUS_SOURCE_ALPHA;
        }
   }
}

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;
}

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;
}

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);
      }
   }
}

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;
}

//подключаем неймспейс альтернативы
import alternativa.engine3d.alternativa3d;
use namespace alternativa3d;
...
//центр луча
private var localOrigin:Vector3D = new Vector3D();
//направление
private var localDirection:Vector3D = new Vector3D();
public function calculateMouseInObjectSpace(obj:Object3D):Vector3D {
  //у камеры присутсвует метод calculateRay 
   //который рассчитывает центр и направление луча
 //передаем туда ссылки на наши вектора localOrigin и localDirection
 //и координаты мыши соответственно
 camera.calculateRay(localOrigin, localDirection, stage.mouseX, stage.mouseY);
   //формируем матрицу объекта
  obj.composeTransforms();
    //пробегаемся по всей иерархии вверх и добавляем все матрицы
  var root:Object3D = obj;
    while (root.parent != null) {
       root = root.parent;
     root.composeTransforms();
       obj.transform.append(root.transform);
   }
   //ивертируем матрицу для перевода луча в локальное пространство объекта
    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;
   //переводим центр луча в локальное пространство объекта
  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;
   //переводим направление луча в локальное пространство объекта
  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;
  //теперь у нас есть центр и направление луча в пространстве объекта
  //поэтому теперь можно вызвать метод intersectRay 
    //который вернет результат пересечения RayIntersectionData
 var data:RayIntersectionData = obj.intersectRay(localOrigin, localDirection);
   if (data) {
     return data.point;
  }
   return null;
}

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 {
      //первая текстура
     public var diffuseMap:TextureResource;
      //вторая текстура
     public var dynamicMap:TextureResource;
      //прозрачность
      public var alpha:Number = 1;
        //позиция мыши
       public var mousePos:Vector3D = new Vector3D();
      //вершинный шейдер
       private var _vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
     //фрагментный шейдер
       private var _fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
       //шейдер-программа
       private var program:ShaderProgram;
      //контекст, для загрузки ресурсов
        private var context:Context3D;
      //интенсивность
        public var intesivity:Number;
       //конструктор материала
     public function CustomMaterial(diffuseMap:TextureResource, dynamicMap:TextureResource, context:Context3D) {
         this.diffuseMap = diffuseMap;
           this.dynamicMap = dynamicMap;
           this.context = context;
         program = new ShaderProgram(null, null);
            //вершинный шейдер
           _vertexShaderAssembler.assemble(Context3DProgramType.VERTEX, 
               //прогоняем позицию через матрицу проекции
              "m44 vt0, va0, vc0\n" + 
               //передаем фрагментному шейдеру UV-координаты
              "mov v0, va1\n" +
              //передаем фрагментному шейдеру позицию вершины 
               "mov v1, va0\n"+
               //Output Position = позиция вершинны, после "прогона" через матрицу проекции
             "mov op, vt0\n"
            );
          //фрагментный шейдер
           _fragmentShaderAssembler.assemble(Context3DProgramType.FRAGMENT, 
               //текструра №1
               "tex ft0, v0, fs0 <2D, repeat, linear, miplinear>\n" + 
                //текструра №2
               "tex ft1, v0, fs1 <2D, repeat, linear, miplinear>\n" +
             //alpha 
                "mov ft0.w, fc0.w\n" +
             //тут мы вычисляем корень квадратный
              //(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/интенсивность
                "div ft3.x, ft2.w, fc1.w\n" +
              //инверсируем 
               "rcp ft3.x, ft3.x\n" +
             //умножаем канал RED текстуры №1 на наш коэффициент
              "mul ft0.x, ft0.x, ft3.x\n" + 
             //умножаем канал GREEN текстуры №1 на наш коэффициент
                "mul ft0.y, ft0.y, ft3.x\n" + 
             //умножаем канал BLUE текстуры №1 на наш коэффициент
             "mul ft0.z, ft0.z, ft3.x\n" + 
             //умножаем текстуру №1 на текстуру №2
             "mul ft0, ft0, ft1\n" + 
               //выводим результат
             "mov oc, ft0"
           );
      }
       //переопределяем метод заливки ресурсов в видео-карту
      override alternativa3d function fillResources(resources:Dictionary, resourceType:Class):void {
          super.fillResources(resources, resourceType);
           //текстура №1
         if (diffuseMap != null && A3DUtils.checkParent(getDefinitionByName(getQualifiedClassName(diffuseMap)) as Class, resourceType)) {
                resources[diffuseMap] = true;
           }
           //текстура №2
         if (dynamicMap != null && A3DUtils.checkParent(getDefinitionByName(getQualifiedClassName(dynamicMap)) as Class, resourceType)) {
                resources[dynamicMap] = true;
           }
           //шейдерная программа
         program.program = context.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);
            //буфер uv-координат
          var uvBuffer:VertexBuffer3D = geometry.getVertexBuffer(VertexAttributes.TEXCOORDS[0]);
 
            var drawUnit:DrawUnit = camera.renderer.createDrawUnit(object, program.program, geometry._indexBuffer, surface.indexBegin, surface.numTriangles, program);
          //для вершинного шейдера загружаем буфер позиции и uv-координат
          //при этом указываем их формат float3, float2
           drawUnit.setVertexBufferAt(0, positionBuffer, 0, "float3");
         drawUnit.setVertexBufferAt(1, uvBuffer, 3, "float2");
           //передаем матрицу проекции
          drawUnit.setProjectionConstants(camera, 0, object.localToCameraTransform);
 
            //передаем alpha        
            drawUnit.setFragmentConstantsFromNumbers(0, 0, 0, 0, alpha);
            //передаем позицию мыши и интенсивность
            drawUnit.setFragmentConstantsFromNumbers(1, mousePos.x, mousePos.y, mousePos.z, intesivity);
 
            //устанавливаем текстуру №1
          drawUnit.setTextureAt(0, diffuseMap._texture);
          //устанавливаем текстуру №2
          drawUnit.setTextureAt(1, dynamicMap._texture);
          //добавляем сурфейс на отрисовку
         camera.renderer.addDrawUnit(drawUnit, objectRenderPriority >= 0 ? objectRenderPriority:RenderPriority.OPAQUE);
      }
   }
}