Functions
def	analyze
def	attachCollisionRay
def	attachCollisionSegment
def	attachCollisionSphere
def	colorInterval
def	colorScaleInterval
def	deselect
def	explore
def	flattenMultitex
def	getAncestry
def	getChildrenAsList
	def __hash__(self): // inside c code return self.getKey()
def	getNumDescendants
def	getTightBounds
def	hideCS
def	hideSiblings
def	hprInterval
def	hprScaleInterval
def	id
	Dtool_funcToMethod(func, class) del func.
def	iHpr
def	iPos
def	iPosHpr
def	iPosHprScale
def	iScale
def	isolate
def	lerpColor
def	lerpColorRGBA
def	lerpColorRGBARGBA
def	lerpColorScale
	user callable lerp methods
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	r_constructCollisionTree
def	r_subdivideCollisions
def	remove
def	removeChildren
def	removeNonCollisions
def	reverseLsNames
def	rgbPanel
def	scaleInterval
def	select
def	shearInterval
def	showAllDescendants
def	showCS
def	showSiblings
def	subdivideCollisions
def	toggleVis

Function Documentation

def extensions_native.NodePath_extensions.analyze ( self )

def extensions_native.NodePath_extensions.attachCollisionRay	(	self,
		name,
		ox,
		oy,
		oz,
		dx,
		dy,
		dz,
		fromCollide,
		intoCollide
	)

def extensions_native.NodePath_extensions.attachCollisionSegment	(	self,
		name,
		ax,
		ay,
		az,
		bx,
		by,
		bz,
		fromCollide,
		intoCollide
	)

def extensions_native.NodePath_extensions.attachCollisionSphere	(	self,
		name,
		cx,
		cy,
		cz,
		r,
		fromCollide,
		intoCollide
	)

def extensions_native.NodePath_extensions.colorInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.colorScaleInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.deselect ( self )

def extensions_native.NodePath_extensions.explore ( self )

def extensions_native.NodePath_extensions.flattenMultitex	(	self,
		stateFrom = `None`,
		target = `None`,
		useGeom = `0`,
		allowTexMat = `0`,
		win = `None`
	)

def extensions_native.NodePath_extensions.getAncestry ( self )

Get a list of a node path's ancestors

def extensions_native.NodePath_extensions.getChildrenAsList ( self )

def __hash__(self): // inside c code return self.getKey()

Converts a node path's child NodePathCollection into a list

def extensions_native.NodePath_extensions.getNumDescendants ( self )

def extensions_native.NodePath_extensions.getTightBounds ( self )

def extensions_native.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_native.NodePath_extensions.hideSiblings ( self )

Hide all the siblings of a node path

def extensions_native.NodePath_extensions.hprInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.hprScaleInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.id ( self )

Dtool_funcToMethod(func, class) del func.

Returns a unique id identifying the NodePath instance

def extensions_native.NodePath_extensions.iHpr	(	self,
		other = `None`
	)

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

def extensions_native.NodePath_extensions.iPos	(	self,
		other = `None`
	)

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

def extensions_native.NodePath_extensions.iPosHpr	(	self,
		other = `None`
	)

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

def extensions_native.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_native.NodePath_extensions.iScale	(	self,
		other = `None`
	)

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

def extensions_native.NodePath_extensions.isolate ( self )

Show the node path and hide its siblings

def extensions_native.NodePath_extensions.lerpColor	(	self,
		posArgs,
		keyArgs
	)

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

def extensions_native.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_native.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_native.NodePath_extensions.lerpColorScale	(	self,
		posArgs,
		keyArgs
	)

user callable lerp methods

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

def extensions_native.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_native.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_native.NodePath_extensions.lerpColorScaleVBase4	(	self,
		endColor,
		time,
		blendType = `"noBlend"`,
		auto = `None`,
		task = `None`
	)

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

def extensions_native.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_native.NodePath_extensions.lerpColorVBase4	(	self,
		endColor,
		time,
		blendType = `"noBlend"`,
		auto = `None`,
		task = `None`
	)

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

def extensions_native.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_native.NodePath_extensions.lerpHpr	(	self,
		posArgs,
		keyArgs
	)

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

def extensions_native.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_native.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_native.NodePath_extensions.lerpPos	(	self,
		posArgs,
		keyArgs
	)

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

def extensions_native.NodePath_extensions.lerpPosHpr	(	self,
		posArgs,
		keyArgs
	)

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

def extensions_native.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_native.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_native.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_native.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_native.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_native.NodePath_extensions.lerpScale	(	self,
		posArgs,
		keyArgs
	)

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

def extensions_native.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_native.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_native.NodePath_extensions.lsNames ( self )

Walk down a tree and print out the path

def extensions_native.NodePath_extensions.lsNamesRecurse	(	self,
		indentString = `' '`
	)

Walk down a tree and print out the path

def extensions_native.NodePath_extensions.place ( self )

def extensions_native.NodePath_extensions.posHprInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.posHprScaleInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.posHprScaleShearInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.posInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.posQuatInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.posQuatScaleInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.posQuatScaleShearInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.pPrintString	(	self,
		other = `None`
	)

pretty print

def extensions_native.NodePath_extensions.printChildren ( self )

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

def extensions_native.NodePath_extensions.printHpr	(	self,
		other = `None`,
		sd = `2`
	)

Pretty print a node path's hpr

def extensions_native.NodePath_extensions.printPos	(	self,
		other = `None`,
		sd = `2`
	)

Pretty print a node path's pos

def extensions_native.NodePath_extensions.printPosHpr	(	self,
		other = `None`,
		sd = `2`
	)

Pretty print a node path's pos and, hpr

def extensions_native.NodePath_extensions.printPosHprScale	(	self,
		other = `None`,
		sd = `2`
	)

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

def extensions_native.NodePath_extensions.printScale	(	self,
		other = `None`,
		sd = `2`
	)

Pretty print a node path's scale

def extensions_native.NodePath_extensions.printTransform	(	self,
		other = `None`,
		sd = `2`,
		fRecursive = `0`
	)

def extensions_native.NodePath_extensions.quatInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.quatScaleInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.r_constructCollisionTree	(	self,
		solidTree,
		parentNode,
		colName
	)

def extensions_native.NodePath_extensions.r_subdivideCollisions	(	self,
		solids,
		numSolidsInLeaves
	)

def extensions_native.NodePath_extensions.remove ( self )

Remove a node path from the scene graph

def extensions_native.NodePath_extensions.removeChildren ( self )

Deletes the children of the bottom node of a node path

def extensions_native.NodePath_extensions.removeNonCollisions ( self )

def extensions_native.NodePath_extensions.reverseLsNames ( self )

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

def extensions_native.NodePath_extensions.rgbPanel	(	self,
		cb = `None`
	)

def extensions_native.NodePath_extensions.scaleInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.select ( self )

def extensions_native.NodePath_extensions.shearInterval	(	self,
		args,
		kw
	)

def extensions_native.NodePath_extensions.showAllDescendants ( self )

Show the node path and all its children

def extensions_native.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_native.NodePath_extensions.showSiblings ( self )

Show all the siblings of a node path

def extensions_native.NodePath_extensions.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

def extensions_native.NodePath_extensions.toggleVis ( self )

Toggles visibility of a nodePath

Package extensions_native.NodePath_extensions

Functions

Function Documentation