Package extensions.NodePath-extensions

Functions
def	__hash__
def	attachCollisionRay
def	attachCollisionSegment
def	attachCollisionSphere
def	colorInterval
def	colorScaleInterval
def	deselect
def	explore
def	flattenMultitex
def	getAncestry
def	getChildrenAsList
def	getTightBounds
def	hideCS
def	hideSiblings
def	hprInterval
def	hprScaleInterval
def	id
def	iHpr
def	iPos
def	iPosHpr
def	iPosHprScale
def	iScale
def	isolate
def	lerpColor
def	lerpColorRGBA
def	lerpColorRGBARGBA
def	lerpColorScale
def	lerpColorScaleRGBA
def	lerpColorScaleRGBARGBA
def	lerpColorScaleVBase4
def	lerpColorScaleVBase4VBase4
def	lerpColorVBase4
def	lerpColorVBase4VBase4
def	lerpHpr
def	lerpHprHPR
def	lerpHprVBase3
def	lerpPos
def	lerpPosHpr
def	lerpPosHprPoint3VBase3
def	lerpPosHprScale
def	lerpPosHprXYZHPR
def	lerpPosPoint3
def	lerpPosXYZ
def	lerpScale
def	lerpScaleVBase3
def	lerpScaleXYZ
def	lsNames
def	lsNamesRecurse
def	place
def	posHprInterval
def	posHprScaleInterval
def	posHprScaleShearInterval
def	posInterval
def	posQuatInterval
def	posQuatScaleInterval
def	posQuatScaleShearInterval
def	pPrintString
def	printChildren
def	printHpr
def	printPos
def	printPosHpr
def	printPosHprScale
def	printScale
def	printTransform
def	quatInterval
def	quatScaleInterval
def	remove
def	removeChildren
def	reverseLsNames
def	rgbPanel
def	scaleInterval
def	select
def	shearInterval
def	showAllDescendants
def	showCS
def	showSiblings
def	toggleVis

---

Function Documentation

def extensions.NodePath-extensions.__hash__

(

self

)

def extensions.NodePath-extensions.attachCollisionRay	(		self,
			name,
			ox,
			oy,
			oz,
			dx,
			dy,
			dz,
			fromCollide,
			intoCollide
	)

def extensions.NodePath-extensions.attachCollisionSegment	(		self,
			name,
			ax,
			ay,
			az,
			bx,
			by,
			bz,
			fromCollide,
			intoCollide
	)

def extensions.NodePath-extensions.attachCollisionSphere	(		self,
			name,
			cx,
			cy,
			cz,
			r,
			fromCollide,
			intoCollide
	)

def extensions.NodePath-extensions.colorInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.colorScaleInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.deselect

(

self

)

def extensions.NodePath-extensions.explore

(

self

)

def extensions.NodePath-extensions.flattenMultitex	(		self,
			stateFrom = None,
			target = None,
			useGeom = 0,
			allowTexMat = 0,
			win = None
	)

def extensions.NodePath-extensions.getAncestry

(

self

)

Get a list of a node path's ancestors

def extensions.NodePath-extensions.getChildrenAsList

(

self

)

Converts a node path's child NodePathCollection into a list

def extensions.NodePath-extensions.getTightBounds

(

self

)

def extensions.NodePath-extensions.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.

def extensions.NodePath-extensions.hideSiblings

(

self

)

Hide all the siblings of a node path

def extensions.NodePath-extensions.hprInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.hprScaleInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.id

(

self

)

Returns a unique id identifying the NodePath instance

def extensions.NodePath-extensions.iHpr	(		self,
			other = None
	)

Set node path's hpr to 0, 0, 0 

def extensions.NodePath-extensions.iPos	(		self,
			other = None
	)

Set node path's pos to 0, 0, 0 

def extensions.NodePath-extensions.iPosHpr	(		self,
			other = None
	)

Set node path's pos and hpr to 0, 0, 0 

def extensions.NodePath-extensions.iPosHprScale	(		self,
			other = None
	)

Set node path's pos and hpr to 0, 0, 0 and scale to 1, 1, 1 

def extensions.NodePath-extensions.iScale	(		self,
			other = None
	)

SEt node path's scale to 1, 1, 1 

def extensions.NodePath-extensions.isolate

(

self

)

Show the node path and hide its siblings

def extensions.NodePath-extensions.lerpColor	(		self,
			posArgs,
			keyArgs
	)

determine which lerpColor* to call based on arguments

def extensions.NodePath-extensions.lerpColorRGBA	(		self,
			r,
			g,
			b,
			a,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorRGBA(self, float, float, float, float, float,
string="noBlend", string=none, string=none)

def extensions.NodePath-extensions.lerpColorRGBARGBA	(		self,
			sr,
			sg,
			sb,
			sa,
			er,
			eg,
			eb,
			ea,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorRGBARGBA(self, float, float, float, float, float,
float, float, float, float, string="noBlend", string=none, string=none)

def extensions.NodePath-extensions.lerpColorScale	(		self,
			posArgs,
			keyArgs
	)

lerpColorScale(self, *positionArgs, **keywordArgs)
determine which lerpColorScale* to call based on arguments

def extensions.NodePath-extensions.lerpColorScaleRGBA	(		self,
			r,
			g,
			b,
			a,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorScaleRGBA(self, float, float, float, float, float,
string="noBlend", string=none, string=none)

def extensions.NodePath-extensions.lerpColorScaleRGBARGBA	(		self,
			sr,
			sg,
			sb,
			sa,
			er,
			eg,
			eb,
			ea,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorScaleRGBARGBA(self, float, float, float, float, float,
float, float, float, float, string="noBlend", string=none, string=none)

def extensions.NodePath-extensions.lerpColorScaleVBase4	(		self,
			endColor,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorScaleVBase4(self, VBase4, float, string="noBlend", string=none,
string=none)

def extensions.NodePath-extensions.lerpColorScaleVBase4VBase4	(		self,
			startColor,
			endColor,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorScaleVBase4VBase4(self, VBase4, VBase4, float, string="noBlend",
string=none, string=none)

def extensions.NodePath-extensions.lerpColorVBase4	(		self,
			endColor,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorVBase4(self, VBase4, float, string="noBlend", string=none,
string=none)

def extensions.NodePath-extensions.lerpColorVBase4VBase4	(		self,
			startColor,
			endColor,
			time,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpColorVBase4VBase4(self, VBase4, VBase4, float, string="noBlend",
string=none, string=none)

def extensions.NodePath-extensions.lerpHpr	(		self,
			posArgs,
			keyArgs
	)

lerpHpr(self, *positionArgs, **keywordArgs)
Determine whether to call lerpHprHPR or lerpHprVBase3
based on first argument

def extensions.NodePath-extensions.lerpHprHPR	(		self,
			h,
			p,
			r,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None,
			shortest = 1
	)

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

def extensions.NodePath-extensions.lerpHprVBase3	(		self,
			hpr,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None,
			shortest = 1
	)

lerpHprVBase3(self, VBase3, float, string="noBlend", string=none,
string=none, NodePath=None)
Perform a hpr lerp with a VBase3 as the end point

def extensions.NodePath-extensions.lerpPos	(		self,
			posArgs,
			keyArgs
	)

lerpPos(self, *positionArgs, **keywordArgs)
Determine whether to call lerpPosXYZ or lerpPosPoint3
based on the first argument

def extensions.NodePath-extensions.lerpPosHpr	(		self,
			posArgs,
			keyArgs
	)

lerpPosHpr(self, *positionArgs, **keywordArgs)
Determine whether to call lerpPosHprXYZHPR or lerpHprPoint3VBase3
based on first argument

def extensions.NodePath-extensions.lerpPosHprPoint3VBase3	(		self,
			pos,
			hpr,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None,
			shortest = 1
	)

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

def extensions.NodePath-extensions.lerpPosHprScale	(		self,
			pos,
			hpr,
			scale,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None,
			shortest = 1
	)

lerpPosHpr(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

def extensions.NodePath-extensions.lerpPosHprXYZHPR	(		self,
			x,
			y,
			z,
			h,
			p,
			r,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None,
			shortest = 1
	)

lerpPosHpr(self, float, string="noBlend", string=none,
string=none, NodePath=None)

def extensions.NodePath-extensions.lerpPosPoint3	(		self,
			pos,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpPosPoint3(self, Point3, float, string="noBlend", string=None,
string=None, NodePath=None)
Perform a pos lerp with a Point3 as the end point

def extensions.NodePath-extensions.lerpPosXYZ	(		self,
			x,
			y,
			z,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpPosXYZ(self, float, float, float, float, string="noBlend",
string=None, NodePath=None)
Perform a pos lerp with three floats as the end point

def extensions.NodePath-extensions.lerpScale	(		self,
			posArgs,
			keyArgs
	)

lerpSclae(self, *positionArgs, **keywordArgs)
Determine whether to call lerpScaleXYZ or lerpScaleaseV3
based on the first argument

def extensions.NodePath-extensions.lerpScaleVBase3	(		self,
			scale,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None
	)

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

def extensions.NodePath-extensions.lerpScaleXYZ	(		self,
			sx,
			sy,
			sz,
			time,
			other = None,
			blendType = "noBlend",
			auto = None,
			task = None
	)

lerpPos(self, float, float, float, float, string="noBlend",
string=none, string=none, NodePath=None)

def extensions.NodePath-extensions.lsNames

(

self

)

Walk down a tree and print out the path

def extensions.NodePath-extensions.lsNamesRecurse	(		self,
			indentString = ' '
	)

Walk down a tree and print out the path

def extensions.NodePath-extensions.place

(

self

)

def extensions.NodePath-extensions.posHprInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.posHprScaleInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.posHprScaleShearInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.posInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.posQuatInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.posQuatScaleInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.posQuatScaleShearInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.pPrintString	(		self,
			other = None
	)

pretty print

def extensions.NodePath-extensions.printChildren

(

self

)

Prints out the children of the bottom node of a node path

def extensions.NodePath-extensions.printHpr	(		self,
			other = None,
			sd = 2
	)

Pretty print a node path's hpr 

def extensions.NodePath-extensions.printPos	(		self,
			other = None,
			sd = 2
	)

Pretty print a node path's pos 

def extensions.NodePath-extensions.printPosHpr	(		self,
			other = None,
			sd = 2
	)

Pretty print a node path's pos and, hpr 

def extensions.NodePath-extensions.printPosHprScale	(		self,
			other = None,
			sd = 2
	)

Pretty print a node path's pos, hpr, and scale 

def extensions.NodePath-extensions.printScale	(		self,
			other = None,
			sd = 2
	)

Pretty print a node path's scale 

def extensions.NodePath-extensions.printTransform	(		self,
			other = None,
			sd = 2,
			fRecursive = 0
	)

def extensions.NodePath-extensions.quatInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.quatScaleInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.remove

(

self

)

Remove a node path from the scene graph

def extensions.NodePath-extensions.removeChildren

(

self

)

Deletes the children of the bottom node of a node path

def extensions.NodePath-extensions.reverseLsNames

(

self

)

Walk up a tree and print out the path to the root

def extensions.NodePath-extensions.rgbPanel	(		self,
			cb = None
	)

def extensions.NodePath-extensions.scaleInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.select

(

self

)

def extensions.NodePath-extensions.shearInterval	(		self,
			args,
			kw
	)

def extensions.NodePath-extensions.showAllDescendants

(

self

)

Show the node path and all its children

def extensions.NodePath-extensions.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.

def extensions.NodePath-extensions.showSiblings

(

self

)

Show all the siblings of a node path

def extensions.NodePath-extensions.toggleVis

(

self

)

Toggles visibility of a nodePath