how to use CubeTexture?

/**
 * Copyright codeonwort ( http://wonderfl.net/user/codeonwort )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/tjse
 */

package {
    
    import flash.display.Sprite
    import flash.events.Event
    
    import flash.display3D.Context3D
    
    public class Stage3DBase extends Sprite {
        
        private var context:Context3D
        
        public function Stage3DBase() {
            // write as3 code here..
            stage ? init() : addEventListener("addedToStage", init)
        }
        
        private function init(e:Event = null):void {
            // never mind
            if(e) removeEventListener(e.type, arguments.callee)
            
            // request context 3d
            stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, contextGained)
            stage.stage3Ds[0].requestContext3D("auto")
        }
        
        // when I request context3D by Stage3D::requestContext3D
        // or when device loss occurs this listener is called.
        // make this listener to handle both situations.
        private function contextGained(e:Event):void {
            context = e.target.context3D
            
            var study:StudyBase = new StudyCubeTexture
            study.init(this, context)
        }
        
    }
    
}

import flash.utils.ByteArray
import flash.display.Stage
import flash.display.Sprite
import flash.display3D.Context3D
import flash.display3D.Program3D
import flash.display3D.IndexBuffer3D
import flash.display3D.VertexBuffer3D
import com.adobe.utils.AGALMiniAssembler
class StudyBase {
    
    protected var document:Sprite
    protected var stage:Stage
    protected var context:Context3D
    protected var asm:AGALMiniAssembler
    
    protected var hardwareAccelerated:Boolean
    
    protected var vertBuf:VertexBuffer3D
    protected var idxBuf:IndexBuffer3D
    protected var program:Program3D
    
    public function StudyBase() {
        asm = new AGALMiniAssembler
    }
    
    public function init(doc:Sprite, cont:Context3D):void {
        if(context) context.dispose()
        context = cont
        document = doc
        stage = document.stage
        
        hardwareAccelerated = context.driverInfo.toLowerCase().indexOf("software") == -1
        
        program = context.createProgram()
    }
    
    protected function makeVertBuf(verts:Vector.<Number>, data32PerVert:uint):void {
        vertBuf = context.createVertexBuffer(verts.length / data32PerVert, data32PerVert)
        vertBuf.uploadFromVector(verts, 0, verts.length / data32PerVert)
    }
    protected function makeIdxBuf(indices:Vector.<uint>):void {
        idxBuf = context.createIndexBuffer(indices.length)
        idxBuf.uploadFromVector(indices, 0, indices.length)
    }
    
}

import flash.text.TextFormat
import flash.text.TextField
import flash.display.BitmapData
import flash.display3D.textures.CubeTexture
class StudyCubeTexture extends StudyBase {
    
    private var tex:CubeTexture
    
    public override function init(doc:Sprite, cont:Context3D):void {
        super.init(doc, cont)
        
        readyResources()
        render()
    }
    
    private function readyResources():void {
        // width, height, anti-alising level, useDepthBufferAndStencilBuffer
        context.configureBackBuffer(465, 465, 4, false)
        
        makeVertBuf(Vector.<Number>([-1,1,0, 0,1,0, -1,0,0, 0,0,0]), 3)
        makeIdxBuf(Vector.<uint>([0,1,2, 2,1,3]))
        
        var vertShaderCode:String = "mov op, va0"
        var vertShaderProgram:ByteArray = asm.assemble("vertex", vertShaderCode)
        
        var fragShaderCode:String = "mov oc, fc0";"tex oc, fc0.xyz, fs0<cube,linear,mapnearest>"
        var fragShaderProgram:ByteArray = asm.assemble("fragment", fragShaderCode)
        
        program.upload(vertShaderProgram, fragShaderProgram)
        
        tex = makeCubeTexture(256)
        
        // your code
    }
    
    private function render():void {
        context.clear(0.3, 0.3, 0.3)
        
        // your code
        context.setCulling("none")
        context.enableErrorChecking = true
        context.setTextureAt(0, tex)
        context.setVertexBufferAt(0, vertBuf, 0, "float3")
        context.setProgramConstantsFromVector("fragment", 0, Vector.<Number>([1,0,0,0]))
        context.setProgram(program)
        try{
        context.drawTriangles(idxBuf)
        }catch(e:Error){
            var tf:TextField = new TextField
            tf.text = e.message
            document.addChild(tf)
        }
        context.present()
    }
    
    private function makeCubeTexture(size:uint):CubeTexture {
        var tex:CubeTexture = context.createCubeTexture(size, "bgra", false)
        
        var mm:uint = 0
        for(; size != 0 ; size >>= 1){
            tex.uploadFromBitmapData( bd(size, 0xff0000), 0, mm)
            tex.uploadFromBitmapData( bd(size, 0x00ff00), 1, mm)
            tex.uploadFromBitmapData( bd(size, 0x0000ff), 2, mm)
            tex.uploadFromBitmapData( bd(size, 0xff00ff), 3, mm)
            tex.uploadFromBitmapData( bd(size, 0xffff00), 4, mm)
            tex.uploadFromBitmapData( bd(size, 0x00ffff), 5, mm)
            mm ++
        }
        return tex
    }
    
    private function bd(size:uint, color:uint):BitmapData {
        return new BitmapData(size, size, false, color)
    }
    
}