Top
Summary
Constructors
Instance properties
Instance methods
Event handlers

Viewport3D

Kind of class:	public class
Package:	org.papervision3d.view
Inherits from:	Sprite
Implements:	IViewport3D
Known subclasses:	BitmapViewport3D
Classpath:	org.papervision3d.view.Viewport3D
File last modified:	Sunday, 02 March 2008, 15:23:48

► View source

▼ Hide source

package org.papervision3d.view {
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.geom.Point;
    import flash.geom.Rectangle;
    
    import org.papervision3d.core.culling.DefaultParticleCuller;
    import org.papervision3d.core.culling.DefaultTriangleCuller;
    import org.papervision3d.core.culling.IParticleCuller;
    import org.papervision3d.core.culling.ITriangleCuller;
    import org.papervision3d.core.culling.RectangleParticleCuller;
    import org.papervision3d.core.culling.RectangleTriangleCuller;
    import org.papervision3d.core.culling.ViewportObjectFilter;
    import org.papervision3d.core.ns.pv3dview;
    import org.papervision3d.core.render.IRenderEngine;
    import org.papervision3d.core.render.command.IRenderListItem;
    import org.papervision3d.core.render.command.RenderableListItem;
    import org.papervision3d.core.render.data.RenderHitData;
    import org.papervision3d.core.utils.InteractiveSceneManager;
    import org.papervision3d.core.view.IViewport3D;
    import org.papervision3d.events.RendererEvent;
    import org.papervision3d.render.BasicRenderEngine;
    import org.papervision3d.view.layer.ViewportBaseLayer;
    import org.papervision3d.view.layer.ViewportLayer;    

    /**
     * @Author Ralph Hauwert
     */
     
    /* Changed to protected methods on 11/27/2007 by John */
    
    public class Viewport3D extends Sprite implements IViewport3D
    {
        
        //use namespace org.papervision3d.core.ns.pv3dview;
        protected var _width:Number;
        protected var _hWidth:Number;
        protected var _height:Number;
        protected var _hHeight:Number;
        
        protected var _autoClipping:Boolean;
        protected var _autoCulling:Boolean;
        protected var _autoScaleToStage:Boolean;
        protected var _interactive:Boolean;
        protected var _lastRenderer:IRenderEngine;
        protected var _viewportObjectFilter:ViewportObjectFilter;
        
        public var sizeRectangle:Rectangle;
        public var cullingRectangle:Rectangle;
        protected var _containerSprite:ViewportBaseLayer;
        
        public var triangleCuller:ITriangleCuller;
        public var particleCuller:IParticleCuller;
        public var lastRenderList:Array;
        public var interactiveSceneManager:InteractiveSceneManager;
        
        public function Viewport3D(viewportWidth:Number = 640, viewportHeight:Number = 480, autoScaleToStage:Boolean = false, interactive:Boolean = false, autoClipping:Boolean = true, autoCulling:Boolean = true)
        {
            super();
            this.interactive = interactive;
            init();
            
            this.viewportWidth = viewportWidth;
            this.viewportHeight = viewportHeight;
            
            this.autoClipping = autoClipping;
            this.autoCulling = autoCulling;
            
            this.autoScaleToStage = autoScaleToStage;
        }
        
        protected function init():void
        {
            lastRenderList = new Array();
            sizeRectangle = new Rectangle();
            cullingRectangle = new Rectangle();
            
            _containerSprite = new ViewportBaseLayer(this);
            
            addChild(_containerSprite);
            
            // ISM must be created AFTER adding containerSprite to the stage
            if( interactive ) interactiveSceneManager = new InteractiveSceneManager(this);
            
            addEventListener(Event.ADDED_TO_STAGE, onAddedToStage);
            addEventListener(Event.REMOVED_FROM_STAGE, onRemovedFromStage);
        }
                
        public function hitTestMouse():RenderHitData
        {
            var p:Point = new Point(containerSprite.mouseX, containerSprite.mouseY);
            return hitTestPoint2D(p);
        }
        
        public function hitTestPoint2D(point:Point):RenderHitData
        {
            if(interactive){
                var rli:RenderableListItem;
                var rhd:RenderHitData = new RenderHitData();
                var rc:IRenderListItem;
                for(var i:uint = lastRenderList.length; rc = lastRenderList[--i]; )
                {
                    if(rc is RenderableListItem)
                    {
                        rli = rc as RenderableListItem;
                        rhd = rli.hitTestPoint2D(point, rhd);
                        
                        if(rhd.hasHit)
                        {                
                            return rhd;
                        }
                    }
                }
            }
            
            return new RenderHitData();
        }
        
        protected function onAddedToStage(event:Event):void
        {
            stage.addEventListener(Event.RESIZE, onStageResize);
            onStageResize();
        }
        
        protected function onRemovedFromStage(event:Event):void
        {
            stage.removeEventListener(Event.RESIZE, onStageResize);
        }
        
        protected function onStageResize(event:Event = null):void
        {
            if(_autoScaleToStage)
            {
                viewportWidth = stage.stageWidth;
                viewportHeight = stage.stageHeight;
            }
        }
        
        protected function handleRenderDone(e:RendererEvent):void
        {
            interactiveSceneManager.updateRenderHitData();
        }
        
        public function set lastRenderer(value:BasicRenderEngine):void
        {
            if( !interactive ) return;
            value.removeEventListener(RendererEvent.RENDER_DONE, handleRenderDone);
            value.addEventListener(RendererEvent.RENDER_DONE, handleRenderDone);
        }
        
        public function set viewportWidth(width:Number):void
        {
            _width = width;
            _hWidth = width/2;
            containerSprite.x = _hWidth;
            
            
            sizeRectangle.width = width;
            
            cullingRectangle.x = -_hWidth;
            cullingRectangle.width = width;
            
            scrollRect = sizeRectangle;
        }
        
        public function get viewportWidth():Number
        {
            return _width;
        }
        
        public function set viewportHeight(height:Number):void
        {
            _height = height;
            _hHeight = height/2;
            containerSprite.y = _hHeight;
            
            sizeRectangle.height = height;
            
            cullingRectangle.y = -_hHeight;
            cullingRectangle.height = height;
            
            scrollRect = sizeRectangle;
        }
        
        public function get viewportHeight():Number
        {
            return _height;
        }
        
        public function get containerSprite():ViewportLayer
        {
            return _containerSprite;    
        }
        
        public function set autoClipping(clip:Boolean):void
        {
            if(clip){
                scrollRect = sizeRectangle;
            }else{
                scrollRect = null;
            }
            _autoClipping = clip;
        }
        
        public function get autoClipping():Boolean
        {
            return _autoClipping;    
        }
        
        public function set autoCulling(culling:Boolean):void
        {
            if(culling){
                triangleCuller = new RectangleTriangleCuller(cullingRectangle);
                particleCuller = new RectangleParticleCuller(cullingRectangle);
            }else if(!culling){
                triangleCuller = new DefaultTriangleCuller();
                particleCuller = new DefaultParticleCuller();
            }
            _autoCulling = culling;    
        }
        
        public function get autoCulling():Boolean
        {
            return _autoCulling;
        }
        
        public function set autoScaleToStage(scale:Boolean):void
        {
            _autoScaleToStage = scale;
            if(scale && stage != null){
                onStageResize();
            }
        }
        
        public function get autoScaleToStage():Boolean
        {
            return _autoScaleToStage;
        }
        
        public function set interactive(b:Boolean):void
        {
            _interactive = b;
        }
        
        public function get interactive():Boolean
        {
            return _interactive;
        }
        
        public function updateBeforeRender():void
        {
            lastRenderList.length = 0;
            use namespace pv3dview;
            _containerSprite.clear();
        }
        
        public function updateAfterRender():void
        {
            
        }
        
        public function set viewportObjectFilter(vof:ViewportObjectFilter):void
        {
            _viewportObjectFilter = vof;
        }
        
        public function get viewportObjectFilter():ViewportObjectFilter
        {
            return _viewportObjectFilter;
        }
    
    }
}

Summary

Constructor

Viewport3D (viewportWidth:Number = 640, viewportHeight:Number = 480, autoScaleToStage:Boolean = false, interactive:Boolean = false, autoClipping:Boolean = true, autoCulling:Boolean = true)

Instance properties

sizeRectangle : Rectangle
cullingRectangle : Rectangle
triangleCuller : ITriangleCuller
particleCuller : IParticleCuller
lastRenderList : Array
interactiveSceneManager : InteractiveSceneManager
lastRenderer (value:BasicRenderEngine
viewportWidth (width:Number) : Number
viewportHeight (height:Number) : Number
containerSprite : ViewportLayer
autoClipping (clip:Boolean) : Boolean
autoCulling (culling:Boolean) : Boolean
autoScaleToStage (scale:Boolean) : Boolean
interactive (b:Boolean) : Boolean
viewportObjectFilter (vof:ViewportObjectFilter) : ViewportObjectFilter

Instance methods

hitTestMouse : RenderHitData
hitTestPoint2D (point:Point) : RenderHitData
updateBeforeRender : void
updateAfterRender : void

Constructor

Viewport3D

public function Viewport3D (

viewportWidth:Number = 640, viewportHeight:Number = 480, autoScaleToStage:Boolean = false, interactive:Boolean = false, autoClipping:Boolean = true, autoCulling:Boolean = true)

Instance properties

autoClipping

public autoClipping:Boolean

(read,write)

autoCulling

public autoCulling:Boolean

(read,write)

autoScaleToStage

public autoScaleToStage:Boolean

(read,write)

containerSprite

public containerSprite:ViewportLayer

(read)

cullingRectangle

public cullingRectangle:Rectangle

(read,write)

interactive

public interactive:Boolean

(read,write)

interactiveSceneManager

public interactiveSceneManager:InteractiveSceneManager

(read,write)

lastRenderer

public lastRenderer:BasicRenderEngine

(write)

lastRenderList

public lastRenderList:Array

(read,write)

particleCuller

public particleCuller:IParticleCuller

(read,write)

sizeRectangle

public sizeRectangle:Rectangle

(read,write)

triangleCuller

public triangleCuller:ITriangleCuller

(read,write)

viewportHeight

public viewportHeight:Number

(read,write)

viewportObjectFilter

public viewportObjectFilter:ViewportObjectFilter

(read,write)

viewportWidth

public viewportWidth:Number

(read,write)

Instance methods

hitTestMouse

public function hitTestMouse (

) : RenderHitData

hitTestPoint2D

public function hitTestPoint2D (

point:Point) : RenderHitData

updateAfterRender

public function updateAfterRender (

) : void

Specified by:

IViewport3D.updateAfterRender

updateBeforeRender

public function updateBeforeRender (

) : void

Specified by:

IViewport3D.updateBeforeRender