Panda3D
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 Properties