class Application(ShowBase, object): ''' The default Application class which holds the code for Panda3D to run the game ''' def __init__(self, quality): # Set the model quality, (super-low, low or high) self.quality = quality print("[>] PoultryGeist:\t Setting Model Resolution to {}".format( self.quality.upper())) load_prc_file_data("", "win-size 1920 1080") # Run the standard Showbase init if running in super-low resolution mode # Do some stuff if the game is running at normal or high resolution if self.quality != 'super-low': # Construct and create the pipeline self.render_pipeline = RenderPipeline() self.render_pipeline.pre_showbase_init() super(Application, self).__init__() self.render_pipeline.create(self) # Enable anti-aliasing for the game render.setAntialias(AntialiasAttrib.MAuto) # Set the time pipeline lighting simulation time self.render_pipeline.daytime_mgr.time = "20:15" else: super(Application, self).__init__() # Enable the filter handler self.filters = CommonFilters(base.win, base.cam) self.filters.setAmbientOcclusion() # Enable particles and physics self.enableParticles() #Modify the Panda3D config on-the-fly #In this case, edit the window title load_prc_file_data( "", """window-title PoultryGeist threading-model /Draw multisamples 2 framebuffer-multisample 1 """) # Set the window size self.width, self.height = (800, 600) # Initialise the movement controller self.controller = None # Turn off normal mouse controls self.disableMouse() # Hide the cursor self.props = WindowProperties() # self.props.setCursorHidden(True) # Lower the FOV to make the game more difficult self.win.requestProperties(self.props) self.camLens.setFov(60) # Reduces the distance of which the camera can render objects close to it self.camLens.setNear(0.1) # Store and empty renderTree for later use self.emptyRenderTree = deepcopy(self.render) # Register the buttons for movement # TODO remove this and overhaul the button handling self.w_button = KeyboardButton.ascii_key('w'.encode()) self.s_button = KeyboardButton.ascii_key('s'.encode()) self.l_button = KeyboardButton.ascii_key('l'.encode()) self.switch_button = KeyboardButton.ascii_key('p'.encode()) # Initialise the SceneManager self.sceneMgr = SceneManager(self) # Initialise the collision traverser self.collisionTraverser = CollisionTraverser('main_traverser') base.cTrav = self.collisionTraverser base.cTrav.showCollisions(self.render) # Add the sceneMgr events to run as a task taskMgr.add(self.sceneMgr.runSceneTasks, "scene-tasks") def loadSettings(self, options): ''' Iterate a dictionary of settings and apply them to the game ''' # Toggle the audio based on the options if options.get('audio', 'on') == 'off': base.disableAllAudio() windowProperties = WindowProperties() # Set the resolution if options.get('resolution') == '720p': windowProperties.setSize(1280, 720) # Set the app width and height variables self.width, self.height = (1280, 720) else: windowProperties.setSize(1920, 1080) # Set the app width and height variables self.width, self.height = (1920, 1080) # Apply the properties to the window base.win.requestProperties(windowProperties) load_prc_file_data('', 'win-size {} {}'.format(self.width, self.height)) def move(self, forward, dir, elapsed): ''' Move the camera forward or backwards For testing ONLY at the moment ''' if forward: self.sceneMgr.focus += dir * elapsed * 30 else: self.sceneMgr.focus -= dir * elapsed * 30 # Set the position of the camera based on the direction self.camera.setPos(self.sceneMgr.focus - (dir * 5)) def dumpTree(self): for a in self.render.getChildren(): print(a)
""" This is an alternative possibility of initializing the RenderPipeline, which enables you to construct the show base object yourself. """ import sys from direct.showbase.ShowBase import ShowBase # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes. In case you placed the render # pipeline in a subfolder of your project, you have to adjust this. sys.path.insert(0, "../../RenderPipeline") sys.path.insert(0, "../../") # Import render pipeline classes from rpcore import RenderPipeline, SpotLight # Construct and create the pipeline render_pipeline = RenderPipeline() render_pipeline.pre_showbase_init() base = ShowBase() render_pipeline.create(base) base.run()
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)
""" This is an alternative possibility of initializing the RenderPipeline, which uses the (deprecated!) DirectStart interface. This should not be used anymore, except for fast prototyping. """ import sys # Insert the pipeline path to the system path, this is required to be # able to import the pipeline classes. In case you placed the render # pipeline in a subfolder of your project, you have to adjust this. sys.path.insert(0, "../../") sys.path.insert(0, "../../RenderPipeline") # Import render pipeline classes from rpcore import RenderPipeline # Construct and create the pipeline render_pipeline = RenderPipeline() render_pipeline.pre_showbase_init() # Import (deprecated!) DirectStart interface import direct.directbase.DirectStart render_pipeline.create(base) base.run()