topical media & game development

talk show tell print

student-ar-org-papervision3d-core-geom-Vertices3D.ax

student-ar-org-papervision3d-core-geom-Vertices3D.ax [swf] [flash] flex


  package org.papervision3d.core.geom {
        import org.papervision3d.core.culling.IObjectCuller;
          import org.papervision3d.core.geom.renderables.Vertex3D;
          import org.papervision3d.core.math.Matrix3D;
          import org.papervision3d.core.math.Number3D;
          import org.papervision3d.core.proto.GeometryObject3D;
          import org.papervision3d.core.render.data.RenderSessionData;
          import org.papervision3d.objects.DisplayObject3D;        
          
* The @ax-student-ar-org-papervision3d-core-geom-Vertices3D class lets you create and manipulate groups of vertices. *

  
        public class @ax-student-ar-org-papervision3d-core-geom-Vertices3D extends DisplayObject3D
        {
                
* Creates a new @ax-student-ar-org-papervision3d-core-geom-Vertices3D object. * * * @param vertices An array of Vertex3D objects for the vertices of the mesh. * <p/>

  
                public function @ax-student-ar-org-papervision3d-core-geom-Vertices3D( vertices:Array, name:String=null )
                {
                        super( name, new GeometryObject3D() );
                        this.geometry.vertices = vertices || new Array();
                }

                
* Clones this object. * * @return The cloned DisplayObject3D.

   
                public override function clone():DisplayObject3D
                {
                        var object:DisplayObject3D = super.clone();
                        var verts:@ax-student-ar-org-papervision3d-core-geom-Vertices3D = new @ax-student-ar-org-papervision3d-core-geom-Vertices3D(null, object.name);
                        
                        verts.material = object.material;
                        if(object.materials)
                                verts.materials = object.materials.clone();
                                
                        if(this.geometry)
                                verts.geometry = this.geometry.clone(verts);
                                
                        verts.copyTransform(this.transform);
                        
                        return verts;
                }
                
                
* Projects three dimensional coordinates onto a two dimensional plane to simulate the relationship of the camera to subject. * * This is the first step in the process of representing three dimensional shapes two dimensionally. * * @param camera Camera.

  
                public override function project( parent :DisplayObject3D,  renderSessionData:RenderSessionData ):Number
                {
                        super.project( parent, renderSessionData );

                        if( this.culled )
                                return 0;
                                
                        if( renderSessionData.camera is IObjectCuller )
                                return projectFrustum(parent, renderSessionData);
                        
                        if(!this.geometry || !this.geometry.vertices)
                                return 0;
                                
                        return renderSessionData.camera.projectVertices(this.geometry.vertices, this, renderSessionData);
                }
                
                public function projectEmpty(parent:DisplayObject3D, renderSessionData:RenderSessionData):Number{
                        
                        return super.project( parent, renderSessionData );
                }

                
* * @param parent * @param camera * @param sorted * @return

  
                public function projectFrustum( parent :DisplayObject3D, renderSessionData:RenderSessionData ):Number 
                {
                        return 0;
                }
                
                
* Calculates 3D bounding box. * * @return {minX, maxX, minY, maxY, minZ, maxZ}

  
                public function boundingBox():Object
                {
                        var vertices :Array = this.geometry.vertices;
                        var bBox     :Object = new Object();

                        bBox.min  = new Number3D(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
                        bBox.max  = new Number3D(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
                        bBox.size = new Number3D();

                        for each(var v:Vertex3D in vertices)
                        {
                                bBox.min.x = Math.min( v.x, bBox.min.x );
                                bBox.min.y = Math.min( v.y, bBox.min.y );
                                bBox.min.z = Math.min( v.z, bBox.min.z );
                                
                                bBox.max.x = Math.max( v.x, bBox.max.x );
                                bBox.max.y = Math.max( v.y, bBox.max.y );
                                bBox.max.z = Math.max( v.z, bBox.max.z );
                        }

                        bBox.size.x = bBox.max.x - bBox.min.x;
                        bBox.size.y = bBox.max.y - bBox.min.y;
                        bBox.size.z = bBox.max.z - bBox.min.z;

                        return bBox;
                }

                public function transformVertices( transformation:Matrix3D ):void
                {
                        
                        geometry.transformVertices(transformation);

                }
        }}


(C) Æliens 04/09/2009

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.