Panda3D

- Main Page
- Packages
- Classes

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | Public Attributes | Static Public Attributes

# ShowBase Class Reference

Inheritance diagram for ShowBase:

List of all members.

## Public Member Functions
def | __init__
def | addAngularIntegrator
def | addSfxManager
def | adjustWindowAspectRatio
def | backfaceCullingOff
def | backfaceCullingOn
def | changeMouseInterface
def | closeWindow
def | createBaseAudioManagers
def | createStats
def | destroy
def | disableAllAudio
def | disableMouse
def | disableParticles
def | enableAllAudio
def | enableMouse
def | enableMusic
def | enableParticles
def | enableSoftwareMousePointer
def | enableSoundEffects
def | exitfunc
def | finalizeExit
def | getAlt
def | getAspectRatio
def | getAxes
def | getBackgroundColor
def | getControl
def | getExitErrorCode
def | getMeta
def | getRepository
def | getShift
def | getSize
def | initShadowTrav
def | isParticleMgrEnabled
def | isPhysicsMgrEnabled
def | loadMusic
def | loadSfx
def | makeAllPipes
def | makeCamera
def | makeCamera2d
def | makeCamera2dp
def | makeDefaultPipe
def | makeModulePipe
def | movie
def | oobe
def | oobeCull
def | openDefaultWindow
def | openMainWindow
def | openWindow
def | playMusic
def | playSfx
def | popCTrav
def | printEnvDebugInfo
def | pushCTrav
def | removeCameraFrustum
def | restart
def | reviveInput
def | run
def | saveCubeMap
def | saveSphereMap
def | screenshot
def | SetAllSfxEnables
def | setBackgroundColor
def | setFrameRateMeter
def | setMouseOnNode
def | setSceneGraphAnalyzerMeter
def | setSleep
def | setupDataGraph
def | setupMouse
def | setupMouseCB
def | setupRender
def | setupRender2d
def | setupRender2dp
def | setupWindowControls
def | showCameraFrustum
def | shutdown
def | silenceInput
def | sleepCycleTask
def | spawnTkLoop
def | spawnWxLoop
def | startDirect
def | startTk
def | startWx
def | textureOff
def | textureOn
def | tkRun
def | toggleBackface
def | toggleParticles
def | toggleShowVertices
def | toggleTexMem
def | toggleTexture
def | toggleWireframe
def | updateManagers
def | useDrive
def | userExit
def | useTrackball
def | windowEvent
def | wireframeOff
def | wireframeOn
def | wxRun
## Public Attributes
| a2dBackground
| a2dBottom
| a2dBottomCenter
| a2dBottomCenterNs
| a2dBottomLeft
| a2dBottomLeftNs
| a2dBottomRight
| a2dBottomRightNs
| a2dLeft
| a2dLeftCenter
| a2dLeftCenterNs
| a2dpBottom
| a2dpBottomCenter
| a2dpBottomLeft
| a2dpBottomRight
| a2dpLeft
| a2dpLeftCenter
| a2dpRight
| a2dpRightCenter
| a2dpTop
| a2dpTopCenter
| a2dpTopLeft
| a2dpTopRight
| a2dRight
| a2dRightCenter
| a2dRightCenterNs
| a2dTop
| a2dTopCenter
| a2dTopCenterNs
| a2dTopLeft
| a2dTopLeftNs
| a2dTopRight
| a2dTopRightNs
| AppHasAudioFocus
| appRunner
| appTrav
| aspect2d
| aspect2dp
| backfaceCullingEnabled
| bboard
| bufferViewer
| buttonThrowers
| cam
| cam2d
| cam2dp
| camera
| camera2d
| camera2dp
| camFrustumVis
| camLens
| camList
| camNode
| clientSleep
| cluster
| clusterSyncFlag
| config
| cTrav
| cTravStack
| dataRoot
| dataRootNode
| debugRunningMultiplier
| dgTrav
| direct
| drive
| eventMgr
| exitFunc
| finalExitCallbacks
| frameRateMeter
| graphicsEngine
| guiItems
| hidden
| jobMgr
| loader
| mainDir
| mainWinForeground
| mainWinMinimized
| messenger
| mouse2cam
| mouseInterface
| mouseInterfaceNode
| mouseWatcher
| mouseWatcherNode
| multiClientSleep
| musicActive
| musicManager
| musicManagerIsValid
| nextWindowIndex
| oldexitfunc
| oobe2cam
| oobeCamera
| oobeCameraTrackball
| oobeCullFrustum
| oobeLens
| oobeMode
| oobeTrackball
| oobeVis
| particleMgr
| particleMgrEnabled
| physicsMgr
| physicsMgrAngular
| physicsMgrEnabled
| pipe
| pipeList
| pixel2d
| pixel2dp
| pointerWatcherNodes
| recorder
| render
| render2d
| render2dp
| requireWindow
| run
| sceneGraphAnalyzerMeter
| screenshotExtension
| sfxActive
| sfxManagerIsValidList
| sfxManagerList
| sfxPlayer
| shadowTrav
| showVertices
| taskMgr
| texmem
| textureEnabled
| timeButtonThrower
| tkDelay
| tkRoot
| trackball
| transitions
| wantDirect
| wantFog
| wantRender2dp
| wantStats
| wantTk
| wantWx
| win
| winControls
| windowType
| winList
| wireframeEnabled
| wxApp
| wxTimer
## Static Public Attributes
tuple | notify = directNotify.newCategory("ShowBase")

## Constructor & Destructor Documentation

def __init__ | ( |  | self,
|  |  | fStartDirect = `True`,
|  |  | windowType = `None`
| ) |  |

## Member Function Documentation

def addAngularIntegrator | ( |  | self | ) |

def addSfxManager | ( |  | self,
|  |  | extraSfxManager
| ) |  |

def adjustWindowAspectRatio | ( |  | self,
|  |  | aspectRatio
| ) |  |

    This function is normally called internally by
    windowEvent(), but it may also be called to explicitly adjust
    the aspect ratio of the render/render2d DisplayRegion, by a
    class that has redefined these.

def backfaceCullingOff | ( |  | self | ) |

def backfaceCullingOn | ( |  | self | ) |

def changeMouseInterface | ( |  | self,
|  |  | changeTo
| ) |  |

    Switch mouse action

def closeWindow | ( |  | self,
|  |  | win,
|  |  | keepCamera = `False`,
|  |  | removeWindow = `True`
| ) |  |

    Closes the indicated window and removes it from the list of
    windows.  If it is the main window, clears the main window
    pointer to None.

def createBaseAudioManagers | ( |  | self | ) |

def createStats | ( |  | self,
|  |  | hostname = `None`,
|  |  | port = `None`
| ) |  |

def destroy | ( |  | self | ) |

    Call this function to destroy the ShowBase and stop all
    its tasks, freeing all of the Panda resources.  Normally, you
    should not need to call it explicitly, as it is bound to the
    exitfunc and will be called at application exit time
    automatically.

    This function is designed to be safe to call multiple times.

def disableAllAudio | ( |  | self | ) |

def disableMouse | ( |  | self | ) |

    Temporarily disable the mouse control of the camera, either
    via the drive interface or the trackball, whichever is
    currently in use.

def disableParticles | ( |  | self | ) |

def enableAllAudio | ( |  | self | ) |

def enableMouse | ( |  | self | ) |

    Reverse the effect of a previous call to disableMouse().
    useDrive() also implicitly enables the mouse.

def enableMusic | ( |  | self,
|  |  | bEnableMusic
| ) |  |

def enableParticles | ( |  | self | ) |

def enableSoftwareMousePointer | ( |  | self | ) |

    Creates some geometry and parents it to render2d to show
    the currently-known mouse position.  Useful if the mouse
    pointer is invisible for some reason.

def enableSoundEffects | ( |  | self,
|  |  | bEnableSoundEffects
| ) |  |

def exitfunc | ( |  | self | ) |

    This should be assigned to sys.exitfunc to be called just
    before Python shutdown.  It guarantees that the Panda window
    is closed cleanly, so that we free system resources, restore
    the desktop and keyboard functionality, etc.

def finalizeExit | ( |  | self | ) |

def getAlt | ( |  | self | ) |

def getAspectRatio | ( |  | self,
|  |  | win = `None`
| ) |  |

def getAxes | ( |  | self | ) |

def getBackgroundColor | ( |  | self,
|  |  | win = `None`
| ) |  |

    Returns the current window background color.  This assumes
    the window is set up to clear the color each frame (this is
    the normal setting).

def getControl | ( |  | self | ) |

def getExitErrorCode | ( |  | self | ) |

def getMeta | ( |  | self | ) |

def getRepository | ( |  | self | ) |

def getShift | ( |  | self | ) |

def getSize | ( |  | self,
|  |  | win = `None`
| ) |  |

def initShadowTrav | ( |  | self | ) |

def isParticleMgrEnabled | ( |  | self | ) |

def isPhysicsMgrEnabled | ( |  | self | ) |

def loadMusic | ( |  | self,
|  |  | name
| ) |  |

def loadSfx | ( |  | self,
|  |  | name
| ) |  |

def makeAllPipes | ( |  | self | ) |

    Creates all GraphicsPipes that the system knows about and fill up
    self.pipeList with them.

def makeCamera | ( |  | self,
|  |  | win,
|  |  | sort = `0`,
|  |  | scene = `None`,
|  |  | displayRegion = `(0, 1`,
|  |  | stereo = `None`,
|  |  | aspectRatio = `None`,
|  |  | clearDepth = `0`,
|  |  | clearColor = `None`,
|  |  | lens = `None`,
|  |  | camName = `'cam'`,
|  |  | mask = `None`,
|  |  | useCamera = `None`
| ) |  |

    Makes a new 3-d camera associated with the indicated window,
    and creates a display region in the indicated subrectangle.

    If stereo is True, then a stereo camera is created, with a
    pair of DisplayRegions.  If stereo is False, then a standard
    camera is created.  If stereo is None or omitted, a stereo
    camera is created if the window says it can render in stereo.

    If useCamera is not None, it is a NodePath to be used as the
    camera to apply to the window, rather than creating a new
    camera.

def makeCamera2d | ( |  | self,
|  |  | win,
|  |  | sort = `10`,
|  |  | displayRegion = `(0, 1`,
|  |  | coords = `(-1, 1`,
|  |  | lens = `None`,
|  |  | cameraName = `None`
| ) |  |

    Makes a new camera2d associated with the indicated window, and
    assigns it to render the indicated subrectangle of render2d.

def makeCamera2dp | ( |  | self,
|  |  | win,
|  |  | sort = `20`,
|  |  | displayRegion = `(0, 1`,
|  |  | coords = `(-1, 1`,
|  |  | lens = `None`,
|  |  | cameraName = `None`
| ) |  |

    Makes a new camera2dp associated with the indicated window, and
    assigns it to render the indicated subrectangle of render2dp.

def makeDefaultPipe | ( |  | self,
|  |  | printPipeTypes = `True`
| ) |  |

    Creates the default GraphicsPipe, which will be used to make
    windows unless otherwise specified.

def makeModulePipe | ( |  | self,
|  |  | moduleName
| ) |  |

    Returns a GraphicsPipe from the indicated module,
    e.g. 'pandagl' or 'pandadx9'.  Does not affect base.pipe or
    base.pipeList.

def movie | ( |  | self,
|  |  | namePrefix = `'movie'`,
|  |  | duration = `1.0`,
|  |  | fps = `30`,
|  |  | format = `'png'`,
|  |  | sd = `4`,
|  |  | source = `None`
| ) |  |

    Spawn a task to capture a movie using the screenshot function.
    - namePrefix will be used to form output file names (can include
      path information (e.g. '/i/beta/frames/myMovie')
    - duration is the length of the movie in seconds
    - fps is the frame rate of the resulting movie
    - format specifies output file format (e.g. png, bmp)
    - sd specifies number of significant digits for frame count in the
      output file name (e.g. if sd = 4, movie_0001.png)
    - source is the Window, Buffer, DisplayRegion, or Texture from which
      to save the resulting images.  The default is the main window.

def oobe | ( |  | self,
|  |  | cam = `None`
| ) |  |

    Enable a special "out-of-body experience" mouse-interface
    mode.  This can be used when a "god" camera is needed; it
    moves the camera node out from under its normal node and sets
    the world up in trackball state.  Button events are still sent
    to the normal mouse action node (e.g. the DriveInterface), and
    mouse events, if needed, may be sent to the normal node by
    holding down the Control key.

    This is different than useTrackball(), which simply changes
    the existing mouse action to a trackball interface.  In fact,
    OOBE mode doesn't care whether useDrive() or useTrackball() is
    in effect; it just temporarily layers a new trackball
    interface on top of whatever the basic interface is.  You can
    even switch between useDrive() and useTrackball() while OOBE
    mode is in effect.

    This is a toggle; the second time this function is called, it
    disables the mode.

def oobeCull | ( |  | self,
|  |  | cam = `None`
| ) |  |

    While in OOBE mode (see above), cull the viewing frustum as if
    it were still attached to our original camera.  This allows us
    to visualize the effectiveness of our bounding volumes.

def openDefaultWindow | ( |  | self,
|  |  | args,
|  |  | kw
| ) |  |

def openMainWindow | ( |  | self,
|  |  | args,
|  |  | kw
| ) |  |

    Creates the initial, main window for the application, and sets
    up the mouse and render2d structures appropriately for it.  If
    this method is called a second time, it will close the
    previous main window and open a new one, preserving the lens
    properties in base.camLens.

    The return value is true on success, or false on failure (in
    which case base.win may be either None, or the previous,
    closed window).

def openWindow | ( |  | self,
|  |  | props = `None`,
|  |  | fbprops = `None`,
|  |  | pipe = `None`,
|  |  | gsg = `None`,
|  |  | type = `None`,
|  |  | name = `None`,
|  |  | size = `None`,
|  |  | aspectRatio = `None`,
|  |  | makeCamera = `True`,
|  |  | keepCamera = `False`,
|  |  | scene = `None`,
|  |  | stereo = `None`,
|  |  | unexposedDraw = `None`,
|  |  | callbackWindowDict = `None`,
|  |  | requireWindow = `None`
| ) |  |

    Creates a window and adds it to the list of windows that are
    to be updated every frame.

    props is the WindowProperties that describes the window.

    type is either 'onscreen', 'offscreen', or 'none'.

    If keepCamera is true, the existing base.cam is set up to
    render into the new window.

    If keepCamera is false but makeCamera is true, a new camera is
    set up to render into the new window.

    If unexposedDraw is not None, it specifies the initial value
    of GraphicsWindow.setUnexposedDraw().

    If callbackWindowDict is not None, a CallbackGraphicWindow is
    created instead, which allows the caller to create the actual
    window with its own OpenGL context, and direct Panda's
    rendering into that window.

    If requireWindow is true, it means that the function should
    raise an exception if the window fails to open correctly.

def playMusic | ( |  | self,
|  |  | music,
|  |  | looping = `0`,
|  |  | interrupt = `1`,
|  |  | volume = `None`,
|  |  | time = `0.0`
| ) |  |

def playSfx | ( |  | self,
|  |  | sfx,
|  |  | looping = `0`,
|  |  | interrupt = `1`,
|  |  | volume = `None`,
|  |  | time = `0.0`,
|  |  | node = `None`,
|  |  | listener = `None`,
|  |  | cutoff = `None`
| ) |  |

def popCTrav | ( |  | self | ) |

def printEnvDebugInfo | ( |  | self | ) |

    Print some information about the environment that we are running
    in.  Stuff like the model paths and other paths.  Feel free to
    add stuff to this.

def pushCTrav | ( |  | self,
|  |  | cTrav
| ) |  |

def removeCameraFrustum | ( |  | self | ) |

def restart | ( |  | self,
|  |  | clusterSync = `False`,
|  |  | cluster = `None`
| ) |  |

def reviveInput | ( |  | self | ) |

    Restores inputs after a previous call to silenceInput.

def run | ( |  | self | ) |

def saveCubeMap | ( |  | self,
|  |  | namePrefix = `'cube_map_#.png'`,
|  |  | defaultFilename = `0`,
|  |  | source = `None`,
|  |  | camera = `None`,
|  |  | size = `128`,
|  |  | cameraMask = `PandaNode.getAllCameraMask()`
| ) |  |

    Similar to screenshot(), this sets up a temporary cube map
    Texture which it uses to take a series of six snapshots of the
    current scene, one in each of the six cube map directions.
    This requires rendering a new frame.

    Unlike screenshot(), source may only be a GraphicsWindow,
    GraphicsBuffer, or DisplayRegion; it may not be a Texture.

    camera should be the node to which the cubemap cameras will be
    parented.  The default is the camera associated with source,
    if source is a DisplayRegion, or base.camera otherwise.

    The return value is the filename if successful, or None if
    there is a problem.

def saveSphereMap | ( |  | self,
|  |  | namePrefix = `'spheremap.png'`,
|  |  | defaultFilename = `0`,
|  |  | source = `None`,
|  |  | camera = `None`,
|  |  | size = `256`,
|  |  | cameraMask = `PandaNode.getAllCameraMask()`,
|  |  | numVertices = `1000`
| ) |  |

    This works much like saveCubeMap(), and uses the graphics
    API's hardware cube-mapping ability to get a 360-degree view
    of the world.  But then it converts the six cube map faces
    into a single fisheye texture, suitable for applying as a
    static environment map (sphere map).

    For eye-relative static environment maps, sphere maps are
    often preferable to cube maps because they require only a
    single texture and because they are supported on a broader
    range of hardware.

    The return value is the filename if successful, or None if
    there is a problem.

def screenshot | ( |  | self,
|  |  | namePrefix = `'screenshot'`,
|  |  | defaultFilename = `1`,
|  |  | source = `None`,
|  |  | imageComment = `""`
| ) |  |

    Captures a screenshot from the main window or from the
    specified window or Texture and writes it to a filename in the
    current directory (or to a specified directory).

    If defaultFilename is True, the filename is synthesized by
    appending namePrefix to a default filename suffix (including
    the filename extension) specified in the Config variable
    screenshot-filename.  Otherwise, if defaultFilename is False,
    the entire namePrefix is taken to be the filename to write,
    and this string should include a suitable filename extension
    that will be used to determine the type of image file to
    write.

    Normally, the source is a GraphicsWindow, GraphicsBuffer or
    DisplayRegion.  If a Texture is supplied instead, it must have
    a ram image (that is, if it was generated by
    makeTextureBuffer() or makeCubeMap(), the parameter toRam
    should have been set true).  If it is a cube map texture as
    generated by makeCubeMap(), namePrefix should contain the hash
    mark ('#') character.

    The return value is the filename if successful, or None if
    there is a problem.

def SetAllSfxEnables | ( |  | self,
|  |  | bEnabled
| ) |  |

def setBackgroundColor | ( |  | self,
|  |  | r = `None`,
|  |  | g = `None`,
|  |  | b = `None`,
|  |  | a = `0.0`,
|  |  | win = `None`
| ) |  |

    Sets the window background color to the indicated value.
    This assumes the window is set up to clear the color each
    frame (this is the normal setting).

    The color may be either a VBase3 or a VBase4, or a 3-component
    tuple, or the individual r, g, b parameters.

def setFrameRateMeter | ( |  | self,
|  |  | flag
| ) |  |

    Turns on or off (according to flag) a standard frame rate
    meter in the upper-right corner of the main window.

def setMouseOnNode | ( |  | self,
|  |  | newNode
| ) |  |

def setSceneGraphAnalyzerMeter | ( |  | self,
|  |  | flag
| ) |  |

    Turns on or off (according to flag) a standard frame rate
    meter in the upper-right corner of the main window.

def setSleep | ( |  | self,
|  |  | amount
| ) |  |

    Sets up a task that calls python 'sleep' every frame.  This is a simple
    way to reduce the CPU usage (and frame rate) of a panda program.

def setupDataGraph | ( |  | self | ) |

    Creates the data graph and populates it with the basic input
    devices.

def setupMouse | ( |  | self,
|  |  | win,
|  |  | fMultiWin = `False`
| ) |  |

    Creates the structures necessary to monitor the mouse input,
    using the indicated window.  If the mouse has already been set
    up for a different window, those structures are deleted first.

    The return value is the ButtonThrower NodePath created for
    this window.

    If fMultiWin is true, then the previous mouse structures are
    not deleted; instead, multiple windows are allowed to monitor
    the mouse input.  However, in this case, the trackball
    controls are not set up, and must be set up by hand if
    desired.

def setupMouseCB | ( |  | self,
|  |  | win
| ) |  |

def setupRender | ( |  | self | ) |

    Creates the render scene graph, the primary scene graph for
    rendering 3-d geometry.

def setupRender2d | ( |  | self | ) |

    Creates the render2d scene graph, the primary scene graph for
    2-d objects and gui elements that are superimposed over the
    3-d geometry in the window.

def setupRender2dp | ( |  | self | ) |

    Creates a render2d scene graph, the secondary scene graph for
    2-d objects and gui elements that are superimposed over the
    2-d and 3-d geometry in the window.

def setupWindowControls | ( |  | self,
|  |  | winCtrl = `None`
| ) |  |

def showCameraFrustum | ( |  | self | ) |

def shutdown | ( |  | self | ) |

def silenceInput | ( |  | self | ) |

    This is a heavy-handed way of temporarily turning off
    all inputs.  Bring them back with reviveInput().

def sleepCycleTask | ( |  | self,
|  |  | task
| ) |  |

def spawnTkLoop | ( |  | self | ) |

    Call this method to hand the main loop over to Tkinter.
    This sets up a timer callback so that Panda still gets
    updated, but Tkinter owns the main loop (which seems to make
    it happier than the other way around).

def spawnWxLoop | ( |  | self | ) |

    Call this method to hand the main loop over to wxPython.
    This sets up a wxTimer callback so that Panda still gets
    updated, but wxPython owns the main loop (which seems to make
    it happier than the other way around).

def startDirect | ( |  | self,
|  |  | fWantDirect = `1`,
|  |  | fWantTk = `1`,
|  |  | fWantWx = `0`
| ) |  |

def startTk | ( |  | self,
|  |  | fWantTk = `True`
| ) |  |

def startWx | ( |  | self,
|  |  | fWantWx = `True`
| ) |  |

def textureOff | ( |  | self | ) |

def textureOn | ( |  | self | ) |

def tkRun | ( |  | self | ) |

    This method replaces base.run() after we have called
    spawnTkLoop().  Since at this point Tkinter now owns the main
    loop, this method is a call to tkRoot.mainloop().

def toggleBackface | ( |  | self | ) |

def toggleParticles | ( |  | self | ) |

def toggleShowVertices | ( |  | self | ) |

    Toggles a mode that visualizes vertex density per screen
    area.

def toggleTexMem | ( |  | self | ) |

    Toggles a handy texture memory watcher.  See TexMemWatcher
    for more information.

def toggleTexture | ( |  | self | ) |

def toggleWireframe | ( |  | self | ) |

def updateManagers | ( |  | self,
|  |  | state
| ) |  |

def useDrive | ( |  | self | ) |

    Switch mouse action to drive mode

def userExit | ( |  | self | ) |

def useTrackball | ( |  | self | ) |

    Switch mouse action to trackball mode

def windowEvent | ( |  | self,
|  |  | win
| ) |  |

def wireframeOff | ( |  | self | ) |

def wireframeOn | ( |  | self | ) |

def wxRun | ( |  | self | ) |

    This method replaces base.run() after we have called
    spawnWxLoop().  Since at this point wxPython now owns the main
    loop, this method is a call to wxApp.MainLoop().

## Member Data Documentation

a2dBackground

a2dBottom

a2dBottomCenter

a2dBottomCenterNs

a2dBottomLeft

a2dBottomLeftNs

a2dBottomRight

a2dBottomRightNs

a2dLeft

a2dLeftCenter

a2dLeftCenterNs

a2dpBottom

a2dpBottomCenter

a2dpBottomLeft

a2dpBottomRight

a2dpLeft

a2dpLeftCenter

a2dpRight

a2dpRightCenter

a2dpTop

a2dpTopCenter

a2dpTopLeft

a2dpTopRight

a2dRight

a2dRightCenter

a2dRightCenterNs

a2dTop

a2dTopCenter

a2dTopCenterNs

a2dTopLeft

a2dTopLeftNs

a2dTopRight

a2dTopRightNs

AppHasAudioFocus

appRunner

appTrav

aspect2d

aspect2dp

backfaceCullingEnabled

bboard

bufferViewer

buttonThrowers

cam

cam2d

cam2dp

camera

camera2d

camera2dp

camFrustumVis

camLens

camList

camNode

clientSleep

cluster

clusterSyncFlag

config

cTrav

cTravStack

dataRoot

dataRootNode

debugRunningMultiplier

dgTrav

direct

drive

eventMgr

exitFunc

finalExitCallbacks

frameRateMeter

graphicsEngine

guiItems

hidden

jobMgr

loader

mainDir

mainWinForeground

mainWinMinimized

messenger

mouse2cam

mouseInterface

mouseInterfaceNode

mouseWatcher

mouseWatcherNode

multiClientSleep

musicActive

musicManager

musicManagerIsValid

nextWindowIndex

tuple notify = directNotify.newCategory("ShowBase")`[static]`

oldexitfunc

oobe2cam

oobeCamera

oobeCameraTrackball

oobeCullFrustum

oobeLens

oobeMode

oobeTrackball

oobeVis

particleMgr

particleMgrEnabled

physicsMgr

physicsMgrAngular

physicsMgrEnabled

pipe

pipeList

pixel2d

pixel2dp

pointerWatcherNodes

recorder

render

render2d

render2dp

requireWindow

run

sceneGraphAnalyzerMeter

screenshotExtension

sfxActive

sfxManagerIsValidList

sfxManagerList

sfxPlayer

shadowTrav

showVertices

taskMgr

texmem

textureEnabled

timeButtonThrower

tkDelay

tkRoot

trackball

transitions

wantDirect

wantFog

wantRender2dp

wantStats

wantTk

wantWx

win

winControls

windowType

winList

wireframeEnabled

wxApp

wxTimer

All Classes Namespaces Functions Variables Enumerations Enumerator Properties