Reyco1

package
{
    import com.as3dmod.IModifier;
    import com.as3dmod.ModifierStack;
    import com.as3dmod.modifiers.Bend;
    import com.as3dmod.modifiers.Bloat;
    import com.as3dmod.modifiers.Noise;
    import com.as3dmod.modifiers.Perlin;
    import com.as3dmod.modifiers.Skew;
    import com.as3dmod.modifiers.Taper;
    import com.as3dmod.modifiers.Twist;
    import com.as3dmod.plugins.pv3d.LibraryPv3d;
    import com.as3dmod.util.ModConstant;
    import com.as3dmod.util.Phase;
   
    import flash.events.Event;
   
    import org.papervision3d.materials.ColorMaterial;
    import org.papervision3d.materials.WireframeMaterial;
    import org.papervision3d.materials.special.CompositeMaterial;
    import org.papervision3d.materials.utils.MaterialsList;
    import org.papervision3d.objects.primitives.Cube;
    import org.papervision3d.view.BasicView;

    public class SimpleMod extends BasicView
    {
        private var cube:Cube;
        private var modStack:ModifierStack;
        private var bend:Bend;
        private var bendPhase:Phase;
        private var perlin:Perlin;
        private var noise:Noise;
        private var skew:Skew;
        private var skewPhase:Phase;
        private var taper:Taper;
        private var taperPhase:Phase;
        private var twist:Twist;
        private var twistPhase:Phase;
        private var bloat:Bloat;
        private var bloatPhase:Phase;
       
        public function SimpleMod()
        {
            camera.z = -1500;
           
            cerateCube();
            addModifiers();
            configureComboBox();
            startRendering();
        }
       
        private function cerateCube():void
        {
            var colorMat:ColorMaterial = new ColorMaterial(0x00FF00);
            var wireMat:WireframeMaterial = new WireframeMaterial(0xFFFFFF);
            var compositeMat:CompositeMaterial = new CompositeMaterial();
            compositeMat.addMaterial(colorMat);
            compositeMat.addMaterial(wireMat);
           
            var materialsList:MaterialsList = new MaterialsList({ all:compositeMat });
           
            cube = new Cube(materialsList, 500, 500, 1000, 10, 10, 10);
           
            scene.addChild(cube);
        }
       
        private function addModifiers():void
        {
            modStack = new ModifierStack(new LibraryPv3d, cube);
           
            bend = new Bend(0.5, 0.5);
            bendPhase = new Phase();
           
            skew = new Skew(0);
            skewPhase = new Phase();
           
            taper = new Taper(3);
            taper.setFalloff(0.2, 0.5);
            taper.power = 6;
            taperPhase = new Phase();
           
            twist = new Twist(Math.PI / 2);
            twistPhase = new Phase();
           
            perlin = new Perlin(3);
            perlin.setFalloff(1, 0);
           
            noise = new Noise(25);
            noise.constraintAxes(ModConstant.X | ModConstant.Y);
           
            bloat = new Bloat();
        }
       
        private function configureComboBox():void
        {
            modifierCB.addItem({label:"Bend", data:bend});
            modifierCB.addItem({label:"Skew", data:skew});
            modifierCB.addItem({label:"Taper", data:taper});
            modifierCB.addItem({label:"Twist", data:twist});
            modifierCB.addItem({label:"Perlin", data:perlin});
            modifierCB.addItem({label:"Noise", data:noise});
            modifierCB.addItem({label:"Bloat", data:bloat});
            modifierCB.addEventListener(Event.CHANGE, changeHandler);
        }
       
        private function changeHandler($event:Event):void
        {
            modStack.clear();
            modStack.addModifier(modifierCB.selectedItem.data as IModifier);
        }
       
        override protected function onRenderTick(event:Event=null):void
        {
            super.onRenderTick(event);
           
            cube.yaw(.5);
             
            bendPhase.value += 0.05;
            bend.force = bendPhase.phasedValue * .5;
           
            skewPhase.value += 0.05;
            skew.force = skewPhase.phasedValue * 100;
           
            taperPhase.value += 0.05;
            taper.force = taperPhase.absPhasedValue * 2;
           
            twistPhase.value += 0.05;
            twist.angle = Math.PI / 8 * twistPhase.phasedValue;
           
            modStack.apply();
        }
    }
}