#import <CC3Camera.h>

Inheritance diagram for CC3Camera:

Instance Methods
(CC3Vector)	- calculateLocationToShowAllOf:fromDirection:withPadding:

(CC3Vector)	- calculateLocationToShowAllOf:whileLookingAt:fromDirection:withPadding:

(CGPoint)	- cc2PointFromGLPoint:

(void)	- closeWithVisitor:

(CGPoint)	- glPointFromCC2Point:

(void)	- markProjectionDirty

(void)	- moveToShowAllOf:

(void)	- moveToShowAllOf:fromDirection:

(void)	- moveToShowAllOf:fromDirection:withPadding:

(void)	- moveToShowAllOf:whileLookingAt:

(void)	- moveToShowAllOf:whileLookingAt:fromDirection:

(void)	- moveToShowAllOf:whileLookingAt:fromDirection:withPadding:

(void)	- moveToShowAllOf:whileLookingAt:withPadding:

(void)	- moveToShowAllOf:withPadding:

(void)	- moveWithDuration:toShowAllOf:

(void)	- moveWithDuration:toShowAllOf:fromDirection:

(void)	- moveWithDuration:toShowAllOf:fromDirection:withPadding:

(void)	- moveWithDuration:toShowAllOf:whileLookingAt:fromDirection:

(void)	- moveWithDuration:toShowAllOf:whileLookingAt:fromDirection:withPadding:

(void)	- moveWithDuration:toShowAllOf:whileLookingAt:withPadding:

(void)	- moveWithDuration:toShowAllOf:withPadding:

(void)	- moveWithDuration:whileLookingAt:toShowAllOf:

(void)	- openWithVisitor:

(CC3Vector)	- projectLocation:

(CC3Vector)	- projectLocation:onNode:

(CC3Vector)	- projectNode:

(CC3Ray)	- unprojectPoint:

(CC3Vector4)	- unprojectPoint:ontoPlane:

Instance Methods inherited from CC3Node
(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(id)	- __deprecated

(void)	- __deprecated

(void)	- addAndLocalizeChild:

(void)	- addAnimation:asTrack:

(GLuint)	- addAnimationFrom:to:

(void)	- addAnimationFrom:to:asTrack:

(GLuint)	- addAnimationFrom:to:ofBaseTrack:

(void)	- addAnimationFrom:to:ofBaseTrack:asTrack:

(GLuint)	- addAnimationFromCAFFile:

(void)	- addAnimationFromCAFFile:asTrack:

(GLuint)	- addAnimationFromCAFFile:linkedToCSFFile:

(void)	- addAnimationFromCAFFile:linkedToCSFFile:asTrack:

(GLuint)	- addAnimationFromFrame:toFrame:

(void)	- addAnimationFromFrame:toFrame:asTrack:

(GLuint)	- addAnimationFromFrame:toFrame:ofBaseTrack:

(void)	- addAnimationFromFrame:toFrame:ofBaseTrack:asTrack:

(GLuint)	- addAnimationFromPODFile:

(void)	- addAnimationFromPODFile:asTrack:

(GLuint)	- addAnimationInResource:

(void)	- addAnimationInResource:asTrack:

(void)	- addAnimationState:

(void)	- addAxesDirectionMarkers

(void)	- addChild:

(void)	- addContentFromPODFile:

(void)	- addContentFromPODFile:withName:

(void)	- addContentFromPODResourceFile:

(void)	- addContentFromPODResourceFile:withName:

(void)	- addDirectionMarker

(void)	- addDirectionMarkerColored:inDirection:

(void)	- addShadowVolumes

(void)	- addShadowVolumesForLight:

(void)	- addTexture:

(void)	- addTransformListener:

(void)	- alignInvertedTextures

(void)	- alignTextures

(GLfloat)	- animationBlendingWeightOnTrack:

(CCTime)	- animationTimeOnTrack:

(NSString *)	- appendStructureDescriptionTo:withIndent:

(void)	- applyEffectNamed:inPFXResourceFile:

(void)	- applyEffectNamed:inPFXResourceNamed:

(void)	- applyLocalTransformsTo:

(CC3Node *)	- asBumpMapLightTrackingWrapper

(CC3Node *)	- asCameraTrackingWrapper

(CC3Node *)	- asOrientingWrapper

(CC3Node *)	- asTrackingWrapper

(void)	- bindRestPose

(CC3Box)	- boundingBoxRelativeTo:

(void)	- buildTransformMatrixWithVisitor:

(void)	- checkDrawingOrder

(void)	- cleanupActions

(CC3Node *)	- closestNodeIntersectedByGlobalRay:

(BOOL)	- containsAnimationOnTrack:

(id)	- copy

(id)	- copyWithName:

(void)	- createBoundingVolume

(void)	- createBoundingVolumes

(void)	- createGLBuffers

(void)	- createSkinnedBoundingVolumes

(CC3NodeBoundingVolume *)	- defaultBoundingVolume

(void)	- deleteBoundingVolumes

(void)	- deleteGLBuffers

(NSString *)	- describeAnimationStateForFrames:

(NSString *)	- describeAnimationStateForFrames:fromTime:toTime:

(NSString *)	- describeCurrentAnimationState

(void)	- disableAllAnimation

(void)	- disableAllAnimationOnTrack:

(void)	- disableAllLocationAnimation

(void)	- disableAllQuaternionAnimation

(void)	- disableAllScaleAnimation

(void)	- disableAnimation

(void)	- disableAnimationOnTrack:

(void)	- disableLocationAnimation

(void)	- disableQuaternionAnimation

(void)	- disableScaleAnimation

(BOOL)	- doesIntersectBoundingVolume:

(BOOL)	- doesIntersectFrustum:

(BOOL)	- doesIntersectGlobalRay:

(BOOL)	- doesIntersectNode:

(void)	- doNotBufferVertexBitangents

(void)	- doNotBufferVertexBoneIndices

(void)	- doNotBufferVertexBoneWeights

(void)	- doNotBufferVertexColors

(void)	- doNotBufferVertexContent

(void)	- doNotBufferVertexIndices

(void)	- doNotBufferVertexLocations

(void)	- doNotBufferVertexNormals

(void)	- doNotBufferVertexPointSizes

(void)	- doNotBufferVertexTangents

(void)	- doNotBufferVertexTextureCoordinates

(void)	- drawWithVisitor:

(void)	- enableAllAnimation

(void)	- enableAllAnimationOnTrack:

(void)	- enableAllLocationAnimation

(void)	- enableAllQuaternionAnimation

(void)	- enableAllScaleAnimation

(void)	- enableAnimation

(void)	- enableAnimationOnTrack:

(void)	- enableLocationAnimation

(void)	- enableQuaternionAnimation

(void)	- enableScaleAnimation

(void)	- ensureRigidSkeleton

(void)	- establishAnimationFrameAt:

(void)	- establishAnimationFrameAt:onTrack:

(NSArray *)	- flatten

(void)	- flattenInto:

(void)	- flipNormals

(void)	- flipTexturesHorizontally

(void)	- flipTexturesVertically

(void)	- freezeAllInanimatesOnTrack:

(void)	- freezeIfInanimateOnTrack:

(CCAction *)	- getActionByTag:

(CC3NodeAnimation *)	- getAnimationOnTrack:

(CC3NodeAnimationState *)	- getAnimationStateOnTrack:

(CC3MeshNode *)	- getMeshNodeNamed:

(CC3Node *)	- getNodeNamed:

(CC3Node *)	- getNodeTagged:

(CC3ShadowVolumeMeshNode *)	- getShadowVolumeForLight:

(CC3Vector)	- globalLocationOfGlobalRayIntesection:

(CC3Matrix *)	- globalRotationMatrix

(BOOL)	- hasShadowVolumes

(BOOL)	- hasShadowVolumesForLight:

(void)	- hide

(BOOL)	- isAnimationEnabledOnTrack:

(BOOL)	- isDescendantOf:

(BOOL)	- isShadowVisible

(void)	- linkToPODNodes:

(CC3Vector)	- locationOfGlobalRayIntesection:

(void)	- markAnimationDirty

(void)	- markBoundingVolumeDirty

(void)	- markTransformDirty

(PODStructPtr)	- nodePODStructAtIndex:fromPODResource:

(CC3NodePuncturingVisitor *)	- nodesIntersectedByGlobalRay:

(void)	- nodeWasDestroyed:

(void)	- nodeWasTransformed:

(NSInteger)	- numberOfRunningActions

(void)	- pauseAllActions

(void)	- prewarmForShadowVolumes

(void)	- reattachBonesFrom:

(void)	- releaseRedundantContent

(void)	- remove

(void)	- removeAllChildren

(void)	- removeAllDirectionMarkers

(void)	- removeAllTransformListeners

(void)	- removeAnimation:

(void)	- removeAnimationState:

(void)	- removeAnimationTrack:

(void)	- removeChild:

(void)	- removeShaders

(void)	- removeShadowVolumes

(void)	- removeShadowVolumesForLight:

(void)	- removeTransformListener:

(void)	- resumeAllActions

(void)	- retainVertexBitangents

(void)	- retainVertexBoneIndices

(void)	- retainVertexBoneWeights

(void)	- retainVertexColors

(void)	- retainVertexContent

(void)	- retainVertexIndices

(void)	- retainVertexLocations

(void)	- retainVertexNormals

(void)	- retainVertexPointSizes

(void)	- retainVertexTangents

(void)	- retainVertexTextureCoordinates

(void)	- rotateBy:

(void)	- rotateByAngle:aroundAxis:

(void)	- rotateByAngle:aroundAxis:atLocation:

(void)	- rotateByQuaternion:

(CCAction *)	- runAction:

(CCAction *)	- runAction:withTag:

(void)	- selectShaders

(void)	- setAnimationBlendingWeight:onTrack:

(void)	- setSkeletalBoundingVolume:

(void)	- show

(void)	- stopAction:

(void)	- stopActionByTag:

(void)	- stopAllActions

(void)	- touchDisableAll

(void)	- touchEnableAll

(void)	- trackTargetWithVisitor:

(void)	- transformAndDrawWithVisitor:

(void)	- translateBy:

(void)	- updateAfterTransform:

(void)	- updateBeforeTransform:

(void)	- wasAdded

(void)	- wasRemoved

Instance Methods inherited from CC3Identifiable
(id)	- copyAsClass:

(void)	- copyUserDataFrom:

(id)	- copyWithName:asClass:

(id)	- copyWithZone:withName:

(id)	- copyWithZone:withName:asClass:

(BOOL)	- deriveNameFrom:

(BOOL)	- deriveNameFrom:usingSuffix:

(NSString *)	- fullDescription

(id)	- init

(id)	- initAtIndex:fromPODResource:

(void)	- initUserData

(id)	- initWithName:

(id)	- initWithTag:

(id)	- initWithTag:withName:

(GLuint)	- nextTag

(void)	- populateFrom:

Properties
GLfloat nearClippingPlane	__deprecated

GLfloat farClippingPlane	__deprecated

CC3Matrix *modelviewMatrix	__deprecated

GLfloat	effectiveFieldOfView

GLfloat	farClippingDistance

GLfloat	fieldOfView

UIInterfaceOrientation	fieldOfViewAspectOrientation

CC3FieldOfViewOrientation	fieldOfViewOrientation

CC3Vector	forwardDirection

CC3Frustum *	frustum

BOOL	hasInfiniteDepthOfField

BOOL	isCamera

BOOL	isOpen

BOOL	isUsingParallelProjection

GLfloat	nearClippingDistance

CC3Matrix *	projectionMatrix

BOOL	shouldClipToViewport

CC3Matrix *	viewMatrix

CC3Viewport	viewport

Properties inherited from CC3Node
CC3Vector sceneUpDirection	__deprecated

CC3Vector worldUpDirection	__deprecated

GLfloat scaleTolerance	__deprecated

CC3TargettingConstraint axisRestriction	__deprecated

CC3Vector globalLightLocation	__deprecated

CC3Matrix *transformMatrix	__deprecated

CC3Matrix *transformMatrixInverted	__deprecated

CC3Node *dirtiestAncestor	__deprecated

CC3Matrix *parentGlobalTransformMatrix	__deprecated

CC3Matrix *parentTransformMatrix	__deprecated

CC3Scene *world	__deprecated

BOOL shouldCleanupActionsWhenRemoved	__deprecated

BOOL shouldCleanupWhenRemoved	__deprecated

CC3Camera *	activeCamera

ccColor4F	ambientColor

CC3NodeAnimation *	animation

CC3NodeAnimationState *	animationState

ccBlendFunc	blendFunc

CC3Box	boundingBox

CC3NodeBoundingVolume *	boundingVolume

GLfloat	boundingVolumePadding

GLfloat	cameraDistanceProduct

CC3Vector	centerOfGeometry

NSArray *	children

CCColorRef	color

BOOL	containsAnimation

GLfloat	decalOffsetFactor

GLfloat	decalOffsetUnits

GLenum	depthFunction

CC3NodeDescriptor *	descriptorNode

ccColor4F	diffuseColor

NSArray *	directionMarkers

ccColor4F	emissionColor

BOOL	expectsVerticallyFlippedTextures

CC3Vector	forwardDirection

CC3Box	globalBoundingBox

CC3Vector	globalCenterOfGeometry

CC3Vector	globalForwardDirection

CC3Vector4	globalHomogeneousPosition

CC3Vector4	globalLightPosition

CC3Vector	globalLocation

CC3Vector	globalRightDirection

CC3Vector	globalRotation

CC3Vector	globalScale

CC3Matrix *	globalTransformMatrix

CC3Matrix *	globalTransformMatrixInverted

CC3Vector	globalUpDirection

BOOL	hasLocalContent

BOOL	hasSoftBodyContent

BOOL	hasTarget

BOOL	isAnimationEnabled

BOOL	isBasePODNode

BOOL	isBillboard

BOOL	isCamera

BOOL	isLight

BOOL	isLightProbe

BOOL	isMeshNode

BOOL	isOpaque

BOOL	isRunning

BOOL	isScene

BOOL	isShadowVolume

BOOL	isTouchable

BOOL	isTrackingForBumpMapping

BOOL	isTransformDirty

BOOL	isTransformRigid

BOOL	isUniformlyScaledGlobally

BOOL	isUniformlyScaledLocally

GLenum	lineSmoothingHint

GLfloat	lineWidth

CC3Matrix *	localTransformMatrix

CC3Vector	location

CC3NormalScaling	normalScalingMethod

CCOpacity	opacity

CC3Node *	parent

CC3PerformanceStatistics *	performanceStatistics

GLint	podContentIndex

GLint	podParentIndex

GLint	podTargetIndex

CC3Vector	projectedLocation

CGPoint	projectedPosition

CC3Quaternion	quaternion

CC3Vector	referenceUpDirection

GLfloat	reflectivity

const char *	renderStreamGroupMarker

CC3Vector	rightDirection

CC3Node *	rootAncestor

CC3Vector	rotation

GLfloat	rotationAngle

CC3Vector	rotationAxis

CC3Rotator *	rotator

CC3Vector	scale

CC3Scene *	scene

CC3ShaderContext *	shaderContext

CC3ShaderProgram *	shaderProgram

GLfloat	shadowExpansionLimitFactor

GLushort	shadowLagCount

GLushort	shadowLagFactor

GLfloat	shadowOffsetFactor

GLfloat	shadowOffsetUnits

NSArray *	shadowVolumes

GLfloat	shadowVolumeVertexOffsetFactor

GLfloat	shininess

BOOL	shouldAddShadowVolumeEndCapsOnlyWhenNeeded

BOOL	shouldAllowTouchableWhenInvisible

BOOL	shouldApplyOpacityAndColorToMeshContent

BOOL	shouldAutoremoveWhenEmpty

BOOL	shouldAutotargetCamera

BOOL	shouldBlendAtFullOpacity

BOOL	shouldCacheFaces

BOOL	shouldCastShadows

BOOL	shouldCastShadowsWhenInvisible

BOOL	shouldCullBackFaces

BOOL	shouldCullFrontFaces

BOOL	shouldDisableDepthMask

BOOL	shouldDisableDepthTest

BOOL	shouldDrawAllBoundingVolumes

BOOL	shouldDrawAllDescriptors

BOOL	shouldDrawAllLocalContentWireframeBoxes

BOOL	shouldDrawAllWireframeBoxes

BOOL	shouldDrawBoundingVolume

BOOL	shouldDrawDescriptor

BOOL	shouldDrawInClipSpace

BOOL	shouldDrawWireframeBox

BOOL	shouldIgnoreRayIntersection

BOOL	shouldInheritTouchability

BOOL	shouldLogIntersectionMisses

BOOL	shouldLogIntersections

BOOL	shouldShadowBackFaces

BOOL	shouldShadowFrontFaces

BOOL	shouldSmoothLines

BOOL	shouldStopActionsWhenRemoved

BOOL	shouldTrackTarget

BOOL	shouldUseClockwiseFrontFaceWinding

BOOL	shouldUseFixedBoundingVolume

BOOL	shouldUseLighting

BOOL	shouldUseLightProbes

BOOL	shouldUseSmoothShading

CC3Vector	skeletalScale

CC3SoftBodyNode *	softBodyNode

ccColor4F	specularColor

NSString *	structureDescription

CC3Node *	target

CC3Vector	targetLocation

CC3TargettingConstraint	targettingConstraint

CC3Texture *	texture

CC3Node *	touchableNode

BOOL	touchEnabled

NSSet *	transformListeners

GLfloat	uniformScale

CC3Vector	upDirection

BOOL	visible

CC3WireframeBoundingBoxNode *	wireframeBoxNode

GLint	zOrder

Properties inherited from CC3Identifiable
NSObject *sharedUserData	__deprecated

NSString *	name

NSString *	nameSuffix

GLint	podIndex

BOOL	shouldIncludeInDeepCopy

GLuint	tag

NSObject *	userData

Properties inherited from <CC3Cacheable>
NSString *	name

Additional Inherited Members
Class Methods inherited from CC3Node
(GLfloat)	+ __deprecated

(CGFloat)	+ descriptorFontSize

(ccColor4F)	+ directionMarkerColor

(id)	+ node

(id)	+ nodeAtIndex:fromPODResource:

(id)	+ nodeWithName:

(id)	+ nodeWithTag:

(id)	+ nodeWithTag:withName:

(void)	+ setDefaultScaleTolerance:

(void)	+ setDescriptorFontSize:

(void)	+ setDirectionMarkerColor:

(void)	+ setWireframeBoxColor:

(ccColor4F)	+ wireframeBoxColor

Detailed Description

CC3Camera represents the camera viewing the 3D scene.

CC3Camera is a type of CC3Node, and can therefore participate in a structural node assembly. An instance can be the child of another node, and the camera itself can have child nodes. For example, a camera can be mounted on a boom object or truck, and will move along with the parent node. Or the camera node itself might have a light node attached as a child, so that the light will move along with the camera, and point where the camera points.

However, when adding a camera to an assembly of nodes, be aware of whether the parent nodes use scaling. To construct the viewMatrix, the camera makes heavy use of matrix inversion of the cummulative transform matrix of the camera's transforms and the transforms of all its ancestors. If scaling has not been added to any ancestor nodes, the cummulative transform will be a Rigid transform. Inverting a Rigid transform matrix is much, much faster (orders of magnitude) than inverting a matrix that contains scaling and is therefore not rigid. If possible, try to avoid applying scaling to the ancestor nodes of this camera.

Like any CC3Node, CC3Camera can be pointed in a specific direction, pointed at a specific location, or at a specific node by setting the forwardDirection, targetLocation, or target properties, respectively.

The camera can be configured for either perspective or parallel projection, using the isUsingParallelProjection property. By default, the camera will use perspective projection.

You can use the projectLocation: and projectNode: methods to project global locations within the 3D scene into 2D view coordinates, indicating where on the screen a 3D object appears.

You can use the unprojectPoint: and unprojectPoint:ontoPlane: methods to project a 2D screen position into either a ray (a line) in the 3D scene, or into a specific intersection location on a 3D plane.

You can use the moveToShowAllOf:... or moveWithDuration:toShowAllOf: family of methods to have the camera automatically focus on, and display all of, a particular node, or even the whole scene itself.

Scaling a camera is a null operation because it scales everything, including the size of objects, but also the distance from the camera to those objects. The effects cancel out, and visually it appears that nothing has changed.

Therefore, for cameras, the scale and uniformScale properties are not applied to the transform matrix. Instead, the uniformScale property acts as a zoom factor (as if the camera lens is zoomed in or out), and influences the fieldOfView property accordingly. See the description of the fieldOfView property for more information about zooming.

If you find that objects in the periphery of your view appear elongated, you can adjust the fieldOfView and/or uniformScale properties to reduce this "fish-eye" effect. See the notes of the fieldOfView property for more on this.

For cameras, any change in the projection parameters, such as fieldOfView, scale, near or far clipping distances, is considered a transform change, and the transformListeners are sent a notification via the nodeWasTransformed: method when the projection matrix is recalculated.

Method Documentation

- (CC3Vector) calculateLocationToShowAllOf:	(CC3Node *)	aNode
fromDirection:	(CC3Vector)	aDirection
withPadding:	(GLfloat)	padding

Calculates and returns where to position this camera along a line extending in the specified direction from the center of the specified node, so that the camera will show the entire content of the node, including any descendant nodes.

The entire node can then be shown by positioning the camera at the returned location and setting the forwardDirection of the camera to the negated specified direction.

The padding argument indicates the empty-space padding to add around the bounding box of the node when it is framed in the camera. This value is expressed as a fraction of the size of the bounding box of the node. For example, if the padding value is set to 0.1, then this method will locate the camera so that there will be 10% empty space around the node when it is framed by the camera. A negative padding value will cause the node to expand to more fully fill the camera frame, or even expand beyond it.

By setting CC3Scene as the specified node, you can use this method to determine where to position the camera in order to show the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to determine where to locate your camera to capture the entire scene, or a particular node within the scene, when the scene is first drawn.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (CC3Vector) calculateLocationToShowAllOf:	(CC3Node *)	aNode
whileLookingAt:	(CC3Vector)	targetLoc
fromDirection:	(CC3Vector)	aDirection
withPadding:	(GLfloat)	padding

Calculates and returns where to position this camera along a line extending in the specified direction from the specified target location, so that the camera will show the entire content of the node, including any descendant nodes.

The entire node can then be shown by positioning the camera at the returned location and setting the forwardDirection of the camera to the negated specified direction.

The padding argument indicates the empty-space padding to add around the bounding box of the node when it is framed in the camera. This value is expressed as a fraction of the size of the bounding box of the node. For example, if the padding value is set to 0.1, then this method will locate the camera so that there will be 10% empty space around the node when it is framed by the camera. A negative padding value will cause the node to expand to more fully fill the camera frame, or even expand beyond it.

By setting CC3Scene as the specified node, you can use this method to determine where to position the camera in order to show the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to determine where to locate your camera to capture the entire scene, or a particular node within the scene, when the scene is first drawn.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (CGPoint) cc2PointFromGLPoint: (CGPoint) __deprecated

Deprecated:

- (void) closeWithVisitor: (CC3NodeDrawingVisitor *) visitor

Closes the camera for drawing operations.

This method is called automatically by the CC3Scene at the end of each frame drawing cycle. Usually, the application never needs to invoke this method directly.

- (CGPoint) glPointFromCC2Point: (CGPoint) __deprecated

Deprecated:

- (void) markProjectionDirty

Indicates that the projection matrix is dirty and needs to be recalculated.

For cameras, a change in projection is considered a transform change, so the transformListeners are sent a notification via the nodeWasTransformed: method when the projection matrix is rebuilt.

This method is invoked automatically as needed. Usually the application never needs to invoke this method directly.

- (void) moveToShowAllOf: (CC3Node *) aNode

Moves this camera to a location along a line between the center of the specified node and this camera, so that the camera will show the entire content of the node, including any descendant nodes, with minimal padding.

The camera will point back towards the node along the line between itself and the center of the node.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to ensure that the camera is pointed towards the whole scene, or a particular node within the scene, when the scene is first drawn.

Since the camera points to the center of the node, when displayed, the node may not extend to both sides (or top & bottom) of the scene equally, due to perspective. In addition, in some cases, if the bounds of the node are fluid because of movement, or billboards that rotate as the camera moves into position, one or more corners of the node may extend slightly out of the camera's view.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveToShowAllOf:	(CC3Node *)	aNode
fromDirection:	(CC3Vector)	aDirection

Moves this camera to a location along a line extending in the specified direction from the center of the specified node, so that the camera will show the entire content of the node, including any descendant nodes, with minimal padding.

The camera will point back towards the center of the node along the specified direction.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to ensure that the camera is pointed towards the whole scene, or a particular node within the scene, when the scene is first drawn.

Since the camera points to the center of the node, when displayed, the node may not extend to both sides (or top & bottom) of the scene equally, due to perspective. In addition, in some cases, if the bounds of the node are fluid because of movement, or billboards that rotate as the camera moves into position, one or more corners of the node may extend slightly out of the camera's view.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveToShowAllOf:	(CC3Node *)	aNode
fromDirection:	(CC3Vector)	aDirection
withPadding:	(GLfloat)	padding

Moves this camera to a location along a line extending in the specified direction from the center of the specified node, so that the camera will show the entire content of the node, including any descendant nodes.

The camera will point back towards the center of the node along the specified direction.

The padding argument indicates the empty-space padding to add around the bounding box of the node when it is framed in the camera. This value is expressed as a fraction of the size of the bounding box of the node. For example, if the padding value is set to 0.1, then this method will locate the camera so that there will be 10% empty space around the node when it is framed by the camera. A negative padding value will cause the node to expand to more fully fill the camera frame, or even expand beyond it.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to ensure that the camera is pointed towards the whole scene, or a particular node within the scene, when the scene is first drawn.

Since the camera points to the center of the node, when displayed, the node may not extend to both sides (or top & bottom) of the scene equally, due to perspective. In addition, in some cases, if the bounds of the node are fluid because of movement, or billboards that rotate as the camera moves into position, one or more corners of the node may extend slightly out of the camera's view.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveToShowAllOf:	(CC3Node *)	aNode
whileLookingAt:	(CC3Vector)	targetLoc

Moves this camera to a location along a line extending in the specified direction from the specified target location, so that the camera will show the entire content of the node, including any descendant nodes, with minimal padding.

The camera will point back towards the specified target location along the line between itself and the target location.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

Although the camera will point at the specified target location, the targetLocation property of the camera is not set to that location, and the camera will not track that location automatically. If you want the target location to be tracked by the camera, you should set the targetLocation and shouldTrackTarget properties of this camera once this method has finished.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveToShowAllOf:	(CC3Node *)	aNode
whileLookingAt:	(CC3Vector)	targetLoc
fromDirection:	(CC3Vector)	aDirection

Moves this camera to a location along a line extending in the specified direction from the specified target location, so that the camera will show the entire content of the node, including any descendant nodes, with minimal padding.

The camera will point back towards the specified target location along the specified direction.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

Although the camera will point at the specified target location, the targetLocation property of the camera is not set to that location, and the camera will not track that location automatically. If you want the target location to be tracked by the camera, you should set the targetLocation and shouldTrackTarget properties of this camera once this method has finished.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveToShowAllOf:	(CC3Node *)	aNode
whileLookingAt:	(CC3Vector)	targetLoc
fromDirection:	(CC3Vector)	aDirection
withPadding:	(GLfloat)	padding

Moves this camera to a location along a line extending in the specified direction from the specified target location, so that the camera will show the entire content of the node, including any descendant nodes.

The camera will point back towards the specified target location along the specified direction.

The padding argument indicates the empty-space padding to add around the bounding box of the node when it is framed in the camera. This value is expressed as a fraction of the size of the bounding box of the node. For example, if the padding value is set to 0.1, then this method will locate the camera so that there will be 10% empty space around the node when it is framed by the camera. A negative padding value will cause the node to expand to more fully fill the camera frame, or even expand beyond it.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

Although the camera will point at the specified target location, the targetLocation property of the camera is not set to that location, and the camera will not track that location automatically. If you want the target location to be tracked by the camera, you should set the targetLocation and shouldTrackTarget properties of this camera once this method has finished.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveToShowAllOf:	(CC3Node *)	aNode
whileLookingAt:	(CC3Vector)	targetLoc
withPadding:	(GLfloat)	padding

Moves this camera to a location along a line extending in the specified direction from the specified target location, so that the camera will show the entire content of the node, including any descendant nodes.

The camera will point back towards the specified target location along the line between itself and the target location.

The padding argument indicates the empty-space padding to add around the bounding box of the node when it is framed in the camera. This value is expressed as a fraction of the size of the bounding box of the node. For example, if the padding value is set to 0.1, then this method will locate the camera so that there will be 10% empty space around the node when it is framed by the camera. A negative padding value will cause the node to expand to more fully fill the camera frame, or even expand beyond it.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

Although the camera will point at the specified target location, the targetLocation property of the camera is not set to that location, and the camera will not track that location automatically. If you want the target location to be tracked by the camera, you should set the targetLocation and shouldTrackTarget properties of this camera once this method has finished.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveToShowAllOf:	(CC3Node *)	aNode
withPadding:	(GLfloat)	padding

Moves this camera to a location along a line between the center of the specified node and this camera, so that the camera will show the entire content of the node, including any descendant nodes.

The camera will point back towards the node along the line between itself and the center of the node.

The padding argument indicates the empty-space padding to add around the bounding box of the node when it is framed in the camera. This value is expressed as a fraction of the size of the bounding box of the node. For example, if the padding value is set to 0.1, then this method will locate the camera so that there will be 10% empty space around the node when it is framed by the camera. A negative padding value will cause the node to expand to more fully fill the camera frame, or even expand beyond it.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to ensure that the camera is pointed towards the whole scene, or a particular node within the scene, when the scene is first drawn.

Since the camera points to the center of the node, when displayed, the node may not extend to both sides (or top & bottom) of the scene equally, due to perspective. In addition, in some cases, if the bounds of the node are fluid because of movement, or billboards that rotate as the camera moves into position, one or more corners of the node may extend slightly out of the camera's view.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveWithDuration:	(CCTime)	t
toShowAllOf:	(CC3Node *)	aNode

Moves this camera to a location along a line between the center of the specified node and this camera, so that the camera will show the entire content of the node, including any descendant nodes, with minimal padding.

The camera will point back towards the node along the line between itself and the center of the node.

The camera's movement will take the specified amount of time, starting at its current location and orientation, and ending at the calculated location and oriented to point back towards the center of the node.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to ensure that the camera is pointed towards the whole scene, or a particular node within the scene, when the scene is first drawn.

Since the camera points to the center of the node, when displayed, the node may not extend to both sides (or top & bottom) of the scene equally, due to perspective. In addition, in some cases, if the bounds of the node are fluid because of movement, or billboards that rotate as the camera moves into position, one or more corners of the node may extend slightly out of the camera's view.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize (typically after the layer has been opened in its view). This is necessary because the frustum of this camera requires the contentSize of the CC3Layer to determine the projection matrix. Because of this, you cannot invoke this method when creating this camera, or from the initializeScene method of the CC3Scene. If you want to open your scene with the camera automatically framing the entire scene, or a particular node, a good place to invoke this method is in the onOpen callback method of your customized CC3Scene.

- (void) moveWithDuration:	(CCTime)	t
toShowAllOf:	(CC3Node *)	aNode
fromDirection:	(CC3Vector)	aDirection

Moves this camera to a location along a line extending in the specified direction from the center of the specified node, so that the camera will show the entire content of the node, including any descendant nodes, with minimal padding.

The camera will point back towards the center of the node along the specified direction.

The camera's movement will take the specified amount of time, starting at its current location and orientation, and ending at the calculated location and oriented to point back towards the center of the node.

The specified node may be the CC3Scene, in which case, the camera will be located to display the entire scene.

This method can be useful during development to troubleshoot scene display issues. For example, you can invoke this method in the onOpen method of your custom CC3Scene to ensure that the camera is pointed towards the whole scene, or a particular node within the scene, when the scene is first drawn.

Since the camera points to the center of the node, when displayed, the node may not extend to both sides (or top & bottom) of the scene equally, due to perspective. In addition, in some cases, if the bounds of the node are fluid because of movement, or billboards that rotate as the camera moves into position, one or more corners of the node may extend slightly out of the camera's view.

This method requires that the CC3Scene is attached to a CC3Layer that has a valid contentSize. This is necessary so that the frustum of the camera has been set from the contentSize of the CC3Layer.

- (void) moveWithDuration:	(CCTime)	t
toShowAllOf:	(CC3Node *)	aNode
fromDirection:	(CC3Vector)	aDirection
withPadding:	(GLfloat)	padding