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 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 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 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 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 __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)