def OnInit(self): #prepare and start the p3d-wx hybrid-engine mainloop self.wxevt_loop = wx.EventLoop() self.wxevt_old_loop = wx.EventLoop.GetActive() wx.EventLoop.SetActive(self.wxevt_loop) base.taskMgr.add(self._mainLoop, "MainLoopTask") #instantiate and assign the wx UI object self.win = P3dWxWindow(size=wx.Size(640, 480)) self.SetTopWindow(self.win) #show the wx window self.win.Show(True) # is essential to let make up wx window before P3D stuff self._mainLoop() #bind wx events self.win.Bind(wx.EVT_SIZE, self.onSize) self.win.Bind(wx.EVT_CLOSE, self.onClose) self.vetoActivate=False self.win.Bind(wx.EVT_ACTIVATE, self.onActivate) #open the p3d window undecorated to use in the wx frame window wp=WindowProperties().getDefault() wp.setUndecorated(True) wp.setOpen(True) wp.setParentWindow(self.win.getP3DSurface()) wp.setOrigin(0,0) wp.setForeground(True) wp.setSize(*self.win.getP3DSurfaceSize()) print ">>>opening p3dsurface" assert base.openDefaultWindow(props=wp) == True # return True
def bindToWindow(self, windowHandle):
wp = WindowProperties().getDefault()
wp.setOrigin(0,0)
wp.setSize(P3D_WIN_WIDTH, P3D_WIN_HEIGHT)
wp.setParentWindow(windowHandle)
base.openDefaultWindow(props=wp)
self.wp = wp
def OnResize(self, event):
"""When the wx-panel is resized, fit the panda3d window into it."""
frame_size = event.GetSize()
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(frame_size.GetWidth(), frame_size.GetHeight())
self._win.requestProperties(wp)
def OnResize( self, event ):
"""When the wx-panel is resized, fit the panda3d window into it."""
frame_size = event.GetSize()
wp = WindowProperties()
wp.setOrigin( 0, 0 )
wp.setSize( frame_size.GetWidth(), frame_size.GetHeight() )
self._win.requestProperties( wp )
def OnInit(self):
#prepare and start the p3d-wx hybrid-engine mainloop
self.wxevt_loop = wx.EventLoop()
self.wxevt_old_loop = wx.EventLoop.GetActive()
wx.EventLoop.SetActive(self.wxevt_loop)
base.taskMgr.add(self._mainLoop, "MainLoopTask")
#instantiate and assign the wx UI object
self.win = P3dWxWindow(size=wx.Size(640, 480))
self.SetTopWindow(self.win)
#show the wx window
self.win.Show(True)
# is essential to let make up wx window before P3D stuff
self._mainLoop()
#bind wx events
self.win.Bind(wx.EVT_SIZE, self.onSize)
self.win.Bind(wx.EVT_CLOSE, self.onClose)
self.vetoActivate = False
self.win.Bind(wx.EVT_ACTIVATE, self.onActivate)
#open the p3d window undecorated to use in the wx frame window
wp = WindowProperties().getDefault()
wp.setUndecorated(True)
wp.setOpen(True)
wp.setParentWindow(self.win.getP3DSurface())
wp.setOrigin(0, 0)
wp.setForeground(True)
wp.setSize(*self.win.getP3DSurfaceSize())
print ">>>opening p3dsurface"
assert base.openDefaultWindow(props=wp) == True
#
return True
def resize_panda_window(self, widget, request) :
props = WindowProperties().getDefault()
props = WindowProperties(self.base.win.getProperties())
props.setOrigin(0, 0)
props.setSize(request.width, request.height)
props.setParentWindow(widget.window.xid)
self.base.win.requestProperties(props)
def launch_panda_window(panda_widget, size) :
"""
Configure and create Panda window
Connect to the gtk widget resize event
Load a panda
"""
props = WindowProperties().getDefault()
props.setOrigin(0, 0)
props.setSize(*size)
props.setParentWindow(panda_widget.window.xid)
base.openDefaultWindow(props=props)
# ==
panda_widget.connect("size_allocate", resize_panda_window)
# ==
panda = loader.loadModel("panda")
panda.reparentTo(render)
panda.setPos(0, 40, -5)
pl = render.attachNewNode( PointLight( "redPointLight" ) )
pl.node().setColor( Vec4( .9, .8, .8, 1 ) )
render.setLight(pl)
pl.node().setAttenuation( Vec3( 0, 0, 0.05 ) )
slight = Spotlight('slight')
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(2, 20, 0)
mid = PandaNode('mid')
panda.attachNewNode(mid)
# slnp.lookAt(mid)
render.setLight(slnp)
def createBuffer(self, name, xsize, ysize, texgroup, depthbits=1):
""" Low-level buffer creation. Not intended for public use. """
winprops = WindowProperties()
winprops.setSize(xsize, ysize)
props = FrameBufferProperties()
props.setRgbColor(1)
props.setDepthBits(depthbits)
depthtex, colortex, auxtex0, auxtex1 = texgroup
if (auxtex0 != None):
props.setAuxRgba(1)
if (auxtex1 != None):
props.setAuxRgba(2)
buffer=base.graphicsEngine.makeOutput(
self.win.getPipe(), name, -1,
props, winprops, GraphicsPipe.BFRefuseWindow | GraphicsPipe.BFResizeable,
self.win.getGsg(), self.win)
if (buffer == None):
return buffer
if (depthtex):
buffer.addRenderTexture(depthtex, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPDepth)
if (colortex):
buffer.addRenderTexture(colortex, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
if (auxtex0):
buffer.addRenderTexture(auxtex0, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba0)
if (auxtex1):
buffer.addRenderTexture(auxtex1, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba1)
buffer.setSort(self.nextsort)
buffer.disableClears()
buffer.getDisplayRegion(0).disableClears()
self.nextsort += 1
return buffer
def createBuffer(self, name, xsize, ysize, texgroup, depthbits=1):
""" Low-level buffer creation. Not intended for public use. """
winprops = WindowProperties()
winprops.setSize(xsize, ysize)
props = FrameBufferProperties(self.win.getFbProperties())
props.setBackBuffers(0)
props.setRgbColor(1)
props.setDepthBits(depthbits)
depthtex, colortex, auxtex0, auxtex1 = texgroup
if (auxtex0 != None):
props.setAuxRgba(1)
if (auxtex1 != None):
props.setAuxRgba(2)
buffer=base.graphicsEngine.makeOutput(
self.win.getPipe(), name, -1,
props, winprops, GraphicsPipe.BFRefuseWindow | GraphicsPipe.BFResizeable,
self.win.getGsg(), self.win)
if (buffer == None):
return buffer
if (depthtex):
buffer.addRenderTexture(depthtex, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPDepth)
if (colortex):
buffer.addRenderTexture(colortex, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
if (auxtex0):
buffer.addRenderTexture(auxtex0, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba0)
if (auxtex1):
buffer.addRenderTexture(auxtex1, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba1)
buffer.setSort(self.nextsort)
buffer.disableClears()
self.nextsort += 1
return buffer
def onSize(self, evt):
"""Invoked when the viewport is resized."""
if self.win != None:
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.ClientSize.GetWidth(), self.ClientSize.GetHeight())
self.win.requestProperties(wp)
def __init__(self):
ShowBase.__init__(self)
########## Window configuration #########
wp = WindowProperties()
wp.setSize(1024, 860)
self.win.requestProperties(wp)
########## Gameplay settings #########
self.GAME_MODE = PLAY
self.play_mode = SPACE
self.level = 1.5
self.mode_initialized = False
######### Camera #########
self.disableMouse()
self.mainCamera = Camera(self.camera)
self.mainCamera.camObject.setHpr(0, 0, 0)
#Trigger game chain
self.loadLevel(LEVEL)
######### Events #########
self.taskMgr.add(self.gameLoop, "gameLoop", priority = 35)
self.keys = {"w" : 0, "s" : 0, "a" : 0, "d" : 0, "space" : 0}
self.accept("w", self.setKey, ["w", 1])
self.accept("w-up", self.setKey, ["w", 0])
self.accept("s", self.setKey, ["s", 1])
self.accept("s-up", self.setKey, ["s", 0])
self.accept("a", self.setKey, ["a", 1])
self.accept("a-up", self.setKey, ["a", 0])
self.accept("d", self.setKey, ["d", 1])
self.accept("d-up", self.setKey, ["d", 0])
self.accept("space", self.setKey, ["space", 1])
self.accept("space-up", self.setKey, ["space", 0])
self.accept("wheel_up", self.zoomCamera, [-1])
self.accept("wheel_down", self.zoomCamera, [1])
self.accept("escape", self.switchGameMode, [IN_GAME_MENU])
self.accept("window-event", self.handleWindowEvent)
self.accept("playerGroundRayJumping-in", self.avatar.handleCollisionEvent, ["in"])
self.accept("playerGroundRayJumping-out", self.avatar.handleCollisionEvent, ["out"])
######### GUI #########
self.gui_elements = []
def resize_panda_window(self, widget, request):
props = WindowProperties().getDefault()
props = WindowProperties(self.base.win.getProperties())
props.setOrigin(0, 0)
props.setSize(request.width, request.height)
props.setParentWindow(widget.window.xid)
self.base.win.requestProperties(props)
def setupWindow(self, windowType, x, y, width, height,
parent):
""" Applies the indicated window parameters to the prc
settings, for future windows; or applies them directly to the
main window if the window has already been opened. This is
called by the browser. """
if self.started and base.win:
# If we've already got a window, this must be a
# resize/reposition request.
wp = WindowProperties()
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
if windowType == 'embedded':
wp.setParentWindow(parent)
wp.setFullscreen(False)
base.win.requestProperties(wp)
self.windowProperties = wp
return
# If we haven't got a window already, start 'er up. Apply the
# requested setting to the prc file, and to the default
# WindowProperties structure.
self.__clearWindowProperties()
if windowType == 'hidden':
data = 'window-type none\n'
else:
data = 'window-type onscreen\n'
wp = WindowProperties.getDefault()
wp.clearParentWindow()
wp.clearOrigin()
wp.clearSize()
wp.setFullscreen(False)
if windowType == 'fullscreen':
wp.setFullscreen(True)
if windowType == 'embedded':
wp.setParentWindow(parent)
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
self.windowProperties = wp
self.windowPrc = loadPrcFileData("setupWindow", data)
WindowProperties.setDefault(wp)
self.gotWindow = True
# Send this call to the main thread; don't call it directly.
messenger.send('AppRunner_startIfReady', taskChain = 'default')
def bindToWindow(self, windowHandle):
wp = WindowProperties().getDefault()
wp.setOrigin(self._x, self._y)
wp.setSize(self._width, self._height)
wp.setParentWindow(windowHandle)
base.openDefaultWindow(props=wp)
self.wp = wp
def onSize(self, evt):
"""Invoked when the viewport is resized."""
if self.win != None:
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.ClientSize.GetWidth(), self.ClientSize.GetHeight())
self.win.requestProperties(wp)
def launch_panda_window(panda_widget, size):
"""
Configure and create Panda window
Connect to the gtk widget resize event
Load a panda
"""
props = WindowProperties().getDefault()
props.setOrigin(0, 0)
props.setSize(*size)
props.setParentWindow(panda_widget.window.xid)
base.openDefaultWindow(props=props)
# ==
panda_widget.connect("size_allocate", resize_panda_window)
# ==
panda = loader.loadModel("panda")
panda.reparentTo(render)
panda.setPos(0, 40, -5)
pl = render.attachNewNode(PointLight("redPointLight"))
pl.node().setColor(Vec4(.9, .8, .8, 1))
render.setLight(pl)
pl.node().setAttenuation(Vec3(0, 0, 0.05))
slight = Spotlight('slight')
slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(2, 20, 0)
mid = PandaNode('mid')
panda.attachNewNode(mid)
# slnp.lookAt(mid)
render.setLight(slnp)
def setupWindow(self, windowType, x, y, width, height, parent):
""" Applies the indicated window parameters to the prc
settings, for future windows; or applies them directly to the
main window if the window has already been opened. This is
called by the browser. """
if self.started and base.win:
# If we've already got a window, this must be a
# resize/reposition request.
wp = WindowProperties()
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
if windowType == 'embedded':
wp.setParentWindow(parent)
wp.setFullscreen(False)
base.win.requestProperties(wp)
self.windowProperties = wp
return
# If we haven't got a window already, start 'er up. Apply the
# requested setting to the prc file, and to the default
# WindowProperties structure.
self.__clearWindowProperties()
if windowType == 'hidden':
data = 'window-type none\n'
else:
data = 'window-type onscreen\n'
wp = WindowProperties.getDefault()
wp.clearParentWindow()
wp.clearOrigin()
wp.clearSize()
wp.setFullscreen(False)
if windowType == 'fullscreen':
wp.setFullscreen(True)
if windowType == 'embedded':
wp.setParentWindow(parent)
if x or y or windowType == 'embedded':
wp.setOrigin(x, y)
if width or height:
wp.setSize(width, height)
self.windowProperties = wp
self.windowPrc = loadPrcFileData("setupWindow", data)
WindowProperties.setDefault(wp)
self.gotWindow = True
# Send this call to the main thread; don't call it directly.
messenger.send('AppRunner_startIfReady', taskChain='default')
def set(self, pipe, width, height, fullscreen, embedded):
self.notify.debugStateCall(self)
state = False
self.notify.info('SET')
if self.restrict_to_embedded:
fullscreen = 0
embedded = 1
if embedded:
if base.appRunner.windowProperties:
width = base.appRunner.windowProperties.getXSize()
height = base.appRunner.windowProperties.getYSize()
self.current_pipe = base.pipe
self.current_properties = WindowProperties(base.win.getProperties())
properties = self.current_properties
self.notify.debug('DISPLAY PREVIOUS:')
self.notify.debug(' EMBEDDED: %s' % bool(properties.getParentWindow()))
self.notify.debug(' FULLSCREEN: %s' % bool(properties.getFullscreen()))
self.notify.debug(' X SIZE: %s' % properties.getXSize())
self.notify.debug(' Y SIZE: %s' % properties.getYSize())
self.notify.debug('DISPLAY REQUESTED:')
self.notify.debug(' EMBEDDED: %s' % bool(embedded))
self.notify.debug(' FULLSCREEN: %s' % bool(fullscreen))
self.notify.debug(' X SIZE: %s' % width)
self.notify.debug(' Y SIZE: %s' % height)
if self.current_pipe == pipe and bool(self.current_properties.getParentWindow()) == bool(embedded) and self.current_properties.getFullscreen() == fullscreen and self.current_properties.getXSize() == width and self.current_properties.getYSize() == height:
self.notify.info('DISPLAY NO CHANGE REQUIRED')
state = True
else:
properties = WindowProperties()
properties.setSize(width, height)
properties.setFullscreen(fullscreen)
properties.setParentWindow(0)
if embedded:
if base.appRunner.windowProperties:
properties = base.appRunner.windowProperties
original_sort = base.win.getSort()
if self.resetWindowProperties(pipe, properties):
self.notify.debug('DISPLAY CHANGE SET')
properties = base.win.getProperties()
self.notify.debug('DISPLAY ACHIEVED:')
self.notify.debug(' EMBEDDED: %s' % bool(properties.getParentWindow()))
self.notify.debug(' FULLSCREEN: %s' % bool(properties.getFullscreen()))
self.notify.debug(' X SIZE: %s' % properties.getXSize())
self.notify.debug(' Y SIZE: %s' % properties.getYSize())
if bool(properties.getParentWindow()) == bool(embedded) and properties.getFullscreen() == fullscreen and properties.getXSize() == width and properties.getYSize() == height:
self.notify.info('DISPLAY CHANGE VERIFIED')
state = True
else:
self.notify.warning('DISPLAY CHANGE FAILED, RESTORING PREVIOUS DISPLAY')
self.restoreWindowProperties()
else:
self.notify.warning('DISPLAY CHANGE FAILED')
self.notify.warning('DISPLAY SET - BEFORE RESTORE')
self.restoreWindowProperties()
self.notify.warning('DISPLAY SET - AFTER RESTORE')
base.win.setSort(original_sort)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
return state
def set(self, pipe, width, height, fullscreen, embedded):
self.notify.debugStateCall(self)
state = False
self.notify.info('SET')
if self.restrict_to_embedded:
fullscreen = 0
embedded = 1
if embedded:
if base.appRunner.windowProperties:
width = base.appRunner.windowProperties.getXSize()
height = base.appRunner.windowProperties.getYSize()
self.current_pipe = base.pipe
self.current_properties = WindowProperties(base.win.getProperties())
properties = self.current_properties
self.notify.debug('DISPLAY PREVIOUS:')
self.notify.debug(' EMBEDDED: %s' % bool(properties.getParentWindow()))
self.notify.debug(' FULLSCREEN: %s' % bool(properties.getFullscreen()))
self.notify.debug(' X SIZE: %s' % properties.getXSize())
self.notify.debug(' Y SIZE: %s' % properties.getYSize())
self.notify.debug('DISPLAY REQUESTED:')
self.notify.debug(' EMBEDDED: %s' % bool(embedded))
self.notify.debug(' FULLSCREEN: %s' % bool(fullscreen))
self.notify.debug(' X SIZE: %s' % width)
self.notify.debug(' Y SIZE: %s' % height)
if self.current_pipe == pipe and bool(self.current_properties.getParentWindow()) == bool(embedded) and self.current_properties.getFullscreen() == fullscreen and self.current_properties.getXSize() == width and self.current_properties.getYSize() == height:
self.notify.info('DISPLAY NO CHANGE REQUIRED')
state = True
else:
properties = WindowProperties()
properties.setSize(width, height)
properties.setFullscreen(fullscreen)
properties.setParentWindow(0)
if embedded:
if base.appRunner.windowProperties:
properties = base.appRunner.windowProperties
original_sort = base.win.getSort()
if self.resetWindowProperties(pipe, properties):
self.notify.debug('DISPLAY CHANGE SET')
properties = base.win.getProperties()
self.notify.debug('DISPLAY ACHIEVED:')
self.notify.debug(' EMBEDDED: %s' % bool(properties.getParentWindow()))
self.notify.debug(' FULLSCREEN: %s' % bool(properties.getFullscreen()))
self.notify.debug(' X SIZE: %s' % properties.getXSize())
self.notify.debug(' Y SIZE: %s' % properties.getYSize())
if bool(properties.getParentWindow()) == bool(embedded) and properties.getFullscreen() == fullscreen and properties.getXSize() == width and properties.getYSize() == height:
self.notify.info('DISPLAY CHANGE VERIFIED')
state = True
else:
self.notify.warning('DISPLAY CHANGE FAILED, RESTORING PREVIOUS DISPLAY')
self.restoreWindowProperties()
else:
self.notify.warning('DISPLAY CHANGE FAILED')
self.notify.warning('DISPLAY SET - BEFORE RESTORE')
self.restoreWindowProperties()
self.notify.warning('DISPLAY SET - AFTER RESTORE')
base.win.setSort(original_sort)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
return state
def resize_panda_window(widget, request):
""" Connected to resize event of the widget Panda is draw on so that the Panda window update its size """
props = WindowProperties().getDefault()
props = WindowProperties(base.win.getProperties())
props.setOrigin(0, 0)
props.setSize(request.width, request.height)
props.setParentWindow(widget.window.xid)
base.win.requestProperties(props)
def resize_panda_window(widget, request) :
""" Connected to resize event of the widget Panda is draw on so that the Panda window update its size """
props = WindowProperties().getDefault()
props = WindowProperties(base.win.getProperties())
props.setOrigin(0, 0)
props.setSize(request.width, request.height)
props.setParentWindow(widget.window.xid)
base.win.requestProperties(props)
def onSize(self, event):
wp = WindowProperties()
wp.setOrigin(0, 0)
x,y = self.GetClientSize()
wp.setSize(x,y)
base.camLens.setAspectRatio(1.0*y/x)
base.win.requestProperties(wp)
event.Skip()
def setFullscreen(self, settings):
"""Set the window to fullscreen or windowed mode depending on the
configuration in the settings variable"""
props = WindowProperties()
props.setFullscreen(settings.fullscreen)
props.setUndecorated(settings.fullscreen)
if settings.fullscreen:
props.setSize(settings.windowSize[0], settings.windowSize[1])
base.win.requestProperties(props)
base.taskMgr.step()
def resizeWindow(self, window_id, width, height):
"""window_id is an index of a window from base.winList."""
window = self.windows[window_id]
old_wp = window.getProperties()
if old_wp.getXSize() == width and old_wp.getYSize() == height:
return
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(width, height)
window.requestProperties(wp)
def resizeWindow(self, window_id, width, height):
"""window_id is an index of a window from base.winList."""
window = self.windows[window_id]
old_wp = window.getProperties()
if old_wp.getXSize() == width and old_wp.getYSize() == height:
return
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(width, height)
window.requestProperties(wp)
def initialize(self):
self.Update()
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.ClientSize.GetWidth(), self.ClientSize.GetHeight())
assert self.GetHandle() != 0
wp.setParentWindow(self.GetHandle())
# initializing panda window
base.windowType = "onscreen"
props = WindowProperties.getDefault()
props.addProperties(wp)
self.win = base.openWindow(props = props, gsg = ViewportManager.gsg)
if self.win:
self.cam2d = base.makeCamera2d(self.win)
self.cam2d.node().setCameraMask(LE_CAM_MASKS[self.name])
if ViewportManager.gsg == None:
ViewportManager.gsg = self.win.getGsg()
self.cam = base.camList[-1]
self.camera = render.attachNewNode(self.name)
#self.camera.setName(self.name)
#self.camera.reparentTo(render)
self.cam.reparentTo(self.camera)
self.camNode = self.cam.node()
self.camNode.setCameraMask(LE_CAM_MASKS[self.name])
self.bt = base.setupMouse(self.win, True)
self.bt.node().setPrefix('_le_%s_'%self.name[:3])
mw = self.bt.getParent()
mk = mw.getParent()
winCtrl = WindowControls(
self.win, mouseWatcher=mw,
cam=self.camera,
camNode = self.camNode,
cam2d=None,
mouseKeyboard =mk,
grid = self.grid)
base.setupWindowControls(winCtrl)
self.initialized = True
if self.lens != None: self.cam.node().setLens(self.lens)
if self.camPos != None: self.camera.setPos(self.camPos)
if self.camLookAt != None: self.camera.lookAt(self.camLookAt)
self.camLens = self.camNode.getLens()
if self.name in ['top', 'front', 'left']:
x = self.ClientSize.GetWidth() * 0.1
y = self.ClientSize.GetHeight() * 0.1
self.camLens.setFilmSize(x, y)
self.Bind(wx.EVT_SIZE, self.onSize)
def initialize(self):
self.Update()
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.ClientSize.GetWidth(), self.ClientSize.GetHeight())
assert self.GetHandle() != 0
wp.setParentWindow(self.GetHandle())
# initializing panda window
base.windowType = "onscreen"
props = WindowProperties.getDefault()
props.addProperties(wp)
self.win = base.openWindow(props=props, gsg=ViewportManager.gsg)
if self.win:
self.cam2d = base.makeCamera2d(self.win)
self.cam2d.node().setCameraMask(LE_CAM_MASKS[self.name])
if ViewportManager.gsg == None:
ViewportManager.gsg = self.win.getGsg()
self.cam = base.camList[-1]
self.camera = render.attachNewNode(self.name)
#self.camera.setName(self.name)
#self.camera.reparentTo(render)
self.cam.reparentTo(self.camera)
self.camNode = self.cam.node()
self.camNode.setCameraMask(LE_CAM_MASKS[self.name])
self.bt = base.setupMouse(self.win, True)
self.bt.node().setPrefix('_le_%s_' % self.name[:3])
mw = self.bt.getParent()
mk = mw.getParent()
winCtrl = WindowControls(self.win,
mouseWatcher=mw,
cam=self.camera,
camNode=self.camNode,
cam2d=None,
mouseKeyboard=mk,
grid=self.grid)
base.setupWindowControls(winCtrl)
self.initialized = True
if self.lens != None: self.cam.node().setLens(self.lens)
if self.camPos != None: self.camera.setPos(self.camPos)
if self.camLookAt != None: self.camera.lookAt(self.camLookAt)
self.camLens = self.camNode.getLens()
if self.name in ['top', 'front', 'left']:
x = self.ClientSize.GetWidth() * 0.1
y = self.ClientSize.GetHeight() * 0.1
self.camLens.setFilmSize(x, y)
self.Bind(wx.EVT_SIZE, self.onSize)
def initWindow(self):
props = WindowProperties()
props.setTitle('Open Space Drive')
base.win.requestProperties(props)
base.pipe.getDisplayWidth()
props = WindowProperties()
props.setSize(base.pipe.getDisplayWidth(),
base.pipe.getDisplayHeight())
base.win.requestProperties(props)
base.setFrameRateMeter(True)
def fullscreen(self):
'''
Witch between Fullscreen and window mode
'''
self._conf.fullscreen = not self._conf.fullscreen
wp = WindowProperties()
wp.setFullscreen(self._conf.fullscreen)
wp.setOrigin(0, 0)
wp.setSize(int(base.pipe.getDisplayWidth()),
int(base.pipe.getDisplayHeight()))
base.win.requestProperties(wp)
self.option()
def makeGameEngine(self):
''' Creates a new game engine based on settings in GameSettings.
Information for this came from here
http://panda3d.org/phpbb2/viewtopic.php?t=2848'''
LOG.debug("[GXMgr] Building game engine")
# Temporary
# TODO: Fix this
props = WindowProperties()
props.setFullscreen(False)
props.setUndecorated(False)
#screenx = int(base.pipe.getDisplayWidth()/2) - (int(self.ScreenWidth)/2)
#screeny = int(base.pipe.getDisplayHeight()/2) - (int(self.ScreenHeight)/2)
#self.TempScreenSizeRX = int(self.ScreenWidth)
#self.TempScreenSizeRY = int(self.ScreenHeight)
props.setOrigin(100,100)
props.setSize(1024,768)
base.win.requestProperties(props)
# This was the old way that no longer works - I don't know why
## Create a new FrameBufferProperties object using our settings
#fbProps = FrameBufferProperties()
#fbProps.addProperties(FrameBufferProperties.getDefault())
#fbProps.setMultisamples(GameSettings().antiAlias)
#fbProps.setAlphaBits(GameSettings().alphaBits)
#fbProps.setDepthBits(GameSettings().colorDepth)
#fbProps.setColorBits(24)
#
## Create a WindowProperties object
#winProps = WindowProperties( base.win.getProperties() )
#winProps.setFullscreen(GameSettings().fullscreen)
#winProps.setUndecorated(GameSettings().fullscreen)
#winProps.setSize(GameSettings().xRes,GameSettings().yRes)
#winProps.setTitle('PSG - Project Space Game: Alpha')
#
## Create the engine
#base.graphicsEngine.makeOutput(base.pipe, # GraphicsPipe
# 'mainGameOutput', # Name
# 0, # Sort
# fbProps, # FrameBufferProperties
# winProps, # WindowProperties
# GraphicsPipe.BFRequireWindow | GraphicsPipe.BFFbPropsOptional, # Flags
# base.win.getGsg()) # GraphicsStateGaurdian
##base.openMainWindow(props=winProps, gsg=base.win.getGsg(), keepCamera=1)
#base.openMainWindow()
#base.graphicsEngine.openWindows()
#base.win.requestProperties(winProps)
## The following code should proabably be moved somewhere else
#showFPS = GameSettings().showFPS
#base.setFrameRateMeter(showFPS)
def onSize(self, event=None): '''to resize P3d Surface accordingly to his wx window container and to re-gain keyboard focus ''' wp0=base.win.getProperties() if not wp0.getOpen(): print ">>>[app onSize] win wasn't open: lets quit!" return wp=WindowProperties() wp.addProperties(wp0) wp.setSize(*self.win.getP3DSurfaceSize()) wp.setForeground(True) base.win.requestProperties(wp) if event != None: event.Skip()
def onSize(self, event=None):
'''to resize P3d Surface accordingly to his wx window container and to re-gain keyboard focus
'''
wp0 = base.win.getProperties()
if not wp0.getOpen():
print ">>>[app onSize] win wasn't open: lets quit!"
return
wp = WindowProperties()
wp.addProperties(wp0)
wp.setSize(*self.win.getP3DSurfaceSize())
wp.setForeground(True)
base.win.requestProperties(wp)
if event != None: event.Skip()
def __init__(self):
print("began")
self.taskMgr = taskMgr
with open('config.json') as data_file:
self.conf = json.load(data_file)
self.ServerConnection = ServerConnection()#uncomment when going live
self.ServerConnection.connect(self.conf['host'],self.conf['port'])#uncomment when going live
props = WindowProperties( )
props.setTitle( 'Log In' )
props.setFixedSize(True)
props.setSize(1280,740)
props.setOrigin(-2,-2)
base.win.requestProperties( props )
self.base = ShowBase
self.main_theme = base.loader.loadSfx("assets/sounds/terminator_theme.ogg")
self.main_theme.play()
self.username = ""
self.authConnection = AuthConnectionModel(self)#uncomment when going live
self.heartbeatConnection = HeartbeatConnectionModel()#uncomment when going live
self.ServerConnection.setupConnectionModel(self.heartbeatConnection)#uncomment when going live
self.globalChatConnection = ChatConnectionModel(self)
self.ServerConnection.setupConnectionModel(self.globalChatConnection)
self.queueConnection = QueueConnectionModel(self)
self.ServerConnection.setupConnectionModel(self.authConnection)#uncomment when going live
self.friendConnection = FriendConnectionModel(self)
self.ServerConnection.setupConnectionModel(self.friendConnection)
self.taskMgr.doMethodLater(self.conf['heartbeatRate'], self.doHeartbeat, "heartbeat")#uncomment when going live
self.taskMgr.doMethodLater(self.conf['heartbeatRate'], self.doHeartbeat, "heartbeat")
self.screen = Login(self)#uncomment when going live
#self.screen = Menu(self)#comment this one when you are trying to log into it like normal
self.ServerConnection.setupConnectionModel(self.queueConnection)
self.taskMgr.doMethodLater(self.conf['heartbeatRate'], self.doHeartbeat, "heartbeat")
self.taskMgr.doMethodLater(1, self.doSong, "song")
self.screenType = "login"
self.screen.run()
def addWindow(self, handle=None, width=500, height=500):
"""Create a new window showing the scene. Add it to the windows list
and return it.
If handle is not None, it is used as parent window.
"""
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(width, height)
if handle is not None:
wp.setParentWindow(handle)
self.base.openDefaultWindow(props=wp,
type="onscreen",
requireWindow=True)
return self.base.winList[-1]
def click_ok_button(self):
if self.new_screen_resolution:
wp = WindowProperties()
wp.setSize(self.new_screen_resolution[0],
self.new_screen_resolution[1])
base.win.requestProperties(wp)
if self.new_screen_fullscreen is not None:
wp = WindowProperties()
wp.setFullscreen(self.new_screen_fullscreen)
base.win.requestProperties(wp)
self.np.remove()
messenger.send('dialog_closing')
def addWindow(self, handle=None, width=500, height=500):
"""Create a new window showing the scene. Add it to the windows list
and return it.
If handle is not None, it is used as parent window.
"""
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(width, height)
if handle is not None:
wp.setParentWindow(handle)
self.base.openDefaultWindow(props=wp,
type="onscreen",
requireWindow=True)
return self.base.winList[-1]
def onSize(self, evt):
"""Invoked when the viewport is resized."""
if self.win != None:
wp = WindowProperties()
wp.setOrigin(0, 0)
newWidth = self.ClientSize.GetWidth()
newHeight = self.ClientSize.GetHeight()
wp.setSize(newWidth, newHeight)
self.win.requestProperties(wp)
if hasattr(base, "direct") and base.direct:
for dr in base.direct.drList:
if dr.camNode == self.camNode:
dr.updateFilmSize(newWidth, newHeight)
break
def onSize(self, evt):
"""Invoked when the viewport is resized."""
if self.win != None:
wp = WindowProperties()
wp.setOrigin(0, 0)
newWidth = self.ClientSize.GetWidth()
newHeight = self.ClientSize.GetHeight()
wp.setSize(newWidth, newHeight)
self.win.requestProperties(wp)
if hasattr(base, "direct") and base.direct:
for dr in base.direct.drList:
if dr.camNode == self.camNode:
dr.updateFilmSize(newWidth, newHeight)
break
def setFullscreen():
"""Helper function to set the window fullscreen
with width and height set to the screens size"""
# get the displays width and height
w = self.pipe.getDisplayWidth()
h = self.pipe.getDisplayHeight()
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(w, h)
# request the new properties
base.win.requestProperties(props)
def Initialize(self, useMainWin=True):
"""
The panda3d window must be put into the wx-window after it has been
shown, or it will not size correctly.
"""
assert self.GetHandle() != 0
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.ClientSize.GetWidth(), self.ClientSize.GetHeight())
wp.setParentWindow(self.GetHandle())
if self._win is None:
if useMainWin:
base.openDefaultWindow(props=wp, gsg=None)
self._win = base.win
else:
self._win = base.openWindow(props=wp, makeCamera=0)
self.Bind(wx.EVT_SIZE, self.OnResize)
def Initialize( self, useMainWin=True ):
"""
The panda3d window must be put into the wx-window after it has been
shown, or it will not size correctly.
"""
assert self.GetHandle() != 0
wp = WindowProperties()
wp.setOrigin( 0, 0 )
wp.setSize( self.ClientSize.GetWidth(), self.ClientSize.GetHeight() )
wp.setParentWindow( self.GetHandle() )
if self._win is None:
if useMainWin:
base.openDefaultWindow( props=wp, gsg=None )
self._win = base.win
else:
self._win = base.openWindow( props=wp, makeCamera=0 )
self.Bind( wx.EVT_SIZE, self.OnResize )
def configure(self, widget, event):
if self.showbase != None:
x_offset, y_offset = self.translate_coordinates(widget, 0, 0)
x, y = self.gtk_window.window.get_position()
wp = WindowProperties().getDefault()
wp.setOrigin(x + x_offset, y + y_offset)
wp.setSize(self.get_allocation().width, self.get_allocation().height)
wp.setUndecorated(True)
# apply window property changes to the window
self.showbase.win.requestProperties(wp)
# for debugging purposes turn show the frame rate
# to decide about the interval for calling self.step
# with a gobject timeout
self.showbase.setFrameRateMeter(True)
def toggleFullScreen(self):
# If there is an open dialog, then this function
# will not execute.
if dialogService.hasOpenDialog():
return
wp = WindowProperties()
if not browser_config['fullscreen']:
wp.setSize(base.win.getXSize(), base.win.getYSize())
wp.setFullscreen(True)
base.win.requestProperties(wp)
browser_config['fullscreen'] = True
else:
wp.setSize(base.win.getXSize(), base.win.getYSize())
wp.setFullscreen(False)
base.win.requestProperties(wp)
browser_config['fullscreen'] = False
def initialize(self):
self.Update()
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.ClientSize.GetWidth(), self.ClientSize.GetHeight())
assert self.GetHandle() != 0
wp.setParentWindow(self.GetHandle())
Window.__init__(self, extraProps=wp)
self.initialized = True
if self.lens != None: self.camera.node().setLens(self.lens)
if self.camPos != None: self.camera.setPos(self.camPos)
if self.camLookAt != None: self.camera.lookAt(self.camLookAt)
self.Bind(wx.EVT_SIZE, self.onSize)
self.accept("wheel_down", self.zoomOut)
self.accept("wheel_up", self.zoomIn)
self.accept("page_down", self.zoomOut)
self.accept("page_down-repeat", self.zoomOut)
self.accept("page_up", self.zoomIn)
self.accept("page_up-repeat", self.zoomIn)
def __init__(self, World):
#just comment out the two lines below
#self.appRunner = None#added this to overide the login
self.playerList = []
self.World = World
self.WhichScreen = "";
self.lastSelectedFriend = None
# variable to save game selected DD or RR
self.selectedGame = None
#self.taskMgr = World.taskMgr#added this to overide the login
props = WindowProperties()
props.setTitle( 'Main Menu' )
props.setFixedSize(True)
props.setSize(1400,740)
props.setOrigin(-2,-2)
base.win.requestProperties( props )
self.selectedCar = 0
self.screenBtns = []
self.globalChat = []
self.privateChat = {}
self.chatOffset = 0
self.car = None
self.onReturnMatch = self.createMatchMaking
self.createSocialization()
self.World.queueConnection.setHandler(self.handleQueueNotification)
self.World.globalChatConnection.setHandler(self.handleChatNotification)
self.World.friendConnection.setHandlers(self.handleFriendNotification,self.handleFriendListNotification)
#self.World.privateChatConnection.setHandler(self.handlePrivateChatNotification)
self.navi()
self.accept('enter', self.sendMessage)
def createBuffer(self, name, xsize, ysize, texgroup, depthbits=1):
winprops = WindowProperties()
winprops.setSize(xsize, ysize)
props = FrameBufferProperties()
props.setRgbColor(1)
props.setDepthBits(depthbits)
(depthtex, colortex, auxtex0, auxtex1) = texgroup
if auxtex0 != None:
props.setAuxRgba(1)
if auxtex1 != None:
props.setAuxRgba(2)
buffer = base.graphicsEngine.makeOutput(
self.win.getPipe(), name, -1, props, winprops,
GraphicsPipe.BFRefuseWindow | GraphicsPipe.BFResizeable,
self.win.getGsg(), self.win)
if buffer == None:
return buffer
if depthtex:
buffer.addRenderTexture(depthtex, GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPDepthStencil)
if colortex:
buffer.addRenderTexture(colortex, GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPColor)
if auxtex0:
buffer.addRenderTexture(auxtex0, GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPAuxRgba0)
if auxtex1:
buffer.addRenderTexture(auxtex1, GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPAuxRgba1)
buffer.setSort(self.nextsort)
buffer.disableClears()
buffer.getDisplayRegion(0).disableClears()
self.nextsort += 1
return buffer
def __init__( self ):
# setup key bindings
keybindings = { "escape": [ sys.exit , None]
, "f2" : [ self.printPos , None]
, "f3" : [ self.toggleWireframe, None]
, "f6" : [render.analyze , None]
, "f9" : [ base.oobe , None] }
# set keyboard mappings
for mapping, [binding, setting] in keybindings.items():
if setting is not None:
self.accept( mapping, binding, [setting] )
else:
self.accept( mapping, binding )
if USESHOWPOS:
self.guiposOnscreenText = OnscreenText(text = 'position', fg=(1,1,1,1), pos = (-0.9, 0.9), scale = 0.07, mayChange=True, align=TextNode.ALeft )
taskMgr.doMethodLater(0.1, self.updateGuiposTask, 'updateGuiposTask')
if USESOUND:
self.walkSound = loader.loadSfx("data/camera/sounds/walking.mp3")
self.walkSound.setLoop(True)
self.oldPos = None
self.soundOn = False
taskMgr.add(self.playSound, 'playSoundTask')
if True:
wp = WindowProperties()
# set resolution
wp.setSize(RESOLUTION[0], RESOLUTION[1])
# set fullscreen
base.win.requestProperties(wp)
# set background color to black
base.setBackgroundColor( 0,0,0 )
# set camera field of view
base.camLens.setFov(90)
# set near and far clipping planes
base.camLens.setNear( 1 )
base.camLens.setFar( 5000 )
def initialize(self):
self.Update()
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.ClientSize.GetWidth(), self.ClientSize.GetHeight())
assert self.GetHandle() != 0
wp.setParentWindow(self.GetHandle())
Window.__init__(self, extraProps=wp)
self.initialized = True
if self.lens != None:
self.camera.node().setLens(self.lens)
if self.camPos != None:
self.camera.setPos(self.camPos)
if self.camLookAt != None:
self.camera.lookAt(self.camLookAt)
self.Bind(wx.EVT_SIZE, self.onSize)
self.accept("wheel_down", self.zoomOut)
self.accept("wheel_up", self.zoomIn)
self.accept("page_down", self.zoomOut)
self.accept("page_down-repeat", self.zoomOut)
self.accept("page_up", self.zoomIn)
self.accept("page_up-repeat", self.zoomIn)
def __init__(self, gtkParentWidget):
self.pose = {}
self.enter = 1 # 0..1 flies in the cubes
self.currentMessage = self.cornerMessage = None
self.videoFrame = None
self.animSeed = 0
self.cubeNodes = {} # color: NodePath
self.currentLighting = 'train'
self.gtkParentWidget = gtkParentWidget
self.base = base # from DirectStart
props = WindowProperties().getDefault()
props.setOrigin(0, 0)
props.setSize(1,1)
props.setParentWindow(self.gtkParentWidget.window.xid)
self.base.openDefaultWindow(props=props)
self.gtkParentWidget.connect("size_allocate", self.resize_panda_window)
self.originalNodes = self.base.render.getChildren()
self.init()
def __init__(self, gtkParentWidget):
self.pose = {}
self.enter = 1 # 0..1 flies in the cubes
self.currentMessage = self.cornerMessage = None
self.videoFrame = None
self.animSeed = 0
self.cubeNodes = {} # color: NodePath
self.currentLighting = 'train'
self.gtkParentWidget = gtkParentWidget
self.base = base # from DirectStart
props = WindowProperties().getDefault()
props.setOrigin(0, 0)
props.setSize(1, 1)
props.setParentWindow(self.gtkParentWidget.window.xid)
self.base.openDefaultWindow(props=props)
self.gtkParentWidget.connect("size_allocate", self.resize_panda_window)
self.originalNodes = self.base.render.getChildren()
self.init()
def ToggleFullScreen(self):
fullscreen = not base.win.isFullscreen()
props = WindowProperties( base.win.getProperties() )
if(not fullscreen):
props.setFullscreen(False)
props.setSize(850, 480)
else:
props.setFullscreen(True)
w = base.pipe.getDisplayWidth()
h = base.pipe.getDisplayHeight()
if w and h:
props.setSize(w,h)
else:
props.setSize(850, 480)
base.win.requestProperties(props)
messenger.send('window-event',[base.win])
def setResolution(x=800, y=600, fullScreen=False): wp = WindowProperties() wp.setSize(x,y) wp.setFullscreen(fullScreen) base.win.requestProperties(wp)
def setResolution(x=800, y=600, fullScreen=False):
wp = WindowProperties()
wp.setSize(x, y)
wp.setFullscreen(fullScreen)
base.win.requestProperties(wp)
class World(DirectObject):
def __init__(self):
self.last_mousex = 0
self.last_mousey = 0
self.zone = None
self.zone_reload_name = None
self.winprops = WindowProperties()
# simple console output
self.consoleNode = NodePath(PandaNode("console_root"))
self.consoleNode.reparentTo(aspect2d)
self.console_num_lines = 24
self.console_cur_line = -1
self.console_lines = []
for i in range(0, self.console_num_lines):
self.console_lines.append(
OnscreenText(
text="",
style=1,
fg=(1, 1, 1, 1),
pos=(-1.3, 0.4 - i * 0.05),
align=TextNode.ALeft,
scale=0.035,
parent=self.consoleNode,
)
)
# Configuration
self.consoleOut("zonewalk v.%s loading configuration" % VERSION)
self.configurator = Configurator(self)
cfg = self.configurator.config
resaveRes = False
if "xres" in cfg:
self.xres = int(cfg["xres"])
else:
self.xres = 1024
resaveRes = True
if "yres" in cfg:
self.yres = int(cfg["yres"])
else:
self.yres = 768
resaveRes = True
if resaveRes:
self.saveDefaultRes()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.mouse_accum = MouseAccume(lambda: (self.xres_half, self.yres_half))
self.eyeHeight = 7.0
self.rSpeed = 80
self.flyMode = 1
# application window setup
base.win.setClearColor(Vec4(0, 0, 0, 1))
self.winprops.setTitle("zonewalk")
self.winprops.setSize(self.xres, self.yres)
base.win.requestProperties(self.winprops)
base.disableMouse()
# network test stuff
self.login_client = None
if "testnet" in cfg:
if cfg["testnet"] == "1":
self.doLogin()
# Post the instructions
self.title = addTitle("zonewalk v." + VERSION)
self.inst0 = addInstructions(0.95, "[FLYMODE][1]")
self.inst1 = addInstructions(-0.95, "Camera control with WSAD/mouselook. Press K for hotkey list, ESC to exit.")
self.inst2 = addInstructions(0.9, "Loc:")
self.inst3 = addInstructions(0.85, "Hdg:")
self.error_inst = addInstructions(0, "")
self.kh = []
self.campos = Point3(155.6, 41.2, 4.93)
base.camera.setPos(self.campos)
# Accept the application control keys: currently just esc to exit navgen
self.accept("escape", self.exitGame)
self.accept("window-event", self.resizeGame)
# Create some lighting
ambient_level = 0.6
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(ambient_level, ambient_level, ambient_level, 1.0))
render.setLight(render.attachNewNode(ambientLight))
direct_level = 0.8
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0.0, 0.0, -1.0))
directionalLight.setColor(Vec4(direct_level, direct_level, direct_level, 1))
directionalLight.setSpecularColor(Vec4(direct_level, direct_level, direct_level, 1))
render.setLight(render.attachNewNode(directionalLight))
# create a point light that will follow our view point (the camera for now)
# attenuation is set so that this point light has a torch like effect
self.plight = PointLight("plight")
self.plight.setColor(VBase4(0.8, 0.8, 0.8, 1.0))
self.plight.setAttenuation(Point3(0.0, 0.0, 0.0002))
self.plnp = base.camera.attachNewNode(self.plight)
self.plnp.setPos(0, 0, 0)
render.setLight(self.plnp)
self.cam_light = 1
self.keyMap = {
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
"mouse3": 0,
"flymode": 1,
}
# setup FOG
self.fog_colour = (0.8, 0.8, 0.8, 1.0)
self.linfog = Fog("A linear-mode Fog node")
self.linfog.setColor(self.fog_colour)
self.linfog.setLinearRange(700, 980) # onset, opaque distances as params
# linfog.setLinearFallback(45,160,320)
base.camera.attachNewNode(self.linfog)
render.setFog(self.linfog)
self.fog = 1
# camera control
self.campos = Point3(0, 0, 0)
self.camHeading = 0.0
self.camPitch = 0.0
base.camLens.setFov(65.0)
base.camLens.setFar(1200)
self.cam_speed = 0 # index into self.camp_speeds
self.cam_speeds = [40.0, 80.0, 160.0, 320.0, 640.0]
# Collision Detection for "WALKMODE"
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. The ray will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0.0, 0.0, 0.0)
self.camGroundRay.setDirection(0, 0, -1) # straight down
self.camGroundCol = CollisionNode("camRay")
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
# attach the col node to the camCollider dummy node
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
# Uncomment this line to see the collision rays
# self.camGroundColNp.show()
# Uncomment this line to show a visual representation of the
# collisions occuring
# self.cTrav.showCollisions(render)
# Add the spinCameraTask procedure to the task manager.
# taskMgr.add(self.spinCameraTask, "SpinCameraTask")
taskMgr.add(self.camTask, "camTask")
self.toggleControls(1)
# need to step the task manager once to make our fake console work
taskMgr.step()
# CONSOLE ---------------------------------------------------------------------
def consoleScroll(self):
for i in range(0, self.console_num_lines - 1):
self.console_lines[i].setText(self.console_lines[i + 1].getText())
def consoleOut(self, text):
print text # output to stdout/log too
if self.console_cur_line == self.console_num_lines - 1:
self.consoleScroll()
elif self.console_cur_line < self.console_num_lines - 1:
self.console_cur_line += 1
self.console_lines[self.console_cur_line].setText(text)
taskMgr.step()
def consoleOn(self):
self.consoleNode.show()
def consoleOff(self):
self.consoleNode.hide()
# User controls -----------------------------------------------------------
def toggleControls(self, on):
if on == 1:
self.accept("escape", self.exitGame)
self.accept("1", self.setSpeed, ["speed", 0])
self.accept("2", self.setSpeed, ["speed", 1])
self.accept("3", self.setSpeed, ["speed", 2])
self.accept("4", self.setSpeed, ["speed", 3])
self.accept("5", self.setSpeed, ["speed", 4])
self.accept("alt-f", self.fogToggle)
self.accept("t", self.camLightToggle)
self.accept("k", self.displayKeyHelp)
self.accept("f", self.toggleFlymode)
self.accept("l", self.reloadZone)
self.accept("z", self.saveDefaultZone)
self.accept("a", self.setKey, ["cam-left", 1])
self.accept("d", self.setKey, ["cam-right", 1])
self.accept("w", self.setKey, ["forward", 1])
self.accept("mouse1", self.setKey, ["forward", 1])
self.accept("mouse3", self.setKey, ["mouse3", 1])
self.accept("s", self.setKey, ["backward", 1])
self.accept("k-up", self.hideKeyHelp)
self.accept("a-up", self.setKey, ["cam-left", 0])
self.accept("d-up", self.setKey, ["cam-right", 0])
self.accept("w-up", self.setKey, ["forward", 0])
self.accept("mouse1-up", self.setKey, ["forward", 0])
self.accept("mouse3-up", self.setKey, ["mouse3", 0])
self.accept("s-up", self.setKey, ["backward", 0])
else:
messenger.clear()
def setSpeed(self, key, value):
self.cam_speed = value
self.setFlymodeText()
def fogToggle(self):
if self.fog == 1:
render.clearFog()
base.camLens.setFar(100000)
self.fog = 0
else:
render.setFog(self.linfog)
base.camLens.setFar(1200)
self.fog = 1
def camLightToggle(self):
if self.cam_light == 0:
render.setLight(self.plnp)
self.cam_light = 1
else:
render.clearLight(self.plnp)
self.cam_light = 0
def displayKeyHelp(self):
self.kh = []
msg = "HOTKEYS:"
pos = 0.75
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "------------------"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "W: camera fwd, S: camera bck, A: rotate view left, D: rotate view right"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "1-5: set camera movement speed"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "F: toggle Flymode/Walkmode"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "L: load a zone"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "ALT-F: toggle FOG and FAR plane on/off"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = 'T: toggle additional camera "torch" light on/off'
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "Z: set currently loaded zone as new startup default"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
msg = "ESC: exit zonewalk"
pos -= 0.05
self.kh.append(
OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), pos=(-0.5, pos), align=TextNode.ALeft, scale=0.04)
)
def hideKeyHelp(self):
for n in self.kh:
n.removeNode()
def setFlymodeText(self):
zname = ""
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.inst0.setText("[WALKMODE][%i] %s" % (self.cam_speed + 1, zname))
else:
self.inst0.setText("[FLYMODE][%i] %s " % (self.cam_speed + 1, zname))
def toggleFlymode(self):
zname = ""
if self.zone:
zname = self.zone.name
if self.flyMode == 0:
self.flyMode = 1
else:
self.flyMode = 0
self.setFlymodeText()
# Define a procedure to move the camera.
def spinCameraTask(self, task):
angleDegrees = task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
base.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians), 3)
base.camera.setHpr(angleDegrees, 0, 0)
return task.cont
def camTask(self, task):
# query the mouse
mouse_dx = 0
mouse_dy = 0
# if we have a mouse and the right button is depressed
if base.mouseWatcherNode.hasMouse():
if self.keyMap["mouse3"] != 0:
self.mouse_accum.update()
else:
self.mouse_accum.reset()
mouse_dx = self.mouse_accum.dx
mouse_dy = self.mouse_accum.dy
self.rXSpeed = fabs(self.mouse_accum.dx) * (self.cam_speed + 1) * max(5 * 1000 / self.xres, 3)
self.rYSpeed = fabs(self.mouse_accum.dy) * (self.cam_speed + 1) * max(3 * 1000 / self.yres, 1)
if self.keyMap["cam-left"] != 0 or mouse_dx < 0:
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading += self.rXSpeed * globalClock.getDt()
else:
self.camHeading += self.rSpeed * globalClock.getDt()
if self.camHeading > 360.0:
self.camHeading = self.camHeading - 360.0
elif self.keyMap["cam-right"] != 0 or mouse_dx > 0:
if self.rSpeed < 160:
self.rSpeed += 80 * globalClock.getDt()
if mouse_dx != 0:
self.camHeading -= self.rXSpeed * globalClock.getDt()
else:
self.camHeading -= self.rSpeed * globalClock.getDt()
if self.camHeading < 0.0:
self.camHeading = self.camHeading + 360.0
else:
self.rSpeed = 80
if mouse_dy > 0:
self.camPitch += self.rYSpeed * globalClock.getDt()
elif mouse_dy < 0:
self.camPitch -= self.rYSpeed * globalClock.getDt()
# set camera heading and pitch
base.camera.setHpr(self.camHeading, self.camPitch, 0)
# viewer position (camera) movement control
v = render.getRelativeVector(base.camera, Vec3.forward())
if not self.flyMode:
v.setZ(0.0)
move_speed = self.cam_speeds[self.cam_speed]
if self.keyMap["forward"] == 1:
self.campos += v * move_speed * globalClock.getDt()
if self.keyMap["backward"] == 1:
self.campos -= v * move_speed * globalClock.getDt()
# actually move the camera
lastPos = base.camera.getPos()
base.camera.setPos(self.campos)
# self.plnp.setPos(self.campos) # move the point light with the viewer position
# WALKMODE: simple collision detection
# we simply check a ray from slightly below the "eye point" straight down
# for geometry collisions and if there are any we detect the point of collision
# and adjust the camera's Z accordingly
if self.flyMode == 0:
# move the camera to where it would be if it made the move
# the colliderNode moves with it
# base.camera.setPos(self.campos)
# check for collissons
self.cTrav.traverse(render)
entries = []
for i in range(self.camGroundHandler.getNumEntries()):
entry = self.camGroundHandler.getEntry(i)
entries.append(entry)
# print 'collision'
entries.sort(lambda x, y: cmp(y.getSurfacePoint(render).getZ(), x.getSurfacePoint(render).getZ()))
if len(entries) > 0: # and (entries[0].getIntoNode().getName() == "terrain"):
# print len(entries)
self.campos.setZ(entries[0].getSurfacePoint(render).getZ() + self.eyeHeight)
else:
self.campos = lastPos
base.camera.setPos(self.campos)
# if (base.camera.getZ() < self.player.getZ() + 2.0):
# base.camera.setZ(self.player.getZ() + 2.0)
# update loc and hpr display
pos = base.camera.getPos()
hpr = base.camera.getHpr()
self.inst2.setText("Loc: %.2f, %.2f, %.2f" % (pos.getX(), pos.getY(), pos.getZ()))
self.inst3.setText("Hdg: %.2f, %.2f, %.2f" % (hpr.getX(), hpr.getY(), hpr.getZ()))
return task.cont
def exitGame(self):
sys.exit(0)
def resizeGame(self, win):
props = base.win.getProperties()
self.xres = props.getXSize()
self.yres = props.getYSize()
self.xres_half = self.xres / 2
self.yres_half = self.yres / 2
self.saveDefaultRes()
# Records the state of the arrow keys
# this is used for camera control
def setKey(self, key, value):
self.keyMap[key] = value
# -------------------------------------------------------------------------
# this is the mythical MAIN LOOP :)
def update(self):
if self.zone_reload_name != None:
self.doReload(self.zone_reload_name)
self.zone_reload_name = None
if self.zone != None:
self.zone.update()
taskMgr.step()
if self.login_client != None:
self.login_client.update()
# ZONE loading ------------------------------------------------------------
# general zone loader driver
# removes existing zone (if any) and load the new one
def loadZone(self, name, path):
if path[len(path) - 1] != "/":
path += "/"
if self.zone:
self.zone.rootNode.removeNode()
self.zone = Zone(self, name, path)
error = self.zone.load()
if error == 0:
self.consoleOff()
self.setFlymodeText()
base.setBackgroundColor(self.fog_colour)
def saveDefaultRes(self):
cfg = self.configurator.config
cfg["xres"] = str(self.xres)
cfg["yres"] = str(self.yres)
self.configurator.saveConfig()
# initial world load after bootup
def load(self):
cfg = self.configurator.config
if self.login_client != None:
return
zone_name = cfg["default_zone"]
basepath = cfg["basepath"]
self.loadZone(zone_name, basepath)
# config save user interfacce
def saveDefaultZone(self):
if self.zone:
cfg = self.configurator.config
cfg["default_zone"] = self.zone.name
self.configurator.saveConfig()
# zone reload user interface
# this gets called from our update loop when it detects that zone_reload_name has been set
# we do this in this convoluted fashion in order to keep the main loop taskMgr updates ticking
# because otherwise our status console output at various stages during the zone load would not
# be displayed. Yes, this is hacky.
def doReload(self, name):
cfg = self.configurator.config
basepath = cfg["basepath"]
self.loadZone(name, basepath)
# form dialog callback
# this gets called from the form when the user has entered a something
# (hopefully a correct zone short name)
def reloadZoneDialogCB(self, name):
self.frmDialog.end()
self.zone_reload_name = name
self.toggleControls(1)
# this is called when the user presses "l"
# it disables normal controls and fires up our query form dialog
def reloadZone(self):
base.setBackgroundColor((0, 0, 0))
self.toggleControls(0)
self.consoleOn()
self.frmDialog = FileDialog(
"Please enter the shortname of the zone you wish to load:",
"Examples: qrg, blackburrow, freportn, crushbone etc.",
self.reloadZoneDialogCB,
)
self.frmDialog.activate() # relies on the main update loop to run
###############################
# EXPERIMENTAL
def doLogin(self):
self.login_client = UDPClientStream("127.0.0.1", 5998)
base.setBackgroundColor(_background_color)
# Check if we have any screen resolution in our configuration file, if not we use default.
(sx, sy) = DEFAULT_RESOLUTION.split('x')
if 'screen_resolution' in browser_config.getConfigKeys():
resValue = browser_config.getValue('screen_resolution')
(sx, sy) = (int(resValue.split('x')[0]), int(resValue.split('x')[1]))
#
## Set the screen resolution.
wp = WindowProperties()
# Check if we have any fullscreen mode in the configuration.
_fullscreen = DEFAULT_FULLSCREEN
if 'fullscreen' in browser_config.getConfigKeys():
_fullscreen = bool(int(browser_config['fullscreen']))
wp.setFullscreen(_fullscreen)
wp.setSize(int(sx), int(sy))
base.win.requestProperties(wp)
# Disable panda3d mouse handler.
base.disableMouse()
# Initialize the browser in cubemode.
photocube.modes.cubeMode.enable()
# Start Panda3D event loop.
run()
class NSDApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.keys = ReadKeys()
self.wp = WindowProperties()
self.wp.setFullscreen(1)
self.wp.setSize(RESOLUTION)
self.openMainWindow()
self.win.requestProperties(self.wp)
self.graphicsEngine.openWindows()
self.setBackgroundColor(0, 0, 0)
self.disableMouse()
self.props = WindowProperties()
self.props.setCursorHidden(True)
self.win.requestProperties(self.props)
self.title()
def title(self):
#Removes title and loads current room
def destroyTitle(task):
card.removeNode()
startGame()
def startGame():
if os.path.isfile('saves/location.json'):
self.directToRoom()
else:
self.homeFirst()
#Loads title animation
titleText = self.loader.loadTexture('resources/titleText.avi')
titleText.setLoopCount(1)
titleText.play()
#Displays title
cm = CardMaker('titleText')
cm.setFrameFullscreenQuad()
cm.setUvRange(titleText)
# noinspection PyArgumentList
card = NodePath(cm.generate())
card.reparentTo(self.render2d)
card.setTexture(titleText)
self.taskMgr.doMethodLater(5.6, destroyTitle, 'endTitle')
def saveRoom(self, cr):
with open('saves/location.json', 'w+') as outfile:
saveInfo = {'currentRoom': cr}
json.dump(saveInfo,
outfile,
sort_keys=True,
indent=4,
ensure_ascii=False)
def directToRoom(self):
with open('saves/location.json') as df:
data = json.load(df)
def homeFirst(self):
self.homeRoom()
def homeRoom(self):
self.saveRoom("1")
def set(self, pipe, width, height, fullscreen, embedded):
self.notify.debugStateCall(self)
state = False
self.notify.info("SET")
#fullscreen = options.fullscreen_runtime
#embedded = options.embedded_runtime
if self.restrict_to_embedded:
fullscreen = 0
embedded = 1
if embedded:
if base.appRunner.windowProperties:
width = base.appRunner.windowProperties.getXSize()
height = base.appRunner.windowProperties.getYSize()
self.current_pipe = base.pipe
self.current_properties = WindowProperties(base.win.getProperties())
properties = self.current_properties
self.notify.debug("DISPLAY PREVIOUS:")
self.notify.debug(" EMBEDDED: %s" %
bool(properties.getParentWindow()))
self.notify.debug(" FULLSCREEN: %s" %
bool(properties.getFullscreen()))
self.notify.debug(" X SIZE: %s" % properties.getXSize())
self.notify.debug(" Y SIZE: %s" % properties.getYSize())
self.notify.debug("DISPLAY REQUESTED:")
self.notify.debug(" EMBEDDED: %s" % bool(embedded))
self.notify.debug(" FULLSCREEN: %s" % bool(fullscreen))
self.notify.debug(" X SIZE: %s" % width)
self.notify.debug(" Y SIZE: %s" % height)
if ((self.current_pipe == pipe) and \
(bool(self.current_properties.getParentWindow( )) == bool(embedded)) and \
(self.current_properties.getFullscreen ( ) == fullscreen) and \
(self.current_properties.getXSize ( ) == width) and \
(self.current_properties.getYSize ( ) == height)):
# no display change required
self.notify.info("DISPLAY NO CHANGE REQUIRED")
state = True
else:
properties = WindowProperties()
properties.setSize(width, height)
properties.setFullscreen(fullscreen)
properties.setParentWindow(0)
if embedded:
if base.appRunner.windowProperties:
properties = base.appRunner.windowProperties
# get current sort order
original_sort = base.win.getSort()
if self.resetWindowProperties(pipe, properties):
self.notify.debug("DISPLAY CHANGE SET")
# verify display change
properties = base.win.getProperties()
self.notify.debug("DISPLAY ACHIEVED:")
self.notify.debug(" EMBEDDED: %s" %
bool(properties.getParentWindow()))
self.notify.debug(" FULLSCREEN: %s" %
bool(properties.getFullscreen()))
self.notify.debug(" X SIZE: %s" % properties.getXSize())
self.notify.debug(" Y SIZE: %s" % properties.getYSize())
if ((bool(properties.getParentWindow( )) == bool(embedded)) and \
(properties.getFullscreen ( ) == fullscreen) and \
(properties.getXSize ( ) == width) and \
(properties.getYSize ( ) == height)):
self.notify.info("DISPLAY CHANGE VERIFIED")
state = True
else:
self.notify.warning(
"DISPLAY CHANGE FAILED, RESTORING PREVIOUS DISPLAY")
self.restoreWindowProperties()
else:
self.notify.warning("DISPLAY CHANGE FAILED")
self.notify.warning("DISPLAY SET - BEFORE RESTORE")
self.restoreWindowProperties()
self.notify.warning("DISPLAY SET - AFTER RESTORE")
# set current sort order
base.win.setSort(original_sort)
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
return state
def _setresolution(res, fullscreen=False):
wp = WindowProperties()
wp.setSize(int(res[0]), int(res[1]))
wp.setFullscreen(fullscreen)
base.win.requestProperties(wp)
