def __init__(self): self.base = ShowBase() # graphics # window props = WindowProperties() self.win_size = 600 props.setSize(self.win_size, self.win_size) self.base.win.requestProperties(props) # set up key self.accept("c", self.move_center) self.accept("b", self.plot_bananas) self.accept("space", self.change_both) self.num_bananas = 10 # total area is 100 (not true of the game, but just scales. # was easier to make everything 1/2 size for this size window) high_area = 0.25 * 0.33 * 100 middle_area = 0.25 * 100 self.high_radius = sqrt(high_area / pi) self.middle_radius = sqrt(middle_area / pi) self.high_reward = 6 self.middle_reward = 4 self.low_reward = 2 #print self.high_radius #print self.middle_radius self.weight_center = (random.uniform(-5, 5), random.uniform(-5, 5)) #print('weight center', self.weight_center) self.banana_model = [] self.center_model = None self.high_node = None self.high_circle = None self.middle_node = None self.middle_circle = None self.plot_border() self.plot_bananas() self.plot_circles()
def __init__(self): DirectObject.__init__(self) self.base = ShowBase() resolution = (1024, 768) wp = WindowProperties() wp.setSize(int(resolution[0]), int(resolution[1])) wp.setOrigin(0, 0) self.base.win.requestProperties(wp) # depth completely doesn't matter for this, since just 2d, and no layers self.depth = 0 self.base.setBackgroundColor(115 / 255, 115 / 255, 115 / 255) # set up a 2d camera camera = self.base.camList[0] lens = OrthographicLens() lens.setFilmSize(int(resolution[0]), int(resolution[1])) lens.setNearFar(-100, 100) camera.node().setLens(lens) camera.reparentTo(self.base.render) self.accept("escape", sys.exit) # spread out some positions self.positions = [(-200, 0, -200), (0, 0, -200), (200, 0, -200), (-200, 0, 0), (0, 0, 0), (200, 0, 0), (-200, 0, 200), (0, 0, 200), (200, 0, 200)] self.all_smiles()
def __init__(self): # INIT Needed things. # Inst. for Player Class playership. initPlayerShip = PlayerShip() self.playershipOB = initPlayerShip.playerShip ### SETUP CONTROL MAPS ### self.controlMap = {"left": 0, "right": 0, "forward": 0, "backward": 0, "wheel-in": 0, "wheel-out": 0} self.mousebtn = [0, 0, 0] ### SETUP KEYBOARD ### # Setup the control [KEYS] for movement w,a,s,d. | This is basic will have to adjust for advance controls. self.accept("escape", sys.exit) self.accept("w", self.setControl, ["forward", 1]) self.accept("a", self.setControl, ["left", 1]) self.accept("s", self.setControl, ["backward", 1]) self.accept("d", self.setControl, ["right", 1]) self.accept("w-up", self.setControl, ["forward", 0]) self.accept("a-up", self.setControl, ["left", 0]) self.accept("s-up", self.setControl, ["backward", 0]) self.accept("d-up", self.setControl, ["right", 0]) # Setup mouse [ZOOM]. self.accept("wheel_up", self.setControl, ["wheel-in", 1]) self.accept("wheel_down", self.setControl, ["wheel-out", 1]) # Add the "moveTask" taskMgr.add(self.move, "moveTask") # Game State Variable. self.IsMoving = False ###> ### SETUP CAMERA ### # Reparent the -main- Camera to PlayerShip. base.camera.reparentTo(self.playershipOB) # The vertical offset. To view over ship. self.cameraHeight = 0.05 # Camera Distance from playerShip. On Start. self.cameraDistance = 0.23 # Camera Pitch. self.cameraPitch = 0.04 # Disable the basic camera controls. base.disableMouse() # This should be used together with a right click function, for the camera rotate. Like in wow. WinProps = WindowProperties() # Hide the cursor. | This will change with the rightClick function. # Giving us the cursor when not rotating. If the player wants to rotate basic [KEYS] left/right can turn while cursor is active. WinProps.setCursorHidden(True) base.win.requestProperties(WinProps)
def exitGameOver(self): base.taskMgr.remove("menu") properties = WindowProperties() properties.setCursorHidden(True) base.win.requestProperties(properties) self.gm.destroy()
def setMouseModeRelative(self, state): props = WindowProperties() if not state: props.setMouseMode(WindowProperties.MAbsolute) else: props.setMouseMode(WindowProperties.MRelative) self.targetWin.requestProperties(props)
def __init__(self, parent, pos): self.parent = parent self.node = render.attachNewNode('PlayerNode') self.node.setPos(pos[0]*TILE_SIZE,pos[1]*TILE_SIZE,TILE_SIZE*ASPECT/1.5) taskMgr.add(self.updatePlayer, 'UpdatePlayerTask') taskMgr.add(self.updateBullets, 'UpdateBulletsTask') self.centerx = base.win.getProperties().getXSize()/2 self.centery = base.win.getProperties().getYSize()/2 self.speed = TILE_SIZE - 4 self.sprint_speed = self.speed * 1.8 self.can_move = True self.camera = True self.mouse_owner = True self.max_health = 100 self.health = self.max_health self.max_bullets = 10 self.bullets = 4 self.bullet_objects = [] self.sprint = False self.moving = False self.gunshot_at = None props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # Create player flashlight self.slight = Spotlight('slight') self.slight.setColor(VBase4(1, 1, 0.6, 1)) #self.lens = PerspectiveLens() #self.slight.setLens(self.lens) self.slnp = self.node.attachNewNode(self.slight) self.slnp.node().getLens().setFov(88) self.slnp.node().getLens().setNearFar(1, 70) self.slight.setExponent(10) self.slight.setAttenuation(Point3(0.737, 0.134, 0.001)) render.setLight(self.slnp) self.flashlight = True self.shoot_sound = base.loader.loadSfx("audio/GUN_FIRE-GoodSoundForYou-820112263.wav") self.gun_click_sound = base.loader.loadSfx("audio/Dry Fire Gun-SoundBible.com-2053652037.wav") self.heart_sound = base.loader.loadSfx("audio/Slow_HeartBeat-Mike_Koenig-1853475164.wav") self.heart_sound.setLoop(True) self.heart_sound.setVolume(0.6) self.heart_sound.play() self.scratches = loadImageAsPlane('models/scr.png') self.scratches.setTransparency(TransparencyAttrib.MAlpha) self.damage_anim = Parallel() self.keys = {} self.keys['forward'] = 0 self.keys['back'] = 0 self.keys['strafe_left'] = 0 self.keys['strafe_right'] = 0 self.keys['sprint'] = 0 self.setKeyEvents() self.pause = False
def __init__(self): DirectObject.__init__(self) self.close=lambda:None #create main window base=ShowBase() __builtin__.base=base props = WindowProperties() #props.setTitle(ConfigVariableString('win-title').getValue()) props.setFullscreen(ConfigVariableBool('fullscreen').getValue()) props.setSize(ConfigVariableInt('win-width').getValue(),ConfigVariableInt('win-height').getValue()) base.win.requestProperties(props) self.width=base.win.getXSize() self.height=base.win.getYSize() print 'size=',self.width,'x',self.height self.accept('window-event',self.on_resize) base.disableMouse() #set fps limit globalClock=ClockObject.getGlobalClock() globalClock.setMode(ClockObject.MLimited) globalClock.setFrameRate(ConfigVariableDouble('clock-frame-rate').getValue()) __builtin__.screen=self __builtin__.gui=pixel2d.attachNewNode('Screen.gui') #gui is the node for 2d rendering, scaled to the screen resolution, #with origin at bottom-left, and max at top-right gui.setZ(gui,-self.height) __builtin__.console=Console(print_messenger_events=False) __builtin__.out=console.out console.request('Open') __builtin__.mouse=base.pointerWatcherNodes[0] #is used as a stack. stores frames showed to the user (top at the front of the screen) self.frames=[]
def __init__(self, parentChar, keyMap): assert isinstance(parentChar, Character) base.disableMouse() self.char = parentChar self.keyMap = keyMap print 'keymap is',keyMap parentChar.node.rotationallyImmune = True self.floater = NodePath('floater') self.floater.reparentTo(parentChar.node) self.floater.setPos(1,0,2) base.camera.reparentTo(self.floater) base.camera.setPos(0,-5,0) base.camera.setH(0) print base.camera.getPos(render) props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) taskMgr.add(self.controlCamera, 'camera-task') self.h = parentChar.node.getH() self.p = parentChar.node.getP()
def main(): # Handles CLI arguments p = OptionParser() p.add_option('-m', '--nomusic', action="store_false", dest="music", default = True, help = u"Disable music") p.add_option('-e', '--editor-mode', action="store_true", dest="editor", default = False, help = u"Editor mode") options, args = p.parse_args() levelname = 'level1' if args: levelname = args[0] # Instantiate the ShowBase base = ShowBase() # Toggle events verbosity : #base.messenger.toggleVerbose() # Set window properties: # - Hide mouse cursor # - move the window (because of the pekwm bug) curProps = base.win.getProperties() props = WindowProperties() props.setOrigin(curProps.getXOrigin() + 1, curProps.getYOrigin() + 1) props.setCursorHidden(True) base.win.requestProperties(props) # Now instantiate Gate's own stuff fps = FPS(base, levelname, options) osd = OSD(base, fps) mplayer = MusicPlayer(base, osd) if options.music: mplayer.play_random_track() player = Player(base, fps, osd) # And run the ShowBase base.run()
def __init__(self): ShowBase.__init__(self) wp = WindowProperties() wp.setSize(850, 480) wp.setTitle("GAME") base.win.requestProperties(wp) bgg = BlockGeometryGenerator() blocks = [] for x in xrange(1): for y in xrange(512): for z in xrange(64): bid = random.randint(0, 255) blocks.append(bid) bgg.GenerateBlockGeometry(x, y, z, Block(bid), [0]) #blocks[x * 512 * 64 + y * 64 + z] = 1 print x ambientLight = AmbientLight('ambientLight') ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) ambientLightNP = render.attachNewNode(ambientLight) render.setLight(ambientLightNP)
def catchCursor(self): # center the mouse in the middle of the window base.win.movePointer(0, self.win_width_half, self.win_height_half) # Set mouse mode to relative which should work best for our purpose wp = WindowProperties() wp.setMouseMode(WindowProperties.M_relative) base.win.requestProperties(wp)
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(FrameBufferProperties.getDefault()) props.setBackBuffers(0) props.setRgbColor(1) props.setDepthBits(depthbits) props.setStereo(self.win.isStereo()) 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 setResolution( self, w, h ): wp = WindowProperties() wp.setSize( w, h ) if os.name == 'posix': self.openMainWindow() self.graphicsEngine.openWindows() self.win.requestProperties( wp )
def toggleMouse(self): print "Toggling mouse visibility" self.hideMouse = not self.hideMouse wp = WindowProperties() wp.setCursorHidden(self.hideMouse) self.base.win.requestProperties(wp)
def __clearWindowProperties(self): """ Clears the windowPrc file that was created in a previous call to setupWindow(), if any. """ if self.windowPrc: unloadPrcFile(self.windowPrc) self.windowPrc = None WindowProperties.clearDefault()
def setCursor(self): base.win.clearRejectedProperties() props = WindowProperties() if sys.platform.startswith('linux'): props.setCursorFilename("./assets/cursor.x11") else: props.setCursorFilename("./assets/cursor.ico") base.win.requestProperties(props)
def hide_cursor(): """set the Cursor invisible""" props = WindowProperties() props.setCursorHidden(True) # somehow the window gets undecorated after hiding the cursor # so we reset it here to the value we need # props.setUndecorated(settings.fullscreen) base.win.requestProperties(props)
def test_winprops_size_staticmethod(): props = WindowProperties.size(1, 2) assert props.has_size() assert props.get_size() == (1, 2) props = WindowProperties.size((1, 2)) assert props.has_size() assert props.get_size() == (1, 2)
def toggle_fullscreen(self): wp = WindowProperties() self.isFullScreen = not self.isFullScreen wp.setFullscreen(self.isFullScreen) wp.setSize(1024, 768) base.openMainWindow() base.win.requestProperties(wp) base.graphicsEngine.openWindows()
def tick(self): # Select appropriate mouse mode if self.constrain_center_mouse: mouse_mode = WindowProperties.M_relative elif self.confine_mouse: mouse_mode = WindowProperties.M_confined else: mouse_mode = WindowProperties.M_absolute # Set mouse mode props = WindowProperties() props.set_mouse_mode(mouse_mode) props.set_cursor_hidden(not self.mouse_visible) base.win.requestProperties(props) # Get mouse position mouse_node = base.mouseWatcherNode if not mouse_node.hasMouse(): return x = mouse_node.getMouseX() y = mouse_node.getMouseY() mouse_position = x, y last_mouse_position = self.mouse_position if last_mouse_position: last_x, last_y = last_mouse_position mouse_delta = (x - last_x, y - last_y) else: mouse_delta = (0.0, 0.0) # Set mouse position and delta self.mouse_position = mouse_position self.mouse_delta = mouse_delta # Get event states is_down = mouse_node.is_button_down active_events = {v for k, v in panda_to_input_button.items() if is_down(k)} entered_events = active_events - self._down_events released_events = input_button_values - active_events # Build converted state PRESSED = ButtonStates.pressed HELD = ButtonStates.held RELEASED = ButtonStates.released converted_events = {e: HELD for e in active_events} converted_events.update({e: PRESSED for e in entered_events}) converted_events.update({e: RELEASED for e in released_events}) self._down_events = active_events self.buttons_state = converted_events self._world.messenger.send("input_updated", input_manager=self)
def setUpCamera(self): """ puts camera behind the player in third person """ # Set up the camera # Adding the camera to actor is a simple way to keep the camera locked # in behind actor regardless of actor's movement. base.camera.reparentTo(self.actor) # We don't actually want to point the camera at actors's feet. # This value will serve as a vertical offset so we can look over the actor self.cameraTargetHeight = 0.5 # How far should the camera be from the actor self.cameraDistance = 10 # Initialize the pitch of the camera self.cameraPitch = 45 # The mouse moves rotates the camera so lets get rid of the cursor props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) #set up FOV pl = base.cam.node().getLens() pl.setFov(70) base.cam.node().setLens(pl) # A CollisionRay beginning above the camera and going down toward the # ground is used to detect camera collisions and the height of the # camera above the ground. A ray may hit the terrain, or it may hit a # rock or a tree. If it hits the terrain, we detect the camera's # height. If it hits anything else, the camera is in an illegal # position. """ TODO:: This will need to be changed to bullet """ self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0,0,1000) self.groundRay.setDirection(0,0,-1) self.groundCol = CollisionNode('camRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = base.camera.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler) # We will detect anything obstructing the camera's view of the player self.cameraRay = CollisionSegment((0,0,self.cameraTargetHeight),(0,5,5)) self.cameraCol = CollisionNode('cameraRay') self.cameraCol.addSolid(self.cameraRay) self.cameraCol.setFromCollideMask(BitMask32.bit(0)) self.cameraCol.setIntoCollideMask(BitMask32.allOff()) self.cameraColNp = self.actor.attachNewNode(self.cameraCol) self.cameraColHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def pause(self): if self._running: self._running = False props = WindowProperties() props.setCursorHidden(False) base.win.requestProperties(props) if self._revealMouseAt: base.win.movePointer(0, self._revealMouseAt[0], self._revealMouseAt[1]) self._revealMouseAt = None
def __init__(self): ShowBase.__init__(self) wp = WindowProperties() wp.setSize(850, 480) wp.setTitle("GAME") base.win.requestProperties(wp) c = Client()
def stop(self): # For now show the mouseCursor props = WindowProperties() props.setCursorHidden(False) base.win.requestProperties(props) self.ignoreMouseButtons() # App exit temp base.ignore("escape")
def reconnectMouse(self): self.mouse_owner = True md = base.win.getPointer(0) x = md.getX() y = md.getY() props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) base.win.movePointer(0, self.centerx, self.centery)
def start(self): # For now hide the mouseCursor props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # App exit temp base.accept("escape", self.engine.stop) self.setMouseButtons()
def start(self): self.gameApp.disableMouse() self.camera.setP(self.refNode, 0) self.camera.setR(self.refNode, 0) # hide mouse cursor, comment these 3 lines to see the cursor props = WindowProperties() props.setCursorHidden(True) self.gameApp.win.requestProperties(props) # reset mouse to start position: self.gameApp.win.movePointer(0, self.centX, self.centY) self.gameApp.taskMgr.add(self.cameraTask, 'HxMouseLook::cameraTask') # Task for changing direction/position self.accept("w", setattr, [self, "forward", True]) self.accept("shift-w", setattr, [self, "forward", True]) self.accept("w-up", setattr, [self, "forward", False]) self.accept("s", setattr, [self, "backward", True]) self.accept("shift-s", setattr, [self, "backward", True]) self.accept("s-up", setattr, [self, "backward", False]) self.accept("a", setattr, [self, "left", True]) self.accept("shift-a", setattr, [self, "left", True]) self.accept("a-up", setattr, [self, "left", False]) self.accept("d", setattr, [self, "right", True]) self.accept("shift-d", setattr, [self, "right", True]) self.accept("d-up", setattr, [self, "right", False]) self.accept("r", setattr, [self, "up", True]) self.accept("shift-r", setattr, [self, "up", True]) self.accept("r-up", setattr, [self, "up", False]) self.accept("f", setattr, [self, "down", True]) self.accept("shift-f", setattr, [self, "down", True]) self.accept("f-up", setattr, [self, "down", False]) self.accept("q", setattr, [self, "rollLeft", True]) self.accept("q-up", setattr, [self, "rollLeft", False]) self.accept("e", setattr, [self, "rollRight", True]) self.accept("e-up", setattr, [self, "rollRight", False]) self.accept("shift", setattr, [self, "fast", 10.0]) self.accept("shift-up", setattr, [self, "fast", 1.0]) # setup collisions # setup collisions if self.collisionHandler != None: # setup collisions nearDist = self.camera.node().getLens().getNear() # Create a collision node for this camera. # and attach it to the camera. self.collisionNP = self.camera.attachNewNode( CollisionNode("firstPersonCamera")) # Attach a collision sphere solid to the collision node. self.collisionNP.node().addSolid( CollisionSphere(0, 0, 0, nearDist * 1.1)) # self.collisionNP.show() # setup camera "from" bit-mask self.collisionNP.node().setFromCollideMask(self.collideMask) # add to collisionHandler (Pusher) self.collisionHandler.addCollider(self.collisionNP, self.camera) # add camera to collision system self.gameApp.cTrav.addCollider( self.collisionNP, self.collisionHandler)
def test_winprops_copy_ctor(): props = WindowProperties() props.set_size(1, 2) props2 = WindowProperties(props) assert props == props2 assert props2.get_size() == (1, 2) with pytest.raises(TypeError): WindowProperties(None)
def setMouseLook(self, mouseLook): self.mouseLook = mouseLook self.mouseGrabbed = mouseLook # for now wp = WindowProperties() wp.setMouseMode(mouseLook and WindowProperties.MConfined or WindowProperties.MAbsolute) wp.setCursorHidden(mouseLook) self.base.win.requestProperties(wp) self.base.taskMgr.doMethodLater(0, self.resolveMouse, "resolve mouse")
def enterGameOver(self, n): properties = WindowProperties() properties.setCursorHidden(False) base.win.requestProperties(properties) self.gm = gameover.init(n) if n == 1: base.taskMgr.add(base.menusTasks, "menu", extraArgs=["gameover1"], appendTask=True) else: base.taskMgr.add(base.menusTasks, "menu", extraArgs=["gameover2"], appendTask=True)
def __init__(self, rendering: bool): """ Constructor :param rendering: boolean indicating whether to use RenderPipeline or default Panda3d as visualization-module. """ super().__init__(self) self.dir = Filename.fromOsSpecific( pyrado.PANDA_ASSETS_DIR).getFullpath() # Initialize RenderPipeline if rendering: sys.path.insert(0, pyrado.RENDER_PIPELINE_DIR) from rpcore import RenderPipeline self.render_pipeline = RenderPipeline() self.render_pipeline.pre_showbase_init() self.render_pipeline.set_loading_screen_image( osp.join(self.dir, "logo.png")) self.render_pipeline.settings["pipeline.display_debugger"] = False self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = "17:00" else: self.render_pipeline = None # Activate antialiasing self.render.setAntialias(AntialiasAttrib.MAuto) # Set window properties self.windowProperties = WindowProperties() self.windowProperties.setForeground(True) self.windowProperties.setTitle("Experiment") # Set background color self.setBackgroundColor(1, 1, 1) # Configuration of the lighting self.directionalLight1 = DirectionalLight("directionalLight") self.directionalLightNP1 = self.render.attachNewNode( self.directionalLight1) self.directionalLightNP1.setHpr(0, -8, 0) self.render.setLight(self.directionalLightNP1) self.directionalLight2 = DirectionalLight("directionalLight") self.directionalLightNP2 = self.render.attachNewNode( self.directionalLight2) self.directionalLightNP2.setHpr(180, -20, 0) self.render.setLight(self.directionalLightNP2) self.ambientLight = AmbientLight("ambientLight") self.ambientLightNP = self.render.attachNewNode(self.ambientLight) self.ambientLight.setColor((0.1, 0.1, 0.1, 1)) self.render.setLight(self.ambientLightNP) # Create a text node displaying the physic parameters on the top left of the screen self.text = TextNode("parameters") self.textNodePath = aspect2d.attachNewNode(self.text) self.text.setTextColor(0, 0, 0, 1) # black self.textNodePath.setScale(0.07) self.textNodePath.setPos(-1.9, 0, 0.9) # Configure trace self.trace = LineSegs() self.trace.setThickness(3) self.trace.setColor(0.8, 0.8, 0.8) # light grey self.lines = self.render.attachNewNode("Lines") self.last_pos = None # Adds one instance of the update function to the task-manager, thus initializes the animation self.taskMgr.add(self.update, "update")
def main(): props = WindowProperties() props.setTitle('Hostil Galaxy') props.setCursorFilename(Filename.binaryFilename('cursor.ico')) props.setCursorHidden(False) props.setFullscreen(False) props.setSize(1024, 768) game = World() game.win.setClearColor((0, 0, 0, 1)) game.win.requestProperties(props) game.setFrameRateMeter(True) game.run()
class TestScreen: def __init__(self, main_screen, screen): self.main_screen = main_screen self.props = WindowProperties() self.props.set_size(800, 600) self.props.set_origin(100 + screen * self.main_screen.res[0], 100) self.props.set_undecorated(True) self.props.set_foreground(True) self._monitor = screen self.window = self.main_screen.openWindow(props=self.props) self.lens = self.main_screen.camList[-1].node().getLens() def fullscreen(self, border=0): if self.window.get_size()[0] == 800: self.props.set_size((self.main_screen.res[0] - 2 * border, self.main_screen.res[1] - 2 * border)) self.props.setOrigin( self._monitor * self.main_screen.res[0] + border, border) self.lens.setAspectRatio( float(self.main_screen.res[0] / self.main_screen.res[1])) else: self.props.set_size(800, 600) self.props.setOrigin(100 + self._monitor * self.main_screen.res[0], 100) self.lens.setAspectRatio(4 / 3) self.window.requestProperties(self.props)
def __init__(self): super().__init__() # self.set_background_color(0, 0, 0, 1) # base.camera.setPos(0, 0, 0) # print("Skybox") self.skysphere = loader.loadModel("SkySphere.bam") self.skysphere.setBin('background', 1) self.skysphere.setDepthWrite(0) self.skysphere.reparentTo(self.render) lightIntensity = 0.7 # C:\Users\Bill\anaconda3\Lib\site-packages\panda3d\models #self.floor = self.loader.loadModel('myModels/soil_6') # material texture must be png (jpg not okay) #self.floor.setPos(0, 0, -0.5) #-2.5 #self.floor.reparentTo(self.render) self.floor = self.loader.loadModel('myModels/slab') self.floor.setPos(0, 0, -1.5) # -2.5 self.floor.reparentTo(self.render) tex = self.loader.loadTexture('myModels/tex/soil_6.jpg') self.floor.setTexture(tex, 1) self.floor.setTexScale(TextureStage.getDefault(), 50, 50) rndRange = 1.2 for i in range(20): # PUT 3x100 lettuce on teh scene: self.lett_1 = self.loader.loadModel( 'myModels/lettuce_3' ) # material texture must be png (jpg not okay) rnd = random.random() * 0.1 * rndRange self.lett_1.setPos(-0.5 - rnd, 2 + i / 2, -0.5) self.lett_1.setScale(0.1, 0.1, 0.1) self.lett_1.reparentTo(self.render) self.lett_2 = self.loader.loadModel( 'myModels/lettuce_32' ) # material texture must be png (jpg not okay) rnd = random.random() * 0.1 * rndRange self.lett_2.setPos(0 - rnd, 2 + i / 2, -0.5) self.lett_2.setScale(0.1, 0.1, 0.1) self.lett_2.reparentTo(self.render) self.lett_3 = self.loader.loadModel( 'myModels/lettuce_32' ) # material texture must be png (jpg not okay) rnd = random.random() * 0.1 * rndRange self.lett_3.setPos(0.5 - rnd, 2 + i / 2, -0.5) self.lett_3.setScale(0.1, 0.1, 0.1) self.lett_3.reparentTo(self.render) #self.cone = self.loader.loadModel('myModels/cone') # material texture must be png (jpg not okay) #self.cone.setPos(1, 2, -1) ##self.cone.setScale(0.1, 0.1, 0.1) #self.cone.reparentTo(self.render) self.tree3 = self.loader.loadModel('myModels/christmas_tree') self.tree3.setPos(-4, 7, -0.5) self.tree3.reparentTo(self.render) self.box = self.loader.loadModel('models/box') self.box.setPos(0, 0, 0) # liked to camera -0.2 0.2 self.box.setScale(0.2, 0.2, 0.2) self.box.reparentTo(self.cam) # ********* END MODELS ******** # ****** AMBIENT light ********** ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.7, 0.7, 0.7, 1)) # 0.2 0.2 0.2 lightIntensity self.ambientLightNodePath = self.render.attachNewNode( ambientLight) # attach to renderer ambiant light node path #self.trees.setLight(ambientLightNodePath) self.render.setLight( self.ambientLightNodePath) # illuminate everything # ****** DIRECTIONAL light ********** mainLight = DirectionalLight("main light") mainLight.setColor(Vec4(0.5, 0.5, 0.5, 1)) self.mainLightNodePath = self.render.attachNewNode(mainLight) # Turn it around by 45 degrees, and tilt it down by 45 degrees: setHpr(45, -45, 0) self.mainLightNodePath.setHpr(45, -90, 0) render.setLight(self.mainLightNodePath) self.render.setShaderAuto() # create shadow # ********* CAMERA ******** #self.camera.lookAt(0, 1, -0.5) # Camera tilted with Y & Z coordinates self.camera.setPos(0, 0, 0) #self.camera.setHpr(90, 0, 0) #not reacting #base.camera.setHpr(90, 0, 0) # SECOND stationery: wp = WindowProperties() wp.setSize(500, 500) wp.setOrigin(800, 50) win2 = base.openWindow(props=wp, aspectRatio=1) cam2 = base.camList[1] cam2.setPos(0, 18, 5) # 2nd relative to 'camera' 2 -20 10 cam2.lookAt(0, 0, 0) cam2.reparentTo(render) taskMgr.add(self.skysphereTask, "SkySphere Task")
def __init__(self): # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) self.stimtype = 'image_sequence' #session_start self.session_start_time = datetime.datetime.now() self.accept("escape", sys.exit, [0]) self.accept('q', self.close) self.accept('Q', self.close) # disable mouse control so that we can place the camera base.disableMouse() camera.setPosHpr(0, 0, 10, 0, -90, 0) mat = Mat4(camera.getMat()) mat.invertInPlace() base.mouseInterfaceNode.setMat(mat) # base.enableMouse() props = WindowProperties() # props.setFullscreen(True) props.setCursorHidden(True) props.setMouseMode(WindowProperties.M_relative) base.win.requestProperties(props) base.setBackgroundColor(0, 0, 0) # set the background color to black #set up the textures # we now get buffer thats going to hold the texture of our new scene altBuffer = self.win.makeTextureBuffer("hello", 1524, 1024) # altBuffer.getDisplayRegion(0).setDimensions(0.5,0.9,0.5,0.8) # altBuffer = base.win.makeDisplayRegion() # altBuffer.makeDisplayRegion(0,1,0,1) # now we have to setup a new scene graph to make this scene self.dr2 = base.win.makeDisplayRegion(0, 0.1, 0, 0.1) altRender = NodePath("new render") # this takes care of setting up ther camera properly self.altCam = self.makeCamera(altBuffer) self.dr2.setCamera(self.altCam) self.altCam.reparentTo(altRender) self.altCam.setPos(0, -10, 0) self.bufferViewer.setPosition("llcorner") # self.bufferViewer.position = (.1,.4,.1,.4) self.bufferViewer.setCardSize(1.0, 0.0) print(self.bufferViewer.position) self.imagesTexture = MovieTexture("image_sequence") # success = self.imagesTexture.read("models/natural_images.avi") success = self.imagesTexture.read("models/movie_5hz.mpg") self.imagesTexture.setPlayRate(1.0) self.imagesTexture.setLoopCount(10) # self.imageTexture =loader.loadTexture("models/NaturalImages/BSDs_8143.tiff") # self.imagesTexture.reparentTo(altRender) cm = CardMaker("stimwindow") cm.setFrame(-4, 4, -3, 3) # cm.setUvRange(self.imagesTexture) self.card = NodePath(cm.generate()) self.card.reparentTo(altRender) if self.stimtype == 'image_sequence': self.card.setTexture(self.imagesTexture, 1) # self.imagesTexture.play() # self.bufferViewer.setPosition("lrcorner") # self.bufferViewer.setCardSize(1.0, 0.0) self.accept("v", self.bufferViewer.toggleEnable) self.accept("V", self.bufferViewer.toggleEnable) # Load the tunnel self.initTunnel() #initialize some things # for the tunnel construction: self.boundary_to_add_next_segment = -1 * TUNNEL_SEGMENT_LENGTH self.current_number_of_segments = 8 #task flow booleans self.in_waiting_period = False self.stim_started = False self.looking_for_a_cue_zone = True self.in_reward_window = False self.show_stimulus = False #for task control self.interval = 0 self.time_waiting_in_cue_zone = 0 self.wait_time = 1.0 self.stim_duration = 4.0 # in seconds self.max_stim_duration = 6.0 # in seconds self.stim_elapsed = 0.0 # in seconds self.last_position = base.camera.getZ() self.position_on_track = base.camera.getZ() #for reward control self.reward_window = 1.0 # in seconds self.reward_elapsed = 0.0 self.reward_volume = 0.008 # in mL. this is for the hardcoded 0.1 seconds of reward time self.reward_time = 0.1 # in sec, based on volume. hard coded right now but should be modified by the (1) calibration and (2) optionally by the main loop for dynamic reward scheduling # self.lick_buffer = [] #INITIALIZE NIDAQ self.nidevice = 'Dev1' self.encodervinchannel = 0 self.encodervsigchannel = 1 self.invertdo = False self.diport = 1 self.lickline = 1 self.doport = 0 self.rewardline = 0 self.rewardlines = [0] self._setupDAQ() self.do.WriteBit(1, 1) self.do.WriteBit( 3, 1 ) #set reward high, because the logic is flipped somehow. possibly by haphazard wiring of the circuit (12/24/2018 djd) self.previous_encoder_position = self.ai.data[0][2] self.encoder_gain = -20 #INITIALIZE LICK SENSOR self._lickSensorSetup() #INITIALIZE output data self.lickData = [] self.x = [] self.t = [] self.trialData = [] self.rewardData = [] #INITIALIZE KEY SENSOR, for backup inputs and other user controls self.keys = key.KeyStateHandler() self.accept('r', self._give_reward, [self.reward_volume]) img_list = glob.glob('models/NaturalImages/*.tiff')[:10] print(img_list) self.imageTextures = [loader.loadTexture(img) for img in img_list] if AUTO_MODE: self.gameTask = taskMgr.add(self.autoLoop2, "autoLoop2") self.rewardTask = taskMgr.add(self.rewardControl, "reward") self.cue_zone = concatenate( (self.cue_zone, arange( self.current_number_of_segments * -TUNNEL_SEGMENT_LENGTH - 10, self.current_number_of_segments * -TUNNEL_SEGMENT_LENGTH - TUNNEL_SEGMENT_LENGTH - 10, -1))) self.auto_position_on_track = 0 self.auto_restart = False self.auto_running = True self.contTunnel() else: # Now we create the task. taskMgr is the task manager that actually # calls the function each frame. The add method creates a new task. # The first argument is the function to be called, and the second # argument is the name for the task. It returns a task object which # is passed to the function each frame. self.gameTask = taskMgr.add(self.gameLoop, "gameLoop") # self.stimulusTask = taskMgr.add(self.stimulusControl, "stimulus") self.lickTask = taskMgr.add(self.lickControl, "lick") self.rewardTask = taskMgr.add(self.rewardControl, "reward")
def properties(self): if not self.pipe: self.makeDefaultPipe() props = WindowProperties() props.setTitle("Title placeholder") if self.option[Options.FULL.value]: props.setSize(self.option[Options.RES.value][Options.X.value], self.option[Options.RES.value][Options.Y.value]) props.setFullscreen(True) loadPrcFileData('', 'fullscreen t') else: props.setSize(self.option[Options.RES.value][Options.X.value], self.option[Options.RES.value][Options.Y.value]) props.setCursorHidden(True) props.setDefault(props) self.openMainWindow(props)
from direct.gui.DirectGui import * import sys import random import math import buildingsDB from cameraController import CameraController from planetInfoView import PlanetInfoView from planetBuildView import PlanetBuildView from star import Star from planet import Planet from moon import Moon base = ShowBase() wp = WindowProperties() wp.setSize(1080, 600) base.win.requestProperties(wp) class World(DirectObject): def __init__(self): # The standard camera, light and background initialization base.setBackgroundColor(0, 0, 0) base.disableMouse() self.cam_ctrl = CameraController() self.cam_ctrl.reset() alight = AmbientLight('alight') alight.setColor((0.2, 0.2, 0.2, 1)) alnp = render.attachNewNode(alight)
def __init__(self): ShowBase.__init__(self) # self.setFrameRateMeter(True) wp = WindowProperties() wp.setSize(1280, 720) wp.setFullscreen(False) self.win.requestProperties(wp) self.disableMouse() # Load the background starfield. self.setBackgroundColor((0, 0, 0, 1)) self.font = loader.loadFont('textures/inconsolata.egg') self.bg = loadObject("star_field.png", scale=73, depth=200, transparency=False) self.bg.setTag('back_ground', '1') self.bg.setSx(73*16/9) # Load the ship and set its initial velocity. Create a ship entity self.keys = { "turnLeft": 0, "turnRight": 0, "accel": 0, "fire": 0, "laser": 0, "e_to_s": 0, "s_to_e": 0, "cloak": 0, "p2turnLeft": 0, "p2turnRight": 0, "p2accel": 0, "p2fire": 0, "p2laser": 0, "e_to_s2": 0, "s_to_e2": 0, "cloak2": 0, "toggle_debug": 0, "e_field": 0, "e_field2": 0, "mouse_l": 0, } self.accept("escape", sys.exit) # Escape quits # Other keys events set the appropriate value in our key dictionary self.accept("a", self.setKey, ["turnLeft", 1]) self.accept("a-up", self.setKey, ["turnLeft", 0]) self.accept("d", self.setKey, ["turnRight", 1]) self.accept("d-up", self.setKey, ["turnRight", 0]) self.accept("w", self.setKey, ["accel", 1]) self.accept("w-up", self.setKey, ["accel", 0]) self.accept("f", self.setKey, ["fire", 1]) self.accept("f-up", self.setKey, ["fire", 0]) self.accept("h", self.setKey, ["laser", 1]) self.accept("h-up", self.setKey, ["laser", 0]) self.accept("r", self.setKey, ["e_to_s", 1]) self.accept("r-up", self.setKey, ["e_to_s", 0]) self.accept("t", self.setKey, ["s_to_e", 1]) self.accept("t-up", self.setKey, ["s_to_e", 0]) self.accept("s", self.setKey, ["cloak", 1]) self.accept("s-up", self.setKey, ["cloak", 0]) self.accept("g", self.setKey, ["e_field", 1]) self.accept("g-up", self.setKey, ["e_field", 0]) self.accept("arrow_left", self.setKey, ["p2turnLeft", 1]) self.accept("arrow_left-up", self.setKey, ["p2turnLeft", 0]) self.accept("arrow_right", self.setKey, ["p2turnRight", 1]) self.accept("arrow_right-up", self.setKey, ["p2turnRight", 0]) self.accept("arrow_up", self.setKey, ["p2accel", 1]) self.accept("arrow_up-up", self.setKey, ["p2accel", 0]) # NUMPAD for p2 self.accept("1", self.setKey, ["p2fire", 1]) self.accept("1-up", self.setKey, ["p2fire", 0]) self.accept("3", self.setKey, ["p2laser", 1]) self.accept("3-up", self.setKey, ["p2laser", 0]) self.accept("4", self.setKey, ["e_to_s2", 1]) self.accept("4-up", self.setKey, ["e_to_s2", 0]) self.accept("5", self.setKey, ["s_to_e2", 1]) self.accept("5-up", self.setKey, ["s_to_e2", 0]) self.accept("2", self.setKey, ["e_field2", 1]) self.accept("2-up", self.setKey, ["e_field2", 0]) # NO NUMPAD for p2 self.accept("l", self.setKey, ["p2fire", 1]) self.accept("l-up", self.setKey, ["p2fire", 0]) self.accept("'", self.setKey, ["p2laser", 1]) self.accept("'-up", self.setKey, ["p2laser", 0]) self.accept("o", self.setKey, ["e_to_s2", 1]) self.accept("o-up", self.setKey, ["e_to_s2", 0]) self.accept("p", self.setKey, ["s_to_e2", 1]) self.accept("p-up", self.setKey, ["s_to_e2", 0]) self.accept(";", self.setKey, ["e_field2", 1]) self.accept(";-up", self.setKey, ["e_field2", 0]) self.accept("arrow_down", self.setKey, ["cloak2", 1]) self.accept("arrow_down-up", self.setKey, ["cloak2", 0]) self.accept("f1", self.setKey, ["toggle_debug", 1]) self.accept("mouse1", self.setKey, ["mouse_l", 1]) self.accept("mouse1-up", self.setKey, ["mouse_l", 0]) init_menu(self) self.gameTask = taskMgr.add(self.menuLoop, "gameLoop")
def showMouse(self): props = WindowProperties() props.setCursorHidden(False) base.win.requestProperties(props)
def __init__(self): ShowBase.__init__(self) #renaming properties properties = WindowProperties() #set windows size property properties.setSize(1000, 750) #activate the property to the current window self.win.requestProperties(properties) #Calling one of Panda's lighting functions and naming it ambientLight = AmbientLight("ambient light") #setting the colour ambientLight.setColor(Vec4(1, 1, 1, 1)) #creating a lighting node and adding it to the render list (doesn't do anything yet) self.ambientLightNodePath = self.render.attachNewNode(ambientLight) #We need to also use the setLight function to actually light the scene self.render.setLight(self.ambientLightNodePath) #choose shader self.render.setShaderAuto() #gather main camera generated by showbase self.first_person_camera_node = self.cam self.mouseLook = FirstPersonCamera(self, self.first_person_camera_node, self.render) lens = OrthographicLens() lens.setFilmSize(2, 2) # Or whatever is appropriate for your scene self.spot_camera = Camera("Spot Camera") self.spot_camera.setLens(lens) self.spot_camera_node = self.render.attachNewNode(self.spot_camera) self.spot_camera_node.node().setLens(lens) self.spot_camera_node.setName("Spot Camera") self.spot_camera_node.setPos(2, 0, 0) self.spot_camera_node.lookAt(0, 0, 0) dr = base.camNode.getDisplayRegion(0) dr.setActive(0) window = dr.getWindow() dr1 = window.makeDisplayRegion(0, 0.8, 0, 1) dr1.setSort(dr.getSort()) dr2 = window.makeDisplayRegion(0.8, 0.9, 0.2, 0.4) dr2.setSort(dr.getSort()) dr1.setCamera(self.first_person_camera_node) dr2.setCamera(self.spot_camera_node) axes = self.createAxes(2) axes.reparentTo(self.render) self.Line = self.render.attachNewNode(LineSegs().create()) self.taskMgr.add(self.update, "Update")
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')
props.setSize(width, height) if base and base.win: base.win.requestProperties(props) # Start ShowBase, but don't open a Panda window yet base = ShowBase(windowType='none') # Start Tkinter integration, get the root window handle base.startTk() frame = base.tkRoot frame.bind('<Configure>', on_resize) frame.update() id = frame.winfo_id() width = frame.winfo_width() height = frame.winfo_height() props = WindowProperties() props.setParentWindow(id) props.setOrigin(0, 0) props.setSize(width, height) base.makeDefaultPipe() base.openDefaultWindow(props=props) scene = base.loader.loadModel("environment") scene.reparentTo(base.render) base.run()
def __init__(self): ShowBase.__init__(self) self.disableMouse() properties = WindowProperties() properties.setSize(1000, 750) self.win.requestProperties(properties) mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ambientLightNodePath = render.attachNewNode(ambientLight) render.setLight(self.ambientLightNodePath) render.setShaderAuto() self.environment = loader.loadModel("Models/Misc/environment") self.environment.reparentTo(render) self.camera.setPos(0, 0, 32) self.camera.setP(-90) self.keyMap = { "up" : False, "down" : False, "left" : False, "right" : False, "shoot" : False } self.accept("w", self.updateKeyMap, ["up", True]) self.accept("w-up", self.updateKeyMap, ["up", False]) self.accept("s", self.updateKeyMap, ["down", True]) self.accept("s-up", self.updateKeyMap, ["down", False]) self.accept("a", self.updateKeyMap, ["left", True]) self.accept("a-up", self.updateKeyMap, ["left", False]) self.accept("d", self.updateKeyMap, ["right", True]) self.accept("d-up", self.updateKeyMap, ["right", False]) self.accept("mouse1", self.updateKeyMap, ["shoot", True]) self.accept("mouse1-up", self.updateKeyMap, ["shoot", False]) self.pusher = CollisionHandlerPusher() self.cTrav = CollisionTraverser() self.pusher.setHorizontal(True) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(8.0) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(-8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(-8.0) self.updateTask = taskMgr.add(self.update, "update") self.player = Player(Vec3(0, 0, 0), "Models/PandaChan/act_p3d_chan", { "stand" : "Models/PandaChan/a_p3d_chan_idle", "walk" : "Models/PandaChan/a_p3d_chan_run" }, 5, 10, "player") self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0))
def __init__(self): ShowBase.__init__(self) self.models = [] self.base_textures = [] # window title props = WindowProperties() props.setTitle(pathlib.Path(args.project).name) base.win.requestProperties(props) # we would like an orthographic lens self.lens = OrthographicLens() self.lens.setFilmSize(20, 15) base.camNode.setLens(self.lens) self.cam_pos = [0.0, 0.0, 10000.0] self.camera.setPos(self.cam_pos[0], self.cam_pos[1], self.cam_pos[2]) self.camera.setHpr(0, -90.0, 0) self.view_size = 100.0 self.last_ysize = 0 self.top_image = 0 # modules self.surface = surface.Surface(proj.analysis_dir) self.annotations = annotations.Annotations(self.render, self.surface, proj, ned_ref, tk_root) self.reticle = reticle.Reticle(self.render, self.surface, ned_ref) self.draw_reticle = True #self.messenger.toggleVerbose() # event handlers self.accept('arrow_left', self.cam_move, [-0.1, 0, 0]) self.accept('arrow_right', self.cam_move, [0.1, 0, 0]) self.accept('arrow_down', self.cam_move, [0, -0.1, 0]) self.accept('arrow_up', self.cam_move, [0, 0.1, 0]) self.accept('=', self.cam_zoom, [1.1]) self.accept('shift-=', self.cam_zoom, [1.1]) self.accept('-', self.cam_zoom, [1.0 / 1.1]) self.accept('wheel_up', self.cam_zoom, [1.1]) self.accept('wheel_down', self.cam_zoom, [1.0 / 1.1]) self.accept('mouse1', self.mouse_state, [0, 1]) self.accept('mouse1-up', self.mouse_state, [0, 0]) self.accept('0', self.image_select, [0]) self.accept('1', self.image_select, [1]) self.accept('2', self.image_select, [2]) self.accept('3', self.image_select, [3]) self.accept('4', self.image_select, [4]) self.accept('5', self.image_select, [5]) self.accept('6', self.image_select, [6]) self.accept('7', self.image_select, [7]) self.accept('8', self.image_select, [8]) self.accept('9', self.image_select, [9]) self.accept('f', self.toggle_filter) self.accept('m', self.toggle_view_mode) self.accept('r', self.toggle_reticle) self.accept(',', self.update_sequential_num, [-1]) self.accept('.', self.update_sequential_num, [1]) self.accept('escape', self.quit) self.accept('mouse3', self.annotations.toggle, [self.cam_pos]) # mouse state self.last_mpos = [0, 0] self.mouse = [0, 0, 0] self.last_mouse = [0, 0, 0] # Add the tasks to the task manager. self.taskMgr.add(self.updateCameraTask, "updateCameraTask") # Shader (aka filter?) self.filter = 'none' # Set default view mode self.view_mode = 'best' # self.view_mode = 'sequential' self.sequential_num = 0 # dump a summary of supposed card capabilities self.query_capabilities(display=True) # test shader # self.shader = Shader.load(Shader.SL_GLSL, vertex="explore/myshader.vert", fragment="explore/myshader.frag", geometry="explore/myshader.geom") self.shader = Shader.load(Shader.SL_GLSL, vertex="explore/myshader.vert", fragment="explore/myshader.frag")
def __updateCursor(self, cursorName): wp = WindowProperties() wp.setCursorFilename(self.MouseCursors.get(cursorName)) base.win.requestProperties(wp)
class Panda3dViewer(BaseViewer, ShowBase): def __init__(self, params=None, **kwargs): # Load 3d-Model and parameter super(Panda3dViewer, self).__init__(params=params) self.world_x_range = kwargs.pop("x_range", [-40, 40]) self.world_y_range = kwargs.pop("y_range", [-40, 40]) self.follow_agent_id = kwargs.pop("follow_agent_id", -1) self.screen_dims = kwargs.pop("screen_dims", [1024, 1024]) self.path = os.path.join( os.path.dirname(os.path.abspath(__file__)) ) # TODO(@fortiss): load into parameter at a earlier stage self.agent_model_path = kwargs.pop("model_path", self.path + "/models/box_car") self.agent_scale = kwargs.pop("model_scale", np.array([3.65, 1.8, 0.8], dtype=float)) self.agent_orientation = \ kwargs.pop("model_orientation",np.array([180, 0,0], dtype=float)) self.agent_translation = kwargs.pop("model_translation", np.array([3.2, 0.9], dtype=float)) self.range_for_zoom = kwargs.pop("is_zoom_range", False) self.line_thicknesses = kwargs.pop( "line_thickness", { #Dict of keys cameras and values [line thickness, height] which are needed to calculate the dynamic thickness -2: [0.35, 700], -1: [0.35, 700], 0: [0.1, 70] }) # Parameter for agent camera views # [driving direction offset, height, x-orientation,y-orientation,z-orientation offset to driving direction, LookAt?] self.agent_cam_parameter = kwargs.pop( "agent_view", { "bird_agent": [0, 70, 0, 270, 270, False], "third": [-35, 15, 0, 0, 0, True], "first": [1.2, 2.7, 180, 190, 90, False] }) # Set Window Size self.wp = WindowProperties().getDefault() self.wp.setSize(self.screen_dims[0], self.screen_dims[1]) self.wp.setTitle("BARK Panda3d Viewer") WindowProperties.setDefault(self.wp) ShowBase.__init__(self) # Render Objects Dict self.agent_nodes = {} # Agent Poses Dict self.agent_poses = {} self.setLight() # Creating a plane as floor #TODO parameter from map parameter frame = [ -self.screen_dims[0] / 2, self.screen_dims[0] / 2, -self.screen_dims[1] / 2, self.screen_dims[1] / 2 ] color = VBase4(self.plane_color[0], self.plane_color[1], self.plane_color[2], self.plane_alpha) self.createPlane(frame=frame, color=color) # Set up the camera loop task self.camera_list = [-1] self.initCam() self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") # Set up the line generator self.setDrawer(budget=100000) # -2 : global camera with camera control, -1: transition state for enabling mouse control, 0: agent cameras self.perspectives = { -2: ["birdview", "autozoom"], -1: ["None"], 0: ["bird_agent", "third", "first"] } self.perspective = self.perspectives[self.camIndex( self.follow_agent_id)] self.line_thickness = self.line_thicknesses[self.camIndex( self.follow_agent_id)][0] self.addButtons() def setDrawer(self, budget=100000): """Initializes the MeshDrawer() generator to draw lines in Panda3d Keyword Arguments: budget {int} -- maximum triangles for rendering the mesh (default: {100000}) """ self.generator = MeshDrawer() self.generator.setBudget(budget) self.generatorNode = self.generator.getRoot() self.generatorNode.reparentTo(self.render) def createPlane(self, frame=None, color=VBase4(1, 1, 1, 1)): """ Creates a Plane/Card with the Panda3d Cardmaker() class Keyword Arguments: frame {list} -- The coordinates [x1,y1,x2,y2] of the planes/cards edges (default: {[-1, -1, 1, 1]}) color {VBase4} -- The color of the planes/cards (default: {VBase4(1, 1, 1, 1)}) """ frame = frame or [-1, -1, 1, 1] card = CardMaker("plane") card.set_color(color) card.set_frame(frame[0], frame[1], frame[2], frame[3]) n = NodePath() self.plane = n.attach_new_node(card.generate()) self.plane.reparentTo(self.render) self.plane.setHpr(0, 270, 0) def setLight(self, color=VBase4(1, 1, 1, 1)): """Sets an ambient and omnidirectional light for rendering Keyword Arguments: color {VBase4} -- color of the ambient light (default: {VBase4(1, 1, 1, 1)}) """ alight = AmbientLight('alight') alight.setColor(color) alnp = self.render.attachNewNode(alight) self.render.setLight(alnp) def addButtons(self): self.cam_btn = DirectButton(text="Camera", scale=0.05, command=self.switchCamera, pos=Vec3(0.9, 0, 0.9)) self.per_btn = DirectButton(text="View", scale=0.05, command=self.switchView, pos=Vec3(0.9, 0, 0.85)) def camIndex(self, follow_id): return np.minimum(follow_id, 0) def switchCamera(self): # Switches between global and agent cameras self.follow_agent_id = self.camera_list.pop(0) self.camera_list.append(self.follow_agent_id) self.perspective = self.perspectives[self.camIndex( self.follow_agent_id)].copy() self.line_thickness = self.line_thicknesses[self.camIndex( self.follow_agent_id)][0] def switchView(self): # Switches between the perspectives defined by the camera self.perspective.append(self.perspective[0]) self.perspective.pop(0) def updateCamera(self, lookAt=False): """Updates the camera position from calls using variables self.cam_pose and self.cam_or Keyword Arguments: lookAt {bool} -- If true the orientation is calculated by the agents position (default: {False}) """ self.camera.setPos(self.cam_pose[0], self.cam_pose[1], self.cam_pose[2]) if lookAt: self.camera.lookAt(self.agent_nodes[self.follow_agent_id]) else: self.camera.setHpr(self.cam_or[2], self.cam_or[1], self.cam_or[0]) def spinCameraTask(self, task): """This function sets and updates the camera according to environment variables and parameters Arguments: task {task} -- Panda3d Task Returns: Task.cont -- Panda3d Task Return """ if self.follow_agent_id is -1: # Transition into camera control view self.setMouseControl() if self.follow_agent_id is -2: # Global Camera if (self.perspective[0] is self.perspectives[-2][1]): self.setAutoZoomCam(self.agent_poses) if self.follow_agent_id >= 0: # Camera for all agents self.setAgentCam(self.perspective[0], self.agent_poses[self.follow_agent_id]) return Task.cont def initCam(self, poses=None, orientation=None): #TODO Calculate from map parameter before poses = poses or [0, 0, 700] orientation = orientation or [0, 270, 0] self.cam_pose = np.array(poses, dtype=float) self.cam_or = np.array(orientation, dtype=float) def setMouseControl(self): # Enables Panda3d Standard Mouse Control # Right mouse button: zoom, left mouse Button: move, middle mouse button: tilt self.initCam() self.updateCamera(lookAt=False) self.mat = Mat4(self.camera.getMat()) self.mat.invertInPlace() base.mouseInterfaceNode.setMat(self.mat) base.enableMouse() self.follow_agent_id = -2 self.perspective = self.perspectives[self.camIndex( self.follow_agent_id)].copy() def setAutoZoomCam(self, agent_poses): """This function calculates the camera position so that all agents are visible Arguments: agent_poses {[dict]} -- [look up table of all agent poses] """ points = np.array([[]], dtype=float) if ((self.world_x_range is not None) and (self.world_y_range is not None) and self.range_for_zoom): points = np.array([[self.world_x_range[0], self.world_y_range[0]], [self.world_x_range[1], self.world_y_range[1]]]) # Build concat matrix of all positions for _, agent in agent_poses.items(): if points.size is 0: points = np.array([[agent[0], agent[1]]], dtype=float) else: points = np.append(points, [[agent[0], agent[1]]], axis=0) # Calculate maximum distance between min,max of x or y poses max_dist = np.max(np.max(points, axis=0) - np.min(points, axis=0)) # Calculate mean positions as center for camera center = (np.max(points, axis=0) + np.min(points, axis=0)) / 2 # Lower bound for vieweable area max_dist = np.maximum(max_dist * 1.25, 40) # Calculate camera height zoom = max_dist * np.tan(pi * (60 / 180)) self.cam_pose = np.array([center[0], center[1], zoom], dtype=float) self.cam_or = np.array([0, 270, 0], dtype=float) self.updateCamera(lookAt=False) def setAgentCam(self, perspective, agent_poses): """Sets up the class variable for the camerea position and orientation Arguments: perspective {list} -- List of strings describing the perspective currently ["bird_agent","third","first"] which is used as an index for the parameters dict agent_poses {np.array([x,y,theta])} -- Describes the agent position """ base.disableMouse() self.cam_pose[0] = agent_poses[0] + self.agent_cam_parameter[ perspective][0] * np.cos(agent_poses[2]) self.cam_pose[1] = agent_poses[1] + self.agent_cam_parameter[ perspective][0] * np.sin(agent_poses[2]) self.cam_pose[2] = self.agent_cam_parameter[perspective][1] self.cam_or = np.array([ self.agent_cam_parameter[perspective][2], self.agent_cam_parameter[perspective][3], (agent_poses[2] * 180) / pi + self.agent_cam_parameter[perspective][4] ], dtype=float) self.updateCamera(lookAt=self.agent_cam_parameter[perspective][5]) def calcLineThickness(self, cameras=None): """Uses a linear approximation between two cameras to calculate the line thickness Arguments: cameras {int array} -- Sets the indices of the target cameras Returns: [float] -- [The approximated thickness] """ cameras = cameras or [-1, 0] incline = (self.line_thicknesses[cameras[0]][0] - self.line_thicknesses[cameras[1]][0]) / ( self.line_thicknesses[cameras[0]][1] - self.line_thicknesses[cameras[1]][1]) return np.maximum( (self.line_thicknesses[cameras[1]][0] + incline * (self.camera.getZ() - self.line_thicknesses[cameras[1]][1])), 0.01) def drawPolygon2d(self, polygon, color, alpha): # Draws a polygon with drawLine2d points = polygon.toArray() self.line_thickness = self.calcLineThickness() for point in points: self.generator.link_segment(Vec3(point[0], point[1], 2), Vec4(0, 0, 1, 1), self.line_thickness, self.getColor(color)) self.generator.link_segment_end(Vec4(0, 0, 1, 1), self.getColor(color)) def drawLine2d(self, line2d, color=Viewer.Color.Blue, alpha=1.0): line2d_np = line2d.toArray() for point in line2d_np: self.generator.link_segment(Vec3(point[0], point[1], 2), Vec4(0, 0, 1, 1), self.line_thickness, self.getColor(color)) self.generator.link_segment_end(Vec4(0, 0, 1, 1), self.getColor(color)) def drawAgent(self, agent): """Draws an agent object with a model previosly set in set with self.agent_model_path Arguments: agent -- Agent object from world """ # Adds new agent to dict of Panda3d nodes if not agent.id in self.agent_nodes: self.agent_nodes[agent.id] = self.loader.loadModel( self.agent_model_path) self.agent_nodes[agent.id].reparentTo(self.render) self.agent_nodes[agent.id].setPos(0, 0, 2) self.agent_nodes[agent.id].setScale(self.agent_scale[0], self.agent_scale[1], self.agent_scale[2]) self.agent_poses[agent.id] = np.array([0, 0, 0], dtype=float) self.camera_list.insert(len(self.camera_list), agent.id) # Set new pose of agent in world cordinates state = agent.followed_trajectory[-1, :] self.agent_poses[agent.id][0] = state[int(StateDefinition.X_POSITION)] self.agent_poses[agent.id][1] = state[int(StateDefinition.Y_POSITION)] self.agent_poses[agent.id][2] = state[int( StateDefinition.THETA_POSITION)] transformed_polygon = agent.shape.transform(self.agent_poses[agent.id]) self.drawPolygon2d(transformed_polygon, self.color_agents, 1.0) # Fitting of 3d-Model frame to agent positon angle = ((self.agent_poses[agent.id][2] * 180) / pi + self.agent_orientation[0]) self.agent_nodes[agent.id].setHpr(angle, self.agent_orientation[1], self.agent_orientation[2]) translation = self.agent_translation if not np.all(translation == 0): r = np.array([[ np.cos(self.agent_poses[agent.id][2]), np.sin(self.agent_poses[agent.id][2]) ], [ np.cos(self.agent_poses[agent.id][2] + pi * 0.5), np.sin(self.agent_poses[agent.id][2] + pi * 0.5) ]], dtype=float) translation = np.dot(translation, r) self.agent_nodes[agent.id].setPos( self.agent_poses[agent.id][0] + translation[0], self.agent_poses[agent.id][1] + translation[1], 2) if self.draw_route: self.drawRoute(agent) def getColor(self, color): if isinstance(color, Viewer.Color): return { Viewer.Color.White: Vec4(1, 1, 1, 1), Viewer.Color.Red: Vec4(1, 0, 0, 1), Viewer.Color.Blue: Vec4(0, 0, 1, 1), Viewer.Color.Magenta: Vec4(100.0 / 255.0, 1, 100.0 / 255.0, 1), Viewer.Color.Brown: Vec4(150.0 / 255.0, 50.0 / 255.0, 50.0 / 255.0, 1), Viewer.Color.Black: Vec4(0, 0, 0, 1) }.get(color, Vec4(0, 0, 0, 1)) else: return Vec4(color[0], color[1], color[2], 1) def drawWorld(self, world, eval_agent_ids=None): self.generator.begin(base.cam, self.render) super(Panda3dViewer, self).drawWorld(world, eval_agent_ids) self.generator.end() self.taskMgr.step()
def __init__(self, cam_pos=np.array([2.0, 0.5, 2.0]), lookat_pos=np.array([0, 0, 0.25]), up=np.array([0, 0, 1]), fov=40, w=1920, h=1080, lens_type="perspective", toggle_debug=False, auto_cam_rotate=False): """ :param cam_pos: :param lookat_pos: :param fov: :param w: width of window :param h: height of window author: weiwei date: 2015?, 20201115 """ # the taskMgr, loader, render2d, etc. are added to builtin after initializing the showbase parental class super().__init__() # set up window winprops = WindowProperties(base.win.getProperties()) winprops.setTitle("WRS Robot Planning and Control System") base.win.requestProperties(winprops) self.disableAllAudio() self.setBackgroundColor(1, 1, 1) # set up lens lens = PerspectiveLens() lens.setFov(fov) lens.setNearFar(0.001, 5000.0) if lens_type == "orthographic": lens = OrthographicLens() lens.setFilmSize(640, 480) # disable the default mouse control self.disableMouse() self.cam.setPos(cam_pos[0], cam_pos[1], cam_pos[2]) self.cam.lookAt(Point3(lookat_pos[0], lookat_pos[1], lookat_pos[2]), Vec3(up[0], up[1], up[2])) self.cam.node().setLens(lens) # set up slight ## ambient light ablight = AmbientLight("ambientlight") ablight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ablightnode = self.cam.attachNewNode(ablight) self.render.setLight(self.ablightnode) ## point light 1 ptlight0 = PointLight("pointlight0") ptlight0.setColor(Vec4(1, 1, 1, 1)) self._ptlightnode0 = self.cam.attachNewNode(ptlight0) self._ptlightnode0.setPos(0, 0, 0) self.render.setLight(self._ptlightnode0) ## point light 2 ptlight1 = PointLight("pointlight1") ptlight1.setColor(Vec4(.4, .4, .4, 1)) self._ptlightnode1 = self.cam.attachNewNode(ptlight1) self._ptlightnode1.setPos(self.cam.getPos().length(), 0, self.cam.getPos().length()) self.render.setLight(self._ptlightnode1) ## point light 3 ptlight2 = PointLight("pointlight2") ptlight2.setColor(Vec4(.3, .3, .3, 1)) self._ptlightnode2 = self.cam.attachNewNode(ptlight2) self._ptlightnode2.setPos(-self.cam.getPos().length(), 0, self.cam.getPos().length()) self.render.setLight(self._ptlightnode2) # helpers self.p3dh = p3dh # self.o3dh = o3dh self.rbtmath = rm # set up inputmanager self.lookatpos = lookat_pos self.inputmgr = im.InputManager(self, self.lookatpos) taskMgr.add(self._interaction_update, "interaction", appendTask=True) # set up rotational cam if auto_cam_rotate: taskMgr.doMethodLater(.1, self._rotatecam_update, "rotate cam") # set window size props = WindowProperties() props.setSize(w, h) self.win.requestProperties(props) # outline edge shader # self.set_outlineshader() # set up cartoon effect self._separation = 1 self.filter = flt.Filter(self.win, self.cam) self.filter.setCartoonInk(separation=self._separation) # self.filter.setViewGlow() # set up physics world self.physics_scale = 1e3 self.physicsworld = BulletWorld() self.physicsworld.setGravity(Vec3(0, 0, -9.81 * self.physics_scale)) taskMgr.add(self._physics_update, "physics", appendTask=True) globalbprrender = base.render.attachNewNode("globalbpcollider") debugNode = BulletDebugNode('Debug') debugNode.showWireframe(True) debugNode.showConstraints(True) debugNode.showBoundingBoxes(False) debugNode.showNormals(True) self._debugNP = globalbprrender.attachNewNode(debugNode) self._debugNP.show() self.toggledebug = toggle_debug if toggle_debug: self.physicsworld.setDebugNode(self._debugNP.node()) self.physicsbodylist = [] # set up render update (TODO, only for dynamics?) self._internal_update_obj_list = [ ] # the nodepath, collision model, or bullet dynamics model to be drawn self._internal_update_robot_list = [] taskMgr.add(self._internal_update, "internal_update", appendTask=True) # for remote visualization self._external_update_objinfo_list = [] # see anime_info.py self._external_update_robotinfo_list = [] taskMgr.add(self._external_update, "external_update", appendTask=True) # for stationary models self._noupdate_model_list = []
def set_window_icon(file: str): winprops = WindowProperties() winprops.setIconFilename(file) base = app.get_show_base() base.win.requestProperties(winprops)
def __init__(self, parent, pos): self.parent = parent self.node = render.attachNewNode('PlayerNode') self.node.setPos(pos[0] * TILE_SIZE, pos[1] * TILE_SIZE, TILE_SIZE * ASPECT / 1.5) taskMgr.add(self.updatePlayer, 'UpdatePlayerTask') taskMgr.add(self.updateBullets, 'UpdateBulletsTask') self.centerx = base.win.getProperties().getXSize() / 2 self.centery = base.win.getProperties().getYSize() / 2 self.speed = TILE_SIZE - 4 self.sprint_speed = self.speed * 1.8 self.can_move = True self.camera = True self.mouse_owner = True self.max_health = 100 self.health = self.max_health self.max_bullets = 10 self.bullets = 4 self.bullet_objects = [] self.sprint = False self.moving = False self.gunshot_at = None props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # Create player flashlight self.slight = Spotlight('slight') self.slight.setColor(VBase4(1, 1, 0.6, 1)) #self.lens = PerspectiveLens() #self.slight.setLens(self.lens) self.slnp = self.node.attachNewNode(self.slight) self.slnp.node().getLens().setFov(88) self.slnp.node().getLens().setNearFar(1, 70) self.slight.setExponent(10) self.slight.setAttenuation(Point3(0.737, 0.134, 0.001)) render.setLight(self.slnp) self.flashlight = True self.shoot_sound = base.loader.loadSfx( "audio/GUN_FIRE-GoodSoundForYou-820112263.wav") self.gun_click_sound = base.loader.loadSfx( "audio/Dry Fire Gun-SoundBible.com-2053652037.wav") self.heart_sound = base.loader.loadSfx( "audio/Slow_HeartBeat-Mike_Koenig-1853475164.wav") self.heart_sound.setLoop(True) self.heart_sound.setVolume(0.6) self.heart_sound.play() self.scratches = loadImageAsPlane('models/scr.png') self.scratches.setTransparency(TransparencyAttrib.MAlpha) self.damage_anim = Parallel() self.keys = {} self.keys['forward'] = 0 self.keys['back'] = 0 self.keys['strafe_left'] = 0 self.keys['strafe_right'] = 0 self.keys['sprint'] = 0 self.setKeyEvents() self.pause = False
def hide_cursor(self): props = WindowProperties() props.setCursorHidden(True) self.win.requestProperties(props)
def __init__(self): ShowBase.__init__(self) self.disableMouse() properties = WindowProperties() properties.setSize(1000, 750) self.win.requestProperties(properties) self.exitFunc = self.cleanup mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ambientLightNodePath = render.attachNewNode(ambientLight) render.setLight(self.ambientLightNodePath) render.setShaderAuto() self.environment = loader.loadModel("Models/Misc/environment") self.environment.reparentTo(render) self.camera.setPos(0, 0, 32) self.camera.setP(-90) self.keyMap = { "up": False, "down": False, "left": False, "right": False, "shoot": False } self.accept("w", self.updateKeyMap, ["up", True]) self.accept("w-up", self.updateKeyMap, ["up", False]) self.accept("s", self.updateKeyMap, ["down", True]) self.accept("s-up", self.updateKeyMap, ["down", False]) self.accept("a", self.updateKeyMap, ["left", True]) self.accept("a-up", self.updateKeyMap, ["left", False]) self.accept("d", self.updateKeyMap, ["right", True]) self.accept("d-up", self.updateKeyMap, ["right", False]) self.accept("mouse1", self.updateKeyMap, ["shoot", True]) self.accept("mouse1-up", self.updateKeyMap, ["shoot", False]) self.pusher = CollisionHandlerPusher() self.cTrav = CollisionTraverser() self.pusher.setHorizontal(True) self.pusher.add_in_pattern("%fn-into-%in") self.accept("trapEnemy-into-wall", self.stopTrap) self.accept("trapEnemy-into-trapEnemy", self.stopTrap) self.accept("trapEnemy-into-player", self.trapHitsSomething) self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(8.0) wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setY(-8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(8.0) wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(-8.0) self.updateTask = taskMgr.add(self.update, "update") self.player = None self.enemies = [] self.trapEnemies = [] self.deadEnemies = [] self.spawnPoints = [] numPointsPerWall = 5 for i in range(numPointsPerWall): coord = 7.0 / numPointsPerWall + 0.5 self.spawnPoints.append(Vec3(-7.0, coord, 0)) self.spawnPoints.append(Vec3(7.0, coord, 0)) self.spawnPoints.append(Vec3(coord, -7.0, 0)) self.spawnPoints.append(Vec3(coord, 7.0, 0)) self.initialSpawnInterval = 1.0 self.minimumSpawnInterval = 0.2 self.spawnInterval = self.initialSpawnInterval self.spawnTimer = self.spawnInterval self.maxEnemies = 2 self.maximumMaxEnemies = 20 self.numTrapsPerSide = 2 self.difficultyInterval = 5.0 self.difficultyTimer = self.difficultyInterval self.enemySpawnSound = loader.loadSfx("Sounds/enemySpawn.ogg") self.gameOverScreen = DirectDialog(frameSize=(-0.7, 0.7, -0.7, 0.7), fadeScreen=0.4, relief=DGG.FLAT, frameTexture="UI/stoneFrame.png") self.gameOverScreen.hide() self.font = loader.loadFont("Fonts/Wbxkomik.ttf") buttonImages = (loader.loadTexture("UI/UIButton.png"), loader.loadTexture("UI/UIButtonPressed.png"), loader.loadTexture("UI/UIButtonHighlighted.png"), loader.loadTexture("UI/UIButtonDisabled.png")) label = DirectLabel(text="Game Over!", parent=self.gameOverScreen, scale=0.1, pos=(0, 0, 0.2), text_font=self.font, relief=None) self.finalScoreLabel = DirectLabel(text="", parent=self.gameOverScreen, scale=0.07, pos=(0, 0, 0), text_font=self.font, relief=None) btn = DirectButton(text="Restart", command=self.startGame, pos=(-0.3, 0, -0.2), parent=self.gameOverScreen, scale=0.07, text_font=self.font, clickSound=loader.loadSfx("Sounds/UIClick.ogg"), frameTexture=buttonImages, frameSize=(-4, 4, -1, 1), text_scale=0.75, relief=DGG.FLAT, text_pos=(0, -0.2)) btn.setTransparency(True) btn = DirectButton(text="Quit", command=self.quit, pos=(0.3, 0, -0.2), parent=self.gameOverScreen, scale=0.07, text_font=self.font, clickSound=loader.loadSfx("Sounds/UIClick.ogg"), frameTexture=buttonImages, frameSize=(-4, 4, -1, 1), text_scale=0.75, relief=DGG.FLAT, text_pos=(0, -0.2)) btn.setTransparency(True) self.titleMenuBackdrop = DirectFrame(frameColor=(0, 0, 0, 1), frameSize=(-1, 1, -1, 1), parent=render2d) self.titleMenu = DirectFrame(frameColor=(1, 1, 1, 0)) title = DirectLabel(text="Panda-chan", scale=0.1, pos=(0, 0, 0.9), parent=self.titleMenu, relief=None, text_font=self.font, text_fg=(1, 1, 1, 1)) title2 = DirectLabel(text="and the", scale=0.07, pos=(0, 0, 0.79), parent=self.titleMenu, text_font=self.font, frameColor=(0.5, 0.5, 0.5, 1)) title3 = DirectLabel(text="Endless Horde", scale=0.125, pos=(0, 0, 0.65), parent=self.titleMenu, relief=None, text_font=self.font, text_fg=(1, 1, 1, 1)) btn = DirectButton(text="Start Game", command=self.startGame, pos=(0, 0, 0.2), parent=self.titleMenu, scale=0.1, text_font=self.font, clickSound=loader.loadSfx("Sounds/UIClick.ogg"), frameTexture=buttonImages, frameSize=(-4, 4, -1, 1), text_scale=0.75, relief=DGG.FLAT, text_pos=(0, -0.2)) btn.setTransparency(True) btn = DirectButton(text="Quit", command=self.quit, pos=(0, 0, -0.2), parent=self.titleMenu, scale=0.1, text_font=self.font, clickSound=loader.loadSfx("Sounds/UIClick.ogg"), frameTexture=buttonImages, frameSize=(-4, 4, -1, 1), text_scale=0.75, relief=DGG.FLAT, text_pos=(0, -0.2)) btn.setTransparency(True) music = loader.loadMusic("Music/Defending-the-Princess-Haunted.ogg") music.setLoop(True) music.setVolume(0.075) music.play()
def __init__(self, params=None, **kwargs): # Load 3d-Model and parameter super(Panda3dViewer, self).__init__(params=params) self.world_x_range = kwargs.pop("x_range", [-40, 40]) self.world_y_range = kwargs.pop("y_range", [-40, 40]) self.follow_agent_id = kwargs.pop("follow_agent_id", -1) self.screen_dims = kwargs.pop("screen_dims", [1024, 1024]) self.path = os.path.join( os.path.dirname(os.path.abspath(__file__)) ) # TODO(@fortiss): load into parameter at a earlier stage self.agent_model_path = kwargs.pop("model_path", self.path + "/models/box_car") self.agent_scale = kwargs.pop("model_scale", np.array([3.65, 1.8, 0.8], dtype=float)) self.agent_orientation = \ kwargs.pop("model_orientation",np.array([180, 0,0], dtype=float)) self.agent_translation = kwargs.pop("model_translation", np.array([3.2, 0.9], dtype=float)) self.range_for_zoom = kwargs.pop("is_zoom_range", False) self.line_thicknesses = kwargs.pop( "line_thickness", { #Dict of keys cameras and values [line thickness, height] which are needed to calculate the dynamic thickness -2: [0.35, 700], -1: [0.35, 700], 0: [0.1, 70] }) # Parameter for agent camera views # [driving direction offset, height, x-orientation,y-orientation,z-orientation offset to driving direction, LookAt?] self.agent_cam_parameter = kwargs.pop( "agent_view", { "bird_agent": [0, 70, 0, 270, 270, False], "third": [-35, 15, 0, 0, 0, True], "first": [1.2, 2.7, 180, 190, 90, False] }) # Set Window Size self.wp = WindowProperties().getDefault() self.wp.setSize(self.screen_dims[0], self.screen_dims[1]) self.wp.setTitle("BARK Panda3d Viewer") WindowProperties.setDefault(self.wp) ShowBase.__init__(self) # Render Objects Dict self.agent_nodes = {} # Agent Poses Dict self.agent_poses = {} self.setLight() # Creating a plane as floor #TODO parameter from map parameter frame = [ -self.screen_dims[0] / 2, self.screen_dims[0] / 2, -self.screen_dims[1] / 2, self.screen_dims[1] / 2 ] color = VBase4(self.plane_color[0], self.plane_color[1], self.plane_color[2], self.plane_alpha) self.createPlane(frame=frame, color=color) # Set up the camera loop task self.camera_list = [-1] self.initCam() self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") # Set up the line generator self.setDrawer(budget=100000) # -2 : global camera with camera control, -1: transition state for enabling mouse control, 0: agent cameras self.perspectives = { -2: ["birdview", "autozoom"], -1: ["None"], 0: ["bird_agent", "third", "first"] } self.perspective = self.perspectives[self.camIndex( self.follow_agent_id)] self.line_thickness = self.line_thicknesses[self.camIndex( self.follow_agent_id)][0] self.addButtons()
def disconnectMouse(self): self.mouse_owner = False props = WindowProperties() props.setCursorHidden(False) base.win.requestProperties(props)
def __init__(self): ShowBase.__init__(self) self.accept("escape", sys.exit) self.accept("mouse1", self.startShoot) self.accept("mouse1-up", self.endShoot) base.disableMouse() props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) self.heading = 0 self.pitch = 0 self.mousex = 0 self.mousey = 0 self.flight = [] self.cs_flight = [] self.explosion = [] self.score = 0 self.life = 20 self.m1down = 1 self.environ = self.loader.loadModel("models/terrain") self.environ.reparentTo(self.render) self.environ.setScale(0.8, 0.8, 0.8) self.environ.setPos(0, 0, -10) self.environ.setHpr(-90, 0, 0) for k in range(0, 5): self.flight.append(self.loader.loadModel("models/spitfire")) self.flight[k].reparentTo(self.render) self.flight[k].setScale(0.1, 0.1, 0.1) self.flight[k].setPos(randint(-40, 20), randint(300, 400), randint(10, 20)) self.cs_flight.append(self.flight[k].attachNewNode( CollisionNode(str(k)))) self.cs_flight[k].node().addSolid(CollisionSphere(0, 0, 5, 30)) #self.cs_flight[k].show() self.flight[k].setCollideMask(BitMask32.bit(1)) self.bullets = [] self.crosshair = OnscreenImage(image='models/crosshair.png', pos=(0, 0, 0)) self.crosshair.setScale(0.03, 0.03, 0.03) self.crosshair.setTransparency(TransparencyAttrib.MAlpha) self.title = OnscreenText(" ", style=1, fg=(1, 1, 1, 1), pos=(0, 0), scale=.07) self.taskMgr.add(self.mouse_control, "mouse_control") self.taskMgr.add(self.update_flight, "update_flight") self.picker = CollisionTraverser() self.pq = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.picker.addCollider(self.pickerNP, self.pq) self.gun = OnscreenImage(image='models/gun.png', pos=(0.24, 0, -0.54)) self.gun.setScale(1, 0.6, 0.6) self.gun.setTransparency(TransparencyAttrib.MAlpha) self.sound = base.loader.loadSfx("models/sound.ogg") base.setFrameRateMeter(True)
def show_cursor(self): """set the Cursor visible again""" props = WindowProperties() props.setCursorHidden(False) self.win.requestProperties(props)
config_sfx = ConfigVariableInt('sound-volume', '100') #keys config_forward = ConfigVariableString('key_forward', 'w|arrow_up') config_back = ConfigVariableString('key_back', 's|arrow_down') config_left = ConfigVariableString('key_left', 'a|arrow_left') config_right = ConfigVariableString('key_right', 'd|arrow_right') config_camera_left = ConfigVariableString('key_cam_left', 'q|delete') config_camera_right = ConfigVariableString('key_cam_right', 'e|page_down') config_action1 = ConfigVariableString('key_action1', 'mouse1|enter') config_action2 = ConfigVariableString('key_action2', 'mouse3|space') config_zoomin = ConfigVariableString('key_zoomin', 'wheel_up|r') config_zoomout = ConfigVariableString('key_zoomout', 'wheel_down|f') from panda3d.core import WindowProperties wp = WindowProperties.getDefault() wp.setFixedSize(True) wp.setCursorHidden(False) wp.setFullscreen(False) wp.setUndecorated(True) wp.setTitle("Avolition - Configuration") wp.setSize(512, 512) wp.setOrigin(-2, -2) WindowProperties.setDefault(wp) from direct.gui.DirectGui import * from panda3d.core import * import direct.directbase.DirectStart from direct.showbase.DirectObject import DirectObject import sys #import collections
def __init__(self): ShowBase.__init__(self) properties = WindowProperties() properties.setSize(1000, 750) self.dr = self.camNode.getDisplayRegion(0) self.dr.setActive(0) # disable print(self.dr.getSort()) self.dr1 = self.win.makeDisplayRegion(0.0, 0.5, 0, .5) self.dr1.setSort(self.dr.getSort()) self.dr1.setCamera(self.camList[0]) self.dr2 = self.win.makeDisplayRegion(0.5, 1, 0, 0.5) self.makeCamera(self.win,sort=0,displayRegion=(0.5,1,0.5,1),camName="cam2") self.disableMouse() self.environment = loader.loadModel("environment/environment") self.environment.reparentTo(render) self.monkey = Actor("models/monkey") self.monkey.set_scale(.25) self.monkey.reparentTo(render) self.monkey.set_pos(0,0,2) self.monkey2 = Actor("models/monkey") self.monkey2.set_scale(.25) self.monkey2.reparentTo(render) self.monkey2.set_pos(0,3,2) self.camList[0].reparentTo(self.monkey) self.camList[1].reparentTo(self.monkey2) self.taskMgr.add(self.example_Task, "updateTask") ambientLight = AmbientLight("ambient light") ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) self.ambientLightNodePath = render.attachNewNode(ambientLight) render.setLight(self.ambientLightNodePath) # In the body of your code mainLight = DirectionalLight("main light") self.mainLightNodePath = render.attachNewNode(mainLight) # Turn it around by 45 degrees, and tilt it down by 45 degrees self.mainLightNodePath.setHpr(45, -45, 0) render.setLight(self.mainLightNodePath) render.setShaderAuto() print('Cameras') print(self.camList) print('Number Of Display Regions') print(self.win.getNumDisplayRegions()) print('Active Display Regions') print(self.win.getActiveDisplayRegions()) self.win.removeDisplayRegion(self.win.getDisplayRegion(1)) self.win.removeDisplayRegion(self.win.getDisplayRegion(1)) self.win.removeDisplayRegion(self.win.getDisplayRegion(1)) print(self.win.getDisplayRegions()) print('Number Of Display Regions') print(self.win.getNumDisplayRegions()) self.disableMouse() self.useTrackball() #self.win.getDisplayRegion(2).saveScreenshotDefault('www') #this works but I get black screen because it gets the SC before the rendering texture = self.win.getDisplayRegion(1).getScreenshot() numpy_image_data=np.array(texture.getRamImageAs("RGB"), np.float32) print(np.max(numpy_image_data[123456]))
def __init__(self): ShowBase.__init__(self) self.grid = np.loadtxt("input/maze.txt") f = open("input/start_point.txt", "r") self.start_pos = eval(f.read()) if FULLSCREEN: wp = WindowProperties() wp.setFullscreen(True) base.win.requestProperties(wp) self.disableMouse() self.accept("escape", sys.exit) self.camera.setPosHpr(self.start_pos[0], self.start_pos[1], CAMERA_SCALE, 0, -90, 0) # maze wall offset = 0.05 # expand collision boundaries for the walls for i in range(-1, len(self.grid) + 1): for j in range(-1, len(self.grid[0]) + 1): if i == -1 or j == -1 or i == len(self.grid) or j == len( self.grid[0]) or self.grid[i][j]: #box-1_-1 is not a valid name so we change it to boxa_b texti = i textj = j if i == -1: texti = 'a' if j == -1: textj = 'b' suffix = str(texti) + "_" + str(textj) # model exec("self.box" + suffix + " = self.loader.loadModel('models/cube')") exec("self.box" + suffix + ".reparentTo(self.render)") exec("self.box" + suffix + ".setPos(" + str(i) + ", " + str(j) + ", 1)") # collision node exec("self.boxCollider" + suffix + " = self.box" + suffix + ".attachNewNode(CollisionNode('wall_collide'))") exec( "self.boxCollider" + suffix + ".node().addSolid(CollisionBox(Point3(0-offset,0-offset,0-offset),Point3(1+offset,1+offset,1+offset)))" ) exec("self.boxCollider" + suffix + ".node().setIntoCollideMask(BitMask32.bit(0))") #exec("self.boxCollider" + suffix + ".show()") # maze ground model self.maze = loader.loadModel("models/cube") self.maze.setScale(len(self.grid), len(self.grid[0]), 1) self.maze.reparentTo(self.render) # maze ground collision node self.walls = self.maze.attachNewNode(CollisionNode('wall_collide')) self.walls.node().addSolid( CollisionBox(Point3(0, 0, 0), Point3(1, 1, 1))) self.walls.node().setIntoCollideMask(BitMask32.bit(1)) # maze ground plane collision node self.mazeGround = self.maze.attachNewNode( CollisionNode('ground_collide')) self.mazeGround.node().addSolid( CollisionPlane(Plane(Vec3(0, 0, 1), Point3(2, 2, 1)))) self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1)) # ball model self.ballRoot = render.attachNewNode("ballRoot") self.ball = loader.loadModel("models/ball") self.ball.reparentTo(self.ballRoot) # ball material m = Material() m.setSpecular((1, 1, 1, 1)) m.setShininess(96) self.ball.setMaterial(m, 1) # ball collision node self.ballSphere = self.ball.find("**/ball") self.ballSphere.node().setFromCollideMask(BitMask32.bit(0)) self.ballSphere.node().setIntoCollideMask(BitMask32.allOff()) # collision ray self.ballGroundRay = CollisionRay() self.ballGroundRay.setOrigin(0, 0, 10) self.ballGroundRay.setDirection(0, 0, -1) # ray collision node self.ballGroundCol = CollisionNode('groundRay') self.ballGroundCol.addSolid(self.ballGroundRay) self.ballGroundCol.setFromCollideMask(BitMask32.bit(1)) self.ballGroundCol.setIntoCollideMask(BitMask32.allOff()) # ray self.ballGroundColNp = self.ballRoot.attachNewNode(self.ballGroundCol) # collision traverser and handler queue self.cHandler = CollisionHandlerQueue() self.cTrav = CollisionTraverser() self.cTrav.addCollider(self.ballSphere, self.cHandler) self.cTrav.addCollider(self.ballGroundColNp, self.cHandler) # visual effects ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.55, .55, .55, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(LVector3(0, 0, -1)) directionalLight.setColor((0.375, 0.375, 0.375, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) self.ballRoot.setLight(render.attachNewNode(ambientLight)) self.ballRoot.setLight(render.attachNewNode(directionalLight)) self.start()
def hideMouse(self): #hiding mouse props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props)
class PandaVis(ShowBase): """Base class for all visualizations with panda3d""" def __init__(self, rendering: bool): """ Constructor :param rendering: boolean indicating whether to use RenderPipeline or default Panda3d as visualization-module. """ super().__init__(self) self.dir = Filename.fromOsSpecific( pyrado.PANDA_ASSETS_DIR).getFullpath() # Initialize RenderPipeline if rendering: sys.path.insert(0, pyrado.RENDER_PIPELINE_DIR) from rpcore import RenderPipeline self.render_pipeline = RenderPipeline() self.render_pipeline.pre_showbase_init() self.render_pipeline.set_loading_screen_image( osp.join(self.dir, "logo.png")) self.render_pipeline.settings["pipeline.display_debugger"] = False self.render_pipeline.create(self) self.render_pipeline.daytime_mgr.time = "17:00" else: self.render_pipeline = None # Activate antialiasing self.render.setAntialias(AntialiasAttrib.MAuto) # Set window properties self.windowProperties = WindowProperties() self.windowProperties.setForeground(True) self.windowProperties.setTitle("Experiment") # Set background color self.setBackgroundColor(1, 1, 1) # Configuration of the lighting self.directionalLight1 = DirectionalLight("directionalLight") self.directionalLightNP1 = self.render.attachNewNode( self.directionalLight1) self.directionalLightNP1.setHpr(0, -8, 0) self.render.setLight(self.directionalLightNP1) self.directionalLight2 = DirectionalLight("directionalLight") self.directionalLightNP2 = self.render.attachNewNode( self.directionalLight2) self.directionalLightNP2.setHpr(180, -20, 0) self.render.setLight(self.directionalLightNP2) self.ambientLight = AmbientLight("ambientLight") self.ambientLightNP = self.render.attachNewNode(self.ambientLight) self.ambientLight.setColor((0.1, 0.1, 0.1, 1)) self.render.setLight(self.ambientLightNP) # Create a text node displaying the physic parameters on the top left of the screen self.text = TextNode("parameters") self.textNodePath = aspect2d.attachNewNode(self.text) self.text.setTextColor(0, 0, 0, 1) # black self.textNodePath.setScale(0.07) self.textNodePath.setPos(-1.9, 0, 0.9) # Configure trace self.trace = LineSegs() self.trace.setThickness(3) self.trace.setColor(0.8, 0.8, 0.8) # light grey self.lines = self.render.attachNewNode("Lines") self.last_pos = None # Adds one instance of the update function to the task-manager, thus initializes the animation self.taskMgr.add(self.update, "update") def update(self, task: Task): """ Updates the visualization with every call. :param task: Needed by panda3d task manager. :return Task.cont: indicates that task should be called again next frame. """ return Task.cont def reset(self): """ Resets the the visualization to a certain state, so that in can be run again. Removes the trace. """ self.lines.getChildren().detach() self.last_pos = None def draw_trace(self, point): """ Draws a line from the last point to the current point :param point: Current position of pen. Needs 3 value vector. """ # Check if trace initialized if self.last_pos: # Set starting point of new line self.trace.moveTo(self.last_pos) # Draw line to that point self.trace.drawTo(point) # Save last position of pen self.last_pos = point # Show drawing self.trace_np = NodePath(self.trace.create()) self.trace_np.reparentTo(self.lines)