#import <CC3MeshNode.h>

Inheritance diagram for CC3MeshNode:

Instance Methods
(CC3Material *)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- __deprecated

(void)	- addTexture:

(CC3Face)	- deformedFaceAt:

(CC3Vector)	- deformedFaceCenterAt:

(CC3Vector)	- deformedFaceNormalAt:

(CC3Plane)	- deformedFacePlaneAt:

(CC3Vector)	- deformedVertexLocationAt:fromFaceAt:

(void)	- drawWithVisitor:

(CC3Mesh *)	- ensureMesh

(void)	- expectsVerticallyFlippedTexture:inTextureUnit:

(BOOL)	- expectsVerticallyFlippedTextureInTextureUnit:

(CC3Face)	- faceAt:

(CC3Vector)	- faceCenterAt:

(GLuint)	- faceCountFromVertexCount:

(GLuint)	- faceCountFromVertexIndexCount:

(CC3Face)	- faceFromIndices:

(CC3FaceIndices)	- faceIndicesAt:

(CC3FaceNeighbours)	- faceNeighboursAt:

(CC3Vector)	- faceNormalAt:

(CC3Plane)	- facePlaneAt:

(GLuint)	- findFirst:globalIntersections:ofGlobalRay:acceptBackFaces:acceptBehindRay:

(GLuint)	- findFirst:intersections:ofLocalRay:acceptBackFaces:acceptBehindRay:

(void)	- flipHorizontallyTextureUnit:

(void)	- flipTexturesHorizontally

(void)	- flipTexturesVertically

(void)	- flipVerticallyTextureUnit:

(CC3Material *)	- makeMaterial

(CC3Mesh *)	- makeMesh

(void)	- moveMeshOriginTo:

(void)	- moveMeshOriginToCenterOfGeometry

(void)	- movePivotTo:

(void)	- populateAsBitmapFontLabelFromString:fromFontFile:andLineHeight:andTextAlignment:andRelativeOrigin:andTessellation:

(void)	- populateAsCenteredRectangleWithSize:

(void)	- populateAsCenteredRectangleWithSize:andTessellation:

(void)	- populateAsCenteredRectangleWithSize:andTessellation:withTexture:invertTexture:

(void)	- populateAsCenteredRectangleWithSize:withTexture:invertTexture:

(void)	- populateAsCenteredTexturedRectangleWithSize:

(void)	- populateAsCenteredTexturedRectangleWithSize:andTessellation:

(void)	- populateAsCubeMappedSolidBox:

(void)	- populateAsDiskWithRadius:andTessellation:

(void)	- populateAsHollowConeWithRadius:height:andTessellation:

(void)	- populateAsLineStripWith:vertices:andRetain:

(void)	- populateAsRectangleWithSize:andPivot:

(void)	- populateAsRectangleWithSize:andPivot:andTessellation:

(void)	- populateAsRectangleWithSize:andPivot:andTessellation:withTexture:invertTexture:

(void)	- populateAsRectangleWithSize:andPivot:withTexture:invertTexture:

(void)	- populateAsRectangleWithSize:andRelativeOrigin:

(void)	- populateAsRectangleWithSize:andRelativeOrigin:andTessellation:

(void)	- populateAsSolidBox:

(void)	- populateAsSolidBox:withCorner:

(void)	- populateAsSphereWithRadius:andTessellation:

(void)	- populateAsTexturedBox:

(void)	- populateAsTexturedBox:withCorner:

(void)	- populateAsTexturedRectangleWithSize:andPivot:

(void)	- populateAsTexturedRectangleWithSize:andPivot:andTessellation:

(void)	- populateAsTriangle:withTexCoords:andTessellation:

(void)	- populateAsWireBox:

(CC3Mesh *)	- prepareParametricMesh

(void)	- removeAllTextures

(void)	- removeLocalShaders

(void)	- repeatTexture:

(void)	- repeatTexture:forTextureUnit:

(CC3ShaderProgram *)	- selectShaderProgram

(void)	- setTexture:forTextureUnit:

(void)	- setTextureRectangle:forTextureUnit:

(void)	- setVertexBitangent:at:

(void)	- setVertexBoneIndex:forBoneInfluence:at:

(void)	- setVertexBoneIndices:at:

(void)	- setVertexBoneWeights:at:

(void)	- setVertexColor4B:at:

(void)	- setVertexColor4F:at:

(void)	- setVertexHomogeneousLocation:at:

(void)	- setVertexIndex:at:

(void)	- setVertexLocation:at:

(void)	- setVertexMatrixIndex:forVertexUnit:at:

(void)	- setVertexMatrixIndices:at:

(void)	- setVertexNormal:at:

(void)	- setVertexTangent:at:

(void)	- setVertexTexCoord2F:at:

(void)	- setVertexTexCoord2F:at:forTextureUnit:

(void)	- setVertexTexCoord2F:forTextureUnit:at:

(void)	- setVertexWeight:forBoneInfluence:at:

(void)	- setVertexWeight:forVertexUnit:at:

(void)	- setVertexWeights:at:

(CC3Texture *)	- textureForTextureUnit:

(CGRect)	- textureRectangleForTextureUnit:

(void)	- updateGLBuffers

(void)	- updateVertexBitangentsGLBuffer

(void)	- updateVertexBoneIndicesGLBuffer

(void)	- updateVertexBoneWeightsGLBuffer

(void)	- updateVertexColorsGLBuffer

(void)	- updateVertexIndicesGLBuffer

(void)	- updateVertexLocationsGLBuffer

(void)	- updateVertexNormalsGLBuffer

(void)	- updateVertexTangentsGLBuffer

(void)	- updateVertexTextureCoordinatesGLBuffer

(void)	- updateVertexTextureCoordinatesGLBufferForTextureUnit:

(CC3Vector)	- vertexBitangentAt:

(GLuint)	- vertexBoneIndexForBoneInfluence:at:

(GLvoid *)	- vertexBoneIndicesAt:

(GLfloat *)	- vertexBoneWeightsAt:

(ccColor4B)	- vertexColor4BAt:

(ccColor4F)	- vertexColor4FAt:

(GLuint)	- vertexCountFromFaceCount:

(CC3Vector4)	- vertexHomogeneousLocationAt:

(GLuint)	- vertexIndexAt:

(GLuint)	- vertexIndexCountFromFaceCount:

(CC3Vector)	- vertexLocationAt:

(GLuint)	- vertexMatrixIndexForVertexUnit:at:

(GLvoid *)	- vertexMatrixIndicesAt:

(CC3Vector)	- vertexNormalAt:

(CC3Vector)	- vertexTangentAt:

(ccTex2F)	- vertexTexCoord2FAt:

(ccTex2F)	- vertexTexCoord2FAt:forTextureUnit:

(ccTex2F)	- vertexTexCoord2FForTextureUnit:at:

(GLfloat)	- vertexWeightForBoneInfluence:at:

(GLfloat)	- vertexWeightForVertexUnit:at:

(GLfloat *)	- vertexWeightsAt:

Instance Methods inherited from CC3LocalContentNode
(void)	- checkDrawingOrder

(CC3Box)	- localContentBoundingBoxRelativeTo:

Instance Methods inherited from CC3Node
(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)	- 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)	- 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)	- 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)	- 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
CC3Mesh *meshModel	__deprecated

ccColor4F pureColor	__deprecated

BOOL hasPremultipliedAlpha	__deprecated

GLuint vertexUnitCount	__deprecated

GLenum matrixIndexType	__deprecated

ccColor4F	ambientColor

ccBlendFunc	blendFunc

CCColorRef	color

ccColor4F	diffuseColor

GLenum	drawingMode

CC3NormalScaling	effectiveNormalScalingMethod

ccColor4F	emissionColor

BOOL	expectsVerticallyFlippedTextures

GLuint	faceCount

BOOL	hasRigidSkeleton

BOOL	hasSkeleton

BOOL	hasTextureAlpha

BOOL	hasTexturePremultipliedAlpha

BOOL	isDrawingPointSprites

BOOL	isOpaque

BOOL	isUsingGLBuffers

CC3Material *	material

CC3Mesh *	mesh

CCOpacity	opacity

int	podMaterialIndex

GLfloat	reflectivity

CC3ShaderContext *	shaderContext

CC3ShaderProgram *	shaderProgram

GLfloat	shininess

BOOL	shouldApplyOpacityToColor

BOOL	shouldCacheFaces

BOOL	shouldDrawLowAlpha

BOOL	shouldUseLighting

BOOL	shouldUseLightProbes

ccColor4F	specularColor

CC3Texture *	texture

GLuint	textureCount

CGRect	textureRectangle

GLuint	vertexBoneCount

GLenum	vertexBoneIndexType

GLenum	vertexColorType

CC3VertexContent	vertexContentTypes

GLuint	vertexCount

GLuint	vertexIndexCount

Properties inherited from CC3LocalContentNode
CC3Box	globalLocalContentBoundingBox

CC3Vector	globalLocalContentCenterOfGeometry

CC3Box	localContentBoundingBox

CC3Vector	localContentCenterOfGeometry

CC3WireframeBoundingBoxNode *	localContentWireframeBoxNode

BOOL	shouldDrawLocalContentWireframeBox

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 CC3LocalContentNode
(ccColor4F)	+ localContentWireframeBoxColor

(void)	+ setLocalContentWireframeBoxColor:

Detailed Description

A CC3Node that draws a 3D mesh.

This class forms the base of all visible 3D mesh models in the 3D scene.

CC3MeshNode is a type of CC3Node, and will often participate in a structural node assembly. An instance can be the child of another node, and the mesh node itself can have child nodes.

CC3MeshNodes encapsulate a CC3Mesh instance, and a CC3Material instance. The CC3Mesh instance contains the mesh vertex content. The CC3Material instance describes the material and texture properties covering the mesh, which can be affected by lighting conditions.

If it is not explicitly set beforehand, the material will automatically be created and assigned to the mesh node when a texture is added to the mesh node through the texture property or the addTexture: method, or if any of the material properties of the mesh node are set or accessed, including color, opacity, ambientColor, diffuseColor, specularColor, emissionColor, blendFunc, isOpaque, shouldUseLighting, or shouldDrawLowAlpha.

There are a number of populateAs... parametric population methods available in the CC3MeshNode (ParametricShapes) category extension. These methods can be used to populate the vertices of the mesh contained in a new mesh node to create interesting and useful parametric shapes and surfaces.

When this node is drawn, it delegates to the mesh instance to render the mesh vertices. Before drawing the mesh, it delegates to the material to configure the covering of the mesh.

Each CC3MeshNode can have only one material. For large, complicated meshes that are covered by more than one material, the mesh must be broken into smaller meshes, each of which is covered by a single material. These smaller sub-meshes are sometimes referred to as "vertex groups". Each such sub-mesh is then wrapped in its own CC3MeshNode instance, along with the material that covers that sub-mesh.

These CC3MeshNode instances can then be added as child nodes to a single parent CC3Node instance. This parent CC3Node can then be moved, rotated and scaled, and all of its child nodes will transform in sync. The assembly will behave and be seen as a single object.

When the mesh is set in the mesh property, the CC3MeshNode instance creates and builds a CC3NodeBoundingVolume instance from the mesh data, and sets it into its boundingVolume property.

When a copy is made of a CC3MeshNode instance using the copy method, a copy is made of the material, but the mesh is simply assigned by reference, and is not copied. The result is that the the new and original nodes will have different materials, but will share the same mesh. This design avoids creating multiple copies of volumnious and static mesh data when creating copies of nodes.

Normally, the front faces of a mesh are displayed, and the back faces are culled and not displayed. You can change this behaviour if you need to be changing the values of the shouldCullFrontFaces and shouldCullBackFaces properties. An example might be if you wanted to show the back-side of a planar sign, or if you wanted to show the inside faces of a skybox.

However, be aware that culling is a significant performance-improving technique. You should avoid disabling backface culling except where specifically needed for visual effect. And when you do, if you only need the back faces, turn on front face culling for that mesh by setting the shouldCullFrontFaces property to YES.

Method Documentation

- (CC3Material*) __deprecated

Deprecated:: The material property now performs this functionality lazily.

Implements CC3Node.

- (void) __deprecated

Deprecated:: Renamed to removeLocalShaders.

Implements CC3Node.

- (void) __deprecated

Deprecated:: Renamed to moveMeshOriginToCenterOfGeometry.

Implements CC3Node.

- (void) __deprecated

Deprecated:: Renamed to updateVertexBoneWeightsGLBuffer.

Implements CC3Node.

- (void) __deprecated

Deprecated:: Renamed to updateVertexBoneIndicesGLBuffer.

Implements CC3Node.

- (void) addTexture: (CC3Texture *) aTexture

In most situations, the material will use a single CC3Texture in the texture property.

However, if multi-texturing is used, additional CC3Texture instances can be provided by adding them using this method.

If a material does not yet exist in this mesh node, a new material will be created and the texture will be attached to it.

When multiple textures are attached to a material, when drawing, the material will combine these textures together using configurations contained in the textureUnit property of each texture.

As a consistency convenience, if the texture property has not yet been set directly, the first texture added using this method will appear in that property.

Textures are processed by GL texture units in the order they are added to the material. The first texture added (or set directly into the texture property) will be processed by GL texture unit zero. Subsequent textures added with this method will be processed by subsequent texture units, in the order they were added.

The maximum number of texture units available is platform dependent, but will be at least two. The maximum number of texture units available can be read from the CC3OpenGL.sharedGL.maxNumberOfTextureUnits property. If you attempt to add more than this number of textures to the material, the additional textures will be ignored, and an informational message to that fact will be logged.

Under iOS, during loading, textures are padded to dimensions of a power-of-two (POT) and, because vertical OpenGL coordinates are inverted relative to iOS view coordinates, most texture formats are loaded updside-down.

To compensate, when a texture is attached to a mesh node, the texture coordinates of the mesh are automatically adjusted to correctly display the texture, taking into consideration POT padding and vertical orientation.

When building for iOS, raw PNG and TGA images are pre-processed by Xcode to pre-multiply alpha, and to reorder the pixel component byte order, to optimize the image for the iOS platform. If you want to avoid this pre-processing for PNG or TGA files, for textures such as normal maps or lighting maps, that you don't want to be modified, you can prepend a 'p' to the file extension ("ppng" or "ptga") to cause Xcode to skip this pre-processing and to use a loader that does not pre-multiply the alpha. You can also use this for other file types as well. See the notes for the CC3STBImage useForFileExtensions class-side property for more info.

Implements CC3Node.

- (CC3Face) deformedFaceAt: (GLuint) faceIndex

Returns the face from the mesh at the specified index.

If the vertices of this mesh node represent the skin covering the bones of a soft-body, the vertex locations of the returned face take into consideration the current deformation caused by motion of the bones underlying the this skin mesh. Otherwise, this method returns the same value as the faceAt: method.

In either case, the vertex locations of the returned face are specified in the local coordinate system of this node.

The specified faceIndex value refers to the index of the face, not the vertices themselves. So, a value of 5 will retrieve the three vertices that make up the fifth triangular face in this mesh. The specified index must be between zero, inclusive, and the value of the faceCount property, exclusive.

The returned face structure contains only the locations of the vertices. If the vertex locations are interleaved with other vertex data, such as color or texture coordinates, or other padding, that data will not appear in the returned face structure. For that remaining vertex data, you can use the faceIndicesAt: method to retrieve the indices of the vertex data, and then use the vertex accessor methods to retrieve the individual vertex data components.

Provided by category CC3MeshNode(Skinning).

- (CC3Vector) deformedFaceCenterAt: (GLuint) faceIndex

Returns the center of the mesh face at the specified index.

If the vertices of this mesh node represent the skin covering the bones of a soft-body, the returned location takes into consideration the current deformation caused by motion of the bones underlying the this skin mesh. The returned location is the center of the face in its location and orientation after the skin has been deformed by the current position of the underlying bones. Otherwise, this method returns the same value as the faceCenterAt: method.

In either case, the returned face center is specified in the local coordinate system of this node.

Provided by category CC3MeshNode(Skinning).

- (CC3Vector) deformedFaceNormalAt: (GLuint) faceIndex

Returns the normal of the mesh face at the specified index.

If the vertices of this mesh node represent the skin covering the bones of a soft-body, the returned normal takes into consideration the current deformation caused by motion of the bones underlying the this skin mesh. The returned vector is the normal of the face in its orientation after the skin has been deformed by the current position of the underlying bones. Otherwise, this method returns the same value as the faceNormalAt: method.

In either case, the returned face normal is specified in the local coordinate system of this node.

Provided by category CC3MeshNode(Skinning).

- (CC3Plane) deformedFacePlaneAt: (GLuint) faceIndex

Returns the plane of the mesh face at the specified index.

If the vertices of this mesh node represent the skin covering the bones of a soft-body, the returned plane takes into consideration the current deformation caused by motion of the bones underlying the this skin mesh. The returned plane is the plane of the face in its location and orientation after the skin has been deformed by the current position of the underlying bones. Otherwise, this method returns the same value as the facePlaneAt: method.

In either case, the returned face plane is specified in the local coordinate system of this node.

Provided by category CC3MeshNode(Skinning).

- (CC3Vector) deformedVertexLocationAt:	(GLuint)	vertexIndex
fromFaceAt:	(GLuint)	faceIndex

Returns the vertex from the mesh at the specified vtxIndex, that is within the face at the specified faceIndex.

If the vertices of this mesh node represent the skin covering the bones of a soft-body, the returned vertex location takes into consideration the current deformation caused by motion of the bones underlying the this skin mesh. Otherwise, this method returns the same value as the vertexLocationAt: method.

In either case, the returned vertex location is specified in the local coordinate system of this node.

The specified faceIndex value refers to the index of the face that contains the vertex. It is required to determine the skin section whose bones are deforming the vertex location at the specified vertex index. The specified faceIndex must be between zero, inclusive, and the value of the faceCount property, exclusive.

The specified vtxIndex must be between zero, inclusive, and the value of the vertexCount property, exclusive.

Provided by category CC3MeshNode(Skinning).

- (void) drawWithVisitor: (CC3NodeDrawingVisitor *) visitor

Draws the local content of this mesh node by following these steps:

If the shouldDecorateNode property of the visitor is YES, and this node has a material, invokes the drawWithVisitor method of the material.

 Otherwise, invokes the CC3Material class-side unbind method.

Invokes the drawWithVisitor: method of the encapsulated mesh.

This method is called automatically from the transformAndDrawWithVisitor: method of this node. Usually, the application never needs to invoke this method directly.

Implements CC3Node.

- (CC3Mesh*) ensureMesh

If a mesh does not yet exist, this method invokes the makeMesh method to create a suitable mesh, and sets it into the mesh property.

Does nothing if this mesh node already has a mesh. Returns the mesh (existing or new).

This method is invoked whenever a property is set that would affect the mesh. Usually, you will never need to invoke this method.

- (void) expectsVerticallyFlippedTexture:	(BOOL)	expectsFlipped
inTextureUnit:	(GLuint)	texUnit

Sets whether the texture coordinates for the specfied texture unit expects that the texture was flipped upside-down during texture loading.

See the notes of the expectsVerticallyFlippedTextureInTextureUnit: method for a discussion of texture coordinate orientation.

Setting the value of this property will change the way the texture coordinates are aligned when a texture is assigned to cover this texture unit for this mesh.

- (BOOL) expectsVerticallyFlippedTextureInTextureUnit: (GLuint) texUnit

Returns whether the texture coordinates for the specfied texture unit expects that the texture was flipped upside-down during texture loading.

The vertical axis of the coordinate system of OpenGL is inverted relative to the iOS view coordinate system. This results in textures from most file formats being oriented upside-down, relative to the OpenGL coordinate system. All file formats except PVR format will be oriented upside-down after loading.

The value of this property is used in combination with the value of the isUpsideDown property of a texture to determine whether the texture will be oriented correctly when displayed using these texture coordinates.

When a texture or material is assigned to this mesh node, the value of this property is compared with the isUpsideDown property of the texture to automatically determine whether these texture coordinates need to be flipped vertically in order to display the texture correctly, and if needed, the texture coordinates will be flipped automatically. As part of that inversion, the value of this property will also be flipped, to indicate that the texture coordinates are now aligned differently.

If you need to adjust the value of this property, you sould do so before setting a texture or material into this mesh node.

The initial value of this property is set when the underlying mesh texture coordinates are built or loaded. See the expectsVerticallyFlippedTextures property on the CC3NodesResource class to understand how this property is set during mesh resource loading from model files.

When building meshes programmatically, you should endeavour to design the mesh so that this property will be YES if you will be using vertically-flipped textures (all texture file formats except PVR).

- (CC3Face) faceAt: (GLuint) faceIndex

Returns the face from the mesh at the specified index.

The specified faceIndex value refers to the index of the face, not the vertices themselves. So, a value of 5 will retrieve the three vertices that make up the fifth triangular face in this mesh. The specified index must be between zero, inclusive, and the value of the faceCount property, exclusive.

The returned face structure contains only the locations of the vertices. If the vertex locations are interleaved with other vertex content, such as color or texture coordinates, or other padding, that data will not appear in the returned face structure. For that remaining vertex content, you can use the faceIndicesAt: method to retrieve the indices of the vertex content, and then use the vertex accessor methods to retrieve the individual vertex content components.

If you will be invoking this method frequently, you can optionally set the shouldCacheFaces property to YES to speed access, and possibly improve performance. However, be aware that setting the shouldCacheFaces property to YES can significantly increase the amount of memory used by the mesh.

- (CC3Vector) faceCenterAt: (GLuint) faceIndex

Returns the center of the mesh face at the specified index.

If you will be invoking this method frequently, you can optionally set the shouldCacheFaces property to YES to speed access, and possibly improve performance. However, be aware that setting the shouldCacheFaces property to YES can significantly increase the amount of memory used by the mesh.

- (GLuint) faceCountFromVertexCount: (GLuint) __deprecated

Deprecated:: Renamed to faceCountFromVertexIndexCount:.

- (GLuint) faceCountFromVertexIndexCount: (GLuint) vc

Returns the number of faces to be drawn from the specified number of vertex indices, based on the type of primitives that this mesh is drawing.

- (CC3Face) faceFromIndices: (CC3FaceIndices) faceIndices

Returns the mesh face that is made up of the three vertices at the three indices within the specified face indices structure.

The returned face structure contains only the locations of the vertices. If the vertex locations are interleaved with other vertex content, such as color or texture coordinates, or other padding, that data will not appear in the returned face structure. For that remaining vertex content, you can use the faceIndicesAt: method to retrieve the indices of the vertex content, and then use the vertex accessor methods to retrieve the individual vertex content components.

- (CC3FaceIndices) faceIndicesAt: (GLuint) faceIndex

Returns the face from the mesh at the specified index, as indices into the mesh vertices.

The specified faceIndex value refers to the index of the face, not the vertices themselves. So, a value of 5 will retrieve the three vertices that make up the fifth triangular face in this mesh. The specified index must be between zero, inclusive, and the value of the faceCount property, exclusive.

The returned structure reference contains the indices of the three vertices that make up the triangular face. These indices index into the actual vertex content within the layout of the mesh.

This method takes into consideration any padding (stride) between the vertex indices.

If you will be invoking this method frequently, you can optionally set the shouldCacheFaces property to YES to speed access, and possibly improve performance. However, be aware that setting the shouldCacheFaces property to YES can significantly increase the amount of memory used by the mesh.

- (CC3FaceNeighbours) faceNeighboursAt: (GLuint) faceIndex

Returns the indices of the neighbours of the mesh face at the specified index.

- (CC3Vector) faceNormalAt: (GLuint) faceIndex

Returns the normal of the mesh face at the specified index.

If you will be invoking this method frequently, you can optionally set the shouldCacheFaces property to YES to speed access, and possibly improve performance. However, be aware that setting the shouldCacheFaces property to YES can significantly increase the amount of memory used by the mesh.

- (CC3Plane) facePlaneAt: (GLuint) faceIndex

Returns the plane of the mesh face at the specified index.

If you will be invoking this method frequently, you can optionally set the shouldCacheFaces property to YES to speed access, and possibly improve performance. However, be aware that setting the shouldCacheFaces property to YES can significantly increase the amount of memory used by the mesh.

- (GLuint) findFirst:	(GLuint)	maxHitCount
globalIntersections:	(CC3MeshIntersection *)	intersections
ofGlobalRay:	(CC3Ray)	aRay
acceptBackFaces:	(BOOL)	acceptBackFaces
acceptBehindRay:	(BOOL)	acceptBehind

Populates the specified array with information about the intersections of the specified ray and this mesh, up to the specified maximum number of intersections.

This is a convenience method that converts the specified global ray to the local coordinate system of this node, and invokes the findFirst:intersections:ofLocalRay:acceptBackFaces:acceptBehindRay: method, and converts the location and distance components of each of the elements in the intersections array to the global coordinate system.

See the notes for the findFirst:intersections:ofLocalRay:acceptBackFaces:acceptBehindRay: method to understand more about how to use this method.

- (GLuint) findFirst:	(GLuint)	maxHitCount
intersections:	(CC3MeshIntersection *)	intersections
ofLocalRay:	(CC3Ray)	aRay
acceptBackFaces:	(BOOL)	acceptBackFaces
acceptBehindRay:	(BOOL)	acceptBehind

Populates the specified array with information about the intersections of the specified ray and this mesh, up to the specified maximum number of intersections.

This method returns the actual number of intersections found (up to the specified maximum). This value indicates how many of the elements of the specifed intesections array were populated during the execution of this method. The contents of elements beyond that number are undefined.

Each of the populated elements of the intersections array contains information about the face on which the intersection occurred, the location of the intersection, and the distance from the ray startLocation where the intersection occurred. The location and distance components are specified in the local coordinates system of this mesh.

The intersections array is not sorted in any way. In particular, when the array contains multiple entries, the first element in the array does not necessily contain the closest intersection. If you need to determine the closest intersection, you can iterate the intersections array and compare the values of the location element of each intersection.

To use this method, allocate an array of CC3MeshIntersection structures, pass a reference to it in the intersections parameter, and indicate the size of that array in the maxHitCount parameter.

The method iterates through the faces in the mesh until the indicated number of intersections are found, or until all the faces in the mesh have been inspected. Therefore, to keep performance high, you should set the maxHitCount parameter no higher than the number of intersections that are useful to you. For example, specifiying a value of one for the maxHitCount parameter will cause this method to return as soon as the first intersection is found. In most cases, this is all that is needed.

The allowBackFaces parameter is used to indicate whether to include intersections where the ray pierces a face from its back face. Typically, this means that the ray has intersected the face as the ray exits on the far side of the mesh. In most cases you will interested only where the ray intersects the near side of the mesh, in which case you can set this parameter to NO.

The allowBehind parameter is used to indicate whether to include intersections that occur behind the startLocation of the ray, in the direction opposite to the direction of the ray. Typically, this might mean the mesh is located behind the ray startLocation, or it might mean the ray starts inside the mesh. Again,in most cases, you will be interested only in intersections that occur in the direction the ray is pointing, and can ususally set this parameter to NO.

- (void) flipHorizontallyTextureUnit: (GLuint) texUnit

Convenience method that flips the texture coordinate mapping horizontally for the specified texture channels.

This has the effect of flipping the texture for that texture channel horizontally on the model. and can be useful for creating interesting effects, or mirror images.

This implementation flips correctly if the mesh is mapped to only a section of the texture (a texture atlas).

- (void) flipTexturesHorizontally

Convenience method that flips the texture coordinate mapping horizontally for all texture units.

This has the effect of flipping the textures horizontally on the model. and can be useful for creating interesting effects, or mirror images.

This implementation flips correctly if the mesh is mapped to only a section of the texture (a texture atlas).

This has the same effect as invoking the flipHorizontallyTextureUnit: method for all texture units.

This method will also invoke the superclass behaviour to invoke the same method on each child node.

Implements CC3Node.

- (void) flipTexturesVertically

Convenience method that flips the texture coordinate mapping vertically for all texture units.

This has the effect of flipping the textures vertically on the model. and can be useful for creating interesting effects, or mirror images.

This implementation flips correctly if the mesh is mapped to only a section of the texture (a texture atlas).

This has the same effect as invoking the flipVerticallyTextureUnit: method for all texture units.

This method will also invoke the superclass behaviour to invoke the same method on each child node.

Implements CC3Node.

- (void) flipVerticallyTextureUnit: (GLuint) texUnit

Convenience method that flips the texture coordinate mapping vertically for the specified texture channels.

This has the effect of flipping the texture for that texture channel vertically on the model. and can be useful for creating interesting effects, or mirror images.

This implementation flips correctly if the mesh is mapped to only a section of the texture (a texture atlas).

- (CC3Material*) makeMaterial

Creates and returns a suitable material for this mesh node.

This method is invoked automatically by the material property accessor method if a material is needed, but has not yet been established.

This implementation returns an instance of CC3Material initialized with the default initializer method. Subclasses may override to provide a different material.

- (CC3Mesh*) makeMesh

This template method creates a suitable mesh for this mesh node.

This implementation invokes [CC3Mesh mesh], and returns the result. Subclasses may override to provide a different mesh.

This method is invoked automatically by the ensureMesh method if a mesh is needed, but has not yet been established. Usually, you will never need to invoke this method.

- (void) moveMeshOriginTo: (CC3Vector) aLocation

Changes the mesh vertices so that the origin of the mesh is at the specified location.

The origin of the mesh is the location (0,0,0) in the local coordinate system, and is the location around which all transforms are performed.

This method can be used to adjust the mesh structure to make it easier to apply transformations, by moving the origin of the transformations to a more convenient location in the mesh.

This method changes the location component of every vertex in the mesh. This can be quite costly, and should only be performed once, to adjust a mesh so that it is easier to manipulate. As an alternate, you should consider changing the origin of the mesh at development time using a 3D editor.

Do not use this method to move your model around. Instead, use the transform properties (location, rotation and scale) of this node, and let the GL engine do the heavy lifting of transforming the mesh vertices.

This method automatically invokes the markBoundingVolumeDirty method, to ensure that the boundingVolume encompasses the new vertex locations.

This method also ensures that the GL VBO that holds the vertex content is updated.

- (void) moveMeshOriginToCenterOfGeometry

Changes the mesh vertices so that the origin of the mesh is at the center of geometry of the mesh.

The origin of the mesh is the location (0,0,0) in the local coordinate system, and is the location around which all transforms are performed.

This method can be used to adjust the mesh structure to make it easier to apply transformations, by moving the origin of the transformations to the center of the mesh.

This method changes the location component of every vertex in the mesh. This can be quite costly, and should only be performed once, to adjust a mesh so that it is easier to manipulate. As an alternate, you should consider changing the origin of the mesh at development time using a 3D editor.

Do not use this method to move your model around. Instead, use the transform properties (location, rotation and scale) of this node, and let the GL engine do the heavy lifting of transforming the mesh vertices.

This method automatically invokes the markBoundingVolumeDirty method, to ensure that the boundingVolume encompasses the new vertex locations.

This method also ensures that the GL VBO that holds the vertex content is updated.

- (void) movePivotTo: (CC3Vector) __deprecated

Deprecated:: Renamed to moveMeshOriginTo:.

- (void) populateAsBitmapFontLabelFromString:	(NSString *)	lblString
fromFontFile:	(NSString *)	fontFileName
andLineHeight:	(GLfloat)	lineHeight
andTextAlignment:	(NSTextAlignment)	textAlignment
andRelativeOrigin:	(CGPoint)	origin
andTessellation:	(CC3Tessellation)	divsPerChar

Populates this instance as a rectangular mesh displaying the text of the specified string, built from bitmap character images taken from a texture atlas as defined by the bitmpped font configuration loaded from the specified font configuration file.

A compatible bitmap font configuration file, and associated texture, can be created using any of these editors: http://glyphdesigner.71squared.com/ (Commercial, Mac OS X) http://www.bmglyph.com/ (Commercial, Mac OS X - also available through AppStore) http://www.n4te.com/hiero/hiero.jnlp (Free, Java) http://slick.cokeandcode.com/demos/hiero.jnlp (Free, Java) http://www.angelcode.com/products/bmfont/ (Free, Windows only)

The texture that matches the specified font configuration (and identified in the font configuration), is automatically loaded and assigned to the texture property of this mesh node.

The text may be multi-line, and can be left-, center- or right-aligned, as specified.

The specified lineHeight define the height of a line of text in the coordinate system of this mesh node. This parameter can be set to zero to use the natural line height of the font.

For example, a font with font size of 16 might have a natural line height of 19. Setting the lineHeight parameter to zero would result in a mesh where a line of text would be 19 units high. On the other hand, setting this property to 0.2 will result in a mesh where the same line of text has a height of 0.2 units. Depending on the size of other models in your scene, you may want to set this lineHeight to something compatible. In addition, the visual size of the text will also be affected by the value of the scale or uniformScale properties of this node. Both the lineHeight and scale properties work to establish the visual size of the label text.

For a more granular mesh, each character rectangle can be divided into many smaller divisions. Building a rectanglular surface from more than one division can dramatically improve realism when the surface is illuminated with specular lighting or a tightly focused spotlight, or if the mesh is to be deformed in some way by a later process (such as wrapping the text texture around some other shape).

The divsPerChar argument indicates how to break each character rectangle into multiple faces. The X & Y elements of the divsPerChar argument indicate how each axis if the rectangle for each character should be divided into faces. The number of faces in the rectangle for each character will therefore be the multiplicative product of the X & Y elements of the divsPerChar argument.

For example, a value of {3,2} for the divsPerChar argument will result in each character being divided into 6 smaller rectangular faces, arranged into a 3x2 grid.

The relative origin defines the location of the origin for texture alignment, and is specified as a fraction of the size of the overall label layout, starting from the bottom-left corner.

For example, origin values of (0, 0), (0.5, 0.5), and (1, 1) indicate that the label mesh should be aligned so that the bottom-left corner, center, or top-right corner, respectively, should be located at the local origin of the corresponding mesh.

The vertexContentType property of this mesh may be set prior to invoking this method, to define the content type for each vertex. Content types kCC3VertexContentLocation, kCC3VertexContentNormal, and kCC3VertexContentTextureCoordinate are populated by this method.

If the vertexContentType property has not already been set, that property is set to a value of (kCC3VertexContentLocation | kCC3VertexContentNormal | kCC3VertexContentTextureCoordinate), and the mesh will be populated with location, normal and texture coordinates for each vertex.

This method may be invoked repeatedly to change the label string. The mesh will automomatically be rebuilt to the correct number of vertices required to display the currently specified string.

Provided by category CC3MeshNode(BitmapLabel).

- (void) populateAsCenteredRectangleWithSize: (CGSize) rectSize

Populates this instance as a simple rectangular mesh of the specified size, centered at the origin, and laid out on the X-Y plane.

The rectangular mesh contains only one face with two triangles. The result is the same as invoking populateAsCenteredRectangleWithSize:andTessellation: with the divsPerAxis argument set to {1,1}.

This mesh can be covered with a solid material or a single texture. If this mesh is to be covered with a texture, use the texture property of this node to set the texture. If a solid color is desired, leave the texture property unassigned.

The vertexContentType property of this mesh node may be set prior to invoking this method, to define the content type for each vertex. Content types kCC3VertexContentLocation, kCC3VertexContentNormal, and kCC3VertexContentTextureCoordinate are populated by this method.

If the vertexContentType property has not already been set, that property is set to a value of (kCC3VertexContentLocation | kCC3VertexContentNormal | kCC3VertexContentTextureCoordinate). and the mesh will be populated with location, normal and texture coordinates for each vertex.

Provided by category CC3MeshNode(ParametricShapes).

- (void) populateAsCenteredRectangleWithSize:	(CGSize)	rectSize
andTessellation:	(CC3Tessellation)	divsPerAxis

Populates this instance as a simple rectangular mesh of the specified size, centered at the origin, and laid out on the X-Y plane.

The large rectangle can be divided into many smaller divisions. Building a rectanglular surface from more than one division can dramatically improve realism when the surface is illuminated with specular lighting or a tightly focused spotlight, because increasing the face count increases the number of vertices that interact with the specular or spot lighting.

The divsPerAxis argument indicates how to break this large rectangle into multiple faces. The X & Y elements of the divsPerAxis argument indicate how each axis if the rectangle should be divided into faces. The total number of faces in the rectangle will therefore be the multiplicative product of the X & Y elements of the divsPerAxis argument.

For example, a value of {5,5} for the divsPerAxis argument will result in the rectangle being divided into 25 faces, arranged into a 5x5 grid.

This mesh can be covered with a solid material or a single texture. If this mesh is to be covered with a texture, use the texture property of this node to set the texture. If a solid color is desired, leave the texture property unassigned.

The vertexContentType property of this mesh node may be set prior to invoking this method, to define the content type for each vertex. Content types kCC3VertexContentLocation, kCC3VertexContentNormal, and kCC3VertexContentTextureCoordinate are populated by this method.

If the vertexContentType property has not already been set, that property is set to a value of (kCC3VertexContentLocation | kCC3VertexContentNormal | kCC3VertexContentTextureCoordinate). and the mesh will be populated with location, normal and texture coordinates for each vertex.

Provided by category CC3MeshNode(ParametricShapes).

- (void) populateAsCenteredRectangleWithSize:	(CGSize)	rectSize
andTessellation:	(CC3Tessellation)	divsPerAxis
withTexture:	(CC3Texture *)	texture
invertTexture:	(BOOL)	__deprecated

Deprecated:: Use the populateAsCenteredRectangleWithSize:andTessellation: method instead, and then use the texture property of this node to set the texture.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsCenteredRectangleWithSize:	(CGSize)	rectSize
withTexture:	(CC3Texture *)	texture
invertTexture:	(BOOL)	__deprecated

Deprecated:: Use the populateAsCenteredRectangleWithSize: method instead, and then use the texture property of this node to set the texture.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsCenteredTexturedRectangleWithSize: (CGSize) __deprecated

Deprecated:: Use populateAsCenteredRectangleWithSize:, as it creates a rectangular mesh that can be covered with either a texture or a solid color.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsCenteredTexturedRectangleWithSize:	(CGSize)	rectSize
andTessellation:	(CC3Tessellation)	__deprecated

Deprecated:: Use populateAsCenteredRectangleWithSize:andTessellation:, as it creates a rectangular mesh that can be covered with either a texture or a solid color.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsCubeMappedSolidBox: (CC3Box) box

Populates this instance as a simple rectangular box mesh from the specified bounding box, which contains two of the diagonal corners of the box.

This mesh can be covered with a solid material or a single texture. If this mesh is to be covered with a texture, use the texture property of this node to set the texture. If a solid color is desired, leave the texture property unassigned.

The vertexContentType property of this mesh node may be set prior to invoking this method, to define the content type for each vertex. Content types kCC3VertexContentLocation, kCC3VertexContentNormal, and kCC3VertexContentTextureCoordinate are populated by this method.

If the vertexContentType property has not already been set, that property is set to a value of (kCC3VertexContentLocation | kCC3VertexContentNormal | kCC3VertexContentTextureCoordinate). and the mesh will be populated with location, normal and texture coordinates for each vertex.

If a texture is to be wrapped around this mesh, since the single texture is wrapped around all six sides of the box, the texture will be mapped according to the layout illustrated in the texture file BoxTexture.png, included in the distribution.

The "front" of the box is the side that faces towards the positive-Z axis, the "top" of the box is the side that faces towards the positive-Y axis, and the "right" side of the box is the side that faces towards the positive-X axis.

For the purposes of wrapping the texture around the box, this method assumes that the texture is an unfolded cube. The box can be created with any relative dimensions, but if it is not a cube, the texture may appear stretched or shrunk on two or more sides. The texture will still fully wrap all six sides of the box, but the texture is stretched or shrunk to fit each side according to its dimension relative to the other sides. The appearance will be as if you had started with a textured cube and then pulled one or two of the dimensions out further.

For higher fidelity in applying textures to non-cube boxes, so that the texture will not be stretched to fit, use either of the populateAsSolidBox: or populateAsSolidBox:withCorner: methods, with a texture whose layout is compatible with the aspect ratio of the box.

Thanks to Cocos3D user andyman for contributing the prototype code and texture template file for this method.

Provided by category CC3MeshNode(ParametricShapes).

- (void) populateAsDiskWithRadius:	(GLfloat)	radius
andTessellation:	(CC3Tessellation)	radialAndAngleDivs

Populates this instance as a flat, single-sided circular disk mesh of the specified radius, centered at the origin, and laid out on the X-Y plane.

The surface of the disk is divided into many smaller divisions, both in the radial and angular dimensions.

The radialAndAngleDivs argument indicates how to divide the surface of the disks into divisions. The X element of the radialAndAngleDivs argument indicates how many radial divisions will occur from the center and the circuferential edge. A value of one means that the mesh will consist of a series of radial triangles from the center of the circle to the edge. A larger value for the X element of the radialAndAngleDivs argument will structure the mesh as a series of concentric rings. This value must be at least one.

The Y element of the radialAndAngleDivs argument indicates how many angular divisions will occur around the circumference. This value must be at least three, which will essentially render the circle as a triangle. But, typically, this value will be larger.

For example, a value of {4,24} for the radialAndAngleDivs argument will result in the disk being divided into four concentric rings, each divided into 24 segments around the circumference of the circle.

Each segement, except those in the innermost disk is trapezoidal, and will be constructed from two triangular mesh faces. Therefore, the number of triangles in the mesh will be (2X - 1) * Y, where X = radialAndAngleDivs.x and Y = radialAndAngleDivs.y.

This mesh can be covered with a solid material or a single texture. If this mesh is to be covered with a texture, use the texture property of this node to set the texture. If a solid color is desired, leave the texture property unassigned.

The texture is mapped to the tessellated disk as if a tagential square was overlaid over the circle, starting from the lower left corner, where both X and Y are at a minimum. The center of the disk maps to the center of the texture.

The vertexContentType property of this mesh node may be set prior to invoking this method, to define the content type for each vertex. Content types kCC3VertexContentLocation, kCC3VertexContentNormal, and kCC3VertexContentTextureCoordinate are populated by this method.

If the vertexContentType property has not already been set, that property is set to a value of (kCC3VertexContentLocation | kCC3VertexContentNormal | kCC3VertexContentTextureCoordinate). and the mesh will be populated with location, normal and texture coordinates for each vertex.

Provided by category CC3MeshNode(ParametricShapes).

- (void) populateAsHollowConeWithRadius:	(GLfloat)	radius
height:	(GLfloat)	height
andTessellation:	(CC3Tessellation)	angleAndHeightDivs

Populates this instance as a conical mesh of the specified radius and height.

The mesh is constructed so that the base of the cone is centered on the origin of the X-Z plane, and the apex is on the positive Y-axis at the specified height. The cone is open and does not have a bottom.

The surface of the cone is divided into many smaller divisions, as specified by the angleAndHeightsDivs parameter. The X-coordinate of this parameter indicates how many angular divisions are created around the circumference of the base, and the Y-coordinate of this parameter indicates how many vertical divisions are created between the base and the apex.

For example, a value of {12,8} for the angleAndHeightsDivs parameter will result in a cone with 12 divisions around the circumference of the base, and 8 divisions along the Y-axis to the apex.

By reducing the number of angular divisions to 3 or 4, you can use this method to create a tetrahedron or square pyramid, respectively.

This mesh can be covered with a solid material or a single texture. If this mesh is to be covered with a texture, use the texture property of this mesh to set the texture. If a solid color is desired, leave the texture property unassigned.

The vertexContentType property of this mesh may be set prior to invoking this method, to define the content type for each vertex. Content types kCC3VertexContentLocation, kCC3VertexContentNormal, and kCC3VertexContentTextureCoordinate are populated by this method.

If the vertexContentType property has not already been set, that property is set to a value of (kCC3VertexContentLocation | kCC3VertexContentNormal | kCC3VertexContentTextureCoordinate). and the mesh will be populated with location, normal and texture coordinates for each vertex.

If a texture is applied to this mesh, it is mapped to the cone with a simple horizontal projection. Horizontal lines in the texture will remain parallel, but vertical lines will converge at the apex. Texture wrapping begins at the negative Z-axis, so the center of the texture will be positioned at the point where the cone intersects the positive Z-axis, and the conceptual seam (where the left and right edges of the texture are stitched together) will occur where the cone intersects the negative-Z axis. This texture orientation means that the center of the texture will face the forwardDirection of the cone node.

Provided by category CC3MeshNode(ParametricShapes).

- (void) populateAsLineStripWith:	(GLuint)	vertexCount
vertices:	(CC3Vector *)	vertices
andRetain:	(BOOL)	shouldRetainVertices

Populates this instance as a line strip with the specified number of vertex points.

The data for the points that define the end-points of the lines are contained within the specified vertices array. The vertices array must contain at least vertexCount elements.

The lines are specified and rendered as a strip, where each line is connected to the previous and following lines. Each line starts at the point where the previous line ended, and that point is defined only once in the vertices array. Therefore, the number of lines drawn is equal to one less than the specified vertexCount.

The shouldRetainVertices flag indicates whether the data in the vertices array should be retained by this instance. If this flag is set to YES, the data in the vertices array will be copied to an internal array that is managed by this instance. If this flag is set to NO, the data is not copied internally and, instead, a reference to the vertices data is established. In this case, it is up to you to manage the lifespan of the data contained in the vertices array.

If you are defining the vertices data dynamically in another method, you may want to set this flag to YES to have this instance copy and manage the data. If the vertices array is a static array, you can set this flag to NO.

This is a convenience method for creating a simple, but useful, shape.

Provided by category CC3MeshNode(ParametricShapes).

- (void) populateAsRectangleWithSize:	(CGSize)	rectSize
andPivot:	(CGPoint)	__deprecated

Deprecated:: Renamed to populateAsRectangleWithSize:andRelativeOrigin:.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsRectangleWithSize:	(CGSize)	rectSize
andPivot:	(CGPoint)	pivot
andTessellation:	(CC3Tessellation)	__deprecated

Deprecated:: Renamed to populateAsRectangleWithSize:andRelativeOrigin:andTessellation.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsRectangleWithSize:	(CGSize)	rectSize
andPivot:	(CGPoint)	pivot
andTessellation:	(CC3Tessellation)	divsPerAxis
withTexture:	(CC3Texture *)	texture
invertTexture:	(BOOL)	__deprecated

Deprecated:: Use the populateAsCenteredRectangleWithSize:andRelativeOrigin:andTessellation: method instead, and then use the texture property of this node to set the texture.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsRectangleWithSize:	(CGSize)	rectSize
andPivot:	(CGPoint)	pivot
withTexture:	(CC3Texture *)	texture
invertTexture:	(BOOL)	__deprecated

Deprecated:: Use the populateAsRectangleWithSize:andRelativeOrigin: method instead, and then use the texture property of this node to set the texture.

Provided by category CC3MeshNode(DeprecatedParametricShapes).

- (void) populateAsRectangleWithSize:	(CGSize)	rectSize
andRelativeOrigin:	(CGPoint)	origin

Populates this instance as a simple rectangular mesh of the specified size, with the specified relative origin, and laid out on the X-Y plane.

The rectangular mesh contains only one face with two triangles. The result is the same as invoking the populateAsRectangleWithSize:andRelativeOrigin:andTessellation: with the divsPerAxis argument set to {1,1}.

The relative origin is a fractional point that is relative to the rectangle's extent, and indicates where the origin of the rectangular mesh is to be located. The mesh origin is the origin of the local coordinate system of the mesh, and is the basis for all transforms applied to the mesh (including the location and rotation properties).

The specified relative origin should be a fractional value. If it is {0, 0}, the rectangle will be laid out so that the bottom-left corner is at the origin. If it is {1, 1}, the rectangle will be laid out so that the top-right corner of the rectangle is at the origin. If it is {0.5, 0.5}, the rectangle will be laid out with the origin at the center, as in the populateAsCenteredRectangleWithSize: method.

This mesh can be covered with a solid material or a single texture. If this mesh is to be covered with a texture, use the texture property of this mesh to set the texture. If a solid color is desired, leave the texture property unassigned.

The vertexContentType property of this mesh may be set prior to invoking this method, to define the content type for each vertex. Content types kCC3VertexContentLocation, kCC3VertexContentNormal, and kCC3VertexContentTextureCoordinate are populated by this method.

If the vertexContentType property has not already been set, that property is set to a value of (kCC3VertexContentLocation | kCC3VertexContentNormal | kCC3VertexContentTextureCoordinate), and the mesh will be populated with location, normal and texture coordinates for each vertex.

Provided by category CC3MeshNode(ParametricShapes).

- (void) populateAsRectangleWithSize:	(CGSize)	rectSize
andRelativeOrigin:	(CGPoint)	origin
andTessellation:	(CC3Tessellation)	divsPerAxis