Sneed-Group/Poodletooth-iLand
1
0
Fork 0
mirror of https://github.com/Sneed-Group/Poodletooth-iLand synced 2024-12-27 05:32:41 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions
Poodletooth-iLand/panda/direct/showbase/ShowBase.py
Loudrob 02c7dc11e4 Initial commit
2015-03-03 17:10:12 -05:00

2958 lines
114 KiB
Python
Raw Blame History

"""Undocumented Module"""
__all__ = ['ShowBase', 'WindowControls']
# This module redefines the builtin import function with one
# that prints out every import it does in a hierarchical form
# Annoying and very noisy, but sometimes useful
#import VerboseImport
from pandac.PandaModules import *
# This needs to be available early for DirectGUI imports
import __builtin__
__builtin__.config = getConfigShowbase()
from direct.directnotify.DirectNotifyGlobal import *
from MessengerGlobal import *
from BulletinBoardGlobal import *
from direct.task.TaskManagerGlobal import *
from JobManagerGlobal import *
from EventManagerGlobal import *
from PythonUtil import *
from direct.showbase import PythonUtil
#from direct.interval.IntervalManager import ivalMgr
from direct.interval import IntervalManager
from InputStateGlobal import inputState
from direct.showbase.BufferViewer import BufferViewer
from direct.task import Task
from direct.directutil import Verify
from direct.showbase import GarbageReport
import EventManager
import math,sys,os
import Loader
import time
import gc
from direct.fsm import ClassicFSM
from direct.fsm import State
from direct.showbase import ExceptionVarDump
import DirectObject
import SfxPlayer
if __debug__:
from direct.directutil import DeltaProfiler
import OnScreenDebug
import AppRunnerGlobal
__builtin__.FADE_SORT_INDEX = 1000
__builtin__.NO_FADE_SORT_INDEX = 2000
# Now ShowBase is a DirectObject. We need this so ShowBase can hang
# hooks on messages, particularly on window-event. This doesn't
# *seem* to cause anyone any problems.
class ShowBase(DirectObject.DirectObject):
notify = directNotify.newCategory("ShowBase")
def __init__(self, fStartDirect = True, windowType = None):
self.__dev__ = config.GetBool('want-dev', __debug__)
__builtin__.__dev__ = self.__dev__
logStackDump = (config.GetBool('log-stack-dump', False) or
config.GetBool('client-log-stack-dump', False))
uploadStackDump = config.GetBool('upload-stack-dump', False)
if logStackDump or uploadStackDump:
ExceptionVarDump.install(logStackDump, uploadStackDump)
# Locate the directory containing the main program
self.mainDir = ExecutionEnvironment.getEnvironmentVariable("MAIN_DIR")
# The appRunner should have been created by the time ShowBase
# has been.
self.appRunner = AppRunnerGlobal.appRunner
#debug running multiplier
self.debugRunningMultiplier = 4
# Get the dconfig object
self.config = config
# Setup wantVerifyPdb as soon as reasonable:
Verify.wantVerifyPdb = self.config.GetBool('want-verify-pdb', 0)
# [gjeon] to disable sticky keys
if self.config.GetBool('disable-sticky-keys', 0):
storeAccessibilityShortcutKeys()
allowAccessibilityShortcutKeys(False)
self.printEnvDebugInfo()
vfs = VirtualFileSystem.getGlobalPtr()
self.nextWindowIndex = 1
self.__directStarted = False
self.__deadInputs = 0
# Store dconfig variables
self.sfxActive = self.config.GetBool('audio-sfx-active', 1)
self.musicActive = self.config.GetBool('audio-music-active', 1)
self.wantFog = self.config.GetBool('want-fog', 1)
self.wantRender2dp = self.config.GetBool('want-render2dp', 1)
self.screenshotExtension = self.config.GetString('screenshot-extension', 'jpg')
self.musicManager = None
self.musicManagerIsValid = None
self.sfxManagerList = []
self.sfxManagerIsValidList = []
self.wantStats = self.config.GetBool('want-pstats', 0)
self.wantTk = False
self.wantWx = False
# Fill this in with a function to invoke when the user "exits"
# the program by closing the main window.
self.exitFunc = None
# Add final-exit callbacks to this list. These will be called
# when sys.exit() is called, after Panda has unloaded, and
# just before Python is about to shut down.
self.finalExitCallbacks = []
Task.TaskManager.taskTimerVerbose = self.config.GetBool('task-timer-verbose', 0)
Task.TaskManager.extendedExceptions = self.config.GetBool('extended-exceptions', 0)
Task.TaskManager.pStatsTasks = self.config.GetBool('pstats-tasks', 0)
# Set up the TaskManager to reset the PStats clock back
# whenever we resume from a pause. This callback function is
# a little hacky, but we can't call it directly from within
# the TaskManager because he doesn't know about PStats (and
# has to run before libpanda is even loaded).
taskMgr.resumeFunc = PStatClient.resumeAfterPause
if self.__dev__:
self.__setupProfile()
# If the aspect ratio is 0 or None, it means to infer the
# aspect ratio from the window size.
# If you need to know the actual aspect ratio call base.getAspectRatio()
self.__configAspectRatio = ConfigVariableDouble('aspect-ratio', 0).getValue()
# This variable is used to see if the aspect ratio has changed when
# we get a window-event.
self.__oldAspectRatio = None
self.windowType = windowType
if self.windowType is None:
self.windowType = self.config.GetString('window-type', 'onscreen')
self.requireWindow = self.config.GetBool('require-window', 1)
# base.win is the main, or only window; base.winList is a list of
# *all* windows. Similarly with base.camList.
self.win = None
self.frameRateMeter = None
self.sceneGraphAnalyzerMeter = None
self.winList = []
self.winControls = []
self.mainWinMinimized = 0
self.mainWinForeground = 0
self.pipe = None
self.pipeList = []
self.mouse2cam = None
self.buttonThrowers = None
self.mouseWatcher = None
self.mouseWatcherNode = None
self.pointerWatcherNodes = None
self.mouseInterface = None
self.drive = None
self.trackball = None
self.texmem = None
self.showVertices = None
self.cam = None
self.cam2d = None
self.cam2dp = None
self.camera = None
self.camera2d = None
self.camera2dp = None
self.camList = []
self.camNode = None
self.camLens = None
self.camFrustumVis = None
self.direct = None
self.wxApp = None
self.tkRoot = None
# This is used for syncing multiple PCs in a distributed cluster
try:
# Has the cluster sync variable been set externally?
self.clusterSyncFlag = clusterSyncFlag
except NameError:
# Has the clusterSyncFlag been set via a config variable
self.clusterSyncFlag = self.config.GetBool('cluster-sync', 0)
self.hidden = NodePath('hidden')
self.graphicsEngine = GraphicsEngine.getGlobalPtr()
self.setupRender()
self.setupRender2d()
self.setupDataGraph()
if self.wantRender2dp:
self.setupRender2dp()
# This is a placeholder for a CollisionTraverser. If someone
# stores a CollisionTraverser pointer here, we'll traverse it
# in the collisionLoop task.
self.shadowTrav = 0
self.cTrav = 0
self.cTravStack = Stack()
# Ditto for an AppTraverser.
self.appTrav = 0
# This is the DataGraph traverser, which we might as well
# create now.
self.dgTrav = DataGraphTraverser()
# Maybe create a RecorderController to record and/or play back
# the user session.
self.recorder = None
playbackSession = self.config.GetString('playback-session', '')
recordSession = self.config.GetString('record-session', '')
if playbackSession:
self.recorder = RecorderController()
self.recorder.beginPlayback(Filename.fromOsSpecific(playbackSession))
elif recordSession:
self.recorder = RecorderController()
self.recorder.beginRecord(Filename.fromOsSpecific(recordSession))
if self.recorder:
# If we're either playing back or recording, pass the
# random seed into the system so each session will have
# the same random seed.
import random #, whrandom
seed = self.recorder.getRandomSeed()
random.seed(seed)
#whrandom.seed(seed & 0xff, (seed >> 8) & 0xff, (seed >> 16) & 0xff)
# Now that we've set up the window structures, assign an exitfunc.
self.oldexitfunc = getattr(sys, 'exitfunc', None)
sys.exitfunc = self.exitfunc
# Open the default rendering window.
if self.windowType != 'none':
props = WindowProperties.getDefault()
if (self.config.GetBool('read-raw-mice', 0)):
props.setRawMice(1)
self.openDefaultWindow(startDirect = False, props=props)
# The default is trackball mode, which is more convenient for
# ad-hoc development in Python using ShowBase. Applications
# can explicitly call base.useDrive() if they prefer a drive
# interface.
self.mouseInterface = self.trackball
self.useTrackball()
self.loader = Loader.Loader(self)
self.graphicsEngine.setDefaultLoader(self.loader.loader)
self.eventMgr = eventMgr
self.messenger = messenger
self.bboard = bulletinBoard
self.taskMgr = taskMgr
self.jobMgr = jobMgr
# Particle manager
self.particleMgr = None
self.particleMgrEnabled = 0
# Physics manager
self.physicsMgr = None
self.physicsMgrEnabled = 0
self.physicsMgrAngular = 0
self.createBaseAudioManagers()
self.createStats()
self.AppHasAudioFocus = 1
# Get a pointer to Panda's global ClockObject, used for
# synchronizing events between Python and C.
globalClock = ClockObject.getGlobalClock()
# Since we have already started up a TaskManager, and probably
# a number of tasks; and since the TaskManager had to use the
# TrueClock to tell time until this moment, make sure the
# globalClock object is exactly in sync with the TrueClock.
trueClock = TrueClock.getGlobalPtr()
globalClock.setRealTime(trueClock.getShortTime())
globalClock.tick()
# Now we can make the TaskManager start using the new globalClock.
taskMgr.globalClock = globalClock
# client CPU affinity is determined by, in order:
# - client-cpu-affinity-mask config
# - pcalt-# (# is CPU number, 0-based)
# - client-cpu-affinity config
# - auto-single-cpu-affinity config
affinityMask = self.config.GetInt('client-cpu-affinity-mask', -1)
if affinityMask != -1:
TrueClock.getGlobalPtr().setCpuAffinity(affinityMask)
else:
# this is useful on machines that perform better with each process
# assigned to a single CPU
autoAffinity = self.config.GetBool('auto-single-cpu-affinity', 0)
affinity = None
if autoAffinity and ('clientIndex' in __builtin__.__dict__):
affinity = abs(int(__builtin__.clientIndex))
else:
affinity = self.config.GetInt('client-cpu-affinity', -1)
if (affinity in (None, -1)) and autoAffinity:
affinity = 0
if affinity not in (None, -1):
# Windows XP supports a 32-bit affinity mask
TrueClock.getGlobalPtr().setCpuAffinity(1 << (affinity % 32))
# Make sure we're not making more than one ShowBase.
if 'base' in __builtin__.__dict__:
raise StandardError, "Attempt to spawn multiple ShowBase instances!"
__builtin__.base = self
__builtin__.render2d = self.render2d
__builtin__.aspect2d = self.aspect2d
__builtin__.pixel2d = self.pixel2d
__builtin__.render = self.render
__builtin__.hidden = self.hidden
__builtin__.camera = self.camera
__builtin__.loader = self.loader
__builtin__.taskMgr = self.taskMgr
__builtin__.jobMgr = self.jobMgr
__builtin__.eventMgr = self.eventMgr
__builtin__.messenger = self.messenger
__builtin__.bboard = self.bboard
# Config needs to be defined before ShowBase is constructed
#__builtin__.config = self.config
__builtin__.run = self.run
__builtin__.ostream = Notify.out()
__builtin__.directNotify = directNotify
__builtin__.giveNotify = giveNotify
__builtin__.globalClock = globalClock
__builtin__.vfs = vfs
__builtin__.cpMgr = ConfigPageManager.getGlobalPtr()
__builtin__.cvMgr = ConfigVariableManager.getGlobalPtr()
__builtin__.pandaSystem = PandaSystem.getGlobalPtr()
__builtin__.wantUberdog = base.config.GetBool('want-uberdog', 1)
if __debug__:
__builtin__.deltaProfiler = DeltaProfiler.DeltaProfiler("ShowBase")
__builtin__.onScreenDebug = OnScreenDebug.OnScreenDebug()
if self.wantRender2dp:
__builtin__.render2dp = self.render2dp
__builtin__.aspect2dp = self.aspect2dp
__builtin__.pixel2dp = self.pixel2dp
if __dev__:
ShowBase.notify.debug('__dev__ == %s' % __dev__)
else:
ShowBase.notify.info('__dev__ == %s' % __dev__)
# set up recording of Functor creation stacks in __dev__
PythonUtil.recordFunctorCreationStacks()
if __dev__ or self.config.GetBool('want-e3-hacks', False):
if self.config.GetBool('track-gui-items', True):
# dict of guiId to gui item, for tracking down leaks
self.guiItems = {}
# optionally restore the default gui sounds from 1.7.2 and earlier
if ConfigVariableBool('orig-gui-sounds', False).getValue():
from direct.gui import DirectGuiGlobals as DGG
DGG.setDefaultClickSound(self.loader.loadSfx("audio/sfx/GUI_click.wav"))
DGG.setDefaultRolloverSound(self.loader.loadSfx("audio/sfx/GUI_rollover.wav"))
# Now hang a hook on the window-event from Panda. This allows
# us to detect when the user resizes, minimizes, or closes the
# main window.
self.accept('window-event', self.windowEvent)
# Transition effects (fade, iris, etc)
import Transitions
self.transitions = Transitions.Transitions(self.loader)
if self.win:
# Setup the window controls - handy for multiwindow applications
self.setupWindowControls()
# Client sleep
sleepTime = self.config.GetFloat('client-sleep', 0.0)
self.clientSleep = 0.0
self.setSleep(sleepTime)
# Extra sleep for running 4+ clients on a single machine
# adds a sleep right after the main render in igloop
# tends to even out the frame rate and keeps it from going
# to zero in the out of focus windows
if base.config.GetBool('multi-sleep', 0):
self.multiClientSleep = 1
else:
self.multiClientSleep = 0
# Offscreen buffer viewing utility.
# This needs to be allocated even if the viewer is off.
self.bufferViewer = BufferViewer()
if self.wantRender2dp:
self.bufferViewer.setRenderParent(self.render2dp)
if self.windowType != 'none':
if fStartDirect: # [gjeon] if this is False let them start direct manually
self.__doStartDirect()
if self.config.GetBool('show-tex-mem', False):
if not self.texmem or self.texmem.cleanedUp:
self.toggleTexMem()
taskMgr.finalInit()
# Start IGLOOP
self.restart()
# add a collision traverser via pushCTrav and remove it via popCTrav
# that way the owner of the new cTrav doesn't need to hold onto the
# previous one in order to put it back
def pushCTrav(self, cTrav):
self.cTravStack.push(self.cTrav)
self.cTrav = cTrav
def popCTrav(self):
self.cTrav = self.cTravStack.pop()
def __setupProfile(self):
""" Sets up the Python profiler, if avaialable, according to
some Panda config settings. """
try:
import profile, pstats
except ImportError:
return
profile.Profile.bias = float(self.config.GetString("profile-bias","0"))
def f8(x):
return ("%"+"8.%df"%base.config.GetInt("profile-decimals",3)) % x
pstats.f8=f8
# temp; see ToonBase.py
def getExitErrorCode(self):
return 0
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.
"""
if self.config.GetBool('want-env-debug-info', 0):
print "\n\nEnvironment Debug Info {"
print "* model path:"
print getModelPath()
#print "* dna path:"
#print getDnaPath()
print "}"
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."""
for cb in self.finalExitCallbacks[:]:
cb()
# [gjeon] restore sticky key settings
if self.config.GetBool('disable-sticky-keys', 0):
allowAccessibilityShortcutKeys(True)
taskMgr.destroy()
if getattr(self, 'musicManager', None):
self.musicManager.shutdown()
self.musicManager = None
for sfxManager in self.sfxManagerList:
sfxManager.shutdown()
self.sfxManagerList = []
if getattr(self, 'loader', None):
self.loader.destroy()
self.loader = None
if getattr(self, 'graphicsEngine', None):
self.graphicsEngine.removeAllWindows()
try:
self.direct.panel.destroy()
except:
pass
if hasattr(self, 'win'):
del self.win
del self.winList
del self.pipe
vfs = VirtualFileSystem.getGlobalPtr()
vfs.unmountAll()
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.
"""
self.destroy()
if self.oldexitfunc:
self.oldexitfunc()
def makeDefaultPipe(self, printPipeTypes = True):
"""
Creates the default GraphicsPipe, which will be used to make
windows unless otherwise specified.
"""
assert self.pipe == None
selection = GraphicsPipeSelection.getGlobalPtr()
if printPipeTypes:
selection.printPipeTypes()
self.pipe = selection.makeDefaultPipe()
if not self.pipe:
self.notify.error(
"No graphics pipe is available!\n"
"Your Config.prc file must name at least one valid panda display\n"
"library via load-display or aux-display.")
self.notify.info("Default graphics pipe is %s (%s)." % (
self.pipe.getType().getName(), self.pipe.getInterfaceName()))
self.pipeList.append(self.pipe)
def makeModulePipe(self, moduleName):
"""
Returns a GraphicsPipe from the indicated module,
e.g. 'pandagl' or 'pandadx9'. Does not affect base.pipe or
base.pipeList.
"""
selection = GraphicsPipeSelection.getGlobalPtr()
return selection.makeModulePipe(moduleName)
def makeAllPipes(self):
"""
Creates all GraphicsPipes that the system knows about and fill up
self.pipeList with them.
"""
shouldPrintPipes = 0
selection = GraphicsPipeSelection.getGlobalPtr()
selection.loadAuxModules()
# First, we should make sure the default pipe exists.
if self.pipe == None:
self.makeDefaultPipe()
# Now go through the list of known pipes, and make each one if
# we don't have one already.
numPipeTypes = selection.getNumPipeTypes()
for i in range(numPipeTypes):
pipeType = selection.getPipeType(i)
# Do we already have a pipe of this type on the list?
# This operation is n-squared, but presumably there won't
# be more than a handful of pipe types, so who cares.
already = 0
for pipe in self.pipeList:
if pipe.getType() == pipeType:
already = 1
if not already:
pipe = selection.makePipe(pipeType)
if pipe:
self.notify.info("Got aux graphics pipe %s (%s)." % (
pipe.getType().getName(), pipe.getInterfaceName()))
self.pipeList.append(pipe)
else:
self.notify.info("Could not make graphics pipe %s." % (
pipeType.getName()))
def openWindow(self, props = None, fbprops = None, pipe = None, gsg = None,
host = 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.
"""
# Save this lambda here for convenience; we'll use it to call
# down to the underlying _doOpenWindow() with all of the above
# parameters.
func = lambda : self._doOpenWindow(
props = props, fbprops = fbprops, pipe = pipe, gsg = gsg,
host = host, type = type, name = name, size = size,
aspectRatio = aspectRatio, makeCamera = makeCamera,
keepCamera = keepCamera, scene = scene, stereo = stereo,
unexposedDraw = unexposedDraw,
callbackWindowDict = callbackWindowDict)
if self.win:
# If we've already opened a window before, this is just a
# pass-through to _doOpenWindow().
win = func()
self.graphicsEngine.openWindows()
return win
if type is None:
type = self.windowType
if requireWindow is None:
requireWindow = self.requireWindow
win = func()
# Give the window a chance to truly open.
self.graphicsEngine.openWindows()
if win != None and not win.isValid():
self.notify.info("Window did not open, removing.")
self.closeWindow(win)
win = None
if win == None and pipe == None:
# Try a little harder if the window wouldn't open.
self.makeAllPipes()
try:
self.pipeList.remove(self.pipe)
except ValueError:
pass
while self.win == None and self.pipeList:
self.pipe = self.pipeList[0]
self.notify.info("Trying pipe type %s (%s)" % (
self.pipe.getType(), self.pipe.getInterfaceName()))
win = func()
self.graphicsEngine.openWindows()
if win != None and not win.isValid():
self.notify.info("Window did not open, removing.")
self.closeWindow(win)
win = None
if win == None:
self.pipeList.remove(self.pipe)
if win == None:
self.notify.warning("Unable to open '%s' window." % (type))
if requireWindow:
# Unless require-window is set to false, it is an
# error not to open a window.
raise StandardError, 'Could not open window.'
else:
self.notify.info("Successfully opened window of type %s (%s)" % (
win.getType(), win.getPipe().getInterfaceName()))
return win
def _doOpenWindow(self, props = None, fbprops = None, pipe = None,
gsg = None, host = None, type = None, name = None,
size = None, aspectRatio = None,
makeCamera = True, keepCamera = False,
scene = None, stereo = None, unexposedDraw = None,
callbackWindowDict = None):
if pipe == None:
pipe = self.pipe
if pipe == None:
self.makeDefaultPipe()
pipe = self.pipe
if pipe == None:
# We couldn't get a pipe.
return None
if isinstance(gsg, GraphicsOutput):
# If the gsg is a window or buffer, it means to use the
# GSG from that buffer.
host = gsg
gsg = gsg.getGsg()
# If we are using DirectX, force a new GSG to be created,
# since at the moment DirectX seems to misbehave if we do
# not do this. This will cause a delay while all textures
# etc. are reloaded, so we should revisit this later if we
# can fix the underlying bug in our DirectX support.
if pipe.getType().getName().startswith('wdx'):
gsg = None
if type == None:
type = self.windowType
if props == None:
props = WindowProperties.getDefault()
if fbprops == None:
fbprops = FrameBufferProperties.getDefault()
if size != None:
# If we were given an explicit size, use it; otherwise,
# the size from the properties is used.
props = WindowProperties(props)
props.setSize(size[0], size[1])
if name == None:
name = 'window%s' % (self.nextWindowIndex)
self.nextWindowIndex += 1
win = None
flags = GraphicsPipe.BFFbPropsOptional
if type == 'onscreen':
flags = flags | GraphicsPipe.BFRequireWindow
elif type == 'offscreen':
flags = flags | GraphicsPipe.BFRefuseWindow
if callbackWindowDict:
flags = flags | GraphicsPipe.BFRequireCallbackWindow
if host:
assert host.isValid()
win = self.graphicsEngine.makeOutput(pipe, name, 0, fbprops,
props, flags, host.getGsg(), host)
elif gsg:
win = self.graphicsEngine.makeOutput(pipe, name, 0, fbprops,
props, flags, gsg)
else:
win = self.graphicsEngine.makeOutput(pipe, name, 0, fbprops,
props, flags)
if win == None:
# Couldn't create a window!
return None
if unexposedDraw is not None and hasattr(win, 'setUnexposedDraw'):
win.setUnexposedDraw(unexposedDraw)
if callbackWindowDict:
# If we asked for (and received) a CallbackGraphicsWindow,
# we now have to assign the callbacks, before we start
# trying to do anything with the window.
for callbackName in ['Events', 'Properties', 'Render']:
func = callbackWindowDict.get(callbackName, None)
if not func:
continue
setCallbackName = 'set%sCallback' % (callbackName)
setCallback = getattr(win, setCallbackName)
setCallback(PythonCallbackObject(func))
# We also need to set up the mouse/keyboard objects.
for inputName in callbackWindowDict.get('inputDevices', ['mouse']):
win.createInputDevice(inputName)
if hasattr(win, "requestProperties"):
win.requestProperties(props)
mainWindow = False
if self.win == None:
mainWindow = True
self.win = win
self.winList.append(win)
# Set up a 3-d camera for the window by default.
if keepCamera:
self.makeCamera(win, scene = scene, aspectRatio = aspectRatio,
stereo = stereo, useCamera = base.cam)
elif makeCamera:
self.makeCamera(win, scene = scene, aspectRatio = aspectRatio,
stereo = stereo)
messenger.send('open_window', [win, mainWindow])
if mainWindow:
messenger.send('open_main_window')
return win
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.
"""
win.setActive(False)
# First, remove all of the cameras associated with display
# regions on the window.
numRegions = win.getNumDisplayRegions()
for i in range(numRegions):
dr = win.getDisplayRegion(i)
# [gjeon] remove drc in base.direct.drList
if base.direct is not None:
for drc in base.direct.drList:
if drc.cam == dr.getCamera():
base.direct.drList.displayRegionList.remove(drc)
break
cam = NodePath(dr.getCamera())
dr.setCamera(NodePath())
if not cam.isEmpty() and \
cam.node().getNumDisplayRegions() == 0 and \
not keepCamera:
# If the camera is used by no other DisplayRegions,
# remove it.
if self.camList.count(cam) != 0:
self.camList.remove(cam)
# Don't throw away self.camera; we want to
# preserve it for reopening the window.
if cam == self.cam:
self.cam = None
if cam == self.cam2d:
self.cam2d = None
if cam == self.cam2dp:
self.cam2dp = None
cam.removeNode()
# [gjeon] remove winControl
for winCtrl in self.winControls:
if winCtrl.win == win:
self.winControls.remove(winCtrl)
break
# Now we can actually close the window.
if removeWindow:
self.graphicsEngine.removeWindow(win)
self.winList.remove(win)
mainWindow = False
if win == self.win:
mainWindow = True
self.win = None
if self.frameRateMeter:
self.frameRateMeter.clearWindow()
self.frameRateMeter = None
if self.sceneGraphAnalyzerMeter:
self.sceneGraphAnalyzerMeter.clearWindow()
self.sceneGraphAnalyzerMeter = None
messenger.send('close_window', [win, mainWindow])
if mainWindow:
messenger.send('close_main_window')
if not self.winList:
# Give the window(s) a chance to actually close before we
# continue.
base.graphicsEngine.renderFrame()
def openDefaultWindow(self, *args, **kw):
# Creates the main window for the first time, without being
# too particular about the kind of graphics API that is
# chosen. The suggested window type from the load-display
# config variable is tried first; if that fails, the first
# window type that can be successfully opened at all is
# accepted. Returns true on success, false otherwise.
#
# This is intended to be called only once, at application
# startup. It is normally called automatically unless
# window-type is configured to 'none'.
startDirect = kw.get('startDirect', True)
if 'startDirect' in kw:
del kw['startDirect']
self.openMainWindow(*args, **kw)
if startDirect:
self.__doStartDirect()
return self.win != None
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).
"""
keepCamera = kw.get('keepCamera', False)
success = 1
oldWin = self.win
oldLens = self.camLens
oldClearColorActive = None
if self.win != None:
# Close the previous window.
oldClearColorActive = self.win.getClearColorActive()
oldClearColor = VBase4(self.win.getClearColor())
oldClearDepthActive = self.win.getClearDepthActive()
oldClearDepth = self.win.getClearDepth()
oldClearStencilActive = self.win.getClearStencilActive()
oldClearStencil = self.win.getClearStencil()
self.closeWindow(self.win, keepCamera = keepCamera)
# Open a new window.
self.openWindow(*args, **kw)
if self.win == None:
self.win = oldWin
self.winList.append(oldWin)
success = 0
if self.win != None:
if isinstance(self.win, GraphicsWindow):
self.setupMouse(self.win)
self.makeCamera2d(self.win)
self.makeCamera2dp(self.win)
if oldLens != None:
# Restore the previous lens properties.
self.camNode.setLens(oldLens)
self.camLens = oldLens
if oldClearColorActive != None:
# Restore the previous clear properties.
self.win.setClearColorActive(oldClearColorActive)
self.win.setClearColor(oldClearColor)
self.win.setClearDepthActive(oldClearDepthActive)
self.win.setClearDepth(oldClearDepth)
self.win.setClearStencilActive(oldClearStencilActive)
self.win.setClearStencil(oldClearStencil)
flag = self.config.GetBool('show-frame-rate-meter', False)
if self.appRunner is not None and self.appRunner.allowPythonDev:
# In an allow_python_dev p3d application, we always
# start up with the frame rate meter enabled, to
# provide a visual reminder that this flag has been
# set.
flag = True
self.setFrameRateMeter(flag)
flag = self.config.GetBool('show-scene-graph-analyzer-meter', False)
self.setSceneGraphAnalyzerMeter(flag)
return success
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.
"""
if (self.clientSleep == amount):
return
self.clientSleep = amount
if (amount == 0.0):
self.taskMgr.remove('clientSleep')
else:
# Spawn it after igloop (at the end of each frame)
self.taskMgr.remove('clientSleep')
self.taskMgr.add(self.sleepCycleTask, 'clientSleep', sort = 55)
def sleepCycleTask(self, task):
Thread.sleep(self.clientSleep)
#time.sleep(self.clientSleep)
return Task.cont
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.
"""
if flag:
if not self.frameRateMeter:
self.frameRateMeter = FrameRateMeter('frameRateMeter')
self.frameRateMeter.setupWindow(self.win)
else:
if self.frameRateMeter:
self.frameRateMeter.clearWindow()
self.frameRateMeter = None
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.
"""
if flag:
if not self.sceneGraphAnalyzerMeter:
self.sceneGraphAnalyzerMeter = SceneGraphAnalyzerMeter('sceneGraphAnalyzerMeter', self.render.node())
self.sceneGraphAnalyzerMeter.setupWindow(self.win)
else:
if self.sceneGraphAnalyzerMeter:
self.sceneGraphAnalyzerMeter.clearWindow()
self.sceneGraphAnalyzerMeter = None
# [gjeon] now you can add more winControls after creating a showbase instance
def setupWindowControls(self, winCtrl=None):
if winCtrl is None:
winCtrl = WindowControls(
self.win, mouseWatcher=self.mouseWatcher,
cam=self.camera, camNode = self.camNode, cam2d=self.camera2d,
mouseKeyboard = self.dataRoot.find("**/*"))
self.winControls.append(winCtrl)
def setupRender(self):
"""
Creates the render scene graph, the primary scene graph for
rendering 3-d geometry.
"""
self.render = NodePath('render')
self.render.setAttrib(RescaleNormalAttrib.makeDefault())
self.render.setTwoSided(0)
self.backfaceCullingEnabled = 1
self.textureEnabled = 1
self.wireframeEnabled = 0
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.
"""
self.render2d = NodePath('render2d')
# Set up some overrides to turn off certain properties which
# we probably won't need for 2-d objects.
# It's probably important to turn off the depth test, since
# many 2-d objects will be drawn over each other without
# regard to depth position.
# We used to avoid clearing the depth buffer before drawing
# render2d, but nowadays we clear it anyway, since we
# occasionally want to put 3-d geometry under render2d, and
# it's simplest (and seems to be easier on graphics drivers)
# if the 2-d scene has been cleared first.
self.render2d.setDepthTest(0)
self.render2d.setDepthWrite(0)
self.render2d.setMaterialOff(1)
self.render2d.setTwoSided(1)
# The normal 2-d DisplayRegion has an aspect ratio that
# matches the window, but its coordinate system is square.
# This means anything we parent to render2d gets stretched.
# For things where that makes a difference, we set up
# aspect2d, which scales things back to the right aspect
# ratio.
aspectRatio = self.getAspectRatio()
self.aspect2d = self.render2d.attachNewNode(PGTop("aspect2d"))
self.aspect2d.setScale(1.0 / aspectRatio, 1.0, 1.0)
self.a2dBackground = self.aspect2d.attachNewNode("a2dBackground")
# It's important to know the bounds of the aspect2d screen.
self.a2dTop = 1.0
self.a2dBottom = -1.0
self.a2dLeft = -aspectRatio
self.a2dRight = aspectRatio
self.a2dTopCenter = self.aspect2d.attachNewNode("a2dTopCenter")
self.a2dTopCenterNs = self.aspect2d.attachNewNode("a2dTopCenterNS")
self.a2dBottomCenter = self.aspect2d.attachNewNode("a2dBottomCenter")
self.a2dBottomCenterNs = self.aspect2d.attachNewNode("a2dBottomCenterNS")
self.a2dLeftCenter = self.aspect2d.attachNewNode("a2dLeftCenter")
self.a2dLeftCenterNs = self.aspect2d.attachNewNode("a2dLeftCenterNS")
self.a2dRightCenter = self.aspect2d.attachNewNode("a2dRightCenter")
self.a2dRightCenterNs = self.aspect2d.attachNewNode("a2dRightCenterNS")
self.a2dTopLeft = self.aspect2d.attachNewNode("a2dTopLeft")
self.a2dTopLeftNs = self.aspect2d.attachNewNode("a2dTopLeftNS")
self.a2dTopRight = self.aspect2d.attachNewNode("a2dTopRight")
self.a2dTopRightNs = self.aspect2d.attachNewNode("a2dTopRightNS")
self.a2dBottomLeft = self.aspect2d.attachNewNode("a2dBottomLeft")
self.a2dBottomLeftNs = self.aspect2d.attachNewNode("a2dBottomLeftNS")
self.a2dBottomRight = self.aspect2d.attachNewNode("a2dBottomRight")
self.a2dBottomRightNs = self.aspect2d.attachNewNode("a2dBottomRightNS")
# Put the nodes in their places
self.a2dTopCenter.setPos(0, 0, self.a2dTop)
self.a2dTopCenterNs.setPos(0, 0, self.a2dTop)
self.a2dBottomCenter.setPos(0, 0, self.a2dBottom)
self.a2dBottomCenterNs.setPos(0, 0, self.a2dBottom)
self.a2dLeftCenter.setPos(self.a2dLeft, 0, 0)
self.a2dLeftCenterNs.setPos(self.a2dLeft, 0, 0)
self.a2dRightCenter.setPos(self.a2dRight, 0, 0)
self.a2dRightCenterNs.setPos(self.a2dRight, 0, 0)
self.a2dTopLeft.setPos(self.a2dLeft, 0, self.a2dTop)
self.a2dTopLeftNs.setPos(self.a2dLeft, 0, self.a2dTop)
self.a2dTopRight.setPos(self.a2dRight, 0, self.a2dTop)
self.a2dTopRightNs.setPos(self.a2dRight, 0, self.a2dTop)
self.a2dBottomLeft.setPos(self.a2dLeft, 0, self.a2dBottom)
self.a2dBottomLeftNs.setPos(self.a2dLeft, 0, self.a2dBottom)
self.a2dBottomRight.setPos(self.a2dRight, 0, self.a2dBottom)
self.a2dBottomRightNs.setPos(self.a2dRight, 0, self.a2dBottom)
# This special root, pixel2d, uses units in pixels that are relative
# to the window. The upperleft corner of the window is (0, 0),
# the lowerleft corner is (xsize, -ysize), in this coordinate system.
xsize, ysize = self.getSize()
self.pixel2d = self.render2d.attachNewNode(PGTop("pixel2d"))
self.pixel2d.setPos(-1, 0, 1)
if xsize > 0 and ysize > 0:
self.pixel2d.setScale(2.0 / xsize, 1.0, 2.0 / ysize)
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.
"""
self.render2dp = NodePath('render2dp')
# Set up some overrides to turn off certain properties which
# we probably won't need for 2-d objects.
# It's probably important to turn off the depth test, since
# many 2-d objects will be drawn over each other without
# regard to depth position.
dt = DepthTestAttrib.make(DepthTestAttrib.MNone)
dw = DepthWriteAttrib.make(DepthWriteAttrib.MOff)
self.render2dp.setDepthTest(0)
self.render2dp.setDepthWrite(0)
self.render2dp.setMaterialOff(1)
self.render2dp.setTwoSided(1)
# The normal 2-d DisplayRegion has an aspect ratio that
# matches the window, but its coordinate system is square.
# This means anything we parent to render2d gets stretched.
# For things where that makes a difference, we set up
# aspect2d, which scales things back to the right aspect
# ratio.
aspectRatio = self.getAspectRatio()
self.aspect2dp = self.render2dp.attachNewNode(PGTop("aspect2dp"))
self.aspect2dp.node().setStartSort(16384)
self.aspect2dp.setScale(1.0 / aspectRatio, 1.0, 1.0)
# It's important to know the bounds of the aspect2d screen.
self.a2dpTop = 1.0
self.a2dpBottom = -1.0
self.a2dpLeft = -aspectRatio
self.a2dpRight = aspectRatio
self.a2dpTopCenter = self.aspect2dp.attachNewNode("a2dpTopCenter")
self.a2dpBottomCenter = self.aspect2dp.attachNewNode("a2dpBottomCenter")
self.a2dpLeftCenter = self.aspect2dp.attachNewNode("a2dpLeftCenter")
self.a2dpRightCenter = self.aspect2dp.attachNewNode("a2dpRightCenter")
self.a2dpTopLeft = self.aspect2dp.attachNewNode("a2dpTopLeft")
self.a2dpTopRight = self.aspect2dp.attachNewNode("a2dpTopRight")
self.a2dpBottomLeft = self.aspect2dp.attachNewNode("a2dpBottomLeft")
self.a2dpBottomRight = self.aspect2dp.attachNewNode("a2dpBottomRight")
# Put the nodes in their places
self.a2dpTopCenter.setPos(0, 0, self.a2dpTop)
self.a2dpBottomCenter.setPos(0, 0, self.a2dpBottom)
self.a2dpLeftCenter.setPos(self.a2dpLeft, 0, 0)
self.a2dpRightCenter.setPos(self.a2dpRight, 0, 0)
self.a2dpTopLeft.setPos(self.a2dpLeft, 0, self.a2dpTop)
self.a2dpTopRight.setPos(self.a2dpRight, 0, self.a2dpTop)
self.a2dpBottomLeft.setPos(self.a2dpLeft, 0, self.a2dpBottom)
self.a2dpBottomRight.setPos(self.a2dpRight, 0, self.a2dpBottom)
# This special root, pixel2d, uses units in pixels that are relative
# to the window. The upperleft corner of the window is (0, 0),
# the lowerleft corner is (xsize, -ysize), in this coordinate system.
xsize, ysize = self.getSize()
self.pixel2dp = self.render2dp.attachNewNode(PGTop("pixel2dp"))
self.pixel2dp.node().setStartSort(16384)
self.pixel2dp.setPos(-1, 0, 1)
if xsize > 0 and ysize > 0:
self.pixel2dp.setScale(2.0 / xsize, 1.0, 2.0 / ysize)
def setAspectRatio(self, aspectRatio):
""" Sets the global aspect ratio of the main window. Set it
to None to restore automatic scaling. """
self.__configAspectRatio = aspectRatio
self.adjustWindowAspectRatio(self.getAspectRatio())
def getAspectRatio(self, win = None):
# Returns the actual aspect ratio of the indicated (or main
# window), or the default aspect ratio if there is not yet a
# main window.
# If the config it set, we return that
if self.__configAspectRatio:
return self.__configAspectRatio
aspectRatio = 1
if win == None:
win = self.win
if win != None and win.hasSize() and win.getSbsLeftYSize() != 0:
aspectRatio = float(win.getSbsLeftXSize()) / float(win.getSbsLeftYSize())
else:
if win == None or not hasattr(win, "getRequestedProperties"):
props = WindowProperties.getDefault()
else:
props = win.getRequestedProperties()
if not props.hasSize():
props = WindowProperties.getDefault()
if props.hasSize() and props.getYSize() != 0:
aspectRatio = float(props.getXSize()) / float(props.getYSize())
if aspectRatio == 0:
return 1
return aspectRatio
def getSize(self, win = None):
# Returns the actual size of the indicated (or main
# window), or the default size if there is not yet a
# main window.
if win == None:
win = self.win
if win != None and win.hasSize():
return win.getXSize(), win.getYSize()
else:
if win == None or not hasattr(win, "getRequestedProperties"):
props = WindowProperties.getDefault()
else:
props = win.getRequestedProperties()
if not props.hasSize():
props = WindowProperties.getDefault()
if props.hasSize():
return props.getXSize(), props.getYSize()
def makeCamera(self, win, sort = 0, scene = None,
displayRegion = (0, 1, 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.
"""
# self.camera is the parent node of all cameras: a node that
# we can move around to move all cameras as a group.
if self.camera == None:
# We make it a ModelNode with the PTLocal flag, so that
# a wayward flatten operations won't attempt to mangle the
# camera.
self.camera = self.render.attachNewNode(ModelNode('camera'))
self.camera.node().setPreserveTransform(ModelNode.PTLocal)
__builtin__.camera = self.camera
self.mouse2cam.node().setNode(self.camera.node())
if useCamera:
# Use the existing camera node.
cam = useCamera
camNode = useCamera.node()
assert(isinstance(camNode, Camera))
lens = camNode.getLens()
cam.reparentTo(self.camera)
else:
# Make a new Camera node.
camNode = Camera(camName)
if lens == None:
lens = PerspectiveLens()
if aspectRatio == None:
aspectRatio = self.getAspectRatio(win)
lens.setAspectRatio(aspectRatio)
cam = self.camera.attachNewNode(camNode)
if lens != None:
camNode.setLens(lens)
if scene != None:
camNode.setScene(scene)
if mask != None:
if (isinstance(mask, int)):
mask = BitMask32(mask)
camNode.setCameraMask(mask)
if self.cam == None:
self.cam = cam
self.camNode = camNode
self.camLens = lens
self.camList.append(cam)
# Now, make a DisplayRegion for the camera.
if stereo is not None:
if stereo:
dr = win.makeStereoDisplayRegion(*displayRegion)
else:
dr = win.makeMonoDisplayRegion(*displayRegion)
else:
dr = win.makeDisplayRegion(*displayRegion)
dr.setSort(sort)
# By default, we do not clear 3-d display regions (the entire
# window will be cleared, which is normally sufficient). But
# we will if clearDepth is specified.
if clearDepth:
dr.setClearDepthActive(1)
if clearColor:
dr.setClearColorActive(1)
dr.setClearColor(clearColor)
dr.setCamera(cam)
return cam
def makeCamera2d(self, win, sort = 10,
displayRegion = (0, 1, 0, 1), coords = (-1, 1, -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.
"""
dr = win.makeMonoDisplayRegion(*displayRegion)
dr.setSort(sort)
# Enable clearing of the depth buffer on this new display
# region (see the comment in setupRender2d, above).
dr.setClearDepthActive(1)
# Make any texture reloads on the gui come up immediately.
dr.setIncompleteRender(False)
left, right, bottom, top = coords
# Now make a new Camera node.
if (cameraName):
cam2dNode = Camera('cam2d_' + cameraName)
else:
cam2dNode = Camera('cam2d')
if lens == None:
lens = OrthographicLens()
lens.setFilmSize(right - left, top - bottom)
lens.setFilmOffset((right + left) * 0.5, (top + bottom) * 0.5)
lens.setNearFar(-1000, 1000)
cam2dNode.setLens(lens)
# self.camera2d is the analog of self.camera, although it's
# not as clear how useful it is.
if self.camera2d == None:
self.camera2d = self.render2d.attachNewNode('camera2d')
camera2d = self.camera2d.attachNewNode(cam2dNode)
dr.setCamera(camera2d)
if self.cam2d == None:
self.cam2d = camera2d
return camera2d
def makeCamera2dp(self, win, sort = 20,
displayRegion = (0, 1, 0, 1), coords = (-1, 1, -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.
"""
dr = win.makeMonoDisplayRegion(*displayRegion)
dr.setSort(sort)
# Unlike render2d, we don't clear the depth buffer for
# render2dp. Caveat emptor.
if hasattr(dr, 'setIncompleteRender'):
dr.setIncompleteRender(False)
left, right, bottom, top = coords
# Now make a new Camera node.
if (cameraName):
cam2dNode = Camera('cam2dp_' + cameraName)
else:
cam2dNode = Camera('cam2dp')
if lens == None:
lens = OrthographicLens()
lens.setFilmSize(right - left, top - bottom)
lens.setFilmOffset((right + left) * 0.5, (top + bottom) * 0.5)
lens.setNearFar(-1000, 1000)
cam2dNode.setLens(lens)
# self.camera2d is the analog of self.camera, although it's
# not as clear how useful it is.
if self.camera2dp == None:
self.camera2dp = self.render2dp.attachNewNode('camera2dp')
camera2dp = self.camera2dp.attachNewNode(cam2dNode)
dr.setCamera(camera2dp)
if self.cam2dp == None:
self.cam2dp = camera2dp
return camera2dp
def setupDataGraph(self):
"""
Creates the data graph and populates it with the basic input
devices.
"""
self.dataRoot = NodePath('dataRoot')
# Cache the node so we do not ask for it every frame
self.dataRootNode = self.dataRoot.node()
# Now we have the main trackball & drive interfaces.
# useTrackball() and useDrive() switch these in and out; only
# one is in use at a given time.
self.trackball = NodePath(Trackball('trackball'))
self.drive = NodePath(DriveInterface('drive'))
self.mouse2cam = NodePath(Transform2SG('mouse2cam'))
# [gjeon] now you can create multiple mouse watchers to support multiple windows
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.
"""
if not fMultiWin and self.buttonThrowers != None:
for bt in self.buttonThrowers:
mw = bt.getParent()
mk = mw.getParent()
bt.removeNode()
mw.removeNode()
mk.removeNode()
bts, pws = self.setupMouseCB(win)
if fMultiWin:
return bts[0]
self.buttonThrowers = bts[:]
self.pointerWatcherNodes = pws[:]
self.mouseWatcher = self.buttonThrowers[0].getParent()
self.mouseWatcherNode = self.mouseWatcher.node()
if self.mouseInterface:
self.mouseInterface.reparentTo(self.mouseWatcher)
if self.recorder:
# If we have a recorder, the mouseWatcher belongs under a
# special MouseRecorder node, which may intercept the
# mouse activity.
mw = self.buttonThrowers[0].getParent()
mouseRecorder = MouseRecorder('mouse')
self.recorder.addRecorder(
'mouse', mouseRecorder.upcastToRecorderBase())
np = mw.getParent().attachNewNode(mouseRecorder)
mw.reparentTo(np)
# A special ButtonThrower to generate keyboard events and
# include the time from the OS. This is separate only to
# support legacy code that did not expect a time parameter; it
# will eventually be folded into the normal ButtonThrower,
# above.
mw = self.buttonThrowers[0].getParent()
self.timeButtonThrower = mw.attachNewNode(ButtonThrower('timeButtons'))
self.timeButtonThrower.node().setPrefix('time-')
self.timeButtonThrower.node().setTimeFlag(1)
# Tell the gui system about our new mouse watcher.
self.aspect2d.node().setMouseWatcher(mw.node())
self.aspect2dp.node().setMouseWatcher(mw.node())
self.pixel2d.node().setMouseWatcher(mw.node())
self.pixel2dp.node().setMouseWatcher(mw.node())
mw.node().addRegion(PGMouseWatcherBackground())
return self.buttonThrowers[0]
# [gjeon] this function is seperated from setupMouse to allow multiple mouse watchers
def setupMouseCB(self, win):
# For each mouse/keyboard device, we create
# - MouseAndKeyboard
# - MouseWatcher
# - ButtonThrower
# The ButtonThrowers are stored in a list, self.buttonThrowers.
# Given a ButtonThrower, one can access the MouseWatcher and
# MouseAndKeyboard using getParent.
#
# The MouseAndKeyboard generates mouse events and mouse
# button/keyboard events; the MouseWatcher passes them through
# unchanged when the mouse is not over a 2-d button, and passes
# nothing through when the mouse *is* over a 2-d button. Therefore,
# objects that don't want to get events when the mouse is over a
# button, like the driveInterface, should be parented to
# MouseWatcher, while objects that want events in all cases, like the
# chat interface, should be parented to the MouseAndKeyboard.
buttonThrowers = []
pointerWatcherNodes = []
for i in range(win.getNumInputDevices()):
name = win.getInputDeviceName(i)
mk = self.dataRoot.attachNewNode(MouseAndKeyboard(win, i, name))
mw = mk.attachNewNode(MouseWatcher("watcher%s" % (i)))
if win.getSideBySideStereo():
# If the window has side-by-side stereo enabled, then
# we should constrain the MouseWatcher to the window's
# DisplayRegion. This will enable the MouseWatcher to
# track the left and right halves of the screen
# individually.
mw.node().setDisplayRegion(win.getOverlayDisplayRegion())
mb = mw.node().getModifierButtons()
mb.addButton(KeyboardButton.shift())
mb.addButton(KeyboardButton.control())
mb.addButton(KeyboardButton.alt())
mb.addButton(KeyboardButton.meta())
mw.node().setModifierButtons(mb)
bt = mw.attachNewNode(ButtonThrower("buttons%s" % (i)))
if (i != 0):
bt.node().setPrefix('mousedev%s-' % (i))
mods = ModifierButtons()
mods.addButton(KeyboardButton.shift())
mods.addButton(KeyboardButton.control())
mods.addButton(KeyboardButton.alt())
mods.addButton(KeyboardButton.meta())
bt.node().setModifierButtons(mods)
buttonThrowers.append(bt)
if (win.hasPointer(i)):
pointerWatcherNodes.append(mw.node())
return buttonThrowers, pointerWatcherNodes
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.
"""
mouseViz = render2d.attachNewNode('mouseViz')
lilsmiley = loader.loadModel('lilsmiley')
lilsmiley.reparentTo(mouseViz)
aspectRatio = self.getAspectRatio()
# Scale the smiley face to 32x32 pixels.
height = self.win.getSbsLeftYSize()
lilsmiley.setScale(
32.0 / height / aspectRatio,
1.0, 32.0 / height)
self.mouseWatcherNode.setGeometry(mouseViz.node())
def getAlt(self):
return self.mouseWatcherNode.getModifierButtons().isDown(
KeyboardButton.alt())
def getShift(self):
return self.mouseWatcherNode.getModifierButtons().isDown(
KeyboardButton.shift())
def getControl(self):
return self.mouseWatcherNode.getModifierButtons().isDown(
KeyboardButton.control())
def getMeta(self):
return self.mouseWatcherNode.getModifierButtons().isDown(
KeyboardButton.meta())
def addAngularIntegrator(self):
if not self.physicsMgrAngular:
self.physicsMgrAngular = 1
integrator = AngularEulerIntegrator()
self.physicsMgr.attachAngularIntegrator(integrator)
def enableParticles(self):
if not self.particleMgrEnabled:
if not self.particleMgr:
from direct.particles.ParticleManagerGlobal import particleMgr
self.particleMgr = particleMgr
self.particleMgr.setFrameStepping(1)
if not self.physicsMgr:
from PhysicsManagerGlobal import physicsMgr
self.physicsMgr = physicsMgr
integrator = LinearEulerIntegrator()
self.physicsMgr.attachLinearIntegrator(integrator)
self.particleMgrEnabled = 1
self.physicsMgrEnabled = 1
self.taskMgr.remove('manager-update')
self.taskMgr.add(self.updateManagers, 'manager-update')
def disableParticles(self):
if self.particleMgrEnabled:
self.particleMgrEnabled = 0
self.physicsMgrEnabled = 0
self.taskMgr.remove('manager-update')
def toggleParticles(self):
if self.particleMgrEnabled == 0:
self.enableParticles()
else:
self.disableParticles()
def isParticleMgrEnabled(self):
return self.particleMgrEnabled
def isPhysicsMgrEnabled(self):
return self.physicsMgrEnabled
def updateManagers(self, state):
dt = globalClock.getDt()
if (self.particleMgrEnabled == 1):
self.particleMgr.doParticles(dt)
if (self.physicsMgrEnabled == 1):
self.physicsMgr.doPhysics(dt)
return Task.cont
def createStats(self, hostname=None, port=None):
# You can specify pstats-host in your Config.prc or use ~pstats/~aipstats
# The default is localhost
if not self.wantStats:
return False
if PStatClient.isConnected():
PStatClient.disconnect()
# these default values match the C++ default values
if hostname is None:
hostname = ''
if port is None:
port = -1
PStatClient.connect(hostname, port)
return PStatClient.isConnected()
def addSfxManager(self, extraSfxManager):
# keep a list of sfx manager objects to apply settings to,
# since there may be others in addition to the one we create here
self.sfxManagerList.append(extraSfxManager)
newSfxManagerIsValid = (extraSfxManager!=None) and extraSfxManager.isValid()
self.sfxManagerIsValidList.append(newSfxManagerIsValid)
if newSfxManagerIsValid:
extraSfxManager.setActive(self.sfxActive)
def createBaseAudioManagers(self):
self.sfxPlayer = SfxPlayer.SfxPlayer()
sfxManager = AudioManager.createAudioManager()
self.addSfxManager(sfxManager)
self.musicManager = AudioManager.createAudioManager()
self.musicManagerIsValid=self.musicManager!=None \
and self.musicManager.isValid()
if self.musicManagerIsValid:
# ensure only 1 midi song is playing at a time:
self.musicManager.setConcurrentSoundLimit(1)
self.musicManager.setActive(self.musicActive)
# enableMusic/enableSoundEffects are meant to be called in response
# to a user request so sfxActive/musicActive represent how things
# *should* be, regardless of App/OS/HW state
def enableMusic(self, bEnableMusic):
# don't setActive(1) if no audiofocus
if self.AppHasAudioFocus and self.musicManagerIsValid:
self.musicManager.setActive(bEnableMusic)
self.musicActive = bEnableMusic
if bEnableMusic:
# This is useful when we want to play different music
# from what the manager has queued
messenger.send("MusicEnabled")
self.notify.debug("Enabling music")
else:
self.notify.debug("Disabling music")
def SetAllSfxEnables(self, bEnabled):
for i in range(len(self.sfxManagerList)):
if (self.sfxManagerIsValidList[i]):
self.sfxManagerList[i].setActive(bEnabled)
def enableSoundEffects(self, bEnableSoundEffects):
# don't setActive(1) if no audiofocus
if self.AppHasAudioFocus or (bEnableSoundEffects==0):
self.SetAllSfxEnables(bEnableSoundEffects)
self.sfxActive=bEnableSoundEffects
if bEnableSoundEffects:
self.notify.debug("Enabling sound effects")
else:
self.notify.debug("Disabling sound effects")
# enable/disableAllAudio allow a programmable global override-off
# for current audio settings. they're meant to be called when app
# loses audio focus (switched out), so we can turn off sound without
# affecting internal sfxActive/musicActive sound settings, so things
# come back ok when the app is switched back to
def disableAllAudio(self):
self.AppHasAudioFocus = 0
self.SetAllSfxEnables(0)
if self.musicManagerIsValid:
self.musicManager.setActive(0)
self.notify.debug("Disabling audio")
def enableAllAudio(self):
self.AppHasAudioFocus = 1
self.SetAllSfxEnables(self.sfxActive)
if self.musicManagerIsValid:
self.musicManager.setActive(self.musicActive)
self.notify.debug("Enabling audio")
# This function should only be in the loader but is here for
# backwards compatibility. Please do not add code here, add
# it to the loader.
def loadSfx(self, name):
return self.loader.loadSfx(name)
# This function should only be in the loader but is here for
# backwards compatibility. Please do not add code here, add
# it to the loader.
def loadMusic(self, name):
return self.loader.loadMusic(name)
def playSfx(
self, sfx, looping = 0, interrupt = 1, volume = None,
time = 0.0, node = None, listener = None, cutoff = None):
# This goes through a special player for potential localization
return self.sfxPlayer.playSfx(sfx, looping, interrupt, volume, time, node, listener, cutoff)
def playMusic(self, music, looping = 0, interrupt = 1, volume = None, time = 0.0):
if music:
if volume != None:
music.setVolume(volume)
# if interrupt was set to 0, start over even if it's
# already playing
if interrupt or (music.status() != AudioSound.PLAYING):
music.setTime(time)
music.setLoop(looping)
music.play()
def __resetPrevTransform(self, state):
# Clear out the previous velocity deltas now, after we have
# rendered (the previous frame). We do this after the render,
# so that we have a chance to draw a representation of spheres
# along with their velocities. At the beginning of the frame
# really means after the command prompt, which allows the user
# to interactively query these deltas meaningfully.
PandaNode.resetAllPrevTransform()
return Task.cont
def __dataLoop(self, state):
# traverse the data graph. This reads all the control
# inputs (from the mouse and keyboard, for instance) and also
# directly acts upon them (for instance, to move the avatar).
self.dgTrav.traverse(self.dataRootNode)
return Task.cont
def __ivalLoop(self, state):
# Execute all intervals in the global ivalMgr.
IntervalManager.ivalMgr.step()
return Task.cont
def initShadowTrav(self):
if not self.shadowTrav:
# set up the shadow collision traverser
self.shadowTrav = CollisionTraverser("base.shadowTrav")
self.shadowTrav.setRespectPrevTransform(False)
def __shadowCollisionLoop(self, state):
# run the collision traversal if we have a
# CollisionTraverser set.
if self.shadowTrav:
self.shadowTrav.traverse(self.render)
return Task.cont
def __collisionLoop(self, state):
# run the collision traversal if we have a
# CollisionTraverser set.
if self.cTrav:
self.cTrav.traverse(self.render)
if self.appTrav:
self.appTrav.traverse(self.render)
if self.shadowTrav:
self.shadowTrav.traverse(self.render)
messenger.send("collisionLoopFinished")
return Task.cont
def __audioLoop(self, state):
if (self.musicManager != None):
self.musicManager.update()
for x in self.sfxManagerList:
x.update()
return Task.cont
def __garbageCollectStates(self, state):
""" This task is started only when we have
garbage-collect-states set in the Config.prc file, in which
case we're responsible for taking out Panda's garbage from
time to time. This is not to be confused with Python's
garbage collection. """
TransformState.garbageCollect()
RenderState.garbageCollect()
return Task.cont
def __igLoop(self, state):
# We render the watch variables for the onScreenDebug as soon
# as we reasonably can before the renderFrame().
onScreenDebug.render()
if self.recorder:
self.recorder.recordFrame()
# Finally, render the frame.
self.graphicsEngine.renderFrame()
if self.clusterSyncFlag:
self.graphicsEngine.syncFrame()
if self.multiClientSleep:
time.sleep(0)
# We clear the text buffer for the onScreenDebug as soon
# as we reasonably can after the renderFrame().
onScreenDebug.clear()
if self.recorder:
self.recorder.playFrame()
if self.mainWinMinimized:
# If the main window is minimized, slow down the app a bit
# by sleeping here in igLoop so we don't use all available
# CPU needlessly.
# Note: this isn't quite right if multiple windows are
# open. We should base this on whether *all* windows are
# minimized, not just the main window. But it will do for
# now until someone complains.
time.sleep(0.1)
# Lerp stuff needs this event, and it must be generated in
# C++, not in Python.
throwNewFrame()
return Task.cont
def __igLoopSync(self, state):
# We render the watch variables for the onScreenDebug as soon
# as we reasonably can before the renderFrame().
onScreenDebug.render()
if self.recorder:
self.recorder.recordFrame()
self.cluster.collectData()
# Finally, render the frame.
self.graphicsEngine.renderFrame()
if self.clusterSyncFlag:
self.graphicsEngine.syncFrame()
if self.multiClientSleep:
time.sleep(0)
# We clear the text buffer for the onScreenDebug as soon
# as we reasonably can after the renderFrame().
onScreenDebug.clear()
if self.recorder:
self.recorder.playFrame()
if self.mainWinMinimized:
# If the main window is minimized, slow down the app a bit
# by sleeping here in igLoop so we don't use all available
# CPU needlessly.
# Note: this isn't quite right if multiple windows are
# open. We should base this on whether *all* windows are
# minimized, not just the main window. But it will do for
# now until someone complains.
time.sleep(0.1)
self.graphicsEngine.readyFlip()
self.cluster.waitForFlipCommand()
self.graphicsEngine.flipFrame()
# Lerp stuff needs this event, and it must be generated in
# C++, not in Python.
throwNewFrame()
return Task.cont
def restart(self,clusterSync=False,cluster=None):
self.shutdown()
# __resetPrevTransform goes at the very beginning of the frame.
self.taskMgr.add(
self.__resetPrevTransform, 'resetPrevTransform', sort = -51)
# give the dataLoop task a reasonably "early" sort,
# so that it will get run before most tasks
self.taskMgr.add(self.__dataLoop, 'dataLoop', sort = -50)
self.__deadInputs = 0
# spawn the ivalLoop with a later sort, so that it will
# run after most tasks, but before igLoop.
self.taskMgr.add(self.__ivalLoop, 'ivalLoop', sort = 20)
# make the collisionLoop task run before igLoop,
# but leave enough room for the app to insert tasks
# between collisionLoop and igLoop
self.taskMgr.add(self.__collisionLoop, 'collisionLoop', sort = 30)
if ConfigVariableBool('garbage-collect-states').getValue():
self.taskMgr.add(self.__garbageCollectStates, 'garbageCollectStates', sort = 46)
# give the igLoop task a reasonably "late" sort,
# so that it will get run after most tasks
self.cluster = cluster
if (not clusterSync or (cluster == None)):
self.taskMgr.add(self.__igLoop, 'igLoop', sort = 50)
else:
self.taskMgr.add(self.__igLoopSync, 'igLoop', sort = 50)
# the audioLoop updates the positions of 3D sounds.
# as such, it needs to run after the cull traversal in the igLoop.
self.taskMgr.add(self.__audioLoop, 'audioLoop', sort = 60)
self.eventMgr.restart()
def shutdown(self):
self.taskMgr.remove('audioLoop')
self.taskMgr.remove('igLoop')
self.taskMgr.remove('shadowCollisionLoop')
self.taskMgr.remove('collisionLoop')
self.taskMgr.remove('dataLoop')
self.taskMgr.remove('resetPrevTransform')
self.taskMgr.remove('ivalLoop')
self.taskMgr.remove('garbage_collect')
self.eventMgr.shutdown()
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).
"""
if win == None:
win = self.win
return VBase4(win.getClearColor())
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.
"""
if g != None:
color = VBase4(r, g, b, a)
else:
arg = r
if isinstance(arg, VBase4):
color = arg
else:
color = VBase4(arg[0], arg[1], arg[2], a)
if win == None:
win = self.win
if win:
win.setClearColor(color)
def toggleBackface(self):
if self.backfaceCullingEnabled:
self.backfaceCullingOff()
else:
self.backfaceCullingOn()
def backfaceCullingOn(self):
if not self.backfaceCullingEnabled:
self.render.setTwoSided(0)
self.backfaceCullingEnabled = 1
def backfaceCullingOff(self):
if self.backfaceCullingEnabled:
self.render.setTwoSided(1)
self.backfaceCullingEnabled = 0
def toggleTexture(self):
if self.textureEnabled:
self.textureOff()
else:
self.textureOn()
def textureOn(self):
self.render.clearTexture()
self.textureEnabled = 1
def textureOff(self):
self.render.setTextureOff(100)
self.textureEnabled = 0
def toggleWireframe(self):
if self.wireframeEnabled:
self.wireframeOff()
else:
self.wireframeOn()
def wireframeOn(self):
self.render.setRenderModeWireframe(100)
self.render.setTwoSided(1)
self.wireframeEnabled = 1
def wireframeOff(self):
self.render.clearRenderMode()
render.setTwoSided(not self.backfaceCullingEnabled)
self.wireframeEnabled = 0
def disableMouse(self):
"""
Temporarily disable the mouse control of the camera, either
via the drive interface or the trackball, whichever is
currently in use.
"""
# We don't reparent the drive interface or the trackball;
# whichever one was there before will remain in the data graph
# and active. This way they won't lose button events while
# the mouse is disabled. However, we do move the mouse2cam
# object out of there, so we won't be updating the camera any
# more.
if self.mouse2cam:
self.mouse2cam.detachNode()
def enableMouse(self):
"""
Reverse the effect of a previous call to disableMouse().
useDrive() also implicitly enables the mouse.
"""
if self.mouse2cam:
self.mouse2cam.reparentTo(self.mouseInterface)
def silenceInput(self):
"""
This is a heavy-handed way of temporarily turning off
all inputs. Bring them back with reviveInput().
"""
if not self.__deadInputs:
self.__deadInputs = taskMgr.remove('dataLoop')
def reviveInput(self):
"""
Restores inputs after a previous call to silenceInput.
"""
if self.__deadInputs:
self.eventMgr.doEvents()
self.dgTrav.traverse(base.dataRootNode)
self.eventMgr.eventQueue.clear()
self.taskMgr.add(self.__dataLoop, 'dataLoop', sort = -50)
self.__deadInputs = 0
def setMouseOnNode(self, newNode):
if self.mouse2cam:
self.mouse2cam.node().setNode(newNode)
def changeMouseInterface(self, changeTo):
"""
Switch mouse action
"""
# Get rid of the prior interface:
self.mouseInterface.detachNode()
# Update the mouseInterface to point to the drive
self.mouseInterface = changeTo
self.mouseInterfaceNode = self.mouseInterface.node()
# Hookup the drive to the camera.
if self.mouseWatcher:
self.mouseInterface.reparentTo(self.mouseWatcher)
if self.mouse2cam:
self.mouse2cam.reparentTo(self.mouseInterface)
def useDrive(self):
"""
Switch mouse action to drive mode
"""
if self.drive:
self.changeMouseInterface(self.drive)
# Set the height to a good eyeheight
self.mouseInterfaceNode.reset()
self.mouseInterfaceNode.setZ(4.0)
def useTrackball(self):
"""
Switch mouse action to trackball mode
"""
if self.trackball:
self.changeMouseInterface(self.trackball)
def toggleTexMem(self):
""" Toggles a handy texture memory watcher. See TexMemWatcher
for more information. """
if self.texmem and not self.texmem.cleanedUp:
self.texmem.cleanup()
self.texmem = None
return
from direct.showutil.TexMemWatcher import TexMemWatcher
self.texmem = TexMemWatcher()
def toggleShowVertices(self):
""" Toggles a mode that visualizes vertex density per screen
area. """
if self.showVertices:
# Clean up the old mode.
self.showVertices.node().setActive(0)
dr = self.showVertices.node().getDisplayRegion(0)
base.win.removeDisplayRegion(dr)
self.showVertices.removeNode()
self.showVertices = None
return
dr = base.win.makeDisplayRegion()
dr.setSort(1000)
cam = Camera('showVertices')
cam.setLens(base.camLens)
# Set up a funny state to render only vertices.
override = 100000
t = NodePath('t')
t.setColor(1, 0, 1, 0.02, override)
t.setColorScale(1, 1, 1, 1, override)
t.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOneMinusIncomingAlpha), override)
t.setAttrib(RenderModeAttrib.make(RenderModeAttrib.MPoint, 10), override)
t.setTwoSided(True, override)
t.setBin('fixed', 0, override)
t.setDepthTest(False, override)
t.setDepthWrite(False, override)
t.setLightOff(override)
t.setShaderOff(override)
t.setFogOff(override)
t.setAttrib(AntialiasAttrib.make(AntialiasAttrib.MNone), override)
t.setAttrib(RescaleNormalAttrib.make(RescaleNormalAttrib.MNone), override)
t.setTextureOff(override)
# Make the spots round, so there's less static in the display.
# This forces software point generation on many drivers, so
# it's not on by default.
if self.config.GetBool('round-show-vertices', False):
spot = PNMImage(256, 256, 1)
spot.renderSpot((1, 1, 1, 1), (0, 0, 0, 0), 0.8, 1)
tex = Texture('spot')
tex.load(spot)
tex.setFormat(tex.FAlpha)
t.setTexture(tex, override)
t.setAttrib(TexGenAttrib.make(TextureStage.getDefault(), TexGenAttrib.MPointSprite), override)
cam.setInitialState(t.getState())
cam.setCameraMask(~PandaNode.getOverallBit())
self.showVertices = self.cam.attachNewNode(cam)
dr.setCamera(self.showVertices)
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.
"""
if cam is None:
cam = self.cam
# If oobeMode was never set, set it to false and create the
# structures we need to implement OOBE.
if not hasattr(self, 'oobeMode'):
self.oobeMode = 0
self.oobeCamera = self.hidden.attachNewNode('oobeCamera')
self.oobeCameraTrackball = self.oobeCamera.attachNewNode('oobeCameraTrackball')
self.oobeLens = PerspectiveLens()
self.oobeLens.setAspectRatio(self.getAspectRatio())
self.oobeLens.setNearFar(0.1, 10000.0)
self.oobeLens.setMinFov(40)
self.oobeTrackball = NodePath(Trackball('oobeTrackball'))
self.oobe2cam = self.oobeTrackball.attachNewNode(Transform2SG('oobe2cam'))
self.oobe2cam.node().setNode(self.oobeCameraTrackball.node())
self.oobeVis = loader.loadModel('models/misc/camera', okMissing = True)
if not self.oobeVis:
# Sometimes we have default-model-extension set to
# egg, but the file might be a bam file.
self.oobeVis = loader.loadModel('models/misc/camera.bam', okMissing = True)
if not self.oobeVis:
self.oobeVis = NodePath('oobeVis')
self.oobeVis.node().setFinal(1)
self.oobeVis.setLightOff(1)
self.oobeCullFrustum = None
self.accept('oobe-down', self.__oobeButton, extraArgs = [''])
self.accept('oobe-repeat', self.__oobeButton, extraArgs = ['-repeat'])
self.accept('oobe-up', self.__oobeButton, extraArgs = ['-up'])
if self.oobeMode:
# Disable OOBE mode.
if self.oobeCullFrustum != None:
# First, disable OOBE cull mode.
self.oobeCull(cam = cam)
if self.oobeVis:
self.oobeVis.reparentTo(self.hidden)
# Restore the mouse interface node, and remove the oobe
# trackball from the data path.
self.mouseInterfaceNode.clearButton(KeyboardButton.shift())
self.oobeTrackball.detachNode()
bt = self.buttonThrowers[0].node()
bt.setSpecificFlag(1)
bt.setButtonDownEvent('')
bt.setButtonRepeatEvent('')
bt.setButtonUpEvent('')
cam.reparentTo(self.camera)
#if cam == self.cam:
# self.camNode.setLens(self.camLens)
self.oobeCamera.reparentTo(self.hidden)
self.oobeMode = 0
bboard.post('oobeEnabled', False)
else:
bboard.post('oobeEnabled', True)
try:
cameraParent = localAvatar
except:
# Make oobeCamera be a sibling of wherever camera is now.
cameraParent = self.camera.getParent()
self.oobeCamera.reparentTo(cameraParent)
self.oobeCamera.clearMat()
# Make the regular MouseInterface node respond only when
# the shift button is pressed. And the oobe node will
# respond only when shift is *not* pressed.
self.mouseInterfaceNode.requireButton(KeyboardButton.shift(), True)
self.oobeTrackball.node().requireButton(KeyboardButton.shift(), False)
self.oobeTrackball.reparentTo(self.mouseWatcher)
# Set our initial OOB position to be just behind the camera.
mat = Mat4.translateMat(0, -10, 3) * self.camera.getMat(cameraParent)
mat.invertInPlace()
self.oobeTrackball.node().setMat(mat)
cam.reparentTo(self.oobeCameraTrackball)
# Temporarily disable button events by routing them
# through the oobe filters.
bt = self.buttonThrowers[0].node()
bt.setSpecificFlag(0)
bt.setButtonDownEvent('oobe-down')
bt.setButtonRepeatEvent('oobe-repeat')
bt.setButtonUpEvent('oobe-up')
# Don't change the camera lens--keep it with the original lens.
#if cam == self.cam:
# self.camNode.setLens(self.oobeLens)
if self.oobeVis:
self.oobeVis.reparentTo(self.camera)
self.oobeMode = 1
def __oobeButton(self, suffix, button):
if button.startswith('mouse'):
# Eat mouse buttons.
return
# Transmit other buttons.
messenger.send(button + suffix)
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.
"""
if cam is None:
cam = self.cam
# First, make sure OOBE mode is enabled.
if not getattr(self, 'oobeMode', False):
self.oobe(cam = cam)
if self.oobeCullFrustum == None:
# Enable OOBE culling.
pnode = LensNode('oobeCull')
pnode.setLens(self.camLens)
pnode.showFrustum()
self.oobeCullFrustum = self.camera.attachNewNode(pnode)
# Tell the camera to cull from here instead of its own
# origin.
for c in base.camList:
c.node().setCullCenter(self.oobeCullFrustum)
if cam.node().isOfType(Camera):
cam.node().setCullCenter(self.oobeCullFrustum)
for c in cam.findAllMatches('**/+Camera'):
c.node().setCullCenter(self.oobeCullFrustum)
else:
# Disable OOBE culling.
for c in base.camList:
c.node().setCullCenter(NodePath())
if cam.node().isOfType(Camera):
cam.node().setCullCenter(self.oobeCullFrustum)
for c in cam.findAllMatches('**/+Camera'):
c.node().setCullCenter(NodePath())
self.oobeCullFrustum.removeNode()
self.oobeCullFrustum = None
def showCameraFrustum(self):
# Create a visible representation of the frustum.
self.removeCameraFrustum()
geom = self.camLens.makeGeometry()
if geom != None:
gn = GeomNode('frustum')
gn.addGeom(geom)
self.camFrustumVis = self.camera.attachNewNode(gn)
def removeCameraFrustum(self):
if self.camFrustumVis:
self.camFrustumVis.removeNode()
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.
"""
if source == None:
source = self.win
if defaultFilename:
filename = GraphicsOutput.makeScreenshotFilename(namePrefix)
else:
filename = Filename(namePrefix)
if isinstance(source, Texture):
if source.getZSize() > 1:
saved = source.write(filename, 0, 0, 1, 0)
else:
saved = source.write(filename)
else:
saved = source.saveScreenshot(filename, imageComment)
if saved:
# Announce to anybody that a screenshot has been taken
messenger.send('screenshot', [filename])
return filename
return None
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.
"""
if source == None:
source = base.win
if camera == None:
if hasattr(source, "getCamera"):
camera = source.getCamera()
if camera == None:
camera = base.camera
if hasattr(source, "getWindow"):
source = source.getWindow()
rig = NodePath(namePrefix)
buffer = source.makeCubeMap(namePrefix, size, rig, cameraMask, 1)
if buffer == None:
raise StandardError, "Could not make cube map."
# Set the near and far planes from the default lens.
lens = rig.find('**/+Camera').node().getLens()
lens.setNearFar(base.camLens.getNear(), base.camLens.getFar())
# Now render a frame to fill up the texture.
rig.reparentTo(camera)
base.graphicsEngine.openWindows()
base.graphicsEngine.renderFrame()
tex = buffer.getTexture()
saved = self.screenshot(namePrefix = namePrefix,
defaultFilename = defaultFilename,
source = tex)
base.graphicsEngine.removeWindow(buffer)
rig.removeNode()
return saved
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.
"""
if source == None:
source = base.win
if camera == None:
if hasattr(source, "getCamera"):
camera = source.getCamera()
if camera == None:
camera = base.camera
if hasattr(source, "getWindow"):
source = source.getWindow()
# First, make an offscreen buffer to convert the cube map to a
# sphere map. We make it first so we can guarantee the
# rendering order for the cube map.
toSphere = source.makeTextureBuffer(namePrefix, size, size,
Texture(), 1)
# Now make the cube map buffer.
rig = NodePath(namePrefix)
buffer = toSphere.makeCubeMap(namePrefix, size, rig, cameraMask, 0)
if buffer == None:
base.graphicsEngine.removeWindow(toSphere)
raise StandardError, "Could not make cube map."
# Set the near and far planes from the default lens.
lens = rig.find('**/+Camera').node().getLens()
lens.setNearFar(base.camLens.getNear(), base.camLens.getFar())
# Set up the scene to convert the cube map. It's just a
# simple scene, with only the FisheyeMaker object in it.
dr = toSphere.makeMonoDisplayRegion()
camNode = Camera('camNode')
lens = OrthographicLens()
lens.setFilmSize(2, 2)
lens.setNearFar(-1000, 1000)
camNode.setLens(lens)
root = NodePath('buffer')
cam = root.attachNewNode(camNode)
dr.setCamera(cam)
fm = FisheyeMaker('card')
fm.setNumVertices(numVertices)
fm.setSquareInscribed(1, 1.1)
fm.setReflection(1)
card = root.attachNewNode(fm.generate())
card.setTexture(buffer.getTexture())
# Now render a frame. This will render out the cube map and
# then apply it to the the card in the toSphere buffer.
rig.reparentTo(camera)
base.graphicsEngine.openWindows()
base.graphicsEngine.renderFrame()
# One more frame for luck.
base.graphicsEngine.renderFrame()
saved = self.screenshot(namePrefix = namePrefix,
defaultFilename = defaultFilename,
source = toSphere.getTexture())
base.graphicsEngine.removeWindow(buffer)
base.graphicsEngine.removeWindow(toSphere)
rig.removeNode()
return saved
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.
"""
globalClock.setMode(ClockObject.MNonRealTime)
globalClock.setDt(1.0/float(fps))
t = taskMgr.add(self._movieTask, namePrefix + '_task')
t.frameIndex = 0 # Frame 0 is not captured.
t.numFrames = int(duration * fps)
t.source = source
t.outputString = namePrefix + '_%0' + repr(sd) + 'd.' + format
t.setUponDeath(lambda state: globalClock.setMode(ClockObject.MNormal))
def _movieTask(self, state):
if state.frameIndex != 0:
frameName = state.outputString % state.frameIndex
self.notify.info("Capturing frame: " + frameName)
self.screenshot(namePrefix = frameName, defaultFilename = 0,
source = state.source)
state.frameIndex += 1
if state.frameIndex > state.numFrames:
return Task.done
else:
return Task.cont
def windowEvent(self, win):
if win == self.win:
properties = win.getProperties()
self.notify.info("Got window event: %s" % (repr(properties)))
if not properties.getOpen():
# If the user closes the main window, we should exit.
self.notify.info("User closed main window.")
if __dev__ and config.GetBool('auto-garbage-logging', 0):
GarbageReport.b_checkForGarbageLeaks()
self.userExit()
if properties.getForeground() and not self.mainWinForeground:
self.mainWinForeground = 1
elif not properties.getForeground() and self.mainWinForeground:
self.mainWinForeground = 0
if __dev__ and config.GetBool('auto-garbage-logging', 0):
GarbageReport.b_checkForGarbageLeaks()
if properties.getMinimized() and not self.mainWinMinimized:
# If the main window is minimized, throw an event to
# stop the music.
self.mainWinMinimized = 1
messenger.send('PandaPaused')
elif not properties.getMinimized() and self.mainWinMinimized:
# If the main window is restored, throw an event to
# restart the music.
self.mainWinMinimized = 0
messenger.send('PandaRestarted')
# If we have not forced the aspect ratio, let's see if it has
# changed and update the camera lenses and aspect2d parameters
self.adjustWindowAspectRatio(self.getAspectRatio())
# Temporary hasattr for old Pandas
if not hasattr(win, 'getSbsLeftXSize'):
self.pixel2d.setScale(2.0 / win.getXSize(), 1.0, 2.0 / win.getYSize())
self.pixel2dp.setScale(2.0 / win.getXSize(), 1.0, 2.0 / win.getYSize())
else:
self.pixel2d.setScale(2.0 / win.getSbsLeftXSize(), 1.0, 2.0 / win.getSbsLeftYSize())
self.pixel2dp.setScale(2.0 / win.getSbsLeftXSize(), 1.0, 2.0 / win.getSbsLeftYSize())
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. """
if self.__configAspectRatio:
aspectRatio = self.__configAspectRatio
if aspectRatio != self.__oldAspectRatio:
self.__oldAspectRatio = aspectRatio
# Fix up some anything that depends on the aspectRatio
if self.camLens:
self.camLens.setAspectRatio(aspectRatio)
if aspectRatio < 1:
# If the window is TALL, lets expand the top and bottom
self.aspect2d.setScale(1.0, aspectRatio, aspectRatio)
self.a2dTop = 1.0 / aspectRatio
self.a2dBottom = - 1.0 / aspectRatio
self.a2dLeft = -1
self.a2dRight = 1.0
# Don't forget 2dp
self.aspect2dp.setScale(1.0, aspectRatio, aspectRatio)
self.a2dpTop = 1.0 / aspectRatio
self.a2dpBottom = - 1.0 / aspectRatio
self.a2dpLeft = -1
self.a2dpRight = 1.0
else:
# If the window is WIDE, lets expand the left and right
self.aspect2d.setScale(1.0 / aspectRatio, 1.0, 1.0)
self.a2dTop = 1.0
self.a2dBottom = -1.0
self.a2dLeft = -aspectRatio
self.a2dRight = aspectRatio
# Don't forget 2dp
self.aspect2dp.setScale(1.0 / aspectRatio, 1.0, 1.0)
self.a2dpTop = 1.0
self.a2dpBottom = -1.0
self.a2dpLeft = -aspectRatio
self.a2dpRight = aspectRatio
# Reposition the aspect2d marker nodes
self.a2dTopCenter.setPos(0, self.a2dTop, self.a2dTop)
self.a2dBottomCenter.setPos(0, self.a2dBottom, self.a2dBottom)
self.a2dLeftCenter.setPos(self.a2dLeft, 0, 0)
self.a2dRightCenter.setPos(self.a2dRight, 0, 0)
self.a2dTopLeft.setPos(self.a2dLeft, self.a2dTop, self.a2dTop)
self.a2dTopRight.setPos(self.a2dRight, self.a2dTop, self.a2dTop)
self.a2dBottomLeft.setPos(self.a2dLeft, self.a2dBottom, self.a2dBottom)
self.a2dBottomRight.setPos(self.a2dRight, self.a2dBottom, self.a2dBottom)
# Reposition the aspect2d marker nodes
self.a2dTopCenterNs.setPos(0, self.a2dTop, self.a2dTop)
self.a2dBottomCenterNs.setPos(0, self.a2dBottom, self.a2dBottom)
self.a2dLeftCenterNs.setPos(self.a2dLeft, 0, 0)
self.a2dRightCenterNs.setPos(self.a2dRight, 0, 0)
self.a2dTopLeftNs.setPos(self.a2dLeft, self.a2dTop, self.a2dTop)
self.a2dTopRightNs.setPos(self.a2dRight, self.a2dTop, self.a2dTop)
self.a2dBottomLeftNs.setPos(self.a2dLeft, self.a2dBottom, self.a2dBottom)
self.a2dBottomRightNs.setPos(self.a2dRight, self.a2dBottom, self.a2dBottom)
# Reposition the aspect2dp marker nodes
self.a2dpTopCenter.setPos(0, self.a2dpTop, self.a2dpTop)
self.a2dpBottomCenter.setPos(0, self.a2dpBottom, self.a2dpBottom)
self.a2dpLeftCenter.setPos(self.a2dpLeft, 0, 0)
self.a2dpRightCenter.setPos(self.a2dpRight, 0, 0)
self.a2dpTopLeft.setPos(self.a2dpLeft, self.a2dpTop, self.a2dpTop)
self.a2dpTopRight.setPos(self.a2dpRight, self.a2dpTop, self.a2dpTop)
self.a2dpBottomLeft.setPos(self.a2dpLeft, self.a2dpBottom, self.a2dpBottom)
self.a2dpBottomRight.setPos(self.a2dpRight, self.a2dpBottom, self.a2dpBottom)
# If anybody needs to update their GUI, put a callback on this event
messenger.send("aspectRatioChanged")
def userExit(self):
# The user has requested we exit the program. Deal with this.
if self.exitFunc:
self.exitFunc()
self.notify.info("Exiting ShowBase.")
self.finalizeExit()
def finalizeExit(self):
sys.exit()
# [gjeon] start wxPython
def startWx(self, fWantWx = True):
fWantWx = bool(fWantWx)
if self.wantWx != fWantWx:
self.wantWx = fWantWx
if self.wantWx:
self.spawnWxLoop()
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). """
if self.wxApp:
# Don't do this twice.
return
initAppForGui()
import wx
# Create a new base.wxApp.
self.wxApp = wx.PySimpleApp(redirect = False)
if ConfigVariableBool('wx-main-loop', True):
# Put wxPython in charge of the main loop. It really
# seems to like this better; some features of wx don't
# work properly unless this is true.
# Set a timer to run the Panda frame 60 times per second.
wxFrameRate = ConfigVariableDouble('wx-frame-rate', 60.0)
self.wxTimer = wx.Timer(self.wxApp)
self.wxTimer.Start(1000.0 / wxFrameRate.getValue())
self.wxApp.Bind(wx.EVT_TIMER, self.__wxTimerCallback)
# wx is now the main loop, not us any more.
self.run = self.wxRun
self.taskMgr.run = self.wxRun
__builtin__.run = self.wxRun
if self.appRunner:
self.appRunner.run = self.wxRun
else:
# Leave Panda in charge of the main loop. This is
# friendlier for IDE's and interactive editing in general.
def wxLoop(task):
# First we need to ensure that the OS message queue is
# processed.
base.wxApp.Yield()
# Now do all the wxPython events waiting on this frame.
while base.wxApp.Pending():
base.wxApp.Dispatch()
return task.again
self.taskMgr.add(wxLoop, 'wxLoop')
def __wxTimerCallback(self, event):
if Thread.getCurrentThread().getCurrentTask():
# This happens when the wxTimer expires while igLoop is
# rendering. Ignore it.
return
self.taskMgr.step()
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(). """
if Thread.getCurrentThread().getCurrentTask():
# This happens in the p3d environment during startup.
# Ignore it.
return
self.wxApp.MainLoop()
def startTk(self, fWantTk = True):
fWantTk = bool(fWantTk)
if self.wantTk != fWantTk:
self.wantTk = fWantTk
if self.wantTk:
self.spawnTkLoop()
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). """
if self.tkRoot:
# Don't do this twice.
return
from Tkinter import tkinter
import Pmw
# Create a new Tk root.
self.tkRoot = Pmw.initialise()
__builtin__.tkroot = self.tkRoot
initAppForGui()
if ConfigVariableBool('tk-main-loop', True):
# Put Tkinter in charge of the main loop. It really
# seems to like this better; the GUI otherwise becomes
# largely unresponsive on Mac OS X unless this is true.
# Set a timer to run the Panda frame 60 times per second.
tkFrameRate = ConfigVariableDouble('tk-frame-rate', 60.0)
self.tkDelay = int(1000.0 / tkFrameRate.getValue())
self.tkRoot.after(self.tkDelay, self.__tkTimerCallback)
# wx is now the main loop, not us any more.
self.run = self.tkRun
self.taskMgr.run = self.tkRun
__builtin__.run = self.tkRun
if self.appRunner:
self.appRunner.run = self.tkRun
else:
# Leave Panda in charge of the main loop. This is
# friendlier for IDE's and interactive editing in general.
def tkLoop(task):
# Do all the tkinter events waiting on this frame
# dooneevent will return 0 if there are no more events
# waiting or 1 if there are still more.
# DONT_WAIT tells tkinter not to block waiting for events
while tkinter.dooneevent(tkinter.ALL_EVENTS | tkinter.DONT_WAIT):
pass
return task.again
self.taskMgr.add(tkLoop, 'tkLoop')
def __tkTimerCallback(self):
if not Thread.getCurrentThread().getCurrentTask():
self.taskMgr.step()
self.tkRoot.after(self.tkDelay, self.__tkTimerCallback)
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(). """
if Thread.getCurrentThread().getCurrentTask():
# This happens in the p3d environment during startup.
# Ignore it.
return
self.tkRoot.mainloop()
def startDirect(self, fWantDirect = 1, fWantTk = 1, fWantWx = 0):
self.startTk(fWantTk)
self.startWx(fWantWx)
self.wantDirect = fWantDirect
if self.wantDirect:
from direct.directtools import DirectSession
base.direct.enable()
else:
__builtin__.direct = self.direct = None
def getRepository(self):
return None
def getAxes(self):
return loader.loadModel("models/misc/xyzAxis.bam")
def __doStartDirect(self):
if self.__directStarted:
return
self.__directStarted = False
# Start Tk, Wx and DIRECT if specified by Config.prc
fTk = self.config.GetBool('want-tk', 0)
fWx = self.config.GetBool('want-wx', 0)
# Start DIRECT if specified in Config.prc or in cluster mode
fDirect = (self.config.GetBool('want-directtools', 0) or
(self.config.GetString("cluster-mode", '') != ''))
# Set fWantTk to 0 to avoid starting Tk with this call
self.startDirect(fWantDirect = fDirect, fWantTk = fTk, fWantWx = fWx)
def run(self):
# This method runs the TaskManager when self.appRunner is
# None, which is to say, when we are not running from within a
# p3d file. When we *are* within a p3d file, the Panda
# runtime has to be responsible for running the main loop, so
# we can't allow the application to do it.
if self.appRunner is None or self.appRunner.dummy or \
(self.appRunner.interactiveConsole and not self.appRunner.initialAppImport):
self.taskMgr.run()
# A class to encapsulate information necessary for multiwindow support.
class WindowControls:
def __init__(
self, win, cam=None, camNode=None, cam2d=None, mouseWatcher=None,
mouseKeyboard=None, closeCmd=lambda: 0, grid=None):
self.win = win
self.camera = cam
if camNode is None and cam is not None:
camNode = cam.node()
self.camNode = camNode
self.camera2d = cam2d
self.mouseWatcher = mouseWatcher
self.mouseKeyboard = mouseKeyboard
self.closeCommand = closeCmd
self.grid = grid
def __str__(self):
s = "window = " + str(self.win) + "\n"
s += "camera = " + str(self.camera) + "\n"
s += "camNode = " + str(self.camNode) + "\n"
s += "camera2d = " + str(self.camera2d) + "\n"
s += "mouseWatcher = " + str(self.mouseWatcher) + "\n"
s += "mouseAndKeyboard = " + str(self.mouseKeyboard) + "\n"
return s
Reference in a new issue View git blame Copy permalink