Panda3D

- Main Page
- Packages
- Classes

- Packages
- Package Functions

Functions

# Package extensions_native.NodePath_extensions

## 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

All Classes Namespaces Functions Variables Enumerations Enumerator Properties