libpanda :: NodePath :: Class NodePath
[frames] | no frames]

Class NodePath


// // A NodePath is the fundamental unit of high-level interaction with // the scene graph. It encapsulates the complete path down to a node // from some other node, usually the root of the scene graph. This is // used to resolve ambiguities associated with instancing. // // NodePath also contains a number of handy high-level methods for // common scene-graph manipulations, such as reparenting, and common // state changes, such as repositioning. // // There are also a number of NodePath methods for finding nodes deep // within the tree by name or by type. These take a path string, // which at its simplest consists of a series of node names separated // by slashes, like a directory pathname. // // Each component of the path string may optionally consist of one of // the following special names, instead of a node name: // // * -- matches exactly one node, with any name. // ** -- matches any sequence of zero or more nodes. // +typename -- matches any node that is or derives from the given type. // -typename -- matches any node that is the given type exactly. // =tag -- matches any node that has the indicated tag. // =tag=value -- matches any node whose tag matches the indicated value. // // Furthermore, a node name may itself contain standard filename // globbing characters, like *, ?, and [a-z], that will be accepted as // a partial match. (In fact, the '*' special name may be seen as // just a special case of this.) The globbing characters may not be // used with the typename matches or with tag matches, but they may // be used to match a tag's value in the =tag=value syntax. // // The special characters "@@", appearing at the beginning of a node // name, indicate a stashed node. Normally, stashed nodes are not // returned by a find (but see the special flags, below), but a // stashed node may be found if it is explicitly named with its // leading @@ characters. By extension, "@@*" may be used to identify // any stashed node. // // Examples: // // "room//graph" will look for a node named "graph", which is a child // of an unnamed node, which is a child of a node named "room", which // is a child of the starting path. // // "**/red*" will look for any node anywhere in the tree (below the // starting path) with a name that begins with "red". // // "**/+PartBundleNode/**/head" will look for a node named "head", // somewhere below a PartBundleNode anywhere in the tree. // // // The search is always potentially ambiguous, even if the special // wildcard operators are not used, because there may be multiple // nodes in the tree with the same name. In general, in the case of // an ambiguity, the shortest path is preferred; when a method (such // as extend_by) must choose only only one of several possible paths, // it will choose the shortest available; on the other hand, when a // method (such as find_all_matches) is to return all of the matching // paths, it will sort them so that the shortest paths appear first in // the output. // // // Special flags. The entire string may optionally be followed by the // ";" character, followed by one or more of the following special // control flags, with no intervening spaces or punctuation: // // -h Do not return hidden nodes. // +h Do return hidden nodes. // -s Do not return stashed nodes unless explicitly referenced with @@. // +s Return stashed nodes even without any explicit @@ characters. // -i Node name comparisons are not case insensitive: case must match // exactly. // +i Node name comparisons are case insensitive: case is not important. // This affects matches against the node name only; node type // and tag strings are always case sensitive. // // The default flags are +h-s-i. // //////////////////////////////////////////////////////////////////// // Class : NodePath // Description : NodePath is the fundamental system for disambiguating // instances, and also provides a higher-level interface // for manipulating the scene graph. // // A NodePath is a list of connected nodes from the root // of the graph to any sub-node. Each NodePath // therefore uniquely describes one instance of a node. // // NodePaths themselves are lightweight objects that may // easily be copied and passed by value. Their data is // stored as a series of NodePathComponents that are // stored on the nodes. Holding a NodePath will keep a // reference count to all the nodes in the path. // However, if any node in the path is removed or // reparented (perhaps through a different NodePath), // the NodePath will automatically be updated to reflect // the changes. ////////////////////////////////////////////////////////////////////

Nested Classes
  NodePath
// // A NodePath is the fundamental unit of high-level interaction with // the scene graph.
Instance Methods
 
__cmp__(x, y)
cmp(x,y)
 
__delattr__(...)
x.__delattr__('name') <==> del x.name
 
__getattribute__(...)
x.__getattribute__('name') <==> x.name
 
__hash__(x)
hash(x)
 
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
a new object with type S, a subtype of T
__new__(T, S, ...)
 
__nonzero__(x)
x != 0
 
__repr__(x)
repr(x)
 
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
 
__str__(x)
str(x)
 
adjustAllPriorities(...)
C++ Interface: adjustAllPriorities(non-const NodePath this, int adjustment)
 
analyze(...)
C++ Interface: analyze(const NodePath this)
 
anyPath(...)
C++ Interface: anyPath(non-const PandaNode node) anyPath(non-const PandaNode node, non-const Thread current_thread)
 
applyTextureColors(...)
C++ Interface: applyTextureColors(non-const NodePath this)
 
assign(...)
C++ Interface: assign(non-const NodePath this, const NodePath copy)
 
attachCollisionRay(self, name, ox, oy, oz, dx, dy, dz, fromCollide, intoCollide)
 
attachCollisionSegment(self, name, ax, ay, az, bx, by, bz, fromCollide, intoCollide)
 
attachCollisionSphere(self, name, cx, cy, cz, r, fromCollide, intoCollide)
 
attachNewNode(...)
C++ Interface: attachNewNode(const NodePath this, non-const PandaNode node) attachNewNode(const NodePath this, string name) attachNewNode(const NodePath this, non-const PandaNode node, int sort) attachNewNode(const NodePath this, string name, int sort) attachNewNode(const NodePath this, non-const PandaNode node, int sort, non-const Thread current_thread) attachNewNode(const NodePath this, string name, int sort, non-const Thread current_thread)
 
calcTightBounds(...)
C++ Interface: calcTightBounds(const NodePath this, non-const Point3 min_point, non-const Point3 max_point) calcTightBounds(const NodePath this, non-const Point3 min_point, non-const Point3 max_point, non-const Thread current_thread)
 
clearAntialias(...)
C++ Interface: clearAntialias(non-const NodePath this)
 
clearAttrib(...)
C++ Interface: clearAttrib(non-const NodePath this, const TypeHandle type)
 
clearAudioVolume(...)
C++ Interface: clearAudioVolume(non-const NodePath this)
 
clearBillboard(...)
C++ Interface: clearBillboard(non-const NodePath this)
 
clearBin(...)
C++ Interface: clearBin(non-const NodePath this)
 
clearClipPlane(...)
C++ Interface: clearClipPlane(non-const NodePath this) clearClipPlane(non-const NodePath this, const NodePath clip_plane)
 
clearColor(...)
C++ Interface: clearColor(non-const NodePath this)
 
clearColorScale(...)
C++ Interface: clearColorScale(non-const NodePath this)
 
clearCompass(...)
C++ Interface: clearCompass(non-const NodePath this)
 
clearDepthTest(...)
C++ Interface: clearDepthTest(non-const NodePath this)
 
clearDepthWrite(...)
C++ Interface: clearDepthWrite(non-const NodePath this)
 
clearEffect(...)
C++ Interface: clearEffect(non-const NodePath this, const TypeHandle type)
 
clearEffects(...)
C++ Interface: clearEffects(non-const NodePath this)
 
clearFog(...)
C++ Interface: clearFog(non-const NodePath this)
 
clearLight(...)
C++ Interface: clearLight(non-const NodePath this) clearLight(non-const NodePath this, const NodePath light)
 
clearMat(...)
C++ Interface: clearMat(non-const NodePath this)
 
clearMaterial(...)
C++ Interface: clearMaterial(non-const NodePath this)
 
clearModelNodes(...)
C++ Interface: clearModelNodes(non-const NodePath this)
 
clearNormalMap(...)
C++ Interface: clearNormalMap(non-const NodePath this)
 
clearProjectTexture(...)
C++ Interface: clearProjectTexture(non-const NodePath this, non-const TextureStage stage)
 
clearPythonTag(...)
C++ Interface: clearPythonTag(non-const NodePath this, string key)
 
clearRenderMode(...)
C++ Interface: clearRenderMode(non-const NodePath this)
 
clearScissor(...)
C++ Interface: clearScissor(non-const NodePath this)
 
clearShader(...)
C++ Interface: clearShader(non-const NodePath this)
 
clearShaderInput(...)
C++ Interface: clearShaderInput(non-const NodePath this, non-const InternalName id) clearShaderInput(non-const NodePath this, string id)
 
clearTag(...)
C++ Interface: clearTag(non-const NodePath this, string key)
 
clearTexGen(...)
C++ Interface: clearTexGen(non-const NodePath this) clearTexGen(non-const NodePath this, non-const TextureStage stage)
 
clearTexProjector(...)
C++ Interface: clearTexProjector(non-const NodePath this) clearTexProjector(non-const NodePath this, non-const TextureStage stage)
 
clearTexTransform(...)
C++ Interface: clearTexTransform(non-const NodePath this) clearTexTransform(non-const NodePath this, non-const TextureStage stage)
 
clearTexture(...)
C++ Interface: clearTexture(non-const NodePath this) clearTexture(non-const NodePath this, non-const TextureStage stage)
 
clearTransform(...)
C++ Interface: clearTransform(non-const NodePath this) clearTransform(non-const NodePath this, const NodePath other) clearTransform(non-const NodePath this, non-const Thread current_thread) clearTransform(non-const NodePath this, const NodePath other, non-const Thread current_thread)
 
clearTransparency(...)
C++ Interface: clearTransparency(non-const NodePath this)
 
clearTwoSided(...)
C++ Interface: clearTwoSided(non-const NodePath this)
 
colorInterval(self, *args, **kw)
 
colorScaleInterval(self, *args, **kw)
 
compareTo(...)
C++ Interface: compareTo(const NodePath this, const NodePath other)
 
composeColorScale(...)
C++ Interface: composeColorScale(non-const NodePath this, const VBase4 scale) composeColorScale(non-const NodePath this, const VBase4 scale, int priority) composeColorScale(non-const NodePath this, float sx, float sy, float sz, float sa) composeColorScale(non-const NodePath this, float sx, float sy, float sz, float sa, int priority)
 
copyTo(...)
C++ Interface: copyTo(const NodePath this, const NodePath other) copyTo(const NodePath this, const NodePath other, int sort) copyTo(const NodePath this, const NodePath other, int sort, non-const Thread current_thread)
 
countNumDescendants(...)
C++ Interface: countNumDescendants(const NodePath this)
 
deselect(self)
 
detachNode(...)
C++ Interface: detachNode(non-const NodePath this) detachNode(non-const NodePath this, non-const Thread current_thread)
 
doBillboardAxis(...)
C++ Interface: doBillboardAxis(non-const NodePath this, const NodePath camera, float offset)
 
doBillboardPointEye(...)
C++ Interface: doBillboardPointEye(non-const NodePath this, const NodePath camera, float offset)
 
doBillboardPointWorld(...)
C++ Interface: doBillboardPointWorld(non-const NodePath this, const NodePath camera, float offset)
 
eq(...)
C++ Interface: eq(const NodePath this, const NodePath other)
 
explore(self)
 
fail(...)
C++ Interface: fail()
 
find(...)
C++ Interface: find(const NodePath this, string path)
 
findAllMatches(...)
C++ Interface: findAllMatches(const NodePath this, string path)
 
findAllMaterials(...)
C++ Interface: findAllMaterials(const NodePath this) findAllMaterials(const NodePath this, string name)
 
findAllPathsTo(...)
C++ Interface: findAllPathsTo(const NodePath this, non-const PandaNode node)
 
findAllTexcoords(...)
C++ Interface: findAllTexcoords(const NodePath this) findAllTexcoords(const NodePath this, string name)
 
findAllTextureStages(...)
C++ Interface: findAllTextureStages(const NodePath this) findAllTextureStages(const NodePath this, string name)
 
findAllTextures(...)
C++ Interface: findAllTextures(const NodePath this) findAllTextures(const NodePath this, non-const TextureStage stage) findAllTextures(const NodePath this, string name)
 
findAllVertexColumns(...)
C++ Interface: findAllVertexColumns(const NodePath this) findAllVertexColumns(const NodePath this, string name)
 
findMaterial(...)
C++ Interface: findMaterial(const NodePath this, string name)
 
findNetPythonTag(...)
C++ Interface: findNetPythonTag(const NodePath this, string key)
 
findNetTag(...)
C++ Interface: findNetTag(const NodePath this, string key)
 
findPathTo(...)
C++ Interface: findPathTo(const NodePath this, non-const PandaNode node)
 
findTexture(...)
C++ Interface: findTexture(const NodePath this, non-const TextureStage stage) findTexture(const NodePath this, string name)
 
findTextureStage(...)
C++ Interface: findTextureStage(const NodePath this, string name)
 
flattenLight(...)
C++ Interface: flattenLight(non-const NodePath this)
 
flattenMedium(...)
C++ Interface: flattenMedium(non-const NodePath this)
 
flattenMultitex(self, stateFrom=None, target=None, useGeom=0, allowTexMat=0, win=None)
 
flattenStrong(...)
C++ Interface: flattenStrong(non-const NodePath this)
 
forceRecomputeBounds(...)
C++ Interface: forceRecomputeBounds(non-const NodePath this)
 
getAncestor(...)
C++ Interface: getAncestor(const NodePath this, int index) getAncestor(const NodePath this, int index, non-const Thread current_thread)
 
getAncestors(...)
 
getAncestry(self)
Get a list of a node path's ancestors
 
getAntialias(...)
C++ Interface: getAntialias(const NodePath this)
 
getAttrib(...)
C++ Interface: getAttrib(const NodePath this, const TypeHandle type)
 
getAudioVolume(...)
C++ Interface: getAudioVolume(const NodePath this)
 
getBinDrawOrder(...)
C++ Interface: getBinDrawOrder(const NodePath this)
 
getBinName(...)
C++ Interface: getBinName(const NodePath this)
 
getBounds(...)
C++ Interface: getBounds(const NodePath this) getBounds(const NodePath this, non-const Thread current_thread)
 
getChild(...)
C++ Interface: getChild(const NodePath this, int n) getChild(const NodePath this, int n, non-const Thread current_thread)
 
getChildren(...)
C++ Interface: getChildren(const NodePath this) getChildren(const NodePath this, non-const Thread current_thread)
 
getChildrenAsList(self)
Converts a node path's child NodePathCollection into a list
 
getClassType(...)
C++ Interface: getClassType()
 
getCollideMask(...)
C++ Interface: getCollideMask(const NodePath this)
 
getColor(...)
C++ Interface: getColor(const NodePath this)
 
getColorScale(...)
C++ Interface: getColorScale(const NodePath this)
 
getCommonAncestor(...)
C++ Interface: getCommonAncestor(const NodePath this, const NodePath other) getCommonAncestor(const NodePath this, const NodePath other, non-const Thread current_thread)
 
getDepthTest(...)
C++ Interface: getDepthTest(const NodePath this)
 
getDepthWrite(...)
C++ Interface: getDepthWrite(const NodePath this)
 
getDistance(...)
C++ Interface: getDistance(const NodePath this, const NodePath other)
 
getEffect(...)
C++ Interface: getEffect(const NodePath this, const TypeHandle type)
 
getEffects(...)
C++ Interface: getEffects(const NodePath this)
 
getErrorType(...)
C++ Interface: getErrorType(const NodePath this)
 
getFog(...)
C++ Interface: getFog(const NodePath this)
 
getH(...)
C++ Interface: getH(const NodePath this) getH(const NodePath this, const NodePath other)
 
getHiddenAncestor(...)
C++ Interface: getHiddenAncestor(const NodePath this) getHiddenAncestor(const NodePath this, const BitMask camera_mask) getHiddenAncestor(const NodePath this, const BitMask camera_mask, non-const Thread current_thread)
 
getHpr(...)
C++ Interface: getHpr(const NodePath this) getHpr(const NodePath this, const NodePath other)
 
getKey(...)
C++ Interface: getKey(const NodePath this)
 
getMat(...)
C++ Interface: getMat(const NodePath this) getMat(const NodePath this, const NodePath other)
 
getMaterial(...)
C++ Interface: getMaterial(const NodePath this)
 
getMaxSearchDepth(...)
C++ Interface: getMaxSearchDepth()
 
getName(...)
C++ Interface: getName(const NodePath this)
 
getNetAudioVolume(...)
C++ Interface: getNetAudioVolume(const NodePath this)
 
getNetPrevTransform(...)
C++ Interface: getNetPrevTransform(const NodePath this) getNetPrevTransform(const NodePath this, non-const Thread current_thread)
 
getNetPythonTag(...)
C++ Interface: getNetPythonTag(const NodePath this, string key)
 
getNetState(...)
C++ Interface: getNetState(const NodePath this) getNetState(const NodePath this, non-const Thread current_thread)
 
getNetTag(...)
C++ Interface: getNetTag(const NodePath this, string key)
 
getNetTransform(...)
C++ Interface: getNetTransform(const NodePath this) getNetTransform(const NodePath this, non-const Thread current_thread)
 
getNode(...)
C++ Interface: getNode(const NodePath this, int index) getNode(const NodePath this, int index, non-const Thread current_thread)
 
getNodes(...)
 
getNumChildren(...)
C++ Interface: getNumChildren(const NodePath this) getNumChildren(const NodePath this, non-const Thread current_thread)
 
getNumDescendants(self)
 
getNumNodes(...)
C++ Interface: getNumNodes(const NodePath this) getNumNodes(const NodePath this, non-const Thread current_thread)
 
getP(...)
C++ Interface: getP(const NodePath this) getP(const NodePath this, const NodePath other)
 
getParent(...)
C++ Interface: getParent(const NodePath this) getParent(const NodePath this, non-const Thread current_thread)
 
getPos(...)
C++ Interface: getPos(const NodePath this) getPos(const NodePath this, const NodePath other)
 
getPosDelta(...)
C++ Interface: getPosDelta(const NodePath this) getPosDelta(const NodePath this, const NodePath other)
 
getPrevTransform(...)
C++ Interface: getPrevTransform(const NodePath this) getPrevTransform(const NodePath this, const NodePath other) getPrevTransform(const NodePath this, non-const Thread current_thread) getPrevTransform(const NodePath this, const NodePath other, non-const Thread current_thread)
 
getPythonTag(...)
C++ Interface: getPythonTag(const NodePath this, string key)
 
getQuat(...)
C++ Interface: getQuat(const NodePath this) getQuat(const NodePath this, const NodePath other)
 
getR(...)
C++ Interface: getR(const NodePath this) getR(const NodePath this, const NodePath other)
 
getRelativePoint(...)
C++ Interface: getRelativePoint(const NodePath this, const NodePath other, const VBase3 point)
 
getRelativeVector(...)
C++ Interface: getRelativeVector(const NodePath this, const NodePath other, const VBase3 vec)
 
getRenderMode(...)
C++ Interface: getRenderMode(const NodePath this)
 
getRenderModePerspective(...)
C++ Interface: getRenderModePerspective(const NodePath this)
 
getRenderModeThickness(...)
C++ Interface: getRenderModeThickness(const NodePath this)
 
getSa(...)
C++ Interface: getSa(const NodePath this)
 
getSb(...)
C++ Interface: getSb(const NodePath this)
 
getScale(...)
C++ Interface: getScale(const NodePath this) getScale(const NodePath this, const NodePath other)
 
getSg(...)
C++ Interface: getSg(const NodePath this)
 
getShader(...)
C++ Interface: getShader(const NodePath this)
 
getShaderInput(...)
C++ Interface: getShaderInput(const NodePath this, non-const InternalName id) getShaderInput(const NodePath this, string id)
 
getShear(...)
C++ Interface: getShear(const NodePath this) getShear(const NodePath this, const NodePath other)
 
getShxy(...)
C++ Interface: getShxy(const NodePath this) getShxy(const NodePath this, const NodePath other)
 
getShxz(...)
C++ Interface: getShxz(const NodePath this) getShxz(const NodePath this, const NodePath other)
 
getShyz(...)
C++ Interface: getShyz(const NodePath this) getShyz(const NodePath this, const NodePath other)
 
getSort(...)
C++ Interface: getSort(const NodePath this) getSort(const NodePath this, non-const Thread current_thread)
 
getSr(...)
C++ Interface: getSr(const NodePath this)
 
getStashedAncestor(...)
C++ Interface: getStashedAncestor(const NodePath this) getStashedAncestor(const NodePath this, non-const Thread current_thread)
 
getStashedChildren(...)
C++ Interface: getStashedChildren(const NodePath this) getStashedChildren(const NodePath this, non-const Thread current_thread)
 
getState(...)
C++ Interface: getState(const NodePath this) getState(const NodePath this, const NodePath other) getState(const NodePath this, non-const Thread current_thread) getState(const NodePath this, const NodePath other, non-const Thread current_thread)
 
getSx(...)
C++ Interface: getSx(const NodePath this) getSx(const NodePath this, const NodePath other)
 
getSy(...)
C++ Interface: getSy(const NodePath this) getSy(const NodePath this, const NodePath other)
 
getSz(...)
C++ Interface: getSz(const NodePath this) getSz(const NodePath this, const NodePath other)
 
getTag(...)
C++ Interface: getTag(const NodePath this, string key)
 
getTexGen(...)
C++ Interface: getTexGen(const NodePath this, non-const TextureStage stage)
 
getTexGenLight(...)
C++ Interface: getTexGenLight(const NodePath this, non-const TextureStage stage)
 
getTexHpr(...)
C++ Interface: getTexHpr(const NodePath this, non-const TextureStage stage) getTexHpr(const NodePath this, const NodePath other, non-const TextureStage stage)
 
getTexOffset(...)
C++ Interface: getTexOffset(const NodePath this, non-const TextureStage stage) getTexOffset(const NodePath this, const NodePath other, non-const TextureStage stage)
 
getTexPos(...)
C++ Interface: getTexPos(const NodePath this, non-const TextureStage stage) getTexPos(const NodePath this, const NodePath other, non-const TextureStage stage)
 
getTexProjectorFrom(...)
C++ Interface: getTexProjectorFrom(const NodePath this, non-const TextureStage stage)
 
getTexProjectorTo(...)
C++ Interface: getTexProjectorTo(const NodePath this, non-const TextureStage stage)
 
getTexRotate(...)
C++ Interface: getTexRotate(const NodePath this, non-const TextureStage stage) getTexRotate(const NodePath this, const NodePath other, non-const TextureStage stage)
 
getTexScale(...)
C++ Interface: getTexScale(const NodePath this, non-const TextureStage stage) getTexScale(const NodePath this, const NodePath other, non-const TextureStage stage)
 
getTexScale3d(...)
C++ Interface: getTexScale3d(const NodePath this, non-const TextureStage stage) getTexScale3d(const NodePath this, const NodePath other, non-const TextureStage stage)
 
getTexTransform(...)
C++ Interface: getTexTransform(const NodePath this, non-const TextureStage stage) getTexTransform(const NodePath this, const NodePath other, non-const TextureStage stage)
 
getTexture(...)
C++ Interface: getTexture(const NodePath this) getTexture(const NodePath this, non-const TextureStage stage)
 
getTightBounds(self)
 
getTop(...)
C++ Interface: getTop(const NodePath this) getTop(const NodePath this, non-const Thread current_thread)
 
getTopNode(...)
C++ Interface: getTopNode(const NodePath this) getTopNode(const NodePath this, non-const Thread current_thread)
 
getTransform(...)
C++ Interface: getTransform(const NodePath this) getTransform(const NodePath this, const NodePath other) getTransform(const NodePath this, non-const Thread current_thread) getTransform(const NodePath this, const NodePath other, non-const Thread current_thread)
 
getTransparency(...)
C++ Interface: getTransparency(const NodePath this)
 
getTwoSided(...)
C++ Interface: getTwoSided(const NodePath this)
 
getX(...)
C++ Interface: getX(const NodePath this) getX(const NodePath this, const NodePath other)
 
getY(...)
C++ Interface: getY(const NodePath this) getY(const NodePath this, const NodePath other)
 
getZ(...)
C++ Interface: getZ(const NodePath this) getZ(const NodePath this, const NodePath other)
 
hasAntialias(...)
C++ Interface: hasAntialias(const NodePath this)
 
hasAttrib(...)
C++ Interface: hasAttrib(const NodePath this, const TypeHandle type)
 
hasAudioVolume(...)
C++ Interface: hasAudioVolume(const NodePath this)
 
hasBillboard(...)
C++ Interface: hasBillboard(const NodePath this)
 
hasBin(...)
C++ Interface: hasBin(const NodePath this)
 
hasClipPlane(...)
C++ Interface: hasClipPlane(const NodePath this, const NodePath clip_plane)
 
hasClipPlaneOff(...)
C++ Interface: hasClipPlaneOff(const NodePath this) hasClipPlaneOff(const NodePath this, const NodePath clip_plane)
 
hasColor(...)
C++ Interface: hasColor(const NodePath this)
 
hasColorScale(...)
C++ Interface: hasColorScale(const NodePath this)
 
hasCompass(...)
C++ Interface: hasCompass(const NodePath this)
 
hasDepthTest(...)
C++ Interface: hasDepthTest(const NodePath this)
 
hasDepthWrite(...)
C++ Interface: hasDepthWrite(const NodePath this)
 
hasEffect(...)
C++ Interface: hasEffect(const NodePath this, const TypeHandle type)
 
hasFog(...)
C++ Interface: hasFog(const NodePath this)
 
hasFogOff(...)
C++ Interface: hasFogOff(const NodePath this)
 
hasLight(...)
C++ Interface: hasLight(const NodePath this, const NodePath light)
 
hasLightOff(...)
C++ Interface: hasLightOff(const NodePath this) hasLightOff(const NodePath this, const NodePath light)
 
hasMat(...)
C++ Interface: hasMat(const NodePath this)
 
hasMaterial(...)
C++ Interface: hasMaterial(const NodePath this)
 
hasNetPythonTag(...)
C++ Interface: hasNetPythonTag(const NodePath this, string key)
 
hasNetTag(...)
C++ Interface: hasNetTag(const NodePath this, string key)
 
hasParent(...)
C++ Interface: hasParent(const NodePath this) hasParent(const NodePath this, non-const Thread current_thread)
 
hasPythonTag(...)
C++ Interface: hasPythonTag(const NodePath this, string key)
 
hasRenderMode(...)
C++ Interface: hasRenderMode(const NodePath this)
 
hasScissor(...)
C++ Interface: hasScissor(const NodePath this)
 
hasTag(...)
C++ Interface: hasTag(const NodePath this, string key)
 
hasTexGen(...)
C++ Interface: hasTexGen(const NodePath this, non-const TextureStage stage)
 
hasTexProjector(...)
C++ Interface: hasTexProjector(const NodePath this, non-const TextureStage stage)
 
hasTexTransform(...)
C++ Interface: hasTexTransform(const NodePath this, non-const TextureStage stage)
 
hasTexcoord(...)
C++ Interface: hasTexcoord(const NodePath this, string texcoord_name)
 
hasTexture(...)
C++ Interface: hasTexture(const NodePath this) hasTexture(const NodePath this, non-const TextureStage stage)
 
hasTextureOff(...)
C++ Interface: hasTextureOff(const NodePath this) hasTextureOff(const NodePath this, non-const TextureStage stage)
 
hasTransparency(...)
C++ Interface: hasTransparency(const NodePath this)
 
hasTwoSided(...)
C++ Interface: hasTwoSided(const NodePath this)
 
hasVertexColumn(...)
C++ Interface: hasVertexColumn(const NodePath this, const InternalName name)
 
headsUp(...)
C++ Interface: headsUp(non-const NodePath this, const Point3 point) headsUp(non-const NodePath this, const NodePath other) headsUp(non-const NodePath this, const Point3 point, const Vec3 up) headsUp(non-const NodePath this, const NodePath other, const Point3 point) headsUp(non-const NodePath this, const NodePath other, const Point3 point, const Vec3 up) headsUp(non-const NodePath this, float x, float y, float z) headsUp(non-const NodePath this, const NodePath other, float x, float y, float z)
 
hide(...)
C++ Interface: hide(non-const NodePath this) hide(non-const NodePath this, const BitMask camera_mask)
 
hideBounds(...)
C++ Interface: hideBounds(non-const NodePath this)
 
hideCS(self, mask=None)
Hides the collision solids at or below this node.
 
hideSiblings(self)
Hide all the siblings of a node path
 
hprInterval(self, *args, **kw)
 
hprScaleInterval(self, *args, **kw)
 
iHpr(self, other=None)
Set node path's hpr to 0, 0, 0
 
iPos(self, other=None)
Set node path's pos to 0, 0, 0
 
iPosHpr(self, other=None)
Set node path's pos and hpr to 0, 0, 0
 
iPosHprScale(self, other=None)
Set node path's pos and hpr to 0, 0, 0 and scale to 1, 1, 1
 
iScale(self, other=None)
SEt node path's scale to 1, 1, 1
 
id(self)
Returns a unique id identifying the NodePath instance
 
instanceTo(...)
C++ Interface: instanceTo(const NodePath this, const NodePath other) instanceTo(const NodePath this, const NodePath other, int sort) instanceTo(const NodePath this, const NodePath other, int sort, non-const Thread current_thread)
 
instanceUnderNode(...)
C++ Interface: instanceUnderNode(const NodePath this, const NodePath other, string name) instanceUnderNode(const NodePath this, const NodePath other, string name, int sort) instanceUnderNode(const NodePath this, const NodePath other, string name, int sort, non-const Thread current_thread)
 
isAncestorOf(...)
C++ Interface: isAncestorOf(const NodePath this, const NodePath other) isAncestorOf(const NodePath this, const NodePath other, non-const Thread current_thread)
 
isEmpty(...)
C++ Interface: isEmpty(const NodePath this)
 
isHidden(...)
C++ Interface: isHidden(const NodePath this) isHidden(const NodePath this, const BitMask camera_mask)
 
isSameGraph(...)
C++ Interface: isSameGraph(const NodePath this, const NodePath other) isSameGraph(const NodePath this, const NodePath other, non-const Thread current_thread)
 
isSingleton(...)
C++ Interface: isSingleton(const NodePath this) isSingleton(const NodePath this, non-const Thread current_thread)
 
isStashed(...)
C++ Interface: isStashed(const NodePath this)
 
isolate(self)
Show the node path and hide its siblings
 
lerpColor(self, *positionArgs, **keywordArgs)
determine which lerpColor* to call based on arguments
 
lerpColorRGBA(self, float, float, float, float, float, string="noBlend", string=none, string=none)
 
lerpColorRGBARGBA(self, float, float, float, float, float, float, float, float, float, string="noBlend", string=none, string=none)
 
lerpColorScale(self, *positionArgs, **keywordArgs)
determine which lerpColorScale* to call based on arguments
 
lerpColorScaleRGBA(self, float, float, float, float, float, string="noBlend", string=none, string=none)
 
lerpColorScaleRGBARGBA(self, float, float, float, float, float, float, float, float, float, string="noBlend", string=none, string=none)
 
lerpColorScaleVBase4(self, VBase4, float, string="noBlend", string=none, string=none)
 
lerpColorScaleVBase4VBase4(self, VBase4, VBase4, float, string="noBlend", string=none, string=none)
 
lerpColorVBase4(self, VBase4, float, string="noBlend", string=none, string=none)
 
lerpColorVBase4VBase4(self, VBase4, VBase4, float, string="noBlend", string=none, string=none)
 
lerpHpr(self, *positionArgs, **keywordArgs)
Determine whether to call lerpHprHPR or lerpHprVBase3 based on first argument
 
lerpHprHPR(self, float, float, float, float, string="noBlend", string=none, string=none, NodePath=none)
Perform a hpr lerp with three floats as the end point
 
lerpHprVBase3(self, VBase3, float, string="noBlend", string=none, string=none, NodePath=None)
Perform a hpr lerp with a VBase3 as the end point
 
lerpPos(self, *positionArgs, **keywordArgs)
Determine whether to call lerpPosXYZ or lerpPosPoint3 based on the first argument
 
lerpPosHpr(self, *positionArgs, **keywordArgs)
Determine whether to call lerpPosHprXYZHPR or lerpHprPoint3VBase3 based on first argument
 
lerpPosHprPoint3VBase3(self, Point3, VBase3, string="noBlend", string=none, string=none, NodePath=None)
 
lerpPosHprScale(self, Point3, VBase3, float, float, string="noBlend", string=none, string=none, NodePath=None)
Only one case, no need for extra args.
 
lerpPosHprXYZHPR(self, float, string="noBlend", string=none, string=none, NodePath=None)
 
lerpPosPoint3(self, Point3, float, string="noBlend", string=None, string=None, NodePath=None)
Perform a pos lerp with a Point3 as the end point
 
lerpPosXYZ(self, float, float, float, float, string="noBlend", string=None, NodePath=None)
Perform a pos lerp with three floats as the end point
 
lerpScale(self, *positionArgs, **keywordArgs)
Determine whether to call lerpScaleXYZ or lerpScaleaseV3 based on the first argument
 
lerpScaleVBase3(self, VBase3, float, string="noBlend", string=none, string=none, NodePath=None)
 
lerpScaleXYZ(self, float, float, float, float, string="noBlend", string=none, string=none, NodePath=None)
 
lessThan(...)
C++ Interface: lessThan(const NodePath this, const NodePath other)
 
listTags(...)
C++ Interface: listTags(const NodePath this)
 
lookAt(...)
C++ Interface: lookAt(non-const NodePath this, const Point3 point) lookAt(non-const NodePath this, const NodePath other) lookAt(non-const NodePath this, const Point3 point, const Vec3 up) lookAt(non-const NodePath this, const NodePath other, const Point3 point) lookAt(non-const NodePath this, const NodePath other, const Point3 point, const Vec3 up) lookAt(non-const NodePath this, float x, float y, float z) lookAt(non-const NodePath this, const NodePath other, float x, float y, float z)
 
ls(...)
C++ Interface: ls(const NodePath this) ls(const NodePath this, non-const Ostream out) ls(const NodePath this, non-const Ostream out, int indent_level)
 
lsNames(self)
Walk down a tree and print out the path
 
lsNamesRecurse(self, indentString=' ')
Walk down a tree and print out the path
 
ne(...)
C++ Interface: ne(const NodePath this, const NodePath other)
 
node(...)
C++ Interface: node(const NodePath this)
 
notFound(...)
C++ Interface: notFound()
 
output(...)
C++ Interface: output(const NodePath this, non-const Ostream out)
 
pPrintString(self, other=None)
pretty print
 
place(self)
 
posHprInterval(self, *args, **kw)
 
posHprScaleInterval(self, *args, **kw)
 
posHprScaleShearInterval(self, *args, **kw)
 
posInterval(self, *args, **kw)
 
posQuatInterval(self, *args, **kw)
 
posQuatScaleInterval(self, *args, **kw)
 
posQuatScaleShearInterval(self, *args, **kw)
 
premungeScene(...)
C++ Interface: premungeScene(non-const NodePath this) premungeScene(non-const NodePath this, non-const GraphicsStateGuardianBase gsg)
 
prepareScene(...)
C++ Interface: prepareScene(non-const NodePath this, non-const GraphicsStateGuardianBase gsg)
 
printChildren(self)
Prints out the children of the bottom node of a node path
 
printHpr(self, other=None, sd=2)
Pretty print a node path's hpr
 
printPos(self, other=None, sd=2)
Pretty print a node path's pos
 
printPosHpr(self, other=None, sd=2)
Pretty print a node path's pos and, hpr
 
printPosHprScale(self, other=None, sd=2)
Pretty print a node path's pos, hpr, and scale
 
printScale(self, other=None, sd=2)
Pretty print a node path's scale
 
printTransform(self, other=None, sd=2, fRecursive=0)
 
projectTexture(...)
C++ Interface: projectTexture(non-const NodePath this, non-const TextureStage stage, non-const Texture tex, const NodePath projector)
 
quatInterval(self, *args, **kw)
 
quatScaleInterval(self, *args, **kw)
 
r_constructCollisionTree(self, solidTree, parentNode, colName)
 
r_subdivideCollisions(self, solids, numSolidsInLeaves)
 
remove(self)
Remove a node path from the scene graph
 
removeChildren(self)
Deletes the children of the bottom node of a node path
 
removeNode(...)
C++ Interface: removeNode(non-const NodePath this) removeNode(non-const NodePath this, non-const Thread current_thread)
 
removeNonCollisions(self)
 
removed(...)
C++ Interface: removed()
 
reparentTo(...)
C++ Interface: reparentTo(non-const NodePath this, const NodePath other) reparentTo(non-const NodePath this, const NodePath other, int sort) reparentTo(non-const NodePath this, const NodePath other, int sort, non-const Thread current_thread)
 
reverseLs(...)
C++ Interface: reverseLs(const NodePath this) reverseLs(const NodePath this, non-const Ostream out) reverseLs(const NodePath this, non-const Ostream out, int indent_level)
 
reverseLsNames(self)
Walk up a tree and print out the path to the root
 
rgbPanel(self, cb=None)
 
scaleInterval(self, *args, **kw)
 
select(self)
 
setAllColorScale(...)
C++ Interface: setAllColorScale(non-const NodePath this, float scale) setAllColorScale(non-const NodePath this, float scale, int priority)
 
setAlphaScale(...)
C++ Interface: setAlphaScale(non-const NodePath this, float scale) setAlphaScale(non-const NodePath this, float scale, int priority)
 
setAntialias(...)
C++ Interface: setAntialias(non-const NodePath this, unsigned int mode) setAntialias(non-const NodePath this, unsigned int mode, int priority)
 
setAttrib(...)
C++ Interface: setAttrib(non-const NodePath this, const RenderAttrib attrib) setAttrib(non-const NodePath this, const RenderAttrib attrib, int priority)
 
setAudioVolume(...)
C++ Interface: setAudioVolume(non-const NodePath this, float volume) setAudioVolume(non-const NodePath this, float volume, int priority)
 
setAudioVolumeOff(...)
C++ Interface: setAudioVolumeOff(non-const NodePath this) setAudioVolumeOff(non-const NodePath this, int priority)
 
setBillboardAxis(...)
C++ Interface: setBillboardAxis(non-const NodePath this) setBillboardAxis(non-const NodePath this, float offset) setBillboardAxis(non-const NodePath this, const NodePath camera, float offset)
 
setBillboardPointEye(...)
C++ Interface: setBillboardPointEye(non-const NodePath this) setBillboardPointEye(non-const NodePath this, float offset) setBillboardPointEye(non-const NodePath this, const NodePath camera, float offset)
 
setBillboardPointWorld(...)
C++ Interface: setBillboardPointWorld(non-const NodePath this) setBillboardPointWorld(non-const NodePath this, float offset) setBillboardPointWorld(non-const NodePath this, const NodePath camera, float offset)
 
setBin(...)
C++ Interface: setBin(non-const NodePath this, string bin_name, int draw_order) setBin(non-const NodePath this, string bin_name, int draw_order, int priority)
 
setClipPlane(...)
C++ Interface: setClipPlane(non-const NodePath this, const NodePath clip_plane) setClipPlane(non-const NodePath this, const NodePath clip_plane, int priority)
 
setClipPlaneOff(...)
C++ Interface: setClipPlaneOff(non-const NodePath this) setClipPlaneOff(non-const NodePath this, const NodePath clip_plane) setClipPlaneOff(non-const NodePath this, int priority) setClipPlaneOff(non-const NodePath this, const NodePath clip_plane, int priority)
 
setCollideMask(...)
C++ Interface: setCollideMask(non-const NodePath this, const BitMask new_mask) setCollideMask(non-const NodePath this, const BitMask new_mask, const BitMask bits_to_change) setCollideMask(non-const NodePath this, const BitMask new_mask, const BitMask bits_to_change, const TypeHandle node_type)
 
setColor(...)
C++ Interface: setColor(non-const NodePath this, const VBase4 color) setColor(non-const NodePath this, const VBase4 color, int priority) setColor(non-const NodePath this, float r, float g, float b) setColor(non-const NodePath this, float r, float g, float b, float a) setColor(non-const NodePath this, float r, float g, float b, float a, int priority)
 
setColorOff(...)
C++ Interface: setColorOff(non-const NodePath this) setColorOff(non-const NodePath this, int priority)
 
setColorScale(...)
C++ Interface: setColorScale(non-const NodePath this, const VBase4 scale) setColorScale(non-const NodePath this, const VBase4 scale, int priority) setColorScale(non-const NodePath this, float sx, float sy, float sz, float sa) setColorScale(non-const NodePath this, float sx, float sy, float sz, float sa, int priority)
 
setColorScaleOff(...)
C++ Interface: setColorScaleOff(non-const NodePath this) setColorScaleOff(non-const NodePath this, int priority)
 
setCompass(...)
C++ Interface: setCompass(non-const NodePath this) setCompass(non-const NodePath this, const NodePath reference)
 
setDepthTest(...)
C++ Interface: setDepthTest(non-const NodePath this, bool depth_test) setDepthTest(non-const NodePath this, bool depth_test, int priority)
 
setDepthWrite(...)
C++ Interface: setDepthWrite(non-const NodePath this, bool depth_write) setDepthWrite(non-const NodePath this, bool depth_write, int priority)
 
setEffect(...)
C++ Interface: setEffect(non-const NodePath this, const RenderEffect effect)
 
setEffects(...)
C++ Interface: setEffects(non-const NodePath this, const RenderEffects effects)
 
setFluidPos(...)
C++ Interface: setFluidPos(non-const NodePath this, const VBase3 pos) setFluidPos(non-const NodePath this, const NodePath other, const VBase3 pos) setFluidPos(non-const NodePath this, float x, float y, float z) setFluidPos(non-const NodePath this, const NodePath other, float x, float y, float z)
 
setFluidX(...)
C++ Interface: setFluidX(non-const NodePath this, float x) setFluidX(non-const NodePath this, const NodePath other, float x)
 
setFluidY(...)
C++ Interface: setFluidY(non-const NodePath this, float y) setFluidY(non-const NodePath this, const NodePath other, float y)
 
setFluidZ(...)
C++ Interface: setFluidZ(non-const NodePath this, float z) setFluidZ(non-const NodePath this, const NodePath other, float z)
 
setFog(...)
C++ Interface: setFog(non-const NodePath this, non-const Fog fog) setFog(non-const NodePath this, non-const Fog fog, int priority)
 
setFogOff(...)
C++ Interface: setFogOff(non-const NodePath this) setFogOff(non-const NodePath this, int priority)
 
setH(...)
C++ Interface: setH(non-const NodePath this, float h) setH(non-const NodePath this, const NodePath other, float h)
 
setHpr(...)
C++ Interface: setHpr(non-const NodePath this, const VBase3 hpr) setHpr(non-const NodePath this, const NodePath other, const VBase3 hpr) setHpr(non-const NodePath this, float h, float p, float r) setHpr(non-const NodePath this, const NodePath other, float h, float p, float r)
 
setHprScale(...)
C++ Interface: setHprScale(non-const NodePath this, const VBase3 hpr, const VBase3 scale) setHprScale(non-const NodePath this, const NodePath other, const VBase3 hpr, const VBase3 scale) setHprScale(non-const NodePath this, float h, float p, float r, float sx, float sy, float sz) setHprScale(non-const NodePath this, const NodePath other, float h, float p, float r, float sx, float sy, float sz)
 
setLight(...)
C++ Interface: setLight(non-const NodePath this, const NodePath light) setLight(non-const NodePath this, const NodePath light, int priority)
 
setLightOff(...)
C++ Interface: setLightOff(non-const NodePath this) setLightOff(non-const NodePath this, const NodePath light) setLightOff(non-const NodePath this, int priority) setLightOff(non-const NodePath this, const NodePath light, int priority)
 
setMat(...)
C++ Interface: setMat(non-const NodePath this, const Mat4 mat) setMat(non-const NodePath this, const NodePath other, const Mat4 mat)
 
setMaterial(...)
C++ Interface: setMaterial(non-const NodePath this, non-const Material tex) setMaterial(non-const NodePath this, non-const Material tex, int priority)
 
setMaterialOff(...)
C++ Interface: setMaterialOff(non-const NodePath this) setMaterialOff(non-const NodePath this, int priority)
 
setMaxSearchDepth(...)
C++ Interface: setMaxSearchDepth(int max_search_depth)
 
setName(...)
C++ Interface: setName(non-const NodePath this, string name)
 
setNormalMap(...)
C++ Interface: setNormalMap(non-const NodePath this, non-const Texture normal_map) setNormalMap(non-const NodePath this, non-const Texture normal_map, string texcoord_name) setNormalMap(non-const NodePath this, non-const Texture normal_map, string texcoord_name, bool preserve_color)
 
setP(...)
C++ Interface: setP(non-const NodePath this, float p) setP(non-const NodePath this, const NodePath other, float p)
 
setPos(...)
C++ Interface: setPos(non-const NodePath this, const VBase3 pos) setPos(non-const NodePath this, const NodePath other, const VBase3 pos) setPos(non-const NodePath this, float x, float y, float z) setPos(non-const NodePath this, const NodePath other, float x, float y, float z)
 
setPosHpr(...)
C++ Interface: setPosHpr(non-const NodePath this, const VBase3 pos, const VBase3 hpr) setPosHpr(non-const NodePath this, const NodePath other, const VBase3 pos, const VBase3 hpr) setPosHpr(non-const NodePath this, float x, float y, float z, float h, float p, float r) setPosHpr(non-const NodePath this, const NodePath other, float x, float y, float z, float h, float p, float r)
 
setPosHprScale(...)
C++ Interface: setPosHprScale(non-const NodePath this, const VBase3 pos, const VBase3 hpr, const VBase3 scale) setPosHprScale(non-const NodePath this, const NodePath other, const VBase3 pos, const VBase3 hpr, const VBase3 scale) setPosHprScale(non-const NodePath this, float x, float y, float z, float h, float p, float r, float sx, float sy, float sz) setPosHprScale(non-const NodePath this, const NodePath other, float x, float y, float z, float h, float p, float r, float sx, float sy, float sz)
 
setPosHprScaleShear(...)
C++ Interface: setPosHprScaleShear(non-const NodePath this, const VBase3 pos, const VBase3 hpr, const VBase3 scale, const VBase3 shear) setPosHprScaleShear(non-const NodePath this, const NodePath other, const VBase3 pos, const VBase3 hpr, const VBase3 scale, const VBase3 shear)
 
setPosQuat(...)
C++ Interface: setPosQuat(non-const NodePath this, const VBase3 pos, const Quat quat) setPosQuat(non-const NodePath this, const NodePath other, const VBase3 pos, const Quat quat)
 
setPosQuatScale(...)
C++ Interface: setPosQuatScale(non-const NodePath this, const VBase3 pos, const Quat quat, const VBase3 scale) setPosQuatScale(non-const NodePath this, const NodePath other, const VBase3 pos, const Quat quat, const VBase3 scale)
 
setPosQuatScaleShear(...)
C++ Interface: setPosQuatScaleShear(non-const NodePath this, const VBase3 pos, const Quat quat, const VBase3 scale, const VBase3 shear) setPosQuatScaleShear(non-const NodePath this, const NodePath other, const VBase3 pos, const Quat quat, const VBase3 scale, const VBase3 shear)
 
setPrevTransform(...)
C++ Interface: setPrevTransform(non-const NodePath this, const TransformState transform) setPrevTransform(non-const NodePath this, const TransformState transform, non-const Thread current_thread) setPrevTransform(non-const NodePath this, const NodePath other, const TransformState transform) setPrevTransform(non-const NodePath this, const NodePath other, const TransformState transform, non-const Thread current_thread)
 
setPythonTag(...)
C++ Interface: setPythonTag(non-const NodePath this, string key, any value)
 
setQuat(...)
C++ Interface: setQuat(non-const NodePath this, const Quat quat) setQuat(non-const NodePath this, const NodePath other, const Quat quat)
 
setQuatScale(...)
C++ Interface: setQuatScale(non-const NodePath this, const Quat quat, const VBase3 scale) setQuatScale(non-const NodePath this, const NodePath other, const Quat quat, const VBase3 scale)
 
setR(...)
C++ Interface: setR(non-const NodePath this, float r) setR(non-const NodePath this, const NodePath other, float r)
 
setRenderMode(...)
C++ Interface: setRenderMode(non-const NodePath this, int mode, float thickness) setRenderMode(non-const NodePath this, int mode, float thickness, int priority)
 
setRenderModeFilled(...)
C++ Interface: setRenderModeFilled(non-const NodePath this) setRenderModeFilled(non-const NodePath this, int priority)
 
setRenderModePerspective(...)
C++ Interface: setRenderModePerspective(non-const NodePath this, bool perspective) setRenderModePerspective(non-const NodePath this, bool perspective, int priority)
 
setRenderModeThickness(...)
C++ Interface: setRenderModeThickness(non-const NodePath this, float thickness) setRenderModeThickness(non-const NodePath this, float thickness, int priority)
 
setRenderModeWireframe(...)
C++ Interface: setRenderModeWireframe(non-const NodePath this) setRenderModeWireframe(non-const NodePath this, int priority)
 
setSa(...)
C++ Interface: setSa(non-const NodePath this, float sa)
 
setSb(...)
C++ Interface: setSb(non-const NodePath this, float sb)
 
setScale(...)
C++ Interface: setScale(non-const NodePath this, const VBase3 scale) setScale(non-const NodePath this, float scale) setScale(non-const NodePath this, const NodePath other, const VBase3 scale) setScale(non-const NodePath this, const NodePath other, float scale) setScale(non-const NodePath this, float sx, float sy, float sz) setScale(non-const NodePath this, const NodePath other, float sx, float sy, float sz)
 
setScissor(...)
C++ Interface: setScissor(non-const NodePath this, const Point3 a, const Point3 b) setScissor(non-const NodePath this, const NodePath other, const Point3 a, const Point3 b) setScissor(non-const NodePath this, const Point3 a, const Point3 b, const Point3 c, const Point3 d) setScissor(non-const NodePath this, float left, float right, float bottom, float top) setScissor(non-const NodePath this, const NodePath other, const Point3 a, const Point3 b, const Point3 c, const Point3 d)
 
setSg(...)
C++ Interface: setSg(non-const NodePath this, float sg)
 
setShader(...)
C++ Interface: setShader(non-const NodePath this, const Shader sha) setShader(non-const NodePath this, const Shader sha, int priority)
 
setShaderAuto(...)
C++ Interface: setShaderAuto(non-const NodePath this) setShaderAuto(non-const NodePath this, int priority)
 
setShaderInput(...)
C++ Interface: setShaderInput(non-const NodePath this, const ShaderInput inp) setShaderInput(non-const NodePath this, non-const InternalName id) setShaderInput(non-const NodePath this, string id) setShaderInput(non-const NodePath this, non-const InternalName id, const Vec4 v) setShaderInput(non-const NodePath this, non-const InternalName id, const NodePath np) setShaderInput(non-const NodePath this, non-const InternalName id, non-const Texture tex) setShaderInput(non-const NodePath this, string id, const Vec4 v) setShaderInput(non-const NodePath this, string id, const NodePath np) setShaderInput(non-const NodePath this, string id, non-const Texture tex) setShaderInput(non-const NodePath this, non-const InternalName id, float n1) setShaderInput(non-const NodePath this, string id, float n1) setShaderInput(non-const NodePath this, non-const InternalName id, const Vec4 v, int priority) setShaderInput(non-const NodePath this, non-const InternalName id, const NodePath np, int priority) setShaderInput(non-const NodePath this, non-const InternalName id, non-const Texture tex, int priority) setShaderInput(non-const NodePath this, string id, const Vec4 v, int priority) setShaderInput(non-const NodePath this, string id, const NodePath np, int priority) setShaderInput(non-const NodePath this, string id, non-const Texture tex, int priority) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2) setShaderInput(non-const NodePath this, string id, float n1, float n2) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2, float n3) setShaderInput(non-const NodePath this, string id, float n1, float n2, float n3) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2, float n3, float n4) setShaderInput(non-const NodePath this, string id, float n1, float n2, float n3, float n4) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2, float n3, float n4, int priority) setShaderInput(non-const NodePath this, string id, float n1, float n2, float n3, float n4, int priority)
 
setShaderOff(...)
C++ Interface: setShaderOff(non-const NodePath this) setShaderOff(non-const NodePath this, int priority)
 
setShear(...)
C++ Interface: setShear(non-const NodePath this, const VBase3 shear) setShear(non-const NodePath this, const NodePath other, const VBase3 shear) setShear(non-const NodePath this, float shxy, float shxz, float shyz) setShear(non-const NodePath this, const NodePath other, float shxy, float shxz, float shyz)
 
setShxy(...)
C++ Interface: setShxy(non-const NodePath this, float shxy) setShxy(non-const NodePath this, const NodePath other, float shxy)
 
setShxz(...)
C++ Interface: setShxz(non-const NodePath this, float shxz) setShxz(non-const NodePath this, const NodePath other, float shxz)
 
setShyz(...)
C++ Interface: setShyz(non-const NodePath this, float shyz) setShyz(non-const NodePath this, const NodePath other, float shyz)
 
setSr(...)
C++ Interface: setSr(non-const NodePath this, float sr)
 
setState(...)
C++ Interface: setState(non-const NodePath this, const RenderState state) setState(non-const NodePath this, const RenderState state, non-const Thread current_thread) setState(non-const NodePath this, const NodePath other, const RenderState state) setState(non-const NodePath this, const NodePath other, const RenderState state, non-const Thread current_thread)
 
setSx(...)
C++ Interface: setSx(non-const NodePath this, float sx) setSx(non-const NodePath this, const NodePath other, float sx)
 
setSy(...)
C++ Interface: setSy(non-const NodePath this, float sy) setSy(non-const NodePath this, const NodePath other, float sy)
 
setSz(...)
C++ Interface: setSz(non-const NodePath this, float sz) setSz(non-const NodePath this, const NodePath other, float sz)
 
setTag(...)
C++ Interface: setTag(non-const NodePath this, string key, string value)
 
setTexGen(...)
C++ Interface: setTexGen(non-const NodePath this, non-const TextureStage stage, int mode) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, const Point3 constant_value) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, int priority) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, string source_name, const NodePath light) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, const Point3 constant_value, int priority) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, string source_name, const NodePath light, int priority)
 
setTexHpr(...)
C++ Interface: setTexHpr(non-const NodePath this, non-const TextureStage stage, const VBase3 hpr) setTexHpr(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase3 hpr) setTexHpr(non-const NodePath this, non-const TextureStage stage, float h, float p, float r) setTexHpr(non-const NodePath this, const NodePath other, non-const TextureStage stage, float h, float p, float r)
 
setTexOffset(...)
C++ Interface: setTexOffset(non-const NodePath this, non-const TextureStage stage, const VBase2 uv) setTexOffset(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase2 uv) setTexOffset(non-const NodePath this, non-const TextureStage stage, float u, float v) setTexOffset(non-const NodePath this, const NodePath other, non-const TextureStage stage, float u, float v)
 
setTexPos(...)
C++ Interface: setTexPos(non-const NodePath this, non-const TextureStage stage, const VBase3 uvw) setTexPos(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase3 uvw) setTexPos(non-const NodePath this, non-const TextureStage stage, float u, float v, float w) setTexPos(non-const NodePath this, const NodePath other, non-const TextureStage stage, float u, float v, float w)
 
setTexProjector(...)
C++ Interface: setTexProjector(non-const NodePath this, non-const TextureStage stage, const NodePath from, const NodePath to)
 
setTexRotate(...)
C++ Interface: setTexRotate(non-const NodePath this, non-const TextureStage stage, float r) setTexRotate(non-const NodePath this, const NodePath other, non-const TextureStage stage, float r)
 
setTexScale(...)
C++ Interface: setTexScale(non-const NodePath this, non-const TextureStage stage, const VBase2 scale) setTexScale(non-const NodePath this, non-const TextureStage stage, const VBase3 scale) setTexScale(non-const NodePath this, non-const TextureStage stage, float scale) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase2 scale) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase3 scale) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, float scale) setTexScale(non-const NodePath this, non-const TextureStage stage, float su, float sv) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, float su, float sv) setTexScale(non-const NodePath this, non-const TextureStage stage, float su, float sv, float sw) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, float su, float sv, float sw)
 
setTexTransform(...)
C++ Interface: setTexTransform(non-const NodePath this, non-const TextureStage stage, const TransformState transform) setTexTransform(non-const NodePath this, const NodePath other, non-const TextureStage stage, const TransformState transform)
 
setTexture(...)
C++ Interface: setTexture(non-const NodePath this, non-const Texture tex) setTexture(non-const NodePath this, non-const TextureStage stage, non-const Texture tex) setTexture(non-const NodePath this, non-const Texture tex, int priority) setTexture(non-const NodePath this, non-const TextureStage stage, non-const Texture tex, int priority)
 
setTextureOff(...)
C++ Interface: setTextureOff(non-const NodePath this) setTextureOff(non-const NodePath this, non-const TextureStage stage) setTextureOff(non-const NodePath this, int priority) setTextureOff(non-const NodePath this, non-const TextureStage stage, int priority)
 
setTransform(...)
C++ Interface: setTransform(non-const NodePath this, const TransformState transform) setTransform(non-const NodePath this, const TransformState transform, non-const Thread current_thread) setTransform(non-const NodePath this, const NodePath other, const TransformState transform) setTransform(non-const NodePath this, const NodePath other, const TransformState transform, non-const Thread current_thread)
 
setTransparency(...)
C++ Interface: setTransparency(non-const NodePath this, int mode) setTransparency(non-const NodePath this, int mode, int priority)
 
setTwoSided(...)
C++ Interface: setTwoSided(non-const NodePath this, bool two_sided) setTwoSided(non-const NodePath this, bool two_sided, int priority)
 
setX(...)
C++ Interface: setX(non-const NodePath this, float x) setX(non-const NodePath this, const NodePath other, float x)
 
setY(...)
C++ Interface: setY(non-const NodePath this, float y) setY(non-const NodePath this, const NodePath other, float y)
 
setZ(...)
C++ Interface: setZ(non-const NodePath this, float z) setZ(non-const NodePath this, const NodePath other, float z)
 
shearInterval(self, *args, **kw)
 
show(...)
C++ Interface: show(non-const NodePath this) show(non-const NodePath this, const BitMask camera_mask)
 
showAllDescendants(self)
Show the node path and all its children
 
showBounds(...)
C++ Interface: showBounds(non-const NodePath this)
 
showCS(self, mask=None)
Shows the collision solids at or below this node.
 
showSiblings(self)
Show all the siblings of a node path
 
showThrough(...)
C++ Interface: showThrough(non-const NodePath this) showThrough(non-const NodePath this, const BitMask camera_mask)
 
showTightBounds(...)
C++ Interface: showTightBounds(non-const NodePath this)
 
stash(...)
C++ Interface: stash(non-const NodePath this) stash(non-const NodePath this, int sort) stash(non-const NodePath this, int sort, non-const Thread current_thread)
 
stashTo(...)
C++ Interface: stashTo(non-const NodePath this, const NodePath other) stashTo(non-const NodePath this, const NodePath other, int sort) stashTo(non-const NodePath this, const NodePath other, int sort, non-const Thread current_thread)
 
subdivideCollisions(self, numSolidsInLeaves)
expand CollisionNodes out into balanced trees, with a particular number of solids in the leaves TODO: better splitting logic at each level of the tree wrt spatial separation and cost of bounding volume tests vs.
 
toggleVis(self)
Toggles visibility of a nodePath
 
unifyTextureStages(...)
C++ Interface: unifyTextureStages(non-const NodePath this, non-const TextureStage stage)
 
unstash(...)
C++ Interface: unstash(non-const NodePath this) unstash(non-const NodePath this, int sort) unstash(non-const NodePath this, int sort, non-const Thread current_thread)
 
unstashAll(...)
C++ Interface: unstashAll(non-const NodePath this) unstashAll(non-const NodePath this, non-const Thread current_thread)
 
verifyComplete(...)
C++ Interface: verifyComplete(const NodePath this) verifyComplete(const NodePath this, non-const Thread current_thread)
 
writeBamFile(...)
C++ Interface: writeBamFile(const NodePath this, string filename)
 
writeBamStream(...)
C++ Interface: writeBamStream(const NodePath this, non-const Ostream out)
 
writeBounds(...)
C++ Interface: writeBounds(const NodePath this, non-const Ostream out)
 
wrtReparentTo(...)
C++ Interface: wrtReparentTo(non-const NodePath this, const NodePath other) wrtReparentTo(non-const NodePath this, const NodePath other, int sort) wrtReparentTo(non-const NodePath this, const NodePath other, int sort, non-const Thread current_thread)

Inherited from unreachable.DTOOL_SUPPER_BASE111: DtoolGetSupperBase

Inherited from object: __reduce__, __reduce_ex__

Class Variables
  DtoolClassDict = {'DtoolClassDict': {'DtoolClassDict': {'Dtool...
  ETFail = 3
  ETNotFound = 1
  ETOk = 0
  ETRemoved = 2
Properties
  this
C++ This if any
  this_metatype
The dtool meta object

Inherited from object: __class__

Method Details

__cmp__(x, y)
(Comparison operator)

 

cmp(x,y)

Overrides: unreachable.DTOOL_SUPPER_BASE111.__cmp__

__delattr__(...)

 

x.__delattr__('name') <==> del x.name

Overrides: object.__delattr__

__getattribute__(...)

 

x.__getattribute__('name') <==> x.name

Overrides: object.__getattribute__

__hash__(x)
(Hashing function)

 

hash(x)

Overrides: object.__hash__

__init__(...)
(Constructor)

 

x.__init__(...) initializes x; see x.__class__.__doc__ for signature

Overrides: object.__init__

__new__(T, S, ...)

 
Returns: a new object with type S, a subtype of T
Overrides: object.__new__

__repr__(x)
(Representation operator)

 

repr(x)

Overrides: object.__repr__

__setattr__(...)

 

x.__setattr__('name', value) <==> x.name = value

Overrides: object.__setattr__

__str__(x)
(Informal representation operator)

 

str(x)

Overrides: object.__str__

adjustAllPriorities(...)

 

C++ Interface: adjustAllPriorities(non-const NodePath this, int adjustment)

//////////////////////////////////////////////////////////////////// // Function: NodePath::adjust_all_priorities // Access: Published // Description: Adds the indicated adjustment amount (which may be // negative) to the priority for all transitions on the // referenced node, and for all nodes in the subgraph // below. This can be used to force these nodes not to // be overridden by a high-level state change above. If // the priority would drop below zero, it is set to // zero. ////////////////////////////////////////////////////////////////////

analyze(...)

 

C++ Interface: analyze(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::analyze // Access: Published // Description: Analyzes the geometry below this node and reports the // number of vertices, triangles, etc. This is the same // information reported by the bam-info program. ////////////////////////////////////////////////////////////////////

anyPath(...)

 

C++ Interface: anyPath(non-const PandaNode node) anyPath(non-const PandaNode node, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::any_path named constructor // Access: Published, Static // Description: Returns a new NodePath that represents any arbitrary // path from the root to the indicated node. This is // the same thing that would be returned by // NodePath(node), except that no warning is issued if // the path is ambiguous. ////////////////////////////////////////////////////////////////////

applyTextureColors(...)

 

C++ Interface: applyTextureColors(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::apply_texture_colors // Access: Published // Description: Removes textures from Geoms at this node and below by // applying the texture colors to the vertices. This is // primarily useful to simplify a low-LOD model. The // texture colors are replaced by flat colors that // approximate the original textures. // // Only the bottommost texture on each Geom is used (if // there is more than one), and it is applied as if it // were M_modulate, and WM_repeat, regardless of its // actual settings. If the texture has a // simple_ram_image, this may be used if the main image // isn't resident. // // After this call, there will be no texturing specified // at this level and below. Of course, there might // still be texturing inherited from above. ////////////////////////////////////////////////////////////////////

assign(...)

 

C++ Interface: assign(non-const NodePath this, const NodePath copy)

//////////////////////////////////////////////////////////////////// // Function: NodePath::Copy Assignment Operator // Access: Published // Description: ////////////////////////////////////////////////////////////////////

attachNewNode(...)

 

C++ Interface: attachNewNode(const NodePath this, non-const PandaNode node) attachNewNode(const NodePath this, string name) attachNewNode(const NodePath this, non-const PandaNode node, int sort) attachNewNode(const NodePath this, string name, int sort) attachNewNode(const NodePath this, non-const PandaNode node, int sort, non-const Thread current_thread) attachNewNode(const NodePath this, string name, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::attach_new_node // Access: Published // Description: Creates an ordinary PandaNode and attaches it below // the current NodePath, returning a new NodePath that // references it. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::attach_new_node // Access: Published // Description: Attaches a new node, with or without existing // parents, to the scene graph below the referenced node // of this NodePath. This is the preferred way to add // nodes to the graph. // // If the node was already a child of the parent, this // returns a NodePath to the existing child. // // This does *not* automatically extend the current // NodePath to reflect the attachment; however, a // NodePath that does reflect this extension is // returned. ////////////////////////////////////////////////////////////////////

calcTightBounds(...)

 

C++ Interface: calcTightBounds(const NodePath this, non-const Point3 min_point, non-const Point3 max_point) calcTightBounds(const NodePath this, non-const Point3 min_point, non-const Point3 max_point, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::calc_tight_bounds // Access: Published // Description: Calculates the minimum and maximum vertices of all // Geoms at this NodePath's bottom node and below. This // is a tight bounding box; it will generally be tighter // than the bounding volume returned by get_bounds() // (but it is more expensive to compute). // // The return value is true if any points are within the // bounding volume, or false if none are. ////////////////////////////////////////////////////////////////////

clearAntialias(...)

 

C++ Interface: clearAntialias(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_antialias // Access: Published // Description: Completely removes any antialias setting that // may have been set on this node via set_antialias(). ////////////////////////////////////////////////////////////////////

clearAttrib(...)

 

C++ Interface: clearAttrib(non-const NodePath this, const TypeHandle type)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_attrib // Access: Published // Description: Removes the render attribute of the given type from // this node. This node, and the subgraph below, will // now inherit the indicated render attribute from the // nodes above this one. ////////////////////////////////////////////////////////////////////

clearAudioVolume(...)

 

C++ Interface: clearAudioVolume(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_audio_volume // Access: Published // Description: Completely removes any audio volume from the // referenced node. This is preferable to simply // setting the audio volume to identity, as it also // removes the overhead associated with having an audio // volume at all. ////////////////////////////////////////////////////////////////////

clearBillboard(...)

 

C++ Interface: clearBillboard(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_billboard // Access: Published // Description: Removes any billboard effect from the node. ////////////////////////////////////////////////////////////////////

clearBin(...)

 

C++ Interface: clearBin(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_bin // Access: Published // Description: Completely removes any bin adjustment that may have // been set via set_bin() from this particular node. ////////////////////////////////////////////////////////////////////

clearClipPlane(...)

 

C++ Interface: clearClipPlane(non-const NodePath this) clearClipPlane(non-const NodePath this, const NodePath clip_plane)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_clip_plane // Access: Published // Description: Completely removes any clip planes that may have been // set via set_clip_plane() or set_clip_plane_off() from // this particular node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_clip_plane // Access: Published // Description: Removes any reference to the indicated clipping plane // from the NodePath. ////////////////////////////////////////////////////////////////////

clearColor(...)

 

C++ Interface: clearColor(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_color // Access: Published // Description: Completely removes any color adjustment from the node. // This allows the natural color of the geometry, or // whatever color transitions might be otherwise // affecting the geometry, to show instead. ////////////////////////////////////////////////////////////////////

clearColorScale(...)

 

C++ Interface: clearColorScale(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_color_scale // Access: Published // Description: Completely removes any color scale from the // referenced node. This is preferable to simply // setting the color scale to identity, as it also // removes the overhead associated with having a color // scale at all. ////////////////////////////////////////////////////////////////////

clearCompass(...)

 

C++ Interface: clearCompass(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_compass // Access: Published // Description: Removes any compass effect from the node. ////////////////////////////////////////////////////////////////////

clearDepthTest(...)

 

C++ Interface: clearDepthTest(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_depth_test // Access: Published // Description: Completely removes any depth-test adjustment that // may have been set on this node via set_depth_test(). ////////////////////////////////////////////////////////////////////

clearDepthWrite(...)

 

C++ Interface: clearDepthWrite(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_depth_write // Access: Published // Description: Completely removes any depth-write adjustment that // may have been set on this node via set_depth_write(). ////////////////////////////////////////////////////////////////////

clearEffect(...)

 

C++ Interface: clearEffect(non-const NodePath this, const TypeHandle type)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_effect // Access: Published // Description: Removes the render effect of the given type from // this node. ////////////////////////////////////////////////////////////////////

clearEffects(...)

 

C++ Interface: clearEffects(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_effects // Access: Published // Description: Resets this node to have no render effects. ////////////////////////////////////////////////////////////////////

clearFog(...)

 

C++ Interface: clearFog(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_fog // Access: Published // Description: Completely removes any fog adjustment that may // have been set via set_fog() or set_fog_off() // from this particular node. This allows whatever // fogs might be otherwise affecting the geometry to // show instead. ////////////////////////////////////////////////////////////////////

clearLight(...)

 

C++ Interface: clearLight(non-const NodePath this) clearLight(non-const NodePath this, const NodePath light)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_light // Access: Published // Description: Completely removes any lighting operations that may // have been set via set_light() or set_light_off() // from this particular node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_light // Access: Published // Description: Removes any reference to the indicated Light or // PolylightNode from the NodePath. ////////////////////////////////////////////////////////////////////

clearMat(...)

 

C++ Interface: clearMat(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_mat // Access: Published // Description: Completely removes any transform from the referenced // node. ////////////////////////////////////////////////////////////////////

clearMaterial(...)

 

C++ Interface: clearMaterial(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_material // Access: Published // Description: Completely removes any material adjustment that may // have been set via set_material() from this particular // node. ////////////////////////////////////////////////////////////////////

clearModelNodes(...)

 

C++ Interface: clearModelNodes(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_model_nodes // Access: Published // Description: Recursively walks through the scene graph at this // level and below, looking for ModelNodes, and calls // model_node->set_preserve_transform(PT_drop_node) on // each one. This allows a subsequent call to // flatten_strong() to eliminate all of the ModelNodes. // // Returns the number of ModelNodes found. ////////////////////////////////////////////////////////////////////

clearNormalMap(...)

 

C++ Interface: clearNormalMap(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_normal_map // Access: Published // Description: Undoes the effect of a previous call to // set_normal_map(). ////////////////////////////////////////////////////////////////////

clearProjectTexture(...)

 

C++ Interface: clearProjectTexture(non-const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_project_texture // Access: Published // Description: Undoes the effect of project_texture(). ////////////////////////////////////////////////////////////////////

clearPythonTag(...)

 

C++ Interface: clearPythonTag(non-const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_python_tag // Access: Published // Description: Removes the Python object defined for this key on this // particular node. After a call to clear_python_tag(), // has_python_tag() will return false for the indicated // key. ////////////////////////////////////////////////////////////////////

clearRenderMode(...)

 

C++ Interface: clearRenderMode(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_render_mode // Access: Published // Description: Completely removes any render mode adjustment that // may have been set on this node via // set_render_mode_wireframe() or // set_render_mode_filled(). ////////////////////////////////////////////////////////////////////

clearScissor(...)

 

C++ Interface: clearScissor(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_scissor // Access: Published // Description: Removes the scissor region that was defined at this // node level by a previous call to set_scissor(). ////////////////////////////////////////////////////////////////////

clearShader(...)

 

C++ Interface: clearShader(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_shader // Access: Published // Description: ////////////////////////////////////////////////////////////////////

clearShaderInput(...)

 

C++ Interface: clearShaderInput(non-const NodePath this, non-const InternalName id) clearShaderInput(non-const NodePath this, string id)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

clearTag(...)

 

C++ Interface: clearTag(non-const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_tag // Access: Published // Description: Removes the value defined for this key on this // particular node. After a call to clear_tag(), // has_tag() will return false for the indicated key. ////////////////////////////////////////////////////////////////////

clearTexGen(...)

 

C++ Interface: clearTexGen(non-const NodePath this) clearTexGen(non-const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_tex_gen // Access: Published // Description: Removes the texture coordinate generation mode from // all texture stages on this node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_tex_gen // Access: Published // Description: Disables automatic texture coordinate generation for // the indicated texture stage. ////////////////////////////////////////////////////////////////////

clearTexProjector(...)

 

C++ Interface: clearTexProjector(non-const NodePath this) clearTexProjector(non-const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_tex_projector // Access: Published // Description: Removes the TexProjectorEffect for the indicated // stage from this node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_tex_projector // Access: Published // Description: Removes the TexProjectorEffect for all stages from // this node. ////////////////////////////////////////////////////////////////////

clearTexTransform(...)

 

C++ Interface: clearTexTransform(non-const NodePath this) clearTexTransform(non-const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_tex_transform // Access: Published // Description: Removes all texture matrices from the current node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_tex_transform // Access: Published // Description: Removes the texture matrix on the current node for // the given stage. ////////////////////////////////////////////////////////////////////

clearTexture(...)

 

C++ Interface: clearTexture(non-const NodePath this) clearTexture(non-const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_texture // Access: Published // Description: Completely removes any texture adjustment that may // have been set via set_texture() or set_texture_off() // from this particular node. This allows whatever // textures might be otherwise affecting the geometry to // show instead. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_texture // Access: Published // Description: Removes any reference to the indicated texture stage // from the NodePath. ////////////////////////////////////////////////////////////////////

clearTransform(...)

 

C++ Interface: clearTransform(non-const NodePath this) clearTransform(non-const NodePath this, const NodePath other) clearTransform(non-const NodePath this, non-const Thread current_thread) clearTransform(non-const NodePath this, const NodePath other, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_transform // Access: Published // Description: Sets the transform object on this node to identity. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_transform // Access: Published // Description: Sets the transform object on this node to identity, // relative to the other node. This effectively places // this node at the same position as the other node. ////////////////////////////////////////////////////////////////////

clearTransparency(...)

 

C++ Interface: clearTransparency(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_transparency // Access: Published // Description: Completely removes any transparency adjustment that // may have been set on this node via set_transparency(). // The geometry at this level and below will // subsequently be rendered either transparent or not, // to whatever other nodes may have had // set_transparency() on them. ////////////////////////////////////////////////////////////////////

clearTwoSided(...)

 

C++ Interface: clearTwoSided(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::clear_two_sided // Access: Published // Description: Completely removes any two-sided adjustment that // may have been set on this node via set_two_sided(). // The geometry at this level and below will // subsequently be rendered either two-sided or // one-sided, according to whatever other nodes may have // had set_two_sided() on it, or according to the // initial state otherwise. ////////////////////////////////////////////////////////////////////

compareTo(...)

 

C++ Interface: compareTo(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::compare_to // Access: Published // Description: Returns a number less than zero if this NodePath // sorts before the other one, greater than zero if it // sorts after, or zero if they are equivalent. // // Two NodePaths are considered equivalent if they // consist of exactly the same list of nodes in the same // order. Otherwise, they are different; different // NodePaths will be ranked in a consistent but // undefined ordering; the ordering is useful only for // placing the NodePaths in a sorted container like an // STL set. ////////////////////////////////////////////////////////////////////

composeColorScale(...)

 

C++ Interface: composeColorScale(non-const NodePath this, const VBase4 scale) composeColorScale(non-const NodePath this, const VBase4 scale, int priority) composeColorScale(non-const NodePath this, float sx, float sy, float sz, float sa) composeColorScale(non-const NodePath this, float sx, float sy, float sz, float sa, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::compose_color_scale // Access: Published // Description: Sets the color scale component of the transform ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::compose_color_scale // Access: Published // Description: multiplies the color scale component of the transform, // with previous color scale leaving translation and // rotation untouched. ////////////////////////////////////////////////////////////////////

copyTo(...)

 

C++ Interface: copyTo(const NodePath this, const NodePath other) copyTo(const NodePath this, const NodePath other, int sort) copyTo(const NodePath this, const NodePath other, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::copy_to // Access: Published // Description: Functions like instance_to(), except a deep // copy is made of the referenced node and all of its // descendents, which is then parented to the indicated // node. A NodePath to the newly created copy is // returned. ////////////////////////////////////////////////////////////////////

countNumDescendants(...)

 

C++ Interface: countNumDescendants(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::count_num_descendants // Access: Published // Description: Returns the number of nodes at and below this level. ////////////////////////////////////////////////////////////////////

detachNode(...)

 

C++ Interface: detachNode(non-const NodePath this) detachNode(non-const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::detach_node // Access: Published // Description: Disconnects the referenced node from its parent, but // does not immediately delete it. The NodePath retains // a pointer to the node, and becomes a singleton // NodePath. // // This should be called to detach a node from the scene // graph, with the option of reattaching it later to the // same parent or to a different parent. // // In practice, the only difference between // remove_node() and detach_node() is that remove_node() // also resets the NodePath to empty, which will cause // the node to be deleted immediately if there are no // other references. On the other hand, detach_node() // leaves the NodePath referencing the node, which will // keep at least one reference to the node for as long // as the NodePath exists. ////////////////////////////////////////////////////////////////////

doBillboardAxis(...)

 

C++ Interface: doBillboardAxis(non-const NodePath this, const NodePath camera, float offset)

//////////////////////////////////////////////////////////////////// // Function: NodePath::do_billboard_axis // Access: Published // Description: Performs a billboard-type rotate to the indicated // camera node, one time only, and leaves the object // rotated. This is similar in principle to heads_up(). ////////////////////////////////////////////////////////////////////

doBillboardPointEye(...)

 

C++ Interface: doBillboardPointEye(non-const NodePath this, const NodePath camera, float offset)

//////////////////////////////////////////////////////////////////// // Function: NodePath::do_billboard_point_eye // Access: Published // Description: Performs a billboard-type rotate to the indicated // camera node, one time only, and leaves the object // rotated. This is similar in principle to look_at(), // although the point_eye billboard effect cannot be // achieved using the ordinary look_at() call. ////////////////////////////////////////////////////////////////////

doBillboardPointWorld(...)

 

C++ Interface: doBillboardPointWorld(non-const NodePath this, const NodePath camera, float offset)

//////////////////////////////////////////////////////////////////// // Function: NodePath::do_billboard_point_world // Access: Published // Description: Performs a billboard-type rotate to the indicated // camera node, one time only, and leaves the object // rotated. This is similar in principle to look_at(). ////////////////////////////////////////////////////////////////////

eq(...)

 

C++ Interface: eq(const NodePath this, const NodePath other)

// Comparison methods

//////////////////////////////////////////////////////////////////// // Function: NodePath::operator == // Access: Published // Description: Returns true if the two paths are equivalent; that // is, if they contain the same list of nodes in the same // order. ////////////////////////////////////////////////////////////////////

fail(...)

 

C++ Interface: fail()

//////////////////////////////////////////////////////////////////// // Function: NodePath::fail named constructor // Access: Published, Static // Description: Creates a NodePath with the ET_fail error type // set. ////////////////////////////////////////////////////////////////////

find(...)

 

C++ Interface: find(const NodePath this, string path)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find // Access: Published // Description: Searches for a node below the referenced node that // matches the indicated string. Returns the shortest // match found, if any, or an empty NodePath if no match // can be found. ////////////////////////////////////////////////////////////////////

findAllMatches(...)

 

C++ Interface: findAllMatches(const NodePath this, string path)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_matches // Access: Published // Description: Returns the complete set of all NodePaths that begin // with this NodePath and can be extended by // path. The shortest paths will be listed // first. ////////////////////////////////////////////////////////////////////

findAllMaterials(...)

 

C++ Interface: findAllMaterials(const NodePath this) findAllMaterials(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_materials // Access: Published // Description: Returns a list of a materials applied to geometry at // this node and below. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_materials // Access: Published // Description: Returns a list of a materials applied to geometry at // this node and below that match the indicated name // (which may contain wildcard characters). ////////////////////////////////////////////////////////////////////

findAllPathsTo(...)

 

C++ Interface: findAllPathsTo(const NodePath this, non-const PandaNode node)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_paths_to // Access: Published // Description: Returns the set of all NodePaths that extend from // this NodePath down to the indicated node. The // shortest paths will be listed first. ////////////////////////////////////////////////////////////////////

findAllTexcoords(...)

 

C++ Interface: findAllTexcoords(const NodePath this) findAllTexcoords(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_texcoords // Access: Published // Description: Returns a list of all texture coordinate sets used by // any geometry at this node level and below. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_texcoords // Access: Published // Description: Returns a list of all texture coordinate sets used by // any geometry at this node level and below that match // the indicated name (which may contain wildcard // characters). ////////////////////////////////////////////////////////////////////

findAllTextureStages(...)

 

C++ Interface: findAllTextureStages(const NodePath this) findAllTextureStages(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_texture_stages // Access: Published // Description: Returns a list of a TextureStages applied to geometry // at this node and below. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_texture_stages // Access: Published // Description: Returns a list of a TextureStages applied to geometry // at this node and below that match the indicated name // (which may contain wildcard characters). ////////////////////////////////////////////////////////////////////

findAllTextures(...)

 

C++ Interface: findAllTextures(const NodePath this) findAllTextures(const NodePath this, non-const TextureStage stage) findAllTextures(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_textures // Access: Published // Description: Returns a list of a textures applied to geometry at // this node and below. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_textures // Access: Published // Description: Returns a list of a textures applied to geometry at // this node and below that match the indicated name // (which may contain wildcard characters). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_textures // Access: Published // Description: Returns a list of a textures on geometry at // this node and below that are assigned to the // indicated texture stage. ////////////////////////////////////////////////////////////////////

findAllVertexColumns(...)

 

C++ Interface: findAllVertexColumns(const NodePath this) findAllVertexColumns(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_vertex_columns // Access: Published // Description: Returns a list of all vertex array columns stored on // some geometry found at this node level and below. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_all_vertex_columns // Access: Published // Description: Returns a list of all vertex array columns stored on // some geometry found at this node level and below that // match the indicated name (which may contain wildcard // characters). ////////////////////////////////////////////////////////////////////

findMaterial(...)

 

C++ Interface: findMaterial(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_material // Access: Published // Description: Returns the first material found applied to geometry // at this node or below that matches the indicated name // (which may contain wildcards). Returns the material // if it is found, or NULL if it is not. ////////////////////////////////////////////////////////////////////

findNetPythonTag(...)

 

C++ Interface: findNetPythonTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_net_python_tag // Access: Published // Description: Returns the lowest ancestor of this node that // contains a tag definition with the indicated key, if // any, or an empty NodePath if no ancestor of this node // contains this tag definition. See set_python_tag(). ////////////////////////////////////////////////////////////////////

findNetTag(...)

 

C++ Interface: findNetTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_net_tag // Access: Published // Description: Returns the lowest ancestor of this node that // contains a tag definition with the indicated key, if // any, or an empty NodePath if no ancestor of this node // contains this tag definition. See set_tag(). ////////////////////////////////////////////////////////////////////

findPathTo(...)

 

C++ Interface: findPathTo(const NodePath this, non-const PandaNode node)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_path_to // Access: Published // Description: Searches for the indicated node below this node and // returns the shortest NodePath that connects them. ////////////////////////////////////////////////////////////////////

findTexture(...)

 

C++ Interface: findTexture(const NodePath this, non-const TextureStage stage) findTexture(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_texture // Access: Published // Description: Returns the first texture found applied to geometry // at this node or below that matches the indicated name // (which may contain wildcards). Returns the texture // if it is found, or NULL if it is not. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_texture // Access: Published // Description: Returns the first texture found applied to geometry // at this node or below that is assigned to the // indicated texture stage. Returns the texture if it // is found, or NULL if it is not. ////////////////////////////////////////////////////////////////////

findTextureStage(...)

 

C++ Interface: findTextureStage(const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::find_texture_stage // Access: Published // Description: Returns the first TextureStage found applied to // geometry at this node or below that matches the // indicated name (which may contain wildcards). // Returns the TextureStage if it is found, or NULL if // it is not. ////////////////////////////////////////////////////////////////////

flattenLight(...)

 

C++ Interface: flattenLight(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::flatten_light // Access: Published // Description: Lightly flattens out the hierarchy below this node by // applying transforms, colors, and texture matrices // from the nodes onto the vertices, but does not remove // any nodes. // // This can result in improved rendering performance // because there will be fewer transforms in the // resulting scene graph, but the number of nodes will // remain the same. // // In particular, any NodePaths that reference nodes // within this hierarchy will not be damaged. However, // since this operation will remove transforms from the // scene graph, it may be dangerous to apply to nodes // where you expect to dynamically modify the transform, // or where you expect the geometry to remain in a // particular local coordinate system. // // The return value is always 0, since flatten_light // does not remove any nodes. ////////////////////////////////////////////////////////////////////

flattenMedium(...)

 

C++ Interface: flattenMedium(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::flatten_medium // Access: Published // Description: A more thorough flattening than flatten_light(), this // first applies all the transforms, colors, and texture // matrices from the nodes onto the vertices, and then // removes unneeded grouping nodes--nodes that have // exactly one child, for instance, but have no special // properties in themselves. // // This results in improved performance over // flatten_light() because the number of nodes in the // scene graph is reduced. // // The return value is the number of nodes removed. ////////////////////////////////////////////////////////////////////

flattenStrong(...)

 

C++ Interface: flattenStrong(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::flatten_strong // Access: Published // Description: The strongest possible flattening. This first // applies all of the transforms to the vertices, as in // flatten_medium(), but then it will combine sibling // nodes together when possible, in addition to removing // unnecessary parent-child nodes. This can result in // substantially fewer nodes, but any nicely-grouped // hierachical bounding volumes may be lost. // // It is generally a good idea to apply this kind of // flattening only to nodes that will be culled largely // as a single unit, like a car. Applying this to an // entire scene may result in overall poorer performance // because of less-effective culling. ////////////////////////////////////////////////////////////////////

forceRecomputeBounds(...)

 

C++ Interface: forceRecomputeBounds(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::force_recompute_bounds // Access: Published // Description: Forces the recomputing of all the bounding volumes at // every node in the subgraph beginning at this node and // below. // // This should not normally need to be called, since the // bounding volumes are supposed to be recomputed // automatically when necessary. It may be useful when // debugging, to verify that the bounding volumes have // not become inadvertently stale; it may also be useful // to force animated characters to update their bounding // volumes (which does not presently happen // automatically). ////////////////////////////////////////////////////////////////////

getAncestor(...)

 

C++ Interface: getAncestor(const NodePath this, int index) getAncestor(const NodePath this, int index, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_ancestor // Access: Published // Description: Returns the nth ancestor of the path, where 0 is the // NodePath itself and get_num_nodes() - 1 is get_top(). // This requires iterating through the path. // // Also see get_node(), which returns the same thing as // a PandaNode pointer, not a NodePath. ////////////////////////////////////////////////////////////////////

getAntialias(...)

 

C++ Interface: getAntialias(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_antialias // Access: Published // Description: Returns the antialias setting that has been // specifically set on this node via set_antialias(), or // M_none if no setting has been made. ////////////////////////////////////////////////////////////////////

getAttrib(...)

 

C++ Interface: getAttrib(const NodePath this, const TypeHandle type)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_attrib // Access: Published // Description: Returns the render attribute of the indicated type, // if it is defined on the node, or NULL if it is not. // This checks only what is set on this particular node // level, and has nothing to do with what render // attributes may be inherited from parent nodes. ////////////////////////////////////////////////////////////////////

getAudioVolume(...)

 

C++ Interface: getAudioVolume(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_audio_volume // Access: Published // Description: Returns the complete audio volume that has been // applied to this node via a previous call to // set_audio_volume(), or 1. (identity) if no volume has // been applied to this particular node. ////////////////////////////////////////////////////////////////////

getBinDrawOrder(...)

 

C++ Interface: getBinDrawOrder(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_bin_draw_order // Access: Published // Description: Returns the drawing order associated with the bin // that this particular node was assigned to via // set_bin(), or 0 if no bin was assigned. See // set_bin() and has_bin(). ////////////////////////////////////////////////////////////////////

getBinName(...)

 

C++ Interface: getBinName(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_bin_name // Access: Published // Description: Returns the name of the bin that this particular node // was assigned to via set_bin(), or the empty string if // no bin was assigned. See set_bin() and has_bin(). ////////////////////////////////////////////////////////////////////

getBounds(...)

 

C++ Interface: getBounds(const NodePath this) getBounds(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_bounds // Access: Published // Description: Returns a newly-allocated bounding volume containing // the bottom node and all of its descendants. This is // the bounding volume on the bottom arc, converted to // the local coordinate space of the node. ////////////////////////////////////////////////////////////////////

getChild(...)

 

C++ Interface: getChild(const NodePath this, int n) getChild(const NodePath this, int n, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_child // Access: Published // Description: Returns a NodePath representing the nth child of the // referenced node. ////////////////////////////////////////////////////////////////////

getChildren(...)

 

C++ Interface: getChildren(const NodePath this) getChildren(const NodePath this, non-const Thread current_thread)

// Methods that return collections of NodePaths derived from or // related to this one.

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_children // Access: Published // Description: Returns the set of all child nodes of the referenced // node. ////////////////////////////////////////////////////////////////////

getCollideMask(...)

 

C++ Interface: getCollideMask(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_collide_mask // Access: Published // Description: Returns the union of all of the into_collide_masks // for nodes at this level and below. This is the same // thing as node()->get_net_collide_mask(). // // If you want to return what the into_collide_mask of // this node itself is, without regard to its children, // use node()->get_into_collide_mask(). ////////////////////////////////////////////////////////////////////

getColor(...)

 

C++ Interface: getColor(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_color // Access: Published // Description: Returns the color that has been assigned to the node, // or black if no color has been assigned. ////////////////////////////////////////////////////////////////////

getColorScale(...)

 

C++ Interface: getColorScale(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_color_scale // Access: Published // Description: Returns the complete color scale vector that has been // applied to this node via a previous call to // set_color_scale() and/or set_alpha_scale(), or all // 1's (identity) if no scale has been applied to this // particular node. ////////////////////////////////////////////////////////////////////

getCommonAncestor(...)

 

C++ Interface: getCommonAncestor(const NodePath this, const NodePath other) getCommonAncestor(const NodePath this, const NodePath other, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_common_ancestor // Access: Published // Description: Returns the lowest NodePath that both of these two // NodePaths have in common: the first ancestor that // both of them share. If the two NodePaths are // unrelated, returns NodePath::not_found(). ////////////////////////////////////////////////////////////////////

getDepthTest(...)

 

C++ Interface: getDepthTest(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_depth_test // Access: Published // Description: Returns true if depth-test rendering has been // specifically set on this node via set_depth_test(), or // false if depth-test rendering has been specifically // disabled. If nothing has been specifically set, // returns true. See also has_depth_test(). ////////////////////////////////////////////////////////////////////

getDepthWrite(...)

 

C++ Interface: getDepthWrite(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_depth_write // Access: Published // Description: Returns true if depth-write rendering has been // specifically set on this node via set_depth_write(), or // false if depth-write rendering has been specifically // disabled. If nothing has been specifically set, // returns true. See also has_depth_write(). ////////////////////////////////////////////////////////////////////

getDistance(...)

 

C++ Interface: getDistance(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_distance // Access: Published // Description: Returns the straight-line distance between this // referenced node's coordinate frame's origin, and that // of the other node's origin. ////////////////////////////////////////////////////////////////////

getEffect(...)

 

C++ Interface: getEffect(const NodePath this, const TypeHandle type)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_effect // Access: Published // Description: Returns the render effect of the indicated type, // if it is defined on the node, or NULL if it is not. ////////////////////////////////////////////////////////////////////

getEffects(...)

 

C++ Interface: getEffects(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_effects // Access: Published // Description: Returns the complete RenderEffects that will be // applied to this node. ////////////////////////////////////////////////////////////////////

getErrorType(...)

 

C++ Interface: getErrorType(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_error_type // Access: Published // Description: If is_empty() is true, this returns a code that // represents the reason why the NodePath is empty. ////////////////////////////////////////////////////////////////////

getFog(...)

 

C++ Interface: getFog(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_fog // Access: Published // Description: Returns the fog that has been set on this // particular node, or NULL if no fog has been set. // This is not necessarily the fog that will be // applied to the geometry at or below this level, as // another fog at a higher or lower level may // override. ////////////////////////////////////////////////////////////////////

getHiddenAncestor(...)

 

C++ Interface: getHiddenAncestor(const NodePath this) getHiddenAncestor(const NodePath this, const BitMask camera_mask) getHiddenAncestor(const NodePath this, const BitMask camera_mask, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_hidden_ancestor // Access: Published // Description: Returns the NodePath at or above the referenced node // that is hidden to the indicated camera(s), or an // empty NodePath if no ancestor of the referenced node // is hidden (and the node should be visible). ////////////////////////////////////////////////////////////////////

getHpr(...)

 

C++ Interface: getHpr(const NodePath this) getHpr(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_hpr // Access: Published // Description: Retrieves the rotation component of the transform. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_hpr // Access: Published // Description: Returns the relative orientation of the bottom node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getKey(...)

 

C++ Interface: getKey(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_key // Access: Published // Description: Returns an integer that is guaranteed to be the same // for all NodePaths that represent the same node // instance, and different for all NodePaths that // represent a different node instance. // // The same key will be returned for a particular // instance as long as at least one NodePath exists that // represents that instance; if all NodePaths for a // particular instance destruct and a new one is later // created, it may have a different index. However, a // given key will never be reused for a different // instance (unless the app has been running long enough // that we overflow the integer key value). ////////////////////////////////////////////////////////////////////

getMat(...)

 

C++ Interface: getMat(const NodePath this) getMat(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_mat // Access: Published // Description: Returns the transform matrix that has been applied to // the referenced node, or the identity matrix if no // matrix has been applied. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_mat // Access: Published // Description: Returns the matrix that describes the coordinate // space of the bottom node, relative to the other // path's bottom node's coordinate space. ////////////////////////////////////////////////////////////////////

getMaterial(...)

 

C++ Interface: getMaterial(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_material // Access: Published // Description: Returns the material that has been set on this // particular node, or NULL if no material has been set. // This is not necessarily the material that will be // applied to the geometry at or below this level, as // another material at a higher or lower level may // override. // See also find_material(). ////////////////////////////////////////////////////////////////////

getMaxSearchDepth(...)

 

C++ Interface: getMaxSearchDepth()

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_max_search_depth // Access: Published, Static // Description: Returns the current setting of the search depth // limit. See set_max_search_depth. ////////////////////////////////////////////////////////////////////

getName(...)

 

C++ Interface: getName(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_name // Access: Published // Description: Returns the name of the referenced node. ////////////////////////////////////////////////////////////////////

getNetAudioVolume(...)

 

C++ Interface: getNetAudioVolume(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_net_audio_volume // Access: Published // Description: Returns the complete audio volume for this node // taking highers nodes in the graph into account. ////////////////////////////////////////////////////////////////////

getNetPrevTransform(...)

 

C++ Interface: getNetPrevTransform(const NodePath this) getNetPrevTransform(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_net_prev_transform // Access: Published // Description: Returns the net "previous" transform on this node // from the root. See set_prev_transform(). ////////////////////////////////////////////////////////////////////

getNetPythonTag(...)

 

C++ Interface: getNetPythonTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_net_python_tag // Access: Published // Description: Returns the Python object that has been defined on // this node, or the nearest ancestor node, for the // indicated key. If no value has been defined for the // indicated key on any ancestor node, returns None. // See also get_python_tag(). ////////////////////////////////////////////////////////////////////

getNetState(...)

 

C++ Interface: getNetState(const NodePath this) getNetState(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_net_state // Access: Published // Description: Returns the net state on this node from the root. ////////////////////////////////////////////////////////////////////

getNetTag(...)

 

C++ Interface: getNetTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_net_tag // Access: Published // Description: Returns the tag value that has been defined on this // node, or the nearest ancestor node, for the indicated // key. If no value has been defined for the indicated // key on any ancestor node, returns the empty string. // See also get_tag(). ////////////////////////////////////////////////////////////////////

getNetTransform(...)

 

C++ Interface: getNetTransform(const NodePath this) getNetTransform(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_net_transform // Access: Published // Description: Returns the net transform on this node from the root. ////////////////////////////////////////////////////////////////////

getNode(...)

 

C++ Interface: getNode(const NodePath this, int index) getNode(const NodePath this, int index, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_node // Access: Published // Description: Returns the nth node of the path, where 0 is the // referenced (bottom) node and get_num_nodes() - 1 is // the top node. This requires iterating through the // path. // // Also see node(), which is a convenience function to // return the same thing as get_node(0) (since the // bottom node is the most important node in the // NodePath, and is the one most frequently referenced). // // Note that this function returns the same thing as // get_ancestor(index).node(). ////////////////////////////////////////////////////////////////////

getNumChildren(...)

 

C++ Interface: getNumChildren(const NodePath this) getNumChildren(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_num_children // Access: Published // Description: Returns the number of children of the referenced node. ////////////////////////////////////////////////////////////////////

getNumNodes(...)

 

C++ Interface: getNumNodes(const NodePath this) getNumNodes(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_num_nodes // Access: Published // Description: Returns the number of nodes in the path. ////////////////////////////////////////////////////////////////////

getParent(...)

 

C++ Interface: getParent(const NodePath this) getParent(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_parent // Access: Published // Description: Returns the NodePath to the parent of the referenced // node: that is, this NodePath, shortened by one node. // The parent of a singleton NodePath is defined to be // the empty NodePath. ////////////////////////////////////////////////////////////////////

getPos(...)

 

C++ Interface: getPos(const NodePath this) getPos(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_pos // Access: Published // Description: Retrieves the translation component of the transform. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_pos // Access: Published // Description: Returns the relative position of the referenced node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getPosDelta(...)

 

C++ Interface: getPosDelta(const NodePath this) getPosDelta(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_pos_delta // Access: Published // Description: Returns the delta vector from this node's position in // the previous frame (according to // set_prev_transform(), typically set via the use of // set_fluid_pos()) and its position in the current // frame. This is the vector used to determine // collisions. Generally, if the node was last // repositioned via set_pos(), the delta will be zero; // if it was adjusted via set_fluid_pos(), the delta // will represent the change from the previous frame's // position. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_pos_delta // Access: Published // Description: Returns the delta vector from this node's position in // the previous frame (according to // set_prev_transform(), typically set via the use of // set_fluid_pos()) and its position in the current // frame, as seen in the indicated node's coordinate // space. This is the vector used to determine // collisions. Generally, if the node was last // repositioned via set_pos(), the delta will be zero; // if it was adjusted via set_fluid_pos(), the delta // will represent the change from the previous frame's // position. ////////////////////////////////////////////////////////////////////

getPrevTransform(...)

 

C++ Interface: getPrevTransform(const NodePath this) getPrevTransform(const NodePath this, const NodePath other) getPrevTransform(const NodePath this, non-const Thread current_thread) getPrevTransform(const NodePath this, const NodePath other, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_prev_transform // Access: Published // Description: Returns the transform that has been set as this // node's "previous" position. See // set_prev_transform(). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_prev_transform // Access: Published // Description: Returns the relative "previous" transform to this // node from the other node; i.e. the position of this // node in the previous frame, as seen by the other node // in the previous frame. ////////////////////////////////////////////////////////////////////

getPythonTag(...)

 

C++ Interface: getPythonTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_python_tag // Access: Published // Description: Retrieves the Python object that was previously // set on this node for the particular key, if any. If // no object has been previously set, returns None. // See also get_net_python_tag(). ////////////////////////////////////////////////////////////////////

getQuat(...)

 

C++ Interface: getQuat(const NodePath this) getQuat(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_quat // Access: Published // Description: Retrieves the rotation component of the transform. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_quat // Access: Published // Description: Returns the relative orientation of the bottom node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getRelativePoint(...)

 

C++ Interface: getRelativePoint(const NodePath this, const NodePath other, const VBase3 point)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_relative_point // Access: Published // Description: Given that the indicated point is in the coordinate // system of the other node, returns the same point in // this node's coordinate system. ////////////////////////////////////////////////////////////////////

getRelativeVector(...)

 

C++ Interface: getRelativeVector(const NodePath this, const NodePath other, const VBase3 vec)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_relative_vector // Access: Published // Description: Given that the indicated vector is in the coordinate // system of the other node, returns the same vector in // this node's coordinate system. ////////////////////////////////////////////////////////////////////

getRenderMode(...)

 

C++ Interface: getRenderMode(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_render_mode // Access: Published // Description: Returns the render mode that has been specifically // set on this node via set_render_mode(), or // M_unchanged if nothing has been set. ////////////////////////////////////////////////////////////////////

getRenderModePerspective(...)

 

C++ Interface: getRenderModePerspective(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_render_mode_perspective // Access: Published // Description: Returns the flag that has been set on this node via // set_render_mode_perspective(), or false if no flag // has been set. ////////////////////////////////////////////////////////////////////

getRenderModeThickness(...)

 

C++ Interface: getRenderModeThickness(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_render_mode_thickness // Access: Published // Description: Returns the render mode thickness that has been // specifically set on this node via set_render_mode(), // or 1.0 if nothing has been set. ////////////////////////////////////////////////////////////////////

getSa(...)

 

C++ Interface: getSa(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_sa // Access: Published // Description: Gets the alpha scale component of the transform ////////////////////////////////////////////////////////////////////

getSb(...)

 

C++ Interface: getSb(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_sb // Access: Published // Description: Gets the blue scale component of the transform ////////////////////////////////////////////////////////////////////

getScale(...)

 

C++ Interface: getScale(const NodePath this) getScale(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_scale // Access: Published // Description: Retrieves the scale component of the transform. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_scale // Access: Published // Description: Returns the relative scale of the bottom node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getSg(...)

 

C++ Interface: getSg(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_sg // Access: Published // Description: Gets the green scale component of the transform ////////////////////////////////////////////////////////////////////

getShader(...)

 

C++ Interface: getShader(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_shader // Access: Published // Description: ////////////////////////////////////////////////////////////////////

getShaderInput(...)

 

C++ Interface: getShaderInput(const NodePath this, non-const InternalName id) getShaderInput(const NodePath this, string id)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

getShear(...)

 

C++ Interface: getShear(const NodePath this) getShear(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_shear // Access: Published // Description: Retrieves the shear component of the transform. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_shear // Access: Published // Description: Returns the relative shear of the bottom node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getShxy(...)

 

C++ Interface: getShxy(const NodePath this) getShxy(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_shear // Access: Published // Description: Returns the relative shear of the referenced node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getSort(...)

 

C++ Interface: getSort(const NodePath this) getSort(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_sort // Access: Published // Description: Returns the sort value of the referenced node within // its parent; that is, the sort number passed on the // last reparenting operation for this node. This will // control the position of the node within its parent's // list of children. ////////////////////////////////////////////////////////////////////

getSr(...)

 

C++ Interface: getSr(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_sr // Access: Published // Description: Gets the red scale component of the transform ////////////////////////////////////////////////////////////////////

getStashedAncestor(...)

 

C++ Interface: getStashedAncestor(const NodePath this) getStashedAncestor(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_stashed_ancestor // Access: Published // Description: Returns the NodePath at or above the referenced node // that is stashed, or an empty NodePath if no ancestor // of the referenced node is stashed (and the node should // be visible). ////////////////////////////////////////////////////////////////////

getStashedChildren(...)

 

C++ Interface: getStashedChildren(const NodePath this) getStashedChildren(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_stashed_children // Access: Published // Description: Returns the set of all child nodes of the referenced // node that have been stashed. These children are not // normally visible on the node, and do not appear in // the list returned by get_children(). ////////////////////////////////////////////////////////////////////

getState(...)

 

C++ Interface: getState(const NodePath this) getState(const NodePath this, const NodePath other) getState(const NodePath this, non-const Thread current_thread) getState(const NodePath this, const NodePath other, non-const Thread current_thread)

// Aggregate transform and state information.

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_state // Access: Published // Description: Returns the complete state object set on this node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_state // Access: Published // Description: Returns the state changes that must be made to // transition to the render state of this node from the // render state of the other node. ////////////////////////////////////////////////////////////////////

getSx(...)

 

C++ Interface: getSx(const NodePath this) getSx(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_scale // Access: Published // Description: Returns the relative scale of the referenced node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getTag(...)

 

C++ Interface: getTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tag // Access: Published // Description: Retrieves the user-defined value that was previously // set on this node for the particular key, if any. If // no value has been previously set, returns the empty // string. See also get_net_tag(). ////////////////////////////////////////////////////////////////////

getTexGen(...)

 

C++ Interface: getTexGen(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_gen // Access: Published // Description: Returns the texture coordinate generation mode for // the given stage, or M_off if there is no explicit // mode set for the given stage. ////////////////////////////////////////////////////////////////////

getTexGenLight(...)

 

C++ Interface: getTexGenLight(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_gen_light // Access: Published // Description: Returns the particular Light set for the indicated // texgen mode's texture stage, or empty NodePath if no // light is set. This is only meaningful if the texgen // mode (returned by get_tex_gen()) is M_light_vector. ////////////////////////////////////////////////////////////////////

getTexHpr(...)

 

C++ Interface: getTexHpr(const NodePath this, non-const TextureStage stage) getTexHpr(const NodePath this, const NodePath other, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_hpr // Access: Published // Description: Returns the 3-D HPR set for the UVW's for the given // stage on the current node. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_hpr // Access: Published // Description: Returns the 3-D HPR set for the UVW's for the given // stage on the current node. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

getTexOffset(...)

 

C++ Interface: getTexOffset(const NodePath this, non-const TextureStage stage) getTexOffset(const NodePath this, const NodePath other, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_offset // Access: Published // Description: Returns the offset set for the UV's for the given // stage on the current node. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_offset // Access: Published // Description: Returns the offset set for the UV's for the given // stage on the current node. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

getTexPos(...)

 

C++ Interface: getTexPos(const NodePath this, non-const TextureStage stage) getTexPos(const NodePath this, const NodePath other, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_pos // Access: Published // Description: Returns the offset set for the UVW's for the given // stage on the current node. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_pos // Access: Published // Description: Returns the offset set for the UVW's for the given // stage on the current node. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

getTexProjectorFrom(...)

 

C++ Interface: getTexProjectorFrom(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_projector_from // Access: Published // Description: Returns the "from" node associated with the // TexProjectorEffect on the indicated stage. The // relative transform between the "from" and the "to" // nodes is automatically applied to the texture // transform each frame. ////////////////////////////////////////////////////////////////////

getTexProjectorTo(...)

 

C++ Interface: getTexProjectorTo(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_projector_to // Access: Published // Description: Returns the "to" node associated with the // TexProjectorEffect on the indicated stage. The // relative transform between the "from" and the "to" // nodes is automatically applied to the texture // transform each frame. ////////////////////////////////////////////////////////////////////

getTexRotate(...)

 

C++ Interface: getTexRotate(const NodePath this, non-const TextureStage stage) getTexRotate(const NodePath this, const NodePath other, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_rotate // Access: Published // Description: Returns the rotation set for the UV's for the given // stage on the current node. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_rotate // Access: Published // Description: Returns the rotation set for the UV's for the given // stage on the current node. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

getTexScale(...)

 

C++ Interface: getTexScale(const NodePath this, non-const TextureStage stage) getTexScale(const NodePath this, const NodePath other, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_scale // Access: Published // Description: Returns the scale set for the UV's for the given // stage on the current node. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_scale // Access: Published // Description: Returns the scale set for the UV's for the given // stage on the current node. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

getTexScale3d(...)

 

C++ Interface: getTexScale3d(const NodePath this, non-const TextureStage stage) getTexScale3d(const NodePath this, const NodePath other, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_scale_3d // Access: Published // Description: Returns the scale set for the UVW's for the given // stage on the current node. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_scale_3d // Access: Published // Description: Returns the scale set for the UVW's for the given // stage on the current node. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

getTexTransform(...)

 

C++ Interface: getTexTransform(const NodePath this, non-const TextureStage stage) getTexTransform(const NodePath this, const NodePath other, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_transform // Access: Published // Description: Returns the texture matrix on the current node for the // given stage, or identity transform if there is no // explicit transform set for the given stage. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_tex_transform // Access: Published // Description: Returns the texture matrix on the current node for the // given stage, relative to the other node. ////////////////////////////////////////////////////////////////////

getTexture(...)

 

C++ Interface: getTexture(const NodePath this) getTexture(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_texture // Access: Published // Description: Returns the base-level texture that has been set on // this particular node, or NULL if no texture has been // set. This is not necessarily the texture that will // be applied to the geometry at or below this level, as // another texture at a higher or lower level may // override. // // See also find_texture(). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_texture // Access: Published // Description: Returns the texture that has been set on the // indicated stage for this particular node, or NULL if // no texture has been set for this stage. ////////////////////////////////////////////////////////////////////

getTop(...)

 

C++ Interface: getTop(const NodePath this) getTop(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_top // Access: Published // Description: Returns a singleton NodePath that represents the top // of the path, or empty NodePath if this path is empty. ////////////////////////////////////////////////////////////////////

getTopNode(...)

 

C++ Interface: getTopNode(const NodePath this) getTopNode(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_top_node // Access: Published // Description: Returns the top node of the path, or NULL if the path // is empty. This requires iterating through the path. ////////////////////////////////////////////////////////////////////

getTransform(...)

 

C++ Interface: getTransform(const NodePath this) getTransform(const NodePath this, const NodePath other) getTransform(const NodePath this, non-const Thread current_thread) getTransform(const NodePath this, const NodePath other, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_transform // Access: Published // Description: Returns the complete transform object set on this node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_transform // Access: Published // Description: Returns the relative transform to this node from the // other node; i.e. the transformation of this node // as seen from the other node. ////////////////////////////////////////////////////////////////////

getTransparency(...)

 

C++ Interface: getTransparency(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_transparency // Access: Published // Description: Returns the transparent rendering that has been // specifically set on this node via set_transparency(), or // M_none if nontransparent rendering has been specifically // set, or if nothing has been specifically set. See // also has_transparency(). This does not necessarily // imply that the geometry will or will not be rendered // transparent, as there may be other nodes that override. ////////////////////////////////////////////////////////////////////

getTwoSided(...)

 

C++ Interface: getTwoSided(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::get_two_sided // Access: Published // Description: Returns true if two-sided rendering has been // specifically set on this node via set_two_sided(), or // false if one-sided rendering has been specifically // set, or if nothing has been specifically set. See // also has_two_sided(). This does not necessarily // imply that the geometry will or will not be rendered // two-sided, as there may be other nodes that override. ////////////////////////////////////////////////////////////////////

hasAntialias(...)

 

C++ Interface: hasAntialias(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_antialias // Access: Published // Description: Returns true if an antialias setting has been // explicitly mode on this particular node via // set_antialias(). If this returns true, then // get_antialias() may be called to determine what the // setting was. ////////////////////////////////////////////////////////////////////

hasAttrib(...)

 

C++ Interface: hasAttrib(const NodePath this, const TypeHandle type)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_attrib // Access: Published // Description: Returns true if there is a render attribute of the // indicated type defined on this node, or false if // there is not. ////////////////////////////////////////////////////////////////////

hasAudioVolume(...)

 

C++ Interface: hasAudioVolume(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_audio_volume // Access: Published // Description: Returns true if an audio volume has been applied // to the referenced node, false otherwise. It is still // possible that volume at this node might have been // scaled by an ancestor node. ////////////////////////////////////////////////////////////////////

hasBillboard(...)

 

C++ Interface: hasBillboard(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_billboard // Access: Published // Description: Returns true if there is any billboard effect on // the node. ////////////////////////////////////////////////////////////////////

hasBin(...)

 

C++ Interface: hasBin(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_bin // Access: Published // Description: Returns true if the node has been assigned to the a // particular rendering bin via set_bin(), false // otherwise. ////////////////////////////////////////////////////////////////////

hasClipPlane(...)

 

C++ Interface: hasClipPlane(const NodePath this, const NodePath clip_plane)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_clip_plane // Access: Published // Description: Returns true if the indicated clipping plane has been // specifically applied to this particular node. This // means that someone called set_clip_plane() on this // node with the indicated clip_plane. ////////////////////////////////////////////////////////////////////

hasClipPlaneOff(...)

 

C++ Interface: hasClipPlaneOff(const NodePath this) hasClipPlaneOff(const NodePath this, const NodePath clip_plane)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_clip_plane_off // Access: Published // Description: Returns true if all clipping planes have been // specifically disabled on this particular node. This // means that someone called set_clip_plane_off() on // this node with no parameters. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_clip_plane_off // Access: Published // Description: Returns true if the indicated clipping plane has been // specifically disabled on this particular node. This // means that someone called set_clip_plane_off() on // this node with the indicated clip_plane. ////////////////////////////////////////////////////////////////////

hasColor(...)

 

C++ Interface: hasColor(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_color // Access: Published // Description: Returns true if a color has been applied to the given // node, false otherwise. ////////////////////////////////////////////////////////////////////

hasColorScale(...)

 

C++ Interface: hasColorScale(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_color_scale // Access: Published // Description: Returns true if a color scale has been applied // to the referenced node, false otherwise. It is still // possible that color at this node might have been // scaled by an ancestor node. ////////////////////////////////////////////////////////////////////

hasCompass(...)

 

C++ Interface: hasCompass(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_compass // Access: Published // Description: Returns true if there is any compass effect on // the node. ////////////////////////////////////////////////////////////////////

hasDepthTest(...)

 

C++ Interface: hasDepthTest(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_depth_test // Access: Published // Description: Returns true if a depth-test adjustment has been // explicitly set on this particular node via // set_depth_test(). If this returns true, then // get_depth_test() may be called to determine which has // been set. ////////////////////////////////////////////////////////////////////

hasDepthWrite(...)

 

C++ Interface: hasDepthWrite(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_depth_write // Access: Published // Description: Returns true if a depth-write adjustment has been // explicitly set on this particular node via // set_depth_write(). If this returns true, then // get_depth_write() may be called to determine which has // been set. ////////////////////////////////////////////////////////////////////

hasEffect(...)

 

C++ Interface: hasEffect(const NodePath this, const TypeHandle type)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_effect // Access: Published // Description: Returns true if there is a render effect of the // indicated type defined on this node, or false if // there is not. ////////////////////////////////////////////////////////////////////

hasFog(...)

 

C++ Interface: hasFog(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_fog // Access: Published // Description: Returns true if a fog has been applied to this // particular node via set_fog(), false otherwise. // This is not the same thing as asking whether the // geometry at this node will be rendered with // fog, as there may be a fog in effect from a higher or // lower level. ////////////////////////////////////////////////////////////////////

hasFogOff(...)

 

C++ Interface: hasFogOff(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_fog_off // Access: Published // Description: Returns true if a fog has been specifically // disabled on this particular node via // set_fog_off(), false otherwise. This is not the // same thing as asking whether the geometry at this // node will be rendered unfogged, as there may be a // fog in effect from a higher or lower level. ////////////////////////////////////////////////////////////////////

hasLight(...)

 

C++ Interface: hasLight(const NodePath this, const NodePath light)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_light // Access: Published // Description: Returns true if the indicated Light or PolylightNode // has been specifically enabled on this particular // node. This means that someone called set_light() on // this node with the indicated light. ////////////////////////////////////////////////////////////////////

hasLightOff(...)

 

C++ Interface: hasLightOff(const NodePath this) hasLightOff(const NodePath this, const NodePath light)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_light_off // Access: Published // Description: Returns true if all Lights have been specifically // disabled on this particular node. This means that // someone called set_light_off() on this node with no // parameters. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_light_off // Access: Published // Description: Returns true if the indicated Light has been // specifically disabled on this particular node. This // means that someone called set_light_off() on this // node with the indicated light. // // This interface does not support PolylightNodes, which // cannot be turned off at a lower level. ////////////////////////////////////////////////////////////////////

hasMat(...)

 

C++ Interface: hasMat(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_mat // Access: Published // Description: Returns true if a non-identity transform matrix has // been applied to the referenced node, false otherwise. ////////////////////////////////////////////////////////////////////

hasMaterial(...)

 

C++ Interface: hasMaterial(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_material // Access: Published // Description: Returns true if a material has been applied to this // particular node via set_material(), false otherwise. ////////////////////////////////////////////////////////////////////

hasNetPythonTag(...)

 

C++ Interface: hasNetPythonTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_net_python_tag // Access: Published // Description: Returns true if the indicated Python object has been // defined on this node or on any ancestor node, or // false otherwise. See also has_python_tag(). ////////////////////////////////////////////////////////////////////

hasNetTag(...)

 

C++ Interface: hasNetTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_net_tag // Access: Published // Description: Returns true if the indicated tag value has been // defined on this node or on any ancestor node, or // false otherwise. See also has_tag(). ////////////////////////////////////////////////////////////////////

hasParent(...)

 

C++ Interface: hasParent(const NodePath this) hasParent(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_parent // Access: Published // Description: Returns true if the referenced node has a parent; // i.e. the NodePath chain contains at least two nodes. ////////////////////////////////////////////////////////////////////

hasPythonTag(...)

 

C++ Interface: hasPythonTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_python_tag // Access: Published // Description: Returns true if a Python object has been defined on // this node for the particular key (even if that value // is the empty string), or false if no value has been // set. See also has_net_python_tag(). ////////////////////////////////////////////////////////////////////

hasRenderMode(...)

 

C++ Interface: hasRenderMode(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_render_mode // Access: Published // Description: Returns true if a render mode has been explicitly set // on this particular node via set_render_mode() (or // set_render_mode_wireframe() or // set_render_mode_filled()), false otherwise. ////////////////////////////////////////////////////////////////////

hasScissor(...)

 

C++ Interface: hasScissor(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_scissor // Access: Published // Description: Returns true if a scissor region was defined at this // node by a previous call to set_scissor(). This does // not check for scissor regions inherited from a parent // class. It also does not check for the presence of a // low-level ScissorAttrib, which is different from the // ScissorEffect added by set_scissor. ////////////////////////////////////////////////////////////////////

hasTag(...)

 

C++ Interface: hasTag(const NodePath this, string key)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_tag // Access: Published // Description: Returns true if a value has been defined on this node // for the particular key (even if that value is the // empty string), or false if no value has been set. // See also has_net_tag(). ////////////////////////////////////////////////////////////////////

hasTexGen(...)

 

C++ Interface: hasTexGen(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_tex_gen // Access: Published // Description: Returns true if there is a mode for automatic texture // coordinate generation on the current node for the // given stage. ////////////////////////////////////////////////////////////////////

hasTexProjector(...)

 

C++ Interface: hasTexProjector(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_tex_projector // Access: Published // Description: Returns true if this node has a TexProjectorEffect // for the indicated stage, false otherwise. ////////////////////////////////////////////////////////////////////

hasTexTransform(...)

 

C++ Interface: hasTexTransform(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_tex_transform // Access: Published // Description: Returns true if there is an explicit texture matrix // on the current node for the given stage. ////////////////////////////////////////////////////////////////////

hasTexcoord(...)

 

C++ Interface: hasTexcoord(const NodePath this, string texcoord_name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_texcoord // Access: Published // Description: Returns true if there are at least some vertices at // this node and below that use the named texture // coordinate set, false otherwise. Pass the empty // string for the default texture coordinate set. ////////////////////////////////////////////////////////////////////

hasTexture(...)

 

C++ Interface: hasTexture(const NodePath this) hasTexture(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_texture // Access: Published // Description: Returns true if a texture has been applied to this // particular node via set_texture(), false otherwise. // This is not the same thing as asking whether the // geometry at this node will be rendered with // texturing, as there may be a texture in effect from a // higher or lower level. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_texture // Access: Published // Description: Returns true if texturing has been specifically // enabled on this particular node for the indicated // stage. This means that someone called // set_texture() on this node with the indicated stage // name, or the stage_name is the default stage_name, // and someone called set_texture() on this node. ////////////////////////////////////////////////////////////////////

hasTextureOff(...)

 

C++ Interface: hasTextureOff(const NodePath this) hasTextureOff(const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_texture_off // Access: Published // Description: Returns true if texturing has been specifically // disabled on this particular node via // set_texture_off(), false otherwise. This is not the // same thing as asking whether the geometry at this // node will be rendered untextured, as there may be a // texture in effect from a higher or lower level. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_texture_off // Access: Published // Description: Returns true if texturing has been specifically // disabled on this particular node for the indicated // stage. This means that someone called // set_texture_off() on this node with the indicated // stage name, or that someone called set_texture_off() // on this node to remove all stages. ////////////////////////////////////////////////////////////////////

hasTransparency(...)

 

C++ Interface: hasTransparency(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_transparency // Access: Published // Description: Returns true if a transparent-rendering adjustment // has been explicitly set on this particular node via // set_transparency(). If this returns true, then // get_transparency() may be called to determine whether // transparency has been explicitly enabled or // explicitly disabled for this node. ////////////////////////////////////////////////////////////////////

hasTwoSided(...)

 

C++ Interface: hasTwoSided(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_two_sided // Access: Published // Description: Returns true if a two-sided adjustment has been // explicitly set on this particular node via // set_two_sided(). If this returns true, then // get_two_sided() may be called to determine which has // been set. ////////////////////////////////////////////////////////////////////

hasVertexColumn(...)

 

C++ Interface: hasVertexColumn(const NodePath this, const InternalName name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::has_vertex_column // Access: Published // Description: Returns true if there are at least some vertices at // this node and below that contain a reference to the // indicated vertex data column name, false otherwise. // // This is particularly useful for testing whether a // particular model has a given texture coordinate set // (but see has_texcoord()). ////////////////////////////////////////////////////////////////////

headsUp(...)

 

C++ Interface: headsUp(non-const NodePath this, const Point3 point) headsUp(non-const NodePath this, const NodePath other) headsUp(non-const NodePath this, const Point3 point, const Vec3 up) headsUp(non-const NodePath this, const NodePath other, const Point3 point) headsUp(non-const NodePath this, const NodePath other, const Point3 point, const Vec3 up) headsUp(non-const NodePath this, float x, float y, float z) headsUp(non-const NodePath this, const NodePath other, float x, float y, float z)

//////////////////////////////////////////////////////////////////// // Function: NodePath::heads_up // Access: Published // Description: Behaves like look_at(), but with a strong preference // to keeping the up vector oriented in the indicated // "up" direction. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::heads_up // Access: Published // Description: Behaves like look_at(), but with a strong preference // to keeping the up vector oriented in the indicated // "up" direction. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::heads_up // Access: Published // Description: Behaves like look_at(), but with a strong preference // to keeping the up vector oriented in the indicated // "up" direction. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::heads_up // Access: Published // Description: Behaves like look_at(), but with a strong preference // to keeping the up vector oriented in the indicated // "up" direction. ////////////////////////////////////////////////////////////////////

hide(...)

 

C++ Interface: hide(non-const NodePath this) hide(non-const NodePath this, const BitMask camera_mask)

//////////////////////////////////////////////////////////////////// // Function: NodePath::hide // Access: Published // Description: Makes the referenced node (and the entire subgraph // below this node) invisible to all cameras. It // remains part of the scene graph, its bounding volume // still contributes to its parent's bounding volume, // and it will still be involved in collision tests. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::hide // Access: Published // Description: Makes the referenced node invisible just to the // cameras whose camera_mask shares the indicated bits. // // This will also hide any nodes below this node in the // scene graph, including those nodes for which show() // has been called, but it will not hide descendent // nodes for which show_through() has been called. ////////////////////////////////////////////////////////////////////

hideBounds(...)

 

C++ Interface: hideBounds(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::hide_bounds // Access: Published // Description: Stops the rendering of the bounding volume begun with // show_bounds(). ////////////////////////////////////////////////////////////////////

hideCS(self, mask=None)

 

Hides the collision solids at or below this node. If mask is not None, it is a BitMask32 object (e.g. WallBitmask, CameraBitmask) that indicates which particular collision solids should be hidden; otherwise, all of them will be.

instanceTo(...)

 

C++ Interface: instanceTo(const NodePath this, const NodePath other) instanceTo(const NodePath this, const NodePath other, int sort) instanceTo(const NodePath this, const NodePath other, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::instance_to // Access: Published // Description: Adds the referenced node of the NodePath as a child // of the referenced node of the indicated other // NodePath. Any other parent-child relations of the // node are unchanged; in particular, the node is not // removed from its existing parent, if any. // // If the node already had an existing parent, this // method will create a new instance of the node within // the scene graph. // // This does not change the NodePath itself, but does // return a new NodePath that reflects the new instance // node. // // If the destination NodePath is empty, this creates a // new instance which is not yet parented to any node. // A new instance of this sort cannot easily be // differentiated from other similar instances, but it // is nevertheless a different instance and it will // return a different get_id() value. // // If the referenced node is already a child of the // indicated NodePath, returns that already-existing // instance, unstashing it first if necessary. ////////////////////////////////////////////////////////////////////

instanceUnderNode(...)

 

C++ Interface: instanceUnderNode(const NodePath this, const NodePath other, string name) instanceUnderNode(const NodePath this, const NodePath other, string name, int sort) instanceUnderNode(const NodePath this, const NodePath other, string name, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::instance_under_node // Access: Published // Description: Behaves like instance_to(), but implicitly creates a // new node to instance the geometry under, and returns a // NodePath to that new node. This allows the // programmer to set a unique state and/or transform on // this instance. ////////////////////////////////////////////////////////////////////

isAncestorOf(...)

 

C++ Interface: isAncestorOf(const NodePath this, const NodePath other) isAncestorOf(const NodePath this, const NodePath other, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::is_ancestor_of // Access: Published // Description: Returns true if the node represented by this NodePath // is a parent or other ancestor of the other NodePath, // or false if it is not. ////////////////////////////////////////////////////////////////////

isEmpty(...)

 

C++ Interface: isEmpty(const NodePath this)

// Methods to query a NodePath's contents.

//////////////////////////////////////////////////////////////////// // Function: NodePath::is_empty // Access: Published // Description: Returns true if the NodePath contains no nodes. ////////////////////////////////////////////////////////////////////

isHidden(...)

 

C++ Interface: isHidden(const NodePath this) isHidden(const NodePath this, const BitMask camera_mask)

//////////////////////////////////////////////////////////////////// // Function: NodePath::is_hidden // Access: Published // Description: Returns true if the referenced node is hidden from // the indicated camera(s) either directly, or because // some ancestor is hidden. ////////////////////////////////////////////////////////////////////

isSameGraph(...)

 

C++ Interface: isSameGraph(const NodePath this, const NodePath other) isSameGraph(const NodePath this, const NodePath other, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::is_same_graph // Access: Published // Description: Returns true if the node represented by this NodePath // is parented within the same graph as that of the // other NodePath. This is essentially the same thing // as asking whether get_top() of both NodePaths is the // same (e.g., both "render"). ////////////////////////////////////////////////////////////////////

isSingleton(...)

 

C++ Interface: isSingleton(const NodePath this) isSingleton(const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::is_singleton // Access: Published // Description: Returns true if the NodePath contains exactly one // node. ////////////////////////////////////////////////////////////////////

isStashed(...)

 

C++ Interface: isStashed(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::is_stashed // Access: Published // Description: Returns true if the referenced node is stashed either // directly, or because some ancestor is stashed. ////////////////////////////////////////////////////////////////////

lerpPosHprScale(self, Point3, VBase3, float, float, string="noBlend", string=none, string=none, NodePath=None)

 

Only one case, no need for extra args. Call the appropriate lerp (auto, spawned, or blocking) based on how(if) a task name is given

lessThan(...)

 

C++ Interface: lessThan(const NodePath this, const NodePath other)

//////////////////////////////////////////////////////////////////// // Function: NodePath::operator < // Access: Published // Description: Returns true if this NodePath sorts before the other // one, false otherwise. The sorting order of two // nonequivalent NodePaths is consistent but undefined, // and is useful only for storing NodePaths in a sorted // container like an STL set. ////////////////////////////////////////////////////////////////////

listTags(...)

 

C++ Interface: listTags(const NodePath this)

// HAVE_PYTHON

// HAVE_PYTHON //////////////////////////////////////////////////////////////////// // Function: NodePath::list_tags // Access: Published // Description: Lists the tags to the nout stream, one per line. See // PandaNode::list_tags() for a variant that allows you // to specify the output stream. ////////////////////////////////////////////////////////////////////

lookAt(...)

 

C++ Interface: lookAt(non-const NodePath this, const Point3 point) lookAt(non-const NodePath this, const NodePath other) lookAt(non-const NodePath this, const Point3 point, const Vec3 up) lookAt(non-const NodePath this, const NodePath other, const Point3 point) lookAt(non-const NodePath this, const NodePath other, const Point3 point, const Vec3 up) lookAt(non-const NodePath this, float x, float y, float z) lookAt(non-const NodePath this, const NodePath other, float x, float y, float z)

//////////////////////////////////////////////////////////////////// // Function: NodePath::look_at // Access: Published // Description: Sets the transform on this NodePath so that it // rotates to face the indicated point in space. This // will overwrite any previously existing scale on the // node, although it will preserve any translation. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::look_at // Access: Published // Description: Sets the hpr on this NodePath so that it rotates to // face the indicated point in space, which is relative // to the other NodePath. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::look_at // Access: Published // Description: Sets the hpr on this NodePath so that it // rotates to face the indicated point in space. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::look_at // Access: Published // Description: Sets the transform on this NodePath so that it // rotates to face the indicated point in space, which // is relative to the other NodePath. ////////////////////////////////////////////////////////////////////

ls(...)

 

C++ Interface: ls(const NodePath this) ls(const NodePath this, non-const Ostream out) ls(const NodePath this, non-const Ostream out, int indent_level)

//////////////////////////////////////////////////////////////////// // Function: NodePath::ls // Access: Published // Description: Lists the hierarchy at and below the referenced node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::ls // Access: Published // Description: Lists the hierarchy at and below the referenced node. ////////////////////////////////////////////////////////////////////

ne(...)

 

C++ Interface: ne(const NodePath this, const NodePath other)

// Comparison methods

//////////////////////////////////////////////////////////////////// // Function: NodePath::operator != // Access: Published // Description: Returns true if the two paths are not equivalent. ////////////////////////////////////////////////////////////////////

node(...)

 

C++ Interface: node(const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::node // Access: Published // Description: Returns the referenced node of the path. ////////////////////////////////////////////////////////////////////

notFound(...)

 

C++ Interface: notFound()

//////////////////////////////////////////////////////////////////// // Function: NodePath::not_found named constructor // Access: Published, Static // Description: Creates a NodePath with the ET_not_found error type // set. ////////////////////////////////////////////////////////////////////

output(...)

 

C++ Interface: output(const NodePath this, non-const Ostream out)

// Handy ways to look at what's there, and other miscellaneous // operations.

//////////////////////////////////////////////////////////////////// // Function: NodePath::output // Access: Published // Description: Writes a sensible description of the NodePath to the // indicated output stream. ////////////////////////////////////////////////////////////////////

premungeScene(...)

 

C++ Interface: premungeScene(non-const NodePath this) premungeScene(non-const NodePath this, non-const GraphicsStateGuardianBase gsg)

//////////////////////////////////////////////////////////////////// // Function: NodePath::premunge_scene // Access: Published // Description: Walks through the scene graph beginning at the bottom // node, and internally adjusts any GeomVertexFormats // for optimal rendering on the indicated GSG. If this // step is not done prior to rendering, the formats will // be optimized at render time instead, for a small // cost. // // It is not normally necessary to do this on a model // loaded directly from disk, since the loader will do // this by default. ////////////////////////////////////////////////////////////////////

prepareScene(...)

 

C++ Interface: prepareScene(non-const NodePath this, non-const GraphicsStateGuardianBase gsg)

//////////////////////////////////////////////////////////////////// // Function: NodePath::prepare_scene // Access: Published // Description: Walks through the scene graph beginning at the bottom // node, and does whatever initialization is required to // render the scene properly with the indicated GSG. It // is not strictly necessary to call this, since the GSG // will initialize itself when the scene is rendered, // but this may take some of the overhead away from that // process. // // In particular, this will ensure that textures within // the scene are loaded in texture memory, and display // lists are built up from static geometry. ////////////////////////////////////////////////////////////////////

projectTexture(...)

 

C++ Interface: projectTexture(non-const NodePath this, non-const TextureStage stage, non-const Texture tex, const NodePath projector)

//////////////////////////////////////////////////////////////////// // Function: NodePath::project_texture // Access: Published // Description: A convenience function to enable projective texturing // at this node level and below, using the indicated // NodePath (which should contain a LensNode) as the // projector. ////////////////////////////////////////////////////////////////////

removeNode(...)

 

C++ Interface: removeNode(non-const NodePath this) removeNode(non-const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::remove_node // Access: Published // Description: Disconnects the referenced node from the scene graph. // This will also delete the node if there are no other // pointers to it. // // Normally, this should be called only when you are // really done with the node. If you want to remove a // node from the scene graph but keep it around for // later, you should probably use detach_node() instead. // // In practice, the only difference between // remove_node() and detach_node() is that remove_node() // also resets the NodePath to empty, which will cause // the node to be deleted immediately if there are no // other references. On the other hand, detach_node() // leaves the NodePath referencing the node, which will // keep at least one reference to the node for as long // as the NodePath exists. ////////////////////////////////////////////////////////////////////

removed(...)

 

C++ Interface: removed()

//////////////////////////////////////////////////////////////////// // Function: NodePath::removed named constructor // Access: Published, Static // Description: Creates a NodePath with the ET_removed error type // set. ////////////////////////////////////////////////////////////////////

reparentTo(...)

 

C++ Interface: reparentTo(non-const NodePath this, const NodePath other) reparentTo(non-const NodePath this, const NodePath other, int sort) reparentTo(non-const NodePath this, const NodePath other, int sort, non-const Thread current_thread)

// Methods that actually move nodes around in the scene graph. The // optional "sort" parameter can be used to force a particular // ordering between sibling nodes, useful when dealing with LOD's // and similar switch nodes. If the sort value is the same, nodes // will be arranged in the order they were added.

//////////////////////////////////////////////////////////////////// // Function: NodePath::reparent_to // Access: Published // Description: Removes the referenced node of the NodePath from its // current parent and attaches it to the referenced node // of the indicated NodePath. // // If the destination NodePath is empty, this is the // same thing as detach_node(). // // If the referenced node is already a child of the // indicated NodePath (via some other instance), this // operation fails and leaves the NodePath detached. ////////////////////////////////////////////////////////////////////

reverseLs(...)

 

C++ Interface: reverseLs(const NodePath this) reverseLs(const NodePath this, non-const Ostream out) reverseLs(const NodePath this, non-const Ostream out, int indent_level)

//////////////////////////////////////////////////////////////////// // Function: NodePath::reverse_ls // Access: Published // Description: Lists the hierarchy at and above the referenced node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::reverse_ls // Access: Published // Description: Lists the hierarchy at and above the referenced node. ////////////////////////////////////////////////////////////////////

setAllColorScale(...)

 

C++ Interface: setAllColorScale(non-const NodePath this, float scale) setAllColorScale(non-const NodePath this, float scale, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_all_color_scale // Access: Published // Description: Scales all the color components of the object by the // same amount, darkening the object, without (much) // affecting alpha. Note that any priority specified // will also apply to the alpha scale. ////////////////////////////////////////////////////////////////////

setAlphaScale(...)

 

C++ Interface: setAlphaScale(non-const NodePath this, float scale) setAlphaScale(non-const NodePath this, float scale, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_alpha_scale // Access: Published // Description: Sets the alpha scale component of the transform // without (much) affecting the color scale. Note that // any priority specified will also apply to the color // scale. ////////////////////////////////////////////////////////////////////

setAntialias(...)

 

C++ Interface: setAntialias(non-const NodePath this, unsigned int mode) setAntialias(non-const NodePath this, unsigned int mode, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_antialias // Access: Published // Description: Specifies the antialiasing type that should be // applied at this node and below. See AntialiasAttrib. ////////////////////////////////////////////////////////////////////

setAttrib(...)

 

C++ Interface: setAttrib(non-const NodePath this, const RenderAttrib attrib) setAttrib(non-const NodePath this, const RenderAttrib attrib, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_attrib // Access: Published // Description: Adds the indicated render attribute to the scene // graph on this node. This attribute will now apply to // this node and everything below. If there was already // an attribute of the same type, it is replaced. ////////////////////////////////////////////////////////////////////

setAudioVolume(...)

 

C++ Interface: setAudioVolume(non-const NodePath this, float volume) setAudioVolume(non-const NodePath this, float volume, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_audio_volume // Access: Published // Description: Sets the audio volume component of the transform ////////////////////////////////////////////////////////////////////

setAudioVolumeOff(...)

 

C++ Interface: setAudioVolumeOff(non-const NodePath this) setAudioVolumeOff(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_audio_volume_off // Access: Published // Description: Disables any audio volume attribute inherited from // above. This is not the same thing as // clear_audio_volume(), which undoes any previous // set_audio_volume() operation on this node; rather, // this actively disables any set_audio_volume() that // might be inherited from a parent node. // // It is legal to specify a new volume on the same // node with a subsequent call to set_audio_volume(); // this new scale will apply to lower nodes. ////////////////////////////////////////////////////////////////////

setBillboardAxis(...)

 

C++ Interface: setBillboardAxis(non-const NodePath this) setBillboardAxis(non-const NodePath this, float offset) setBillboardAxis(non-const NodePath this, const NodePath camera, float offset)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_billboard_axis // Access: Published // Description: Puts a billboard transition on the node such that it // will rotate in two dimensions around the up axis. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_billboard_axis // Access: Published // Description: Puts a billboard transition on the node such that it // will rotate in two dimensions around the up axis, // towards a specified "camera" instead of to the // viewing camera. ////////////////////////////////////////////////////////////////////

setBillboardPointEye(...)

 

C++ Interface: setBillboardPointEye(non-const NodePath this) setBillboardPointEye(non-const NodePath this, float offset) setBillboardPointEye(non-const NodePath this, const NodePath camera, float offset)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_billboard_point_eye // Access: Published // Description: Puts a billboard transition on the node such that it // will rotate in three dimensions about the origin, // keeping its up vector oriented to the top of the // camera. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_billboard_point_eye // Access: Published // Description: Puts a billboard transition on the node such that it // will rotate in three dimensions about the origin, // keeping its up vector oriented to the top of the // camera, towards a specified "camera" instead of to // the viewing camera. ////////////////////////////////////////////////////////////////////

setBillboardPointWorld(...)

 

C++ Interface: setBillboardPointWorld(non-const NodePath this) setBillboardPointWorld(non-const NodePath this, float offset) setBillboardPointWorld(non-const NodePath this, const NodePath camera, float offset)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_billboard_point_world // Access: Published // Description: Puts a billboard transition on the node such that it // will rotate in three dimensions about the origin, // keeping its up vector oriented to the sky. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_billboard_point_world // Access: Published // Description: Puts a billboard transition on the node such that it // will rotate in three dimensions about the origin, // keeping its up vector oriented to the sky, towards a // specified "camera" instead of to the viewing camera. ////////////////////////////////////////////////////////////////////

setBin(...)

 

C++ Interface: setBin(non-const NodePath this, string bin_name, int draw_order) setBin(non-const NodePath this, string bin_name, int draw_order, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_bin // Access: Published // Description: Assigns the geometry at this level and below to the // named rendering bin. It is the user's responsibility // to ensure that such a bin already exists, either via // the cull-bin Configrc variable, or by explicitly // creating a GeomBin of the appropriate type at // runtime. // // There are two default bins created when Panda is // started: "default" and "fixed". Normally, all // geometry is assigned to "default" unless specified // otherwise. This bin renders opaque geometry in // state-sorted order, followed by transparent geometry // sorted back-to-front. If any geometry is assigned to // "fixed", this will be rendered following all the // geometry in "default", in the order specified by // draw_order for each piece of geometry so assigned. // // The draw_order parameter is meaningful only for // GeomBinFixed type bins, e.g. "fixed". Other kinds of // bins ignore it. ////////////////////////////////////////////////////////////////////

setClipPlane(...)

 

C++ Interface: setClipPlane(non-const NodePath this, const NodePath clip_plane) setClipPlane(non-const NodePath this, const NodePath clip_plane, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_clip_plane // Access: Published // Description: Adds the indicated clipping plane to the list of // planes that apply to geometry at this node and below. // The clipping plane itself, a PlaneNode, should be // parented into the scene graph elsewhere, to represent // the plane's position in space; but until // set_clip_plane() is called it will clip no geometry. ////////////////////////////////////////////////////////////////////

setClipPlaneOff(...)

 

C++ Interface: setClipPlaneOff(non-const NodePath this) setClipPlaneOff(non-const NodePath this, const NodePath clip_plane) setClipPlaneOff(non-const NodePath this, int priority) setClipPlaneOff(non-const NodePath this, const NodePath clip_plane, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_clip_plane_off // Access: Published // Description: Sets the geometry at this level and below to render // using no clip_planes at all. This is different // from not specifying a clip_plane; rather, this // specifically contradicts set_clip_plane() at a higher // node level (or, with a priority, overrides a // set_clip_plane() at a lower level). // // If no clip_planes are in effect on a particular piece // of geometry, that geometry is rendered without being // clipped (other than by the viewing frustum). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_clip_plane_off // Access: Published // Description: Sets the geometry at this level and below to render // without being clipped by the indicated PlaneNode. // This is different from not specifying the PlaneNode; // rather, this specifically contradicts // set_clip_plane() at a higher node level (or, with a // priority, overrides a set_clip_plane() at a lower // level). ////////////////////////////////////////////////////////////////////

setCollideMask(...)

 

C++ Interface: setCollideMask(non-const NodePath this, const BitMask new_mask) setCollideMask(non-const NodePath this, const BitMask new_mask, const BitMask bits_to_change) setCollideMask(non-const NodePath this, const BitMask new_mask, const BitMask bits_to_change, const TypeHandle node_type)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_collide_mask // Access: Published // Description: Recursively applies the indicated CollideMask to the // into_collide_masks for all nodes at this level and // below. If node_type is not TypeHandle::none(), then // only nodes matching (or inheriting from) the // indicated PandaNode subclass are modified. // // The default is to change all bits, but if // bits_to_change is not all bits on, then only the bits // that are set in bits_to_change are modified, allowing // this call to change only a subset of the bits in the // subgraph. ////////////////////////////////////////////////////////////////////

setColor(...)

 

C++ Interface: setColor(non-const NodePath this, const VBase4 color) setColor(non-const NodePath this, const VBase4 color, int priority) setColor(non-const NodePath this, float r, float g, float b) setColor(non-const NodePath this, float r, float g, float b, float a) setColor(non-const NodePath this, float r, float g, float b, float a, int priority)

// Methods that affect appearance of geometry: color, texture, etc. // These affect the state at the bottom level only.

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_color // Access: Published // Description: Applies a scene-graph color to the referenced node. // This color will apply to all geometry at this level // and below (that does not specify a new color or a // set_color_off()). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_color // Access: Published // Description: Applies a scene-graph color to the referenced node. // This color will apply to all geometry at this level // and below (that does not specify a new color or a // set_color_off()). ////////////////////////////////////////////////////////////////////

setColorOff(...)

 

C++ Interface: setColorOff(non-const NodePath this) setColorOff(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_color_off // Access: Published // Description: Sets the geometry at this level and below to render // using the geometry color. This is normally the // default, but it may be useful to use this to // contradict set_color() at a higher node level (or, // with a priority, to override a set_color() at a lower // level). ////////////////////////////////////////////////////////////////////

setColorScale(...)

 

C++ Interface: setColorScale(non-const NodePath this, const VBase4 scale) setColorScale(non-const NodePath this, const VBase4 scale, int priority) setColorScale(non-const NodePath this, float sx, float sy, float sz, float sa) setColorScale(non-const NodePath this, float sx, float sy, float sz, float sa, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_color_scale // Access: Published // Description: Sets the color scale component of the transform ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_color_scale // Access: Published // Description: Sets the color scale component of the transform, // leaving translation and rotation untouched. ////////////////////////////////////////////////////////////////////

setColorScaleOff(...)

 

C++ Interface: setColorScaleOff(non-const NodePath this) setColorScaleOff(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_color_scale_off // Access: Published // Description: Disables any color scale attribute inherited from // above. This is not the same thing as // clear_color_scale(), which undoes any previous // set_color_scale() operation on this node; rather, // this actively disables any set_color_scale() that // might be inherited from a parent node. This also // disables set_alpha_scale() at the same time. // // It is legal to specify a new color scale on the same // node with a subsequent call to set_color_scale() or // set_alpha_scale(); this new scale will apply to lower // geometry. ////////////////////////////////////////////////////////////////////

setCompass(...)

 

C++ Interface: setCompass(non-const NodePath this) setCompass(non-const NodePath this, const NodePath reference)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_compass // Access: Published // Description: Puts a compass effect on the node, so that it will // retain a fixed rotation relative to the reference // node (or render if the reference node is empty) // regardless of the transforms above it. ////////////////////////////////////////////////////////////////////

setDepthTest(...)

 

C++ Interface: setDepthTest(non-const NodePath this, bool depth_test) setDepthTest(non-const NodePath this, bool depth_test, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_depth_test // Access: Published // Description: Specifically sets or disables the testing of the // depth buffer on this particular node. This is // normally on in the 3-d scene graph and off in the 2-d // scene graph; it should be on for rendering most 3-d // objects properly. ////////////////////////////////////////////////////////////////////

setDepthWrite(...)

 

C++ Interface: setDepthWrite(non-const NodePath this, bool depth_write) setDepthWrite(non-const NodePath this, bool depth_write, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_depth_write // Access: Published // Description: Specifically sets or disables the writing to the // depth buffer on this particular node. This is // normally on in the 3-d scene graph and off in the 2-d // scene graph; it should be on for rendering most 3-d // objects properly. ////////////////////////////////////////////////////////////////////

setEffect(...)

 

C++ Interface: setEffect(non-const NodePath this, const RenderEffect effect)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_effect // Access: Published // Description: Adds the indicated render effect to the scene // graph on this node. If there was already an effect // of the same type, it is replaced. ////////////////////////////////////////////////////////////////////

setEffects(...)

 

C++ Interface: setEffects(non-const NodePath this, const RenderEffects effects)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_effects // Access: Published // Description: Sets the complete RenderEffects that will be applied // this node. This completely replaces whatever has // been set on this node via repeated calls to // set_attrib(). ////////////////////////////////////////////////////////////////////

setFluidPos(...)

 

C++ Interface: setFluidPos(non-const NodePath this, const VBase3 pos) setFluidPos(non-const NodePath this, const NodePath other, const VBase3 pos) setFluidPos(non-const NodePath this, float x, float y, float z) setFluidPos(non-const NodePath this, const NodePath other, float x, float y, float z)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_fluid_pos // Access: Published // Description: Sets the translation component, without changing the // "previous" position, so that the collision system // will see the node as moving fluidly from its previous // position to its new position. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_fluid_pos // Access: Published // Description: Sets the translation component, without changing the // "previous" position, so that the collision system // will see the node as moving fluidly from its previous // position to its new position. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_fluid_pos // Access: Published // Description: Sets the translation component, without changing the // "previous" position, so that the collision system // will see the node as moving fluidly from its previous // position to its new position. // See Also: NodePath::set_pos ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_fluid_pos // Access: Published // Description: Sets the translation component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

setFog(...)

 

C++ Interface: setFog(non-const NodePath this, non-const Fog fog) setFog(non-const NodePath this, non-const Fog fog, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_fog // Access: Published // Description: Sets the geometry at this level and below to render // using the indicated fog. ////////////////////////////////////////////////////////////////////

setFogOff(...)

 

C++ Interface: setFogOff(non-const NodePath this) setFogOff(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_fog_off // Access: Published // Description: Sets the geometry at this level and below to render // using no fog. This is normally the default, but // it may be useful to use this to contradict // set_fog() at a higher node level (or, with a // priority, to override a set_fog() at a lower // level). ////////////////////////////////////////////////////////////////////

setHpr(...)

 

C++ Interface: setHpr(non-const NodePath this, const VBase3 hpr) setHpr(non-const NodePath this, const NodePath other, const VBase3 hpr) setHpr(non-const NodePath this, float h, float p, float r) setHpr(non-const NodePath this, const NodePath other, float h, float p, float r)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr // Access: Published // Description: Sets the rotation component of the transform, // leaving translation and scale untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr // Access: Published // Description: Sets the rotation component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr // Access: Published // Description: Sets the rotation component of the transform, // leaving translation and scale untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr // Access: Published // Description: Sets the rotation component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

setHprScale(...)

 

C++ Interface: setHprScale(non-const NodePath this, const VBase3 hpr, const VBase3 scale) setHprScale(non-const NodePath this, const NodePath other, const VBase3 hpr, const VBase3 scale) setHprScale(non-const NodePath this, float h, float p, float r, float sx, float sy, float sz) setHprScale(non-const NodePath this, const NodePath other, float h, float p, float r, float sx, float sy, float sz)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr_scale // Access: Published // Description: Sets the rotation and scale components of the // transform, leaving translation untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr_scale // Access: Published // Description: Sets the rotation and scale components of the // transform, leaving translation untouched. This, or // set_pos_hpr_scale, is the preferred way to update a // transform when both hpr and scale are to be changed. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr_scale // Access: Published // Description: Sets the rotation and scale components of the // transform, leaving translation untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_hpr_scale // Access: Published // Description: Sets the rotation and scale components of the // transform, leaving translation untouched. This, or // set_pos_hpr_scale, is the preferred way to update a // transform when both hpr and scale are to be changed. ////////////////////////////////////////////////////////////////////

setLight(...)

 

C++ Interface: setLight(non-const NodePath this, const NodePath light) setLight(non-const NodePath this, const NodePath light, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_light // Access: Published // Description: Adds the indicated Light or PolylightNode to the list // of lights that illuminate geometry at this node and // below. The light itself should be parented into the // scene graph elsewhere, to represent the light's // position in space; but until set_light() is called it // will illuminate no geometry. ////////////////////////////////////////////////////////////////////

setLightOff(...)

 

C++ Interface: setLightOff(non-const NodePath this) setLightOff(non-const NodePath this, const NodePath light) setLightOff(non-const NodePath this, int priority) setLightOff(non-const NodePath this, const NodePath light, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_light_off // Access: Published // Description: Sets the geometry at this level and below to render // using no lights at all. This is different // from not specifying a light; rather, this // specifically contradicts set_light() at a higher // node level (or, with a priority, overrides a // set_light() at a lower level). // // If no lights are in effect on a particular piece of // geometry, that geometry is rendered with lighting // disabled. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_light_off // Access: Published // Description: Sets the geometry at this level and below to render // without using the indicated Light. This is different // from not specifying the Light; rather, this // specifically contradicts set_light() at a higher node // level (or, with a priority, overrides a set_light() // at a lower level). // // This interface does not support PolylightNodes, which // cannot be turned off at a lower level. ////////////////////////////////////////////////////////////////////

setMat(...)

 

C++ Interface: setMat(non-const NodePath this, const Mat4 mat) setMat(non-const NodePath this, const NodePath other, const Mat4 mat)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_mat // Access: Published // Description: Directly sets an arbitrary 4x4 transform matrix. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_mat // Access: Published // Description: Converts the indicated matrix from the other's // coordinate space to the local coordinate space, and // applies it to the node. ////////////////////////////////////////////////////////////////////

setMaterial(...)

 

C++ Interface: setMaterial(non-const NodePath this, non-const Material tex) setMaterial(non-const NodePath this, non-const Material tex, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_material // Access: Published // Description: Sets the geometry at this level and below to render // using the indicated material. // // Previously, this operation made a copy of the // material structure, but nowadays it assigns the // pointer directly. ////////////////////////////////////////////////////////////////////

setMaterialOff(...)

 

C++ Interface: setMaterialOff(non-const NodePath this) setMaterialOff(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_material_off // Access: Published // Description: Sets the geometry at this level and below to render // using no material. This is normally the default, but // it may be useful to use this to contradict // set_material() at a higher node level (or, with a // priority, to override a set_material() at a lower // level). ////////////////////////////////////////////////////////////////////

setMaxSearchDepth(...)

 

C++ Interface: setMaxSearchDepth(int max_search_depth)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_max_search_depth // Access: Published, Static // Description: Certain operations, such as find() or // find_all_matches(), require a traversal of the scene // graph to search for the target node or nodes. This // traversal does not attempt to detect cycles, so an // arbitrary cap is set on the depth of the traversal as // a poor man's cycle detection, in the event that a // cycle has inadvertently been introduced into the // scene graph. // // There may be other reasons you'd want to truncate a // search before the bottom of the scene graph has been // reached. In any event, this function sets the limit // on the number of levels that a traversal will // continue, and hence the maximum length of a path that // may be returned by a traversal. // // This is a static method, and so changing this // parameter affects all of the NodePaths in the // universe. ////////////////////////////////////////////////////////////////////

setName(...)

 

C++ Interface: setName(non-const NodePath this, string name)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_name // Access: Published // Description: Changes the name of the referenced node. ////////////////////////////////////////////////////////////////////

setNormalMap(...)

 

C++ Interface: setNormalMap(non-const NodePath this, non-const Texture normal_map) setNormalMap(non-const NodePath this, non-const Texture normal_map, string texcoord_name) setNormalMap(non-const NodePath this, non-const Texture normal_map, string texcoord_name, bool preserve_color)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_normal_map // Access: Published // Description: A convenience function to set up a normal map on this // geometry. This uses the single highest-priority // light on the object only. It also requires // multitexture, and consumes at least two texture // stages, in addition to what may already be in use. // // The normal_map parameter is the texture that contains // the normal map information (with a 3-d delta vector // encoded into the r,g,b of each texel). texcoord_name is // the name of the texture coordinate set that contains // the tangent and binormal we wish to use. If // preserve_color is true, then one additional texture // stage is consumed to blend in the geometry's original // vertex color. // // Only one normal map may be in effect through this // interface at any given time. ////////////////////////////////////////////////////////////////////

setPos(...)

 

C++ Interface: setPos(non-const NodePath this, const VBase3 pos) setPos(non-const NodePath this, const NodePath other, const VBase3 pos) setPos(non-const NodePath this, float x, float y, float z) setPos(non-const NodePath this, const NodePath other, float x, float y, float z)

// Methods that get and set the matrix transform: pos, hpr, scale, // in the local coordinate system.

// Methods that get and set the matrix transforms relative to some // other node in the scene graph. These perform an implicit wrt().

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos // Access: Published // Description: Sets the translation component of the transform, // leaving rotation and scale untouched. This also // resets the node's "previous" position, so that the // collision system will see the node as having suddenly // appeared in the new position, without passing any // points in between. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos // Access: Published // Description: Sets the translation component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos // Access: Published // Description: Sets the translation component of the transform, // leaving rotation and scale untouched. This also // resets the node's "previous" position, so that the // collision system will see the node as having suddenly // appeared in the new position, without passing any // points in between. // See Also: NodePath::set_fluid_pos ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos // Access: Published // Description: Sets the translation component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

setPosHpr(...)

 

C++ Interface: setPosHpr(non-const NodePath this, const VBase3 pos, const VBase3 hpr) setPosHpr(non-const NodePath this, const NodePath other, const VBase3 pos, const VBase3 hpr) setPosHpr(non-const NodePath this, float x, float y, float z, float h, float p, float r) setPosHpr(non-const NodePath this, const NodePath other, float x, float y, float z, float h, float p, float r)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr // Access: Published // Description: Sets the translation and rotation component of the // transform, leaving scale untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr // Access: Published // Description: Sets the translation and rotation component of the // transform, relative to the other node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr // Access: Published // Description: Sets the translation and rotation component of the // transform, leaving scale untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr // Access: Published // Description: Sets the translation and rotation component of the // transform, relative to the other node. ////////////////////////////////////////////////////////////////////

setPosHprScale(...)

 

C++ Interface: setPosHprScale(non-const NodePath this, const VBase3 pos, const VBase3 hpr, const VBase3 scale) setPosHprScale(non-const NodePath this, const NodePath other, const VBase3 pos, const VBase3 hpr, const VBase3 scale) setPosHprScale(non-const NodePath this, float x, float y, float z, float h, float p, float r, float sx, float sy, float sz) setPosHprScale(non-const NodePath this, const NodePath other, float x, float y, float z, float h, float p, float r, float sx, float sy, float sz)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr_scale // Access: Published // Description: Completely replaces the transform with new // translation, rotation, and scale components. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr_scale // Access: Published // Description: Completely replaces the transform with new // translation, rotation, and scale components, relative // to the other node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr_scale // Access: Published // Description: Replaces the translation, rotation, and scale // components, implicitly setting shear to 0. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr_scale // Access: Published // Description: Completely replaces the transform with new // translation, rotation, and scale components, relative // to the other node, implicitly setting shear to 0. ////////////////////////////////////////////////////////////////////

setPosHprScaleShear(...)

 

C++ Interface: setPosHprScaleShear(non-const NodePath this, const VBase3 pos, const VBase3 hpr, const VBase3 scale, const VBase3 shear) setPosHprScaleShear(non-const NodePath this, const NodePath other, const VBase3 pos, const VBase3 hpr, const VBase3 scale, const VBase3 shear)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr_scale_shear // Access: Published // Description: Completely replaces the transform with new // translation, rotation, scale, and shear components. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_hpr_scale_shear // Access: Published // Description: Completely replaces the transform with new // translation, rotation, scale, and shear components, // relative to the other node. ////////////////////////////////////////////////////////////////////

setPosQuat(...)

 

C++ Interface: setPosQuat(non-const NodePath this, const VBase3 pos, const Quat quat) setPosQuat(non-const NodePath this, const NodePath other, const VBase3 pos, const Quat quat)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_quat // Access: Published // Description: Sets the translation and rotation component of the // transform, leaving scale untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_quat // Access: Published // Description: Sets the translation and rotation component of the // transform, relative to the other node. ////////////////////////////////////////////////////////////////////

setPosQuatScale(...)

 

C++ Interface: setPosQuatScale(non-const NodePath this, const VBase3 pos, const Quat quat, const VBase3 scale) setPosQuatScale(non-const NodePath this, const NodePath other, const VBase3 pos, const Quat quat, const VBase3 scale)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_quat_scale // Access: Published // Description: Replaces the translation, rotation, and scale // components, implicitly setting shear to 0. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_quat_scale // Access: Published // Description: Completely replaces the transform with new // translation, rotation, and scale components, relative // to the other node, implicitly setting shear to 0. ////////////////////////////////////////////////////////////////////

setPosQuatScaleShear(...)

 

C++ Interface: setPosQuatScaleShear(non-const NodePath this, const VBase3 pos, const Quat quat, const VBase3 scale, const VBase3 shear) setPosQuatScaleShear(non-const NodePath this, const NodePath other, const VBase3 pos, const Quat quat, const VBase3 scale, const VBase3 shear)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_quat_scale_shear // Access: Published // Description: Completely replaces the transform with new // translation, rotation, scale, and shear components. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_pos_quat_scale_shear // Access: Published // Description: Completely replaces the transform with new // translation, rotation, scale, and shear components, // relative to the other node. ////////////////////////////////////////////////////////////////////

setPrevTransform(...)

 

C++ Interface: setPrevTransform(non-const NodePath this, const TransformState transform) setPrevTransform(non-const NodePath this, const TransformState transform, non-const Thread current_thread) setPrevTransform(non-const NodePath this, const NodePath other, const TransformState transform) setPrevTransform(non-const NodePath this, const NodePath other, const TransformState transform, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_prev_transform // Access: Published // Description: Sets the transform that represents this node's // "previous" position, one frame ago, for the purposes // of detecting motion for accurate collision // calculations. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_prev_transform // Access: Published // Description: Sets the "previous" transform object on this node, // relative to the other node. This computes a new // transform object that will have the indicated value // when seen from the other node. ////////////////////////////////////////////////////////////////////

setPythonTag(...)

 

C++ Interface: setPythonTag(non-const NodePath this, string key, any value)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_python_tag // Access: Published // Description: Associates an arbitrary Python object with a // user-defined key which is stored on the node. This // object has no meaning to Panda; but it is stored // indefinitely on the node until it is requested again. // // Each unique key stores a different Python object. // There is no effective limit on the number of // different keys that may be stored or on the nature of // any one key's object. ////////////////////////////////////////////////////////////////////

setQuat(...)

 

C++ Interface: setQuat(non-const NodePath this, const Quat quat) setQuat(non-const NodePath this, const NodePath other, const Quat quat)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_quat // Access: Published // Description: Sets the rotation component of the transform, // leaving translation and scale untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_quat // Access: Published // Description: Sets the rotation component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

setQuatScale(...)

 

C++ Interface: setQuatScale(non-const NodePath this, const Quat quat, const VBase3 scale) setQuatScale(non-const NodePath this, const NodePath other, const Quat quat, const VBase3 scale)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_quat_scale // Access: Published // Description: Sets the rotation and scale components of the // transform, leaving translation untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_quat_scale // Access: Published // Description: Sets the rotation and scale components of the // transform, leaving translation untouched. This, or // set_pos_quat_scale, is the preferred way to update a // transform when both quat and scale are to be changed. ////////////////////////////////////////////////////////////////////

setRenderMode(...)

 

C++ Interface: setRenderMode(non-const NodePath this, int mode, float thickness) setRenderMode(non-const NodePath this, int mode, float thickness, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_render_mode // Access: Published // Description: Sets up the geometry at this level and below (unless // overridden) to render in the specified mode and with // the indicated line and/or point thickness. ////////////////////////////////////////////////////////////////////

setRenderModeFilled(...)

 

C++ Interface: setRenderModeFilled(non-const NodePath this) setRenderModeFilled(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_render_mode_filled // Access: Published // Description: Sets up the geometry at this level and below (unless // overridden) to render in filled (i.e. not wireframe) // mode. ////////////////////////////////////////////////////////////////////

setRenderModePerspective(...)

 

C++ Interface: setRenderModePerspective(non-const NodePath this, bool perspective) setRenderModePerspective(non-const NodePath this, bool perspective, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_render_mode_perspective // Access: Published // Description: Sets up the point geometry at this level and below to // render as perspective sprites (that is, billboarded // quads). The thickness, as specified with // set_render_mode_thickness(), is the width of each // point in 3-D units, unless it is overridden on a // per-vertex basis. This does not affect geometry // other than points. // // If you want the quads to be individually textured, // you should also set a TexGenAttrib::M_point_sprite on // the node. ////////////////////////////////////////////////////////////////////

setRenderModeThickness(...)

 

C++ Interface: setRenderModeThickness(non-const NodePath this, float thickness) setRenderModeThickness(non-const NodePath this, float thickness, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_render_mode_thickness // Access: Published // Description: Sets up the point geometry at this level and below to // render as thick points (that is, billboarded // quads). The thickness is in pixels, unless // set_render_mode_perspective is also true, in which // case it is in 3-D units. // // If you want the quads to be individually textured, // you should also set a TexGenAttrib::M_point_sprite on // the node. ////////////////////////////////////////////////////////////////////

setRenderModeWireframe(...)

 

C++ Interface: setRenderModeWireframe(non-const NodePath this) setRenderModeWireframe(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_render_mode_wireframe // Access: Published // Description: Sets up the geometry at this level and below (unless // overridden) to render in wireframe mode. ////////////////////////////////////////////////////////////////////

setSa(...)

 

C++ Interface: setSa(non-const NodePath this, float sa)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_sa // Access: Published // Description: Sets the alpha scale component of the transform ////////////////////////////////////////////////////////////////////

setSb(...)

 

C++ Interface: setSb(non-const NodePath this, float sb)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_sb // Access: Published // Description: Sets the blue scale component of the transform ////////////////////////////////////////////////////////////////////

setScale(...)

 

C++ Interface: setScale(non-const NodePath this, const VBase3 scale) setScale(non-const NodePath this, float scale) setScale(non-const NodePath this, const NodePath other, const VBase3 scale) setScale(non-const NodePath this, const NodePath other, float scale) setScale(non-const NodePath this, float sx, float sy, float sz) setScale(non-const NodePath this, const NodePath other, float sx, float sy, float sz)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scale // Access: Published // Description: Sets the scale component of the transform, // leaving translation and rotation untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scale // Access: Published // Description: Sets the scale component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scale // Access: Published // Description: Sets the scale component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scale // Access: Published // Description: Sets the scale component of the transform, // leaving translation and rotation untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scale // Access: Published // Description: Sets the scale component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

setScissor(...)

 

C++ Interface: setScissor(non-const NodePath this, const Point3 a, const Point3 b) setScissor(non-const NodePath this, const NodePath other, const Point3 a, const Point3 b) setScissor(non-const NodePath this, const Point3 a, const Point3 b, const Point3 c, const Point3 d) setScissor(non-const NodePath this, float left, float right, float bottom, float top) setScissor(non-const NodePath this, const NodePath other, const Point3 a, const Point3 b, const Point3 c, const Point3 d)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scissor // Access: Published // Description: Sets up a scissor region on the nodes rendered at // this level and below. The four coordinates are // understood to define a rectangle in screen space. // These numbers are relative to the current // DisplayRegion, where (0,0) is the lower-left corner // of the DisplayRegion, and (1,1) is the upper-right // corner. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scissor // Access: Published // Description: Sets up a scissor region on the nodes rendered at // this level and below. The two points are understood // to be relative to this node. When these points are // projected into screen space, they define the // diagonally-opposite points that determine the scissor // region. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scissor // Access: Published // Description: Sets up a scissor region on the nodes rendered at // this level and below. The four points are understood // to be relative to this node. When these points are // projected into screen space, they define the // bounding volume of the scissor region (the scissor // region is the smallest onscreen rectangle that // encloses all four points). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scissor // Access: Published // Description: Sets up a scissor region on the nodes rendered at // this level and below. The two points are understood // to be relative to the indicated other node. When // these points are projected into screen space, they // define the diagonally-opposite points that determine // the scissor region. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_scissor // Access: Published // Description: Sets up a scissor region on the nodes rendered at // this level and below. The four points are understood // to be relative to the indicated other node. When // these points are projected into screen space, they // define the bounding volume of the scissor region (the // scissor region is the smallest onscreen rectangle // that encloses all four points). ////////////////////////////////////////////////////////////////////

setSg(...)

 

C++ Interface: setSg(non-const NodePath this, float sg)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_sg // Access: Published // Description: Sets the alpha scale component of the transform ////////////////////////////////////////////////////////////////////

setShader(...)

 

C++ Interface: setShader(non-const NodePath this, const Shader sha) setShader(non-const NodePath this, const Shader sha, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader // Access: Published // Description: ////////////////////////////////////////////////////////////////////

setShaderAuto(...)

 

C++ Interface: setShaderAuto(non-const NodePath this) setShaderAuto(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_auto // Access: Published // Description: ////////////////////////////////////////////////////////////////////

setShaderInput(...)

 

C++ Interface: setShaderInput(non-const NodePath this, const ShaderInput inp) setShaderInput(non-const NodePath this, non-const InternalName id) setShaderInput(non-const NodePath this, string id) setShaderInput(non-const NodePath this, non-const InternalName id, const Vec4 v) setShaderInput(non-const NodePath this, non-const InternalName id, const NodePath np) setShaderInput(non-const NodePath this, non-const InternalName id, non-const Texture tex) setShaderInput(non-const NodePath this, string id, const Vec4 v) setShaderInput(non-const NodePath this, string id, const NodePath np) setShaderInput(non-const NodePath this, string id, non-const Texture tex) setShaderInput(non-const NodePath this, non-const InternalName id, float n1) setShaderInput(non-const NodePath this, string id, float n1) setShaderInput(non-const NodePath this, non-const InternalName id, const Vec4 v, int priority) setShaderInput(non-const NodePath this, non-const InternalName id, const NodePath np, int priority) setShaderInput(non-const NodePath this, non-const InternalName id, non-const Texture tex, int priority) setShaderInput(non-const NodePath this, string id, const Vec4 v, int priority) setShaderInput(non-const NodePath this, string id, const NodePath np, int priority) setShaderInput(non-const NodePath this, string id, non-const Texture tex, int priority) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2) setShaderInput(non-const NodePath this, string id, float n1, float n2) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2, float n3) setShaderInput(non-const NodePath this, string id, float n1, float n2, float n3) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2, float n3, float n4) setShaderInput(non-const NodePath this, string id, float n1, float n2, float n3, float n4) setShaderInput(non-const NodePath this, non-const InternalName id, float n1, float n2, float n3, float n4, int priority) setShaderInput(non-const NodePath this, string id, float n1, float n2, float n3, float n4, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_input // Access: Published // Description: ////////////////////////////////////////////////////////////////////

setShaderOff(...)

 

C++ Interface: setShaderOff(non-const NodePath this) setShaderOff(non-const NodePath this, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shader_off // Access: Published // Description: ////////////////////////////////////////////////////////////////////

setShear(...)

 

C++ Interface: setShear(non-const NodePath this, const VBase3 shear) setShear(non-const NodePath this, const NodePath other, const VBase3 shear) setShear(non-const NodePath this, float shxy, float shxz, float shyz) setShear(non-const NodePath this, const NodePath other, float shxy, float shxz, float shyz)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shear // Access: Published // Description: Sets the shear component of the transform, // leaving translation, rotation, and scale untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shear // Access: Published // Description: Sets the shear component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shear // Access: Published // Description: Sets the shear component of the transform, // leaving translation and rotation untouched. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_shear // Access: Published // Description: Sets the shear component of the transform, // relative to the other node. ////////////////////////////////////////////////////////////////////

setSr(...)

 

C++ Interface: setSr(non-const NodePath this, float sr)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_sr // Access: Published // Description: Sets the red scale component of the transform ////////////////////////////////////////////////////////////////////

setState(...)

 

C++ Interface: setState(non-const NodePath this, const RenderState state) setState(non-const NodePath this, const RenderState state, non-const Thread current_thread) setState(non-const NodePath this, const NodePath other, const RenderState state) setState(non-const NodePath this, const NodePath other, const RenderState state, non-const Thread current_thread)

// Aggregate transform and state information.

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_state // Access: Published // Description: Changes the complete state object on this node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_state // Access: Published // Description: Sets the state object on this node, relative to // the other node. This computes a new state object // that will have the indicated value when seen from the // other node. ////////////////////////////////////////////////////////////////////

setTag(...)

 

C++ Interface: setTag(non-const NodePath this, string key, string value)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tag // Access: Published // Description: Associates a user-defined value with a user-defined // key which is stored on the node. This value has no // meaning to Panda; but it is stored indefinitely on // the node until it is requested again. // // Each unique key stores a different string value. // There is no effective limit on the number of // different keys that may be stored or on the length of // any one key's value. ////////////////////////////////////////////////////////////////////

setTexGen(...)

 

C++ Interface: setTexGen(non-const NodePath this, non-const TextureStage stage, int mode) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, const Point3 constant_value) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, int priority) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, string source_name, const NodePath light) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, const Point3 constant_value, int priority) setTexGen(non-const NodePath this, non-const TextureStage stage, int mode, string source_name, const NodePath light, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_gen // Access: Published // Description: Enables automatic texture coordinate generation for // the indicated texture stage. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_gen // Access: Published // Description: Enables automatic texture coordinate generation for // the indicated texture stage. This version of this // method is useful when setting M_light_vector, which // requires the name of the texture coordinate set that // supplies the tangent and binormal, as well as the // specific light to generate coordinates for. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_gen // Access: Published // Description: Enables automatic texture coordinate generation for // the indicated texture stage. This version of this // method is useful when setting M_constant, which // requires a constant texture coordinate value. ////////////////////////////////////////////////////////////////////

setTexHpr(...)

 

C++ Interface: setTexHpr(non-const NodePath this, non-const TextureStage stage, const VBase3 hpr) setTexHpr(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase3 hpr) setTexHpr(non-const NodePath this, non-const TextureStage stage, float h, float p, float r) setTexHpr(non-const NodePath this, const NodePath other, non-const TextureStage stage, float h, float p, float r)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_hpr // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated rotation, as a 3-D HPR, to UVW's // for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_hpr // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated rotation, as a 3-D HPR, to UVW's // for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_hpr // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated rotation, as a 3-D HPR, to UVW's // for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_hpr // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated rotation, as a 3-D HPR, to UVW's // for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

setTexOffset(...)

 

C++ Interface: setTexOffset(non-const NodePath this, non-const TextureStage stage, const VBase2 uv) setTexOffset(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase2 uv) setTexOffset(non-const NodePath this, non-const TextureStage stage, float u, float v) setTexOffset(non-const NodePath this, const NodePath other, non-const TextureStage stage, float u, float v)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_offset // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_offset // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_offset // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_offset // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

setTexPos(...)

 

C++ Interface: setTexPos(non-const NodePath this, non-const TextureStage stage, const VBase3 uvw) setTexPos(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase3 uvw) setTexPos(non-const NodePath this, non-const TextureStage stage, float u, float v, float w) setTexPos(non-const NodePath this, const NodePath other, non-const TextureStage stage, float u, float v, float w)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_pos // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_pos // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_pos // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_pos // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated offset to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

setTexProjector(...)

 

C++ Interface: setTexProjector(non-const NodePath this, non-const TextureStage stage, const NodePath from, const NodePath to)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_projector // Access: Published // Description: Establishes a TexProjectorEffect on this node, which // can be used to establish projective texturing (but // see also the NodePath::project_texture() convenience // function), or it can be used to bind this node's // texture transform to particular node's position in // space, allowing a LerpInterval (for instance) to // adjust this node's texture coordinates. ////////////////////////////////////////////////////////////////////

setTexRotate(...)

 

C++ Interface: setTexRotate(non-const NodePath this, non-const TextureStage stage, float r) setTexRotate(non-const NodePath this, const NodePath other, non-const TextureStage stage, float r)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_rotate // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated rotation, clockwise in degrees, to UV's // for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_rotate // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated rotation, clockwise in degrees, to UV's // for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

setTexScale(...)

 

C++ Interface: setTexScale(non-const NodePath this, non-const TextureStage stage, const VBase2 scale) setTexScale(non-const NodePath this, non-const TextureStage stage, const VBase3 scale) setTexScale(non-const NodePath this, non-const TextureStage stage, float scale) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase2 scale) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, const VBase3 scale) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, float scale) setTexScale(non-const NodePath this, non-const TextureStage stage, float su, float sv) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, float su, float sv) setTexScale(non-const NodePath this, non-const TextureStage stage, float su, float sv, float sw) setTexScale(non-const NodePath this, const NodePath other, non-const TextureStage stage, float su, float sv, float sw)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UVW's for the given stage. // // This call is appropriate for 2-d or 3-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UV's for the given stage. // // This call is appropriate for 2-d or 3-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UV's for the given stage. // // This call is appropriate for ordinary 2-d texture // coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_scale // Access: Published // Description: Sets a texture matrix on the current node to apply // the indicated scale to UVW's for the given stage. // // This call is appropriate for 3-d texture coordinates. ////////////////////////////////////////////////////////////////////

setTexTransform(...)

 

C++ Interface: setTexTransform(non-const NodePath this, non-const TextureStage stage, const TransformState transform) setTexTransform(non-const NodePath this, const NodePath other, non-const TextureStage stage, const TransformState transform)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_transform // Access: Published // Description: Sets the texture matrix on the current node to the // indicated transform for the given stage. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_tex_transform // Access: Published // Description: Sets the texture matrix on the current node to the // indicated transform for the given stage. ////////////////////////////////////////////////////////////////////

setTexture(...)

 

C++ Interface: setTexture(non-const NodePath this, non-const Texture tex) setTexture(non-const NodePath this, non-const TextureStage stage, non-const Texture tex) setTexture(non-const NodePath this, non-const Texture tex, int priority) setTexture(non-const NodePath this, non-const TextureStage stage, non-const Texture tex, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_texture // Access: Published // Description: Adds the indicated texture to the list of textures // that will be rendered on the default texture stage. // // This is the convenience single-texture variant of // this method; it is now superceded by set_texture() // that accepts a stage and texture. You may use this // method if you just want to adjust the default stage. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_texture // Access: Published // Description: Adds the indicated texture to the list of textures // that will be rendered on the indicated multitexture // stage. If there are multiple texture stages // specified (possibly on multiple different nodes at // different levels), they will all be applied to // geometry together, according to the stage // specification set up in the TextureStage object. ////////////////////////////////////////////////////////////////////

setTextureOff(...)

 

C++ Interface: setTextureOff(non-const NodePath this) setTextureOff(non-const NodePath this, non-const TextureStage stage) setTextureOff(non-const NodePath this, int priority) setTextureOff(non-const NodePath this, non-const TextureStage stage, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_texture_off // Access: Published // Description: Sets the geometry at this level and below to render // using no texture, on any stage. This is different // from not specifying a texture; rather, this // specifically contradicts set_texture() at a higher // node level (or, with a priority, overrides a // set_texture() at a lower level). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_texture_off // Access: Published // Description: Sets the geometry at this level and below to render // using no texture, on the indicated stage. This is // different from not specifying a texture; rather, this // specifically contradicts set_texture() at a higher // node level (or, with a priority, overrides a // set_texture() at a lower level). ////////////////////////////////////////////////////////////////////

setTransform(...)

 

C++ Interface: setTransform(non-const NodePath this, const TransformState transform) setTransform(non-const NodePath this, const TransformState transform, non-const Thread current_thread) setTransform(non-const NodePath this, const NodePath other, const TransformState transform) setTransform(non-const NodePath this, const NodePath other, const TransformState transform, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_transform // Access: Published // Description: Changes the complete transform object on this node. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_transform // Access: Published // Description: Sets the transform object on this node, relative to // the other node. This computes a new transform object // that will have the indicated value when seen from the // other node. ////////////////////////////////////////////////////////////////////

setTransparency(...)

 

C++ Interface: setTransparency(non-const NodePath this, int mode) setTransparency(non-const NodePath this, int mode, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_transparency // Access: Published // Description: Specifically sets or disables transparent rendering // mode on this particular node. If no other nodes // override, this will cause items with a non-1 value // for alpha color to be rendered partially transparent. ////////////////////////////////////////////////////////////////////

setTwoSided(...)

 

C++ Interface: setTwoSided(non-const NodePath this, bool two_sided) setTwoSided(non-const NodePath this, bool two_sided, int priority)

//////////////////////////////////////////////////////////////////// // Function: NodePath::set_two_sided // Access: Published // Description: Specifically sets or disables two-sided rendering // mode on this particular node. If no other nodes // override, this will cause backfacing polygons to be // drawn (in two-sided mode, true) or culled (in // one-sided mode, false). ////////////////////////////////////////////////////////////////////

show(...)

 

C++ Interface: show(non-const NodePath this) show(non-const NodePath this, const BitMask camera_mask)

// Variants on show and hide

// Variants on show and hide

//////////////////////////////////////////////////////////////////// // Function: NodePath::show // Access: Published // Description: Undoes the effect of a previous hide() on this node: // makes the referenced node (and the entire subgraph // below this node) visible to all cameras. // // This will not reveal the node if a parent node has // been hidden. ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::show // Access: Published // Description: Makes the referenced node visible just to the // cameras whose camera_mask shares the indicated bits. // // This undoes the effect of a previous hide() call. It // will not reveal the node if a parent node has been // hidden. However, see show_through(). ////////////////////////////////////////////////////////////////////

showBounds(...)

 

C++ Interface: showBounds(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::show_bounds // Access: Published // Description: Causes the bounding volume of the bottom node and all // of its descendants (that is, the bounding volume // associated with the the bottom arc) to be rendered, // if possible. The rendering method is less than // optimal; this is intended primarily for debugging. ////////////////////////////////////////////////////////////////////

showCS(self, mask=None)

 

Shows the collision solids at or below this node. If mask is not None, it is a BitMask32 object (e.g. WallBitmask, CameraBitmask) that indicates which particular collision solids should be made visible; otherwise, all of them will be.

showThrough(...)

 

C++ Interface: showThrough(non-const NodePath this) showThrough(non-const NodePath this, const BitMask camera_mask)

//////////////////////////////////////////////////////////////////// // Function: NodePath::show_through // Access: Published // Description: Makes the referenced node visible just to the // cameras whose camera_mask shares the indicated bits. // // Unlike show(), this will reveal the node even if a // parent node has been hidden, thus "showing through" a // parent's hide(). ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////// // Function: NodePath::show_through // Access: Published // Description: Makes the referenced node visible just to the // cameras whose camera_mask shares the indicated bits. // // Unlike show(), this will reveal the node even if a // parent node has been hidden via the one-parameter // hide() method, thus "showing through" a parent's // hide(). (However, it will not show through a // parent's hide() call if the no-parameter form of // hide() was used.) ////////////////////////////////////////////////////////////////////

showTightBounds(...)

 

C++ Interface: showTightBounds(non-const NodePath this)

//////////////////////////////////////////////////////////////////// // Function: NodePath::show_tight_bounds // Access: Published // Description: Similar to show_bounds(), this draws a bounding box // representing the "tight" bounds of this node and all // of its descendants. The bounding box is recomputed // every frame by reexamining all of the vertices; this // is far from efficient, but this is intended for // debugging. ////////////////////////////////////////////////////////////////////

stash(...)

 

C++ Interface: stash(non-const NodePath this) stash(non-const NodePath this, int sort) stash(non-const NodePath this, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::stash // Access: Published // Description: Removes the referenced node (and the entire subgraph // below this node) from the scene graph in any normal // sense. The node will no longer be visible and is not // tested for collisions; furthermore, no normal scene // graph traversal will visit the node. The node's // bounding volume no longer contributes to its parent's // bounding volume. // // A stashed node cannot be located by a normal find() // operation (although a special find string can still // retrieve it). ////////////////////////////////////////////////////////////////////

stashTo(...)

 

C++ Interface: stashTo(non-const NodePath this, const NodePath other) stashTo(non-const NodePath this, const NodePath other, int sort) stashTo(non-const NodePath this, const NodePath other, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::stash_to // Access: Published // Description: Similar to reparent_to(), but the node is added to // its new parent's stashed list, so that the result is // equivalent to calling reparent_to() immediately // followed by stash(). ////////////////////////////////////////////////////////////////////

subdivideCollisions(self, numSolidsInLeaves)

 

expand CollisionNodes out into balanced trees, with a particular number of solids in the leaves TODO: better splitting logic at each level of the tree wrt spatial separation and cost of bounding volume tests vs. cost of collision solid tests

unifyTextureStages(...)

 

C++ Interface: unifyTextureStages(non-const NodePath this, non-const TextureStage stage)

//////////////////////////////////////////////////////////////////// // Function: NodePath::unify_texture_stages // Access: Published // Description: Searches through all TextureStages at this node and // below. Any TextureStages that share the same name as // the indicated TextureStage object are replaced with // this object, thus ensuring that all geometry at this // node and below with a particular TextureStage name is // using the same TextureStage object. ////////////////////////////////////////////////////////////////////

unstash(...)

 

C++ Interface: unstash(non-const NodePath this) unstash(non-const NodePath this, int sort) unstash(non-const NodePath this, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::unstash // Access: Published // Description: Undoes the effect of a previous stash() on this // node: makes the referenced node (and the entire // subgraph below this node) once again part of the // scene graph. ////////////////////////////////////////////////////////////////////

unstashAll(...)

 

C++ Interface: unstashAll(non-const NodePath this) unstashAll(non-const NodePath this, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::unstash_all // Access: Published // Description: Unstashes this node and all stashed child nodes. ////////////////////////////////////////////////////////////////////

verifyComplete(...)

 

C++ Interface: verifyComplete(const NodePath this) verifyComplete(const NodePath this, non-const Thread current_thread)

// Miscellaneous

//////////////////////////////////////////////////////////////////// // Function: NodePath::verify_complete // Access: Published // Description: Returns true if all of the nodes described in the // NodePath are connected, or false otherwise. ////////////////////////////////////////////////////////////////////

writeBamFile(...)

 

C++ Interface: writeBamFile(const NodePath this, string filename)

// HAVE_PYTHON //////////////////////////////////////////////////////////////////// // Function: NodePath::write_bam_file // Access: Published // Description: Writes the contents of this node and below out to a // bam file with the indicated filename. This file may // then be read in again, as is, at some later point. // Returns true if successful, false on some kind of // error. ////////////////////////////////////////////////////////////////////

writeBamStream(...)

 

C++ Interface: writeBamStream(const NodePath this, non-const Ostream out)

//////////////////////////////////////////////////////////////////// // Function: NodePath::write_bam_stream // Access: Published // Description: Writes the contents of this node and below out to the // indicated stream. ////////////////////////////////////////////////////////////////////

writeBounds(...)

 

C++ Interface: writeBounds(const NodePath this, non-const Ostream out)

//////////////////////////////////////////////////////////////////// // Function: NodePath::write_bounds // Access: Published // Description: Writes a description of the bounding volume // containing the bottom node and all of its descendants // to the indicated output stream. ////////////////////////////////////////////////////////////////////

wrtReparentTo(...)

 

C++ Interface: wrtReparentTo(non-const NodePath this, const NodePath other) wrtReparentTo(non-const NodePath this, const NodePath other, int sort) wrtReparentTo(non-const NodePath this, const NodePath other, int sort, non-const Thread current_thread)

//////////////////////////////////////////////////////////////////// // Function: NodePath::wrt_reparent_to // Access: Published // Description: This functions identically to reparent_to(), except // the transform on this node is also adjusted so that // the node remains in the same place in world // coordinates, even if it is reparented into a // different coordinate system. ////////////////////////////////////////////////////////////////////


Class Variable Details

DtoolClassDict

Value:
{'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassD\
ict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {'Dtool\
ClassDict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {\
'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDi\
ct': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolC\
lassDict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {'\
DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDic\
t': {'DtoolClassDict': {'DtoolClassDict': {'DtoolClassDict': {'DtoolCl\
...