| A B C D E F G H I J K L M N O P Q R S T U V W X Y Z |
| pan — Property, interface away3d.materials.utils.IVideoPlayer |
|
Panning
|
| pan — Property, class away3d.materials.utils.SimpleVideoPlayer |
| |
| panAngle — Property, class away3d.controllers.FirstPersonController |
|
Rotation of the camera in degrees around the y axis. |
| panAngle — Property, class away3d.controllers.HoverController |
|
Rotation of the camera in degrees around the y axis. |
| _parent — Property, class away3d.containers.ObjectContainer3D |
| |
| parent — Property, class away3d.containers.ObjectContainer3D |
|
The parent ObjectContainer3D to which this object's transformation is relative. |
| _parent — Property, class away3d.core.partition.NodeBase |
| |
| parent — Property, class away3d.core.partition.NodeBase |
|
The parent node. |
| parentGeometry — Property, interface away3d.core.base.ISubGeometry |
| |
| parentGeometry — Property, class away3d.core.base.SubGeometryBase |
| |
| parentIndex — Property, class away3d.animators.data.SkeletonJoint |
|
The index of the parent joint in the skeleton's joints vector. |
| _parentIsStage — Property, class away3d.containers.View3D |
| |
| parentMesh — Property, class away3d.core.base.SubMesh |
| |
| parentParser — Property, class away3d.loaders.misc.ResourceDependency |
|
The parser which is dependent on this ResourceDependency object. |
| parseAsync(data:any, frameLimit:Number) — method, class away3d.loaders.parsers.ParserBase |
|
Parse data (possibly containing bytearry, plain text or BitmapAsset) asynchronously, meaning that
the parser will periodically stop parsing so that the AVM may proceed to the
next frame. |
| parseComplete — Event, class away3d.loaders.parsers.ParserBase |
|
Dispatched when the parsing finishes. |
| PARSE_COMPLETE — Constant Static Property, class away3d.events.ParserEvent |
|
Dispatched when parsing of an asset completed. |
| parseData(data:any, parser:away3d.loaders.parsers:ParserBase, req:flash.net:URLRequest) — method, class away3d.loaders.misc.SingleFileLoader |
|
Loads a resource from already loaded data. |
| PARSE_DEFAULT — Constant Static Property, class away3d.loaders.parsers.DAEParser |
| |
| parseError — Event, class away3d.loaders.parsers.ParserBase |
|
Dispatched if an error was caught during parsing. |
| PARSE_ERROR — Constant Static Property, class away3d.events.ParserEvent |
|
Dispatched when an error occurs while parsing the data (e.g. |
| PARSE_GEOMETRIES — Constant Static Property, class away3d.loaders.parsers.DAEParser |
| |
| PARSE_IMAGES — Constant Static Property, class away3d.loaders.parsers.DAEParser |
| |
| PARSE_MATERIALS — Constant Static Property, class away3d.loaders.parsers.DAEParser |
| |
| parser — Property, class away3d.loaders.misc.SingleFileLoader |
|
A reference to the parser that will translate the loaded data into a usable resource. |
| ParserBase — class, package away3d.loaders.parsers |
|
ParserBase provides an abstract base class for objects that convert blocks of data to data structures
supported by Away3D. |
| ParserBase(format:String) — Constructor, class away3d.loaders.parsers.ParserBase |
|
Creates a new ParserBase object
|
| ParserDataFormat — class, package away3d.loaders.parsers |
|
An enumeration providing values to describe the data format of parsed data. |
| ParserEvent — class, package away3d.events |
| |
| ParserEvent(type:String, message:String) — Constructor, class away3d.events.ParserEvent |
| |
| Parsers — class, package away3d.loaders.parsers |
| |
| ParserUtil — class, package away3d.loaders.parsers.utils |
| |
| PARSE_VISUAL_SCENES — Constant Static Property, class away3d.loaders.parsers.DAEParser |
| |
| parsingComplete — Property, class away3d.loaders.parsers.AWDParser |
| |
| parsingComplete — Property, class away3d.loaders.parsers.ParserBase |
| |
| PARSING_DONE — Constant Static Property, class away3d.loaders.parsers.ParserBase |
|
Returned by proceedParsing to indicate no more parsing is needed. |
| parsingFailure — Property, class away3d.loaders.parsers.ParserBase |
| |
| parsingPaused — Property, class away3d.loaders.parsers.AWDParser |
| |
| parsingPaused — Property, class away3d.loaders.parsers.ParserBase |
| |
| ParticleAccelerationNode — class, package away3d.animators.nodes |
|
A particle animation node used to apply a constant acceleration vector to the motion of a particle. |
| ParticleAccelerationNode(mode:uint, acceleration:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticleAccelerationNode |
|
Creates a new ParticleAccelerationNode
|
| ParticleAccelerationState — class, package away3d.animators.states |
|
... |
| ParticleAccelerationState(animator:away3d.animators:ParticleAnimator, particleAccelerationNode:away3d.animators.nodes:ParticleAccelerationNode) — Constructor, class away3d.animators.states.ParticleAccelerationState |
| |
| ParticleAnimationData — class, package away3d.animators.data |
|
... |
| ParticleAnimationData(index:uint, startTime:Number, duration:Number, delay:Number, particle:away3d.core.base.data:ParticleData) — Constructor, class away3d.animators.data.ParticleAnimationData |
| |
| ParticleAnimationSet — class, package away3d.animators |
|
The animation data set used by particle-based animators, containing particle animation data. |
| ParticleAnimationSet(usesDuration:Boolean, usesLooping:Boolean, usesDelay:Boolean) — Constructor, class away3d.animators.ParticleAnimationSet |
|
Creates a new ParticleAnimationSet
|
| ParticleAnimator — class, package away3d.animators |
|
Provides an interface for assigning paricle-based animation data sets to mesh-based entity objects
and controlling the various available states of animation through an interative playhead that can be
automatically updated or manually triggered. |
| ParticleAnimator(particleAnimationSet:away3d.animators:ParticleAnimationSet) — Constructor, class away3d.animators.ParticleAnimator |
|
Creates a new ParticleAnimator object. |
| ParticleBezierCurveNode — class, package away3d.animators.nodes |
|
A particle animation node used to control the position of a particle over time along a bezier curve. |
| ParticleBezierCurveNode(mode:uint, controlPoint:flash.geom:Vector3D, endPoint:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticleBezierCurveNode |
|
Creates a new ParticleBezierCurveNode
|
| ParticleBezierCurveState — class, package away3d.animators.states |
|
... |
| ParticleBezierCurveState(animator:away3d.animators:ParticleAnimator, particleBezierCurveNode:away3d.animators.nodes:ParticleBezierCurveNode) — Constructor, class away3d.animators.states.ParticleBezierCurveState |
| |
| ParticleBillboardNode — class, package away3d.animators.nodes |
|
A particle animation node that controls the rotation of a particle to always face the camera. |
| ParticleBillboardNode(billboardAxis:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticleBillboardNode |
|
Creates a new ParticleBillboardNode
|
| ParticleBillboardState — class, package away3d.animators.states |
|
... |
| ParticleBillboardState(animator:away3d.animators:ParticleAnimator, particleNode:away3d.animators.nodes:ParticleBillboardNode) — Constructor, class away3d.animators.states.ParticleBillboardState |
| |
| ParticleColorNode — class, package away3d.animators.nodes |
|
A particle animation node used to control the color variation of a particle over time. |
| ParticleColorNode(mode:uint, usesMultiplier:Boolean, usesOffset:Boolean, usesCycle:Boolean, usesPhase:Boolean, startColor:flash.geom:ColorTransform, endColor:flash.geom:ColorTransform, cycleDuration:Number, cyclePhase:Number) — Constructor, class away3d.animators.nodes.ParticleColorNode |
|
Creates a new ParticleColorNode
|
| ParticleColorState — class, package away3d.animators.states |
|
... |
| ParticleColorState(animator:away3d.animators:ParticleAnimator, particleColorNode:away3d.animators.nodes:ParticleColorNode) — Constructor, class away3d.animators.states.ParticleColorState |
| |
| ParticleData — class, package away3d.core.base.data |
| |
| ParticleData() — Constructor, class away3d.core.base.data.ParticleData |
| |
| ParticleFollowNode — class, package away3d.animators.nodes |
|
A particle animation node used to create a follow behaviour on a particle system. |
| ParticleFollowNode(usesPosition:Boolean, usesRotation:Boolean, smooth:Boolean) — Constructor, class away3d.animators.nodes.ParticleFollowNode |
|
Creates a new ParticleFollowNode
|
| ParticleFollowState — class, package away3d.animators.states |
|
... |
| ParticleFollowState(animator:away3d.animators:ParticleAnimator, particleFollowNode:away3d.animators.nodes:ParticleFollowNode) — Constructor, class away3d.animators.states.ParticleFollowState |
| |
| ParticleGeometry — class, package away3d.core.base |
|
... |
| ParticleGeometry() — Constructor, class away3d.core.base.ParticleGeometry |
| |
| ParticleGeometryHelper — class, package away3d.tools.helpers |
|
... |
| ParticleGeometryTransform — class, package away3d.tools.helpers.data |
|
... |
| ParticleGeometryTransform() — Constructor, class away3d.tools.helpers.data.ParticleGeometryTransform |
| |
| particleIndex — Property, class away3d.core.base.data.ParticleData |
| |
| ParticleInitialColorNode — class, package away3d.animators.nodes |
| |
| ParticleInitialColorNode(mode:uint, usesMultiplier:Boolean, usesOffset:Boolean, initialColor:flash.geom:ColorTransform) — Constructor, class away3d.animators.nodes.ParticleInitialColorNode |
| |
| ParticleInitialColorState — class, package away3d.animators.states |
| |
| ParticleInitialColorState(animator:away3d.animators:ParticleAnimator, particleInitialColorNode:away3d.animators.nodes:ParticleInitialColorNode) — Constructor, class away3d.animators.states.ParticleInitialColorState |
| |
| ParticleNodeBase — class, package away3d.animators.nodes |
|
Provides an abstract base class for particle animation nodes. |
| ParticleNodeBase(name:String, mode:uint, dataLength:uint, priority:int) — Constructor, class away3d.animators.nodes.ParticleNodeBase |
|
Creates a new ParticleNodeBase object. |
| particleNodes — Property, class away3d.animators.ParticleAnimationSet |
|
Returns a vector of the particle animation nodes contained within the set. |
| ParticleOrbitNode — class, package away3d.animators.nodes |
|
A particle animation node used to control the position of a particle over time around a circular orbit. |
| ParticleOrbitNode(mode:uint, usesEulers:Boolean, usesCycle:Boolean, usesPhase:Boolean, radius:Number, cycleDuration:Number, cyclePhase:Number, eulers:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticleOrbitNode |
|
Creates a new ParticleOrbitNode object. |
| ParticleOrbitState — class, package away3d.animators.states |
|
... |
| ParticleOrbitState(animator:away3d.animators:ParticleAnimator, particleOrbitNode:away3d.animators.nodes:ParticleOrbitNode) — Constructor, class away3d.animators.states.ParticleOrbitState |
| |
| ParticleOscillatorNode — class, package away3d.animators.nodes |
|
A particle animation node used to control the position of a particle over time using simple harmonic motion. |
| ParticleOscillatorNode(mode:uint, oscillator:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticleOscillatorNode |
|
Creates a new ParticleOscillatorNode
|
| ParticleOscillatorState — class, package away3d.animators.states |
|
... |
| ParticleOscillatorState(animator:away3d.animators:ParticleAnimator, particleOscillatorNode:away3d.animators.nodes:ParticleOscillatorNode) — Constructor, class away3d.animators.states.ParticleOscillatorState |
| |
| ParticlePositionNode — class, package away3d.animators.nodes |
|
A particle animation node used to set the starting position of a particle. |
| ParticlePositionNode(mode:uint, position:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticlePositionNode |
|
Creates a new ParticlePositionNode
|
| ParticlePositionState — class, package away3d.animators.states |
|
... |
| ParticlePositionState(animator:away3d.animators:ParticleAnimator, particlePositionNode:away3d.animators.nodes:ParticlePositionNode) — Constructor, class away3d.animators.states.ParticlePositionState |
| |
| ParticleProperties — Dynamic Class, package away3d.animators.data |
|
Dynamic class for holding the local properties of a particle, used for processing the static properties
of particles in the particle animation set before beginning upload to the GPU. |
| ParticleProperties() — Constructor, class away3d.animators.data.ParticleProperties |
| |
| ParticlePropertiesMode — class, package away3d.animators.data |
|
Options for setting the properties mode of a particle animation node. |
| ParticleRotateToHeadingNode — class, package away3d.animators.nodes |
|
A particle animation node used to control the rotation of a particle to match its heading vector. |
| ParticleRotateToHeadingNode() — Constructor, class away3d.animators.nodes.ParticleRotateToHeadingNode |
|
Creates a new ParticleBillboardNode
|
| ParticleRotateToHeadingState — class, package away3d.animators.states |
|
... |
| ParticleRotateToHeadingState(animator:away3d.animators:ParticleAnimator, particleNode:away3d.animators.nodes:ParticleNodeBase) — Constructor, class away3d.animators.states.ParticleRotateToHeadingState |
| |
| ParticleRotationalVelocityNode — class, package away3d.animators.nodes |
|
A particle animation node used to set the starting rotational velocity of a particle. |
| ParticleRotationalVelocityNode(mode:uint, rotationalVelocity:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticleRotationalVelocityNode |
|
Creates a new ParticleRotationalVelocityNode
|
| ParticleRotationalVelocityState — class, package away3d.animators.states |
|
... |
| ParticleRotationalVelocityState(animator:away3d.animators:ParticleAnimator, particleRotationNode:away3d.animators.nodes:ParticleRotationalVelocityNode) — Constructor, class away3d.animators.states.ParticleRotationalVelocityState |
| |
| particles — Property, class away3d.core.base.ParticleGeometry |
| |
| ParticleScaleNode — class, package away3d.animators.nodes |
|
A particle animation node used to control the scale variation of a particle over time. |
| ParticleScaleNode(mode:uint, usesCycle:Boolean, usesPhase:Boolean, minScale:Number, maxScale:Number, cycleDuration:Number, cyclePhase:Number) — Constructor, class away3d.animators.nodes.ParticleScaleNode |
|
Creates a new ParticleScaleNode
|
| ParticleScaleState — class, package away3d.animators.states |
|
... |
| ParticleScaleState(animator:away3d.animators:ParticleAnimator, particleScaleNode:away3d.animators.nodes:ParticleScaleNode) — Constructor, class away3d.animators.states.ParticleScaleState |
| |
| ParticleSegmentedColorNode — class, package away3d.animators.nodes |
| |
| ParticleSegmentedColorNode(usesMultiplier:Boolean, usesOffset:Boolean, numSegmentPoint:int, startColor:flash.geom:ColorTransform, endColor:flash.geom:ColorTransform, segmentPoints:Vector$away3d.animators.data:ColorSegmentPoint) — Constructor, class away3d.animators.nodes.ParticleSegmentedColorNode |
| |
| ParticleSegmentedColorState — class, package away3d.animators.states |
| |
| ParticleSegmentedColorState(animator:away3d.animators:ParticleAnimator, particleSegmentedColorNode:away3d.animators.nodes:ParticleSegmentedColorNode) — Constructor, class away3d.animators.states.ParticleSegmentedColorState |
| |
| ParticleSpriteSheetNode — class, package away3d.animators.nodes |
|
A particle animation node used when a spritesheet texture is required to animate the particle. |
| ParticleSpriteSheetNode(mode:uint, usesCycle:Boolean, usesPhase:Boolean, numColumns:int, numRows:uint, cycleDuration:Number, cyclePhase:Number, totalFrames:uint) — Constructor, class away3d.animators.nodes.ParticleSpriteSheetNode |
|
Creates a new ParticleSpriteSheetNode
|
| ParticleSpriteSheetState — class, package away3d.animators.states |
|
... |
| ParticleSpriteSheetState(animator:away3d.animators:ParticleAnimator, particleSpriteSheetNode:away3d.animators.nodes:ParticleSpriteSheetNode) — Constructor, class away3d.animators.states.ParticleSpriteSheetState |
| |
| ParticleStateBase — class, package away3d.animators.states |
|
... |
| ParticleStateBase(animator:away3d.animators:ParticleAnimator, particleNode:away3d.animators.nodes:ParticleNodeBase, needUpdateTime:Boolean) — Constructor, class away3d.animators.states.ParticleStateBase |
| |
| ParticleTimeNode — class, package away3d.animators.nodes |
|
A particle animation node used as the base node for timekeeping inside a particle. |
| ParticleTimeNode(usesDuration:Boolean, usesLooping:Boolean, usesDelay:Boolean) — Constructor, class away3d.animators.nodes.ParticleTimeNode |
|
Creates a new ParticleTimeNode
|
| ParticleTimeState — class, package away3d.animators.states |
|
... |
| ParticleTimeState(animator:away3d.animators:ParticleAnimator, particleTimeNode:away3d.animators.nodes:ParticleTimeNode) — Constructor, class away3d.animators.states.ParticleTimeState |
| |
| ParticleUVNode — class, package away3d.animators.nodes |
|
A particle animation node used to control the UV offset and scale of a particle over time. |
| ParticleUVNode(mode:uint, cycle:Number, scale:Number, axis:String) — Constructor, class away3d.animators.nodes.ParticleUVNode |
|
Creates a new ParticleTimeNode
|
| ParticleUVState — class, package away3d.animators.states |
|
... |
| ParticleUVState(animator:away3d.animators:ParticleAnimator, particleUVNode:away3d.animators.nodes:ParticleUVNode) — Constructor, class away3d.animators.states.ParticleUVState |
| |
| ParticleVelocityNode — class, package away3d.animators.nodes |
|
A particle animation node used to set the starting velocity of a particle. |
| ParticleVelocityNode(mode:uint, velocity:flash.geom:Vector3D) — Constructor, class away3d.animators.nodes.ParticleVelocityNode |
|
Creates a new ParticleVelocityNode
|
| ParticleVelocityState — class, package away3d.animators.states |
|
... |
| ParticleVelocityState(animator:away3d.animators:ParticleAnimator, particleVelocityNode:away3d.animators.nodes:ParticleVelocityNode) — Constructor, class away3d.animators.states.ParticleVelocityState |
| |
| partition — Property, class away3d.containers.ObjectContainer3D |
|
The space partition to be used by the object container and all its recursive children, unless it has its own
space partition assigned. |
| partition — Property, class away3d.containers.Scene3D |
|
The root partition to be used by the Scene3D. |
| Partition3D — class, package away3d.core.partition |
|
Partition3D is the core of a space partition system. |
| Partition3D(rootNode:away3d.core.partition:NodeBase) — Constructor, class away3d.core.partition.Partition3D |
|
Creates a new Partition3D object. |
| PARTITION_CHANGED — Constant Static Property, class away3d.events.Scene3DEvent |
| |
| PartitionTraverser — class, package away3d.core.traverse |
|
IPartitionTraverser is a hierarchical visitor pattern that traverses through a Partition3D data structure. |
| PartitionTraverser() — Constructor, class away3d.core.traverse.PartitionTraverser |
| |
| _passes — Property, class away3d.materials.MaterialBase |
| |
| passes — Property, class away3d.materials.methods.CompositeSpecularMethod |
|
Any passes required that render to a texture used by this method. |
| _passes — Property, class away3d.materials.methods.ShadingMethodBase |
| |
| passes — Property, class away3d.materials.methods.ShadingMethodBase |
|
Any passes required that render to a texture used by this method. |
| _passes — Property, class away3d.materials.passes.CompiledPass |
| |
| _passesDirty — Property, class away3d.materials.passes.CompiledPass |
| |
| passRendersToTexture(index:uint) — method, class away3d.materials.MaterialBase |
| |
| path — Property, class away3d.animators.PathAnimator |
|
defines the path to follow
|
| path — Property, class away3d.extrusions.PathDuplicator |
|
Sets and defines the Path object. |
| path — Property, class away3d.extrusions.PathExtrude |
|
Defines the Path object representing path to extrude along. |
| PathAnimator — class, package away3d.animators |
| |
| PathAnimator(path:away3d.paths:IPath, target:away3d.core.base:Object3D, offset:flash.geom:Vector3D, alignToPath:Boolean, lookAtTarget:away3d.core.base:Object3D, rotations:Vector$flash.geom:Vector3D) — Constructor, class away3d.animators.PathAnimator |
|
Creates a new PathAnimator
|
| PathDuplicator — class, package away3d.extrusions |
| |
| PathDuplicator(path:away3d.paths:IPath, meshes:Vector$away3d.entities:Mesh, scene:away3d.containers:Scene3D, repeat:uint, alignToPath:Boolean, segmentSpread:Boolean, container:away3d.containers:ObjectContainer3D, randomRotationY:Boolean) — Constructor, class away3d.extrusions.PathDuplicator |
|
Creates a new PathDuplicator
Class replicates and distribute one or more mesh(es) along a path. |
| PathEvent — class, package away3d.events |
| |
| PathEvent(type:String) — Constructor, class away3d.events.PathEvent |
| |
| PathExtrude — class, package away3d.extrusions |
| |
| PathExtrude(material:away3d.materials:MaterialBase, path:away3d.paths:IPath, profile:Vector$flash.geom:Vector3D, subdivision:uint, coverAll:Boolean, coverSegment:Boolean, alignToPath:Boolean, centerMesh:Boolean, mapFit:Boolean, flip:Boolean, closePath:Boolean, materials:Vector$away3d.materials:MaterialBase, scales:Vector$flash.geom:Vector3D, smoothScale:Boolean, rotations:Vector$flash.geom:Vector3D, smoothSurface:Boolean, distribute:Boolean, distributeU:Boolean, keepExtremes:Boolean) — Constructor, class away3d.extrusions.PathExtrude |
|
Creates a new PathExtrude
|
| pause() — method, class away3d.audio.Sound3D |
|
Pause playback. |
| pause() — method, interface away3d.audio.drivers.ISound3DDriver |
|
Temporarily pause playback. |
| pause() — method, class away3d.audio.drivers.SimplePanVolumeDriver |
| |
| pause() — method, interface away3d.materials.utils.IVideoPlayer |
|
Temporarily pause playback. |
| pause() — method, class away3d.materials.utils.SimpleVideoPlayer |
| |
| pauseAndRetrieveDependencies() — method, class away3d.loaders.parsers.ParserBase |
| |
| paused — Property, class away3d.audio.Sound3D |
|
Returns a boolean indicating whether or not playback is currently
paused. |
| _paused — Property, class away3d.audio.drivers.AbstractSound3DDriver |
| |
| paused — Property, interface away3d.materials.utils.IVideoPlayer |
|
Indicates whether the video is paused
|
| paused — Property, class away3d.materials.utils.SimpleVideoPlayer |
| |
| PB_BEST_HIT — Constant Static Property, class away3d.core.pick.PickingColliderType |
|
PixelBender-based picking collider that returns the best (closest) hit on an Entity. |
| PB_FIRST_ENCOUNTERED — Constant Static Property, class away3d.core.pick.PickingColliderType |
|
PixelBender-based picking collider that returns the first encountered hit on an Entity. |
| PBPickingCollider — class, package away3d.core.pick |
|
PixelBender-based picking collider for entity objects. |
| PBPickingCollider(findClosestCollision:Boolean) — Constructor, class away3d.core.pick.PBPickingCollider |
|
Creates a new PBPickingCollider object. |
| PerspectiveLens — class, package away3d.cameras.lenses |
|
The PerspectiveLens object provides a projection matrix that projects 3D geometry with perspective distortion. |
| PerspectiveLens(fieldOfView:Number) — Constructor, class away3d.cameras.lenses.PerspectiveLens |
|
Creates a new PerspectiveLens object. |
| PerspectiveOffCenterLens — class, package away3d.cameras.lenses |
|
The PerspectiveLens object provides a projection matrix that projects 3D geometry with perspective distortion. |
| PerspectiveOffCenterLens(minAngleX:Number, maxAngleX:Number, minAngleY:Number, maxAngleY:Number) — Constructor, class away3d.cameras.lenses.PerspectiveOffCenterLens |
|
Creates a new PerspectiveLens object. |
| phase(value:Number) — method, class away3d.animators.AnimatorBase |
|
Sets the animation phase of the current active state's animation clip(s). |
| phase(value:Number) — method, class away3d.animators.states.AnimationClipState |
|
Sets the animation phase of the node. |
| phase(value:Number) — method, class away3d.animators.states.AnimationStateBase |
|
Sets the animation phase of the node. |
| phase(value:Number) — method, interface away3d.animators.states.IAnimationState |
|
Sets the animation phase of the node. |
| phase(value:Number) — method, class away3d.animators.states.SkeletonBinaryLERPState |
|
Sets the animation phase of the node. |
| phase(value:Number) — method, class away3d.animators.states.SkeletonDifferenceState |
|
Sets the animation phase of the node. |
| phase(value:Number) — method, class away3d.animators.states.SkeletonDirectionalState |
|
Sets the animation phase of the node. |
| phase(value:Number) — method, class away3d.animators.states.SkeletonNaryLERPState |
|
Sets the animation phase of the node. |
| PhongSpecularMethod — class, package away3d.materials.methods |
| |
| PhongSpecularMethod() — Constructor, class away3d.materials.methods.PhongSpecularMethod |
|
Creates a new PhongSpecularMethod object. |
| _pickingCollider — Property, class away3d.entities.Entity |
| |
| pickingCollider — Property, class away3d.entities.Entity |
|
Used by the raycast-based picking system to determine how the geometric contents of an entity are processed
in order to offer more details for the picking collision object, including local position, normal vector and uv value. |
| pickingCollider — Property, class away3d.entities.Sprite3D |
| |
| PickingColliderBase — class, package away3d.core.pick |
|
An abstract base class for all picking collider classes. |
| PickingColliderBase() — Constructor, class away3d.core.pick.PickingColliderBase |
| |
| PickingColliderType — class, package away3d.core.pick |
|
Options for setting a picking collider for entity objects. |
| _pickingCollisionVO — Property, class away3d.entities.Entity |
| |
| pickingCollisionVO — Property, class away3d.entities.Entity |
|
Returns a unique picking collision value object for the entity. |
| PickingCollisionVO — class, package away3d.core.pick |
|
Value object for a picking collision returned by a picking collider. |
| PickingCollisionVO(entity:away3d.entities:Entity) — Constructor, class away3d.core.pick.PickingCollisionVO |
|
Creates a new PickingCollisionVO object. |
| PickingType — class, package away3d.core.pick |
|
Options for the different 3D object picking approaches available in Away3D. |
| pitch(angle:Number) — method, class away3d.core.base.Object3D |
|
Rotates the 3d object around it's local x-axis
|
| _pivotPoint — Property, class away3d.core.base.Object3D |
| |
| pivotPoint — Property, class away3d.core.base.Object3D |
|
Defines the local point around which the object rotates. |
| _pivotZero — Property, class away3d.core.base.Object3D |
| |
| PLAIN_TEXT — Constant Static Property, class away3d.loaders.parsers.ParserDataFormat |
|
Describes the format of a plain text file. |
| PlanarReflectionMethod — class, package away3d.materials.methods |
|
PlanarReflectionMethod is a material method that adds reflections from a PlanarReflectionTexture object. |
| PlanarReflectionMethod(texture:away3d.textures:PlanarReflectionTexture, alpha:Number) — Constructor, class away3d.materials.methods.PlanarReflectionMethod |
|
Creates a new PlanarReflectionMethod
|
| PlanarReflectionTexture — class, package away3d.textures |
|
PlanarReflectionTexture is a Texture that can be used for material-based planar reflections, as provided by PlanarReflectionMethod, FresnelPlanarReflectionMethod. |
| PlanarReflectionTexture() — Constructor, class away3d.textures.PlanarReflectionTexture |
|
Creates a new PlanarReflectionTexture object. |
| plane — Property, class away3d.cameras.lenses.ObliqueNearPlaneLens |
| |
| plane — Property, class away3d.extrusions.DelaunayMesh |
|
Defines the projection plane for the class. |
| plane — Property, class away3d.textures.PlanarReflectionTexture |
|
The plane to reflect with. |
| plane — Property, class away3d.tools.utils.Drag3D |
|
Changes the plane the object will be considered on. |
| Plane3D — class, package away3d.core.math |
| |
| Plane3D(a:Number, b:Number, c:Number, d:Number) — Constructor, class away3d.core.math.Plane3D |
|
Create a Plane3D with ABCD coefficients
|
| PlaneClassification — class, package away3d.core.math |
| |
| PlaneGeometry — class, package away3d.primitives |
|
A Plane primitive mesh. |
| PlaneGeometry(width:Number, height:Number, segmentsW:uint, segmentsH:uint, yUp:Boolean, doubleSided:Boolean) — Constructor, class away3d.primitives.PlaneGeometry |
|
Creates a new Plane object. |
| planeNormal — Property, class away3d.tools.utils.Ray |
|
Defines the directional normal of the Ray object
|
| planeObject3d — Property, class away3d.tools.utils.Drag3D |
|
Defines planes as the position of a given ObjectContainer3D
|
| planePosition — Property, class away3d.tools.utils.Drag3D |
|
Defines planes position by a postion Vector3D
|
| PLANE_XY — Constant Static Property, class away3d.extrusions.DelaunayMesh |
| |
| PLANE_XY — Constant Static Property, class away3d.tools.utils.Drag3D |
| |
| PLANE_XZ — Constant Static Property, class away3d.extrusions.DelaunayMesh |
| |
| PLANE_XZ — Constant Static Property, class away3d.tools.utils.Drag3D |
| |
| PLANE_ZY — Constant Static Property, class away3d.extrusions.DelaunayMesh |
| |
| PLANE_ZY — Constant Static Property, class away3d.tools.utils.Drag3D |
| |
| play(name:String, transition:away3d.animators.transitions:IAnimationTransition, offset:Number) — method, class away3d.animators.SkeletonAnimator |
|
Plays an animation state registered with the given name in the animation data set. |
| play(name:String, transition:away3d.animators.transitions:IAnimationTransition, offset:Number) — method, class away3d.animators.SpriteSheetAnimator |
| |
| play(name:String, transition:away3d.animators.transitions:IAnimationTransition, offset:Number) — method, class away3d.animators.UVAnimator |
| |
| play(name:String, transition:away3d.animators.transitions:IAnimationTransition, offset:Number) — method, class away3d.animators.VertexAnimator |
|
Plays a sequence with a given name. |
| play() — method, class away3d.audio.Sound3D |
|
Start (or resume, if paused) playback. |
| play() — method, interface away3d.audio.drivers.ISound3DDriver |
|
Start playing (or resume if paused) the audio. |
| play() — method, class away3d.audio.drivers.SimplePanVolumeDriver |
| |
| play() — method, interface away3d.materials.utils.IVideoPlayer |
|
Start playing (or resume if paused) the video. |
| play() — method, class away3d.materials.utils.SimpleVideoPlayer |
| |
| PLAYBACK_COMPLETE — Constant Static Property, class away3d.events.AnimationStateEvent |
|
Dispatched when a non-looping clip node inside an animation state reaches the end of its timeline. |
| playbackSpeed — Property, class away3d.animators.AnimatorBase |
|
The amount by which passed time should be scaled. |
| player — Property, class away3d.textures.VideoTexture |
| |
| playing — Property, class away3d.audio.Sound3D |
|
Returns a boolean indicating whether or not the sound is currently
playing. |
| _playing — Property, class away3d.audio.drivers.AbstractSound3DDriver |
| |
| playing — Property, interface away3d.materials.utils.IVideoPlayer |
|
Indicates whether the video is playing
|
| playing — Property, class away3d.materials.utils.SimpleVideoPlayer |
| |
| plotAt(x:Number, y:Number, color:uint) — method, class away3d.tools.utils.ColorHitMap |
|
Another method for debug, if you addChild your bitmapdata on screen, this method will colour a pixel at the coordinates
helping you to visualize if your scale factors or entered coordinates are correct. |
| pointData — Property, class away3d.paths.SegmentedPathBase |
| |
| PointLight — class, package away3d.lights |
|
PointLight represents an omni-directional light. |
| PointLight() — Constructor, class away3d.lights.PointLight |
|
Creates a new PointLight object. |
| _pointLightFragmentConstants — Property, class away3d.materials.compilation.LightingShaderCompiler |
| |
| PointLightNode — class, package away3d.core.partition |
|
LightNode is a space partitioning leaf node that contains a LightBase object. |
| PointLightNode(light:away3d.lights:PointLight) — Constructor, class away3d.core.partition.PointLightNode |
|
Creates a new LightNode object. |
| _pointLightRegisters — Property, class away3d.materials.compilation.SuperShaderCompiler |
| |
| pointLights — Property, class away3d.core.traverse.EntityCollector |
| |
| _pointLights — Property, class away3d.materials.lightpickers.LightPickerBase |
| |
| pointLights — Property, class away3d.materials.lightpickers.LightPickerBase |
| |
| pointLightsOffset — Property, class away3d.materials.passes.LightingPass |
| |
| _pointLightVertexConstants — Property, class away3d.materials.compilation.LightingShaderCompiler |
| |
| PoissonLookup — class, package away3d.core.math |
| |
| _pos — Property, class away3d.core.base.Object3D |
| |
| position — Property, class away3d.animators.PathAnimator |
|
returns the current interpolated position on the path with no optional offset applied
|
| position — Property, class away3d.animators.states.ParticlePositionState |
|
Defines the position of the particle when in global mode. |
| position — Property, class away3d.core.base.Object3D |
|
Defines the position of the 3d object, relative to the local coordinates of the parent ObjectContainer3D. |
| position — Property, class away3d.textures.CubeReflectionTexture |
|
The origin where the environment map will be rendered. |
| positionAttribute — Property, class away3d.animators.data.AnimationRegisterCache |
| |
| positionChanged — Event, class away3d.core.base.Object3D |
|
Dispatched when the position of the 3d object changes. |
| POSITION_CHANGED — Constant Static Property, class away3d.events.Object3DEvent |
|
Defines the value of the type property of a positionChanged event object. |
| positionDelta — Property, class away3d.animators.states.AnimationStateBase |
|
Returns a 3d vector representing the translation delta of the animating entity for the current timestep of animation
|
| positionDelta — Property, interface away3d.animators.states.IAnimationState |
| |
| _positionDeltaDirty — Property, class away3d.animators.states.AnimationStateBase |
| |
| positionOffset — Property, class away3d.controllers.SpringController |
|
Offset of spring center from target in target object space, ie: Where the camera should ideally be in the target object space. |
| PositionRenderer — class, package away3d.core.render |
|
The PositionRenderer renders normalized position coordinates. |
| PositionRenderer(renderBlended:Boolean) — Constructor, class away3d.core.render.PositionRenderer |
|
Creates a PositionRenderer object. |
| positionTarget — Property, class away3d.animators.data.AnimationRegisterCache |
| |
| POSITION_VECTOR3D — Constant Static Property, class away3d.animators.nodes.ParticlePositionNode |
|
Reference for position node properties on a single particle (when in local property mode). |
| POSITIVE — Constant Static Property, class away3d.tools.commands.Align |
| |
| positiveX — Property, class away3d.textures.BitmapCubeTexture |
|
The texture on the cube's right face. |
| positiveY — Property, class away3d.textures.BitmapCubeTexture |
|
The texture on the cube's top face. |
| positiveZ — Property, class away3d.textures.BitmapCubeTexture |
|
The texture on the cube's far face. |
| POST_PRIORITY — Constant Static Property, class away3d.animators.ParticleAnimationSet |
|
Property used by particle nodes that require compilation at the end of the shader
|
| power — Property, class away3d.materials.methods.RimLightMethod |
| |
| preciseThickness — Property, class away3d.extrusions.LatheExtrude |
|
Defines if thickness is greater than 0 if the thickness is equally distributed along the volume. |
| present() — method, class away3d.core.managers.Stage3DProxy |
| |
| _preserveAlpha — Property, class away3d.materials.compilation.ShaderCompiler |
| |
| preserveAlpha — Property, class away3d.materials.compilation.ShaderCompiler |
| |
| _preserveAlpha — Property, class away3d.materials.passes.CompiledPass |
| |
| preserveAlpha — Property, class away3d.materials.passes.CompiledPass |
| |
| preventDefault() — method, class away3d.events.LoaderEvent |
| |
| previousTime — Property, class away3d.animators.data.AnimationSubGeometry |
| |
| PrimitiveBase — class, package away3d.primitives |
|
PrimitiveBase is an abstract base class for mesh primitives, which are prebuilt simple meshes. |
| PrimitiveBase() — Constructor, class away3d.primitives.PrimitiveBase |
|
Creates a new PrimitiveBase object. |
| priority — Property, class away3d.animators.nodes.ParticleNodeBase |
|
Returns the priority of the particle animation node, used to order the agal generated in a particle animation set. |
| PROBES — Constant Static Property, class away3d.materials.LightSources |
|
Defines that global lighting probes are to be used as the source for the
lighting component. |
| _probeWeightsIndex — Property, class away3d.materials.compilation.ShaderCompiler |
| |
| probeWeightsIndex — Property, class away3d.materials.compilation.ShaderCompiler |
| |
| _probeWeightsIndex — Property, class away3d.materials.passes.CompiledPass |
| |
| proceedParsing() — method, class away3d.loaders.parsers.AC3DParser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.AWD1Parser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.AWD2Parser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.AWDParser |
|
Find the right conrete parser (AWD1Parser or AWD2Parser) and delegate actual
parsing to it. |
| proceedParsing() — method, class away3d.loaders.parsers.DAEParser |
| |
| proceedParsing() — method, class away3d.loaders.parsers.DXFParser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.ImageParser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.MD2Parser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.MD5AnimParser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.MD5MeshParser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.Max3DSParser |
| |
| proceedParsing() — method, class away3d.loaders.parsers.OBJParser |
|
Parse the next block of data. |
| proceedParsing() — method, class away3d.loaders.parsers.ParserBase |
|
Parse the next block of data. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleBillboardNode |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleColorNode |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleInitialColorNode |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleNodeBase |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleRotateToHeadingNode |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleSegmentedColorNode |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleSpriteSheetNode |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| processAnimationSetting(particleAnimationSet:away3d.animators:ParticleAnimationSet) — method, class away3d.animators.nodes.ParticleUVNode |
|
Called internally by the particle animation set when determining the requirements of the particle animation node AGAL. |
| profile — Property, class away3d.core.managers.Stage3DProxy |
| |
| profile — Property, class away3d.extrusions.LatheExtrude |
| |
| profile — Property, class away3d.extrusions.PathExtrude |
|
Defines a Vector.<Vector3D> of Vector3D objects representing the profile information to be projected along the Path object. |
| _profile — Property, class away3d.materials.compilation.ShaderCompiler |
| |
| profiles — Property, class away3d.extrusions.SkinExtrude |
|
Defines if the texture(s) should be stretched to cover the entire mesh or per step between segments. |
| _program3Dids — Property, class away3d.materials.passes.MaterialPassBase |
| |
| _program3Ds — Property, class away3d.materials.passes.MaterialPassBase |
| |
| progress — Property, class away3d.animators.PathAnimator |
|
Represents the progress of the animation playhead from the start (0) to the end (1) of the animation. |
| project(point3d:flash.geom:Vector3D) — method, class away3d.cameras.Camera3D |
|
Calculates the normalised position in screen space of the given scene position. |
| project(point3d:flash.geom:Vector3D) — method, class away3d.cameras.lenses.LensBase |
|
Calculates the normalised position in screen space of the given scene position relative to the camera. |
| project(point3d:flash.geom:Vector3D) — method, class away3d.containers.View3D |
|
Calculates the projected position in screen space of the given scene position. |
| project(orientation:String, obj:away3d.containers:ObjectContainer3D) — Static Method , class away3d.tools.utils.Projector |
|
Class remaps the uv data of a mesh
|
| projectionDependencies — Property, class away3d.materials.compilation.MethodDependencyCounter |
| |
| projectionFragment — Property, class away3d.materials.compilation.ShaderRegisterData |
| |
| projectionHeight — Property, class away3d.cameras.lenses.OrthographicLens |
|
The vertical field of view of the projection. |
| ProjectiveTextureMethod — class, package away3d.materials.methods |
|
ProjectiveTextureMethod is a material method used to project a texture unto the surface of an object. |
| ProjectiveTextureMethod(projector:away3d.entities:TextureProjector, mode:String) — Constructor, class away3d.materials.methods.ProjectiveTextureMethod |
|
Creates a new ProjectiveTextureMethod object. |
| projector — Property, class away3d.materials.methods.ProjectiveTextureMethod |
|
The TextureProjector object that defines the projection properties as well as the texture. |
| Projector — class, package away3d.tools.utils |
| |
|
| A B C D E F G H I J K L M N O P Q R S T U V W X Y Z |
