def __init__(self): ShowBase.__init__(self) simplepbr.init() self.accept('escape', sys.exit) self.accept('f11', self.debug) m = loader.load_model("pbrcube.bam") m.reparent_to(render) # Camera self.cam_gimbal = NodePath('gimbal') self.cam_gimbal.reparent_to(render) base.cam.reparent_to(self.cam_gimbal) base.cam.set_pos(0, -10, 0) base.cam.look_at(0, 0, 0) self.add_task(self.update_camera) # Light light = PointLight('plight') light.set_color((10, 10, 10, 10)) light.set_attenuation((1, 0, 1)) light_np = base.cam.attach_new_node(light) render.set_light(light_np) light_np.set_pos(0, 0, 2) # Debug info render.ls() render.analyze()
def __init__(self): ShowBase.__init__(self) simplepbr.init() self.building = loader.loadModel("models/building/building.gltf") self.building.setPos(0, 50, 0) self.building.reparentTo(render)
def __init__(self, shot=None, monitor=False): if self.is_game is None: raise Exception(f"'{self.__class__.__name__}' must set 'is_game' attribute") self.stdout = pt.terminal.Run() super().__init__(self) HUD.__init__(self) base.setBackgroundColor(0.04, 0.04, 0.04) simplepbr.init(enable_shadows=ani.settings['graphics']['shadows'], max_lights=13) if not ani.settings['graphics']['shader']: render.set_shader_off() globalClock.setMode(ClockObject.MLimited) globalClock.setFrameRate(ani.settings['graphics']['fps']) self.shots = SystemCollection() self.tasks = {} self.disableMouse() self.mouse = Mouse() self.player_cam = PlayerCam() ModeManager.__init__(self) self.scene = None self.frame = 0 self.add_task(self.increment_frame, 'increment_frame') if monitor: self.add_task(self.monitor, 'monitor')
def run_game(simplepbr=False, simplepbr_kwargs=None): # Application Basics ShowBase() base.disable_mouse() if simplepbr is True: import simplepbr if simplepbr_kwargs is None: simplepbr_kwargs = {} # i.e. dict(max_lights=1) simplepbr.init(**simplepbr_kwargs) # Handy Helpers: esc to quit, f11 for pdb, f12 for pstats base.accept('escape', sys.exit) base.frame_rame_meter_visible = False base.set_frame_rate_meter(base.frame_rame_meter_visible) def toggle_frame_rate_meter(): base.frame_rame_meter_visible = not base.frame_rame_meter_visible base.set_frame_rate_meter(base.frame_rame_meter_visible) base.accept('f10', toggle_frame_rate_meter) def debug(): import pdb; pdb.set_trace() base.accept('f11', debug) def pstats(): base.pstats = True PStatClient.connect() base.accept('f12', pstats) # Set up the world: import game for sort, system_type in enumerate(game.system_types): base.add_system(system_type(), sort) # And here we go... base.run()
def __init__(self): ShowBase.__init__(self) # We must call simplepbr's init method here. simplepbr.init() self.building = loader.loadModel("models/building/building.gltf") self.building.setPos(0, 50, 0) self.building.reparentTo(render)
def __init__(self): ShowBase.__init__(self) simplepbr.init() self.terrain = loader.loadModel("models/terrain/terrain.gltf") # Let's position the terrain. self.terrain.setPos(0, 0, -1) self.terrain.reparentTo(render)
def setup(self, quality): self.quality_menu.hide() base.quality = quality is_fullscreen = self.win.get_properties().fullscreen self.main_menu = Menu('pollen.', [ ('begin.', self.start_game), ('no music.', self.toggle_music), ('window.' if is_fullscreen else 'fullscreen.', self.toggle_fullscreen), ('leave.', self.stop_game), ]) self.pause_menu = Menu('paused.', [ ('resume.', self.resume), ('no music.', self.toggle_music), ('stop.', self.stop_game), ]) base.paused = False #base.cam.set_pos(-3, 0, 10) base.cam.set_pos(0, 0, 10) base.cam.set_hpr(0, 5, 0) if base.quality >= QUALITY_HIGH: samples = 8 elif base.quality >= QUALITY_MEDIUM: samples = 4 else: samples = 0 simplepbr.init(msaa_samples=samples, max_lights=2) self.world = World() self.accept('f12', self.screenshot) #self.accept('1', self.oobeCull) self.starting = False self.started = False self.music_on = True self.main_menu.show() self.accept('gamepad-start', self.start_game) self.setBackgroundColor((0.6, 1.0, 1.4, 1.0))
def __init__(self): ShowBase.__init__(self) simplepbr.init() # Let's load and position the terrain. self.terrain = loader.loadModel("models/terrain/terrain.gltf") self.terrain.setPos(0, 0, -1) self.terrain.reparentTo(render) # Let's import, position, scale and rotate the actor. self.slug = Actor("actors/slug/slug.gltf") self.slug.setPos(0, 0, -1) self.slug.setScale(10, 10, 10) self.slug.setH(90) self.slug.reparentTo(render) # play animation self.slug.loop('idle')
def __init__(self): if len(sys.argv) < 2: print("Missing input file") sys.exit(1) super().__init__() simplepbr.init() gltf.patch_loader(self.loader) infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1])) p3d.get_model_path().prepend_directory(infile.get_dirname()) self.model_root = self.loader.load_model(infile, noCache=True) self.accept('escape', sys.exit) self.accept('q', sys.exit) self.accept('w', self.toggle_wireframe) self.accept('t', self.toggle_texture) self.accept('shift-l', self.model_root.ls) self.accept('shift-a', self.model_root.analyze) if not self.model_root.find('**/+Light'): self.light = self.render.attach_new_node(p3d.PointLight('light')) self.light.set_pos(-5, 5, 5) self.render.set_light(self.light) self.cam.set_pos(-6, 6, 6) self.cam.look_at(self.model_root) self.model_root.reparent_to(self.render) if self.model_root.find('**/+Character'): self.anims = p3d.AnimControlCollection() p3d.autoBind(self.model_root.node(), self.anims, ~0) if self.anims.get_num_anims() > 0: self.anims.get_anim(0).loop(True)
def __init__(self): """initialise the engine""" ShowBase.__init__(self) base.notify.info("Version {}".format(config.versionstring)) FSM.__init__(self, "FSM-Game") config.Config.__init__(self) self.setBackgroundColor(0, 0, 0) # # PBR SHADING # pipeline = simplepbr.init() pipeline.use_normals_map = True pipeline.enable_shadows = True # # INITIALIZE GAME CONTENT # # Client and Server self.canStartClient = True self.gameServer = None self.air = None self.cr = None # Audio self.audioMgr = AudioManager() # show or hide the game chat self.showChat = True # # EVENT HANDLING # # By default we accept the escape key self.accept("escape", self.__escape) # # COLLISION DETECTION # base.cTrav = CollisionTraverser() #base.cTrav.showCollisions(base.render) self.exitFunc = self.cleanExit # # ENTER GAMES INITIAL FSM STATE # self.request("MainMenu")
def test_setup(showbase): pipeline = simplepbr.init( render_node=showbase.render, window=showbase.win, camera_node=showbase.cam, use_normal_maps=True, enable_shadows=True, enable_fog=True, use_occlusion_maps=True, ) if not pipeline.use_330: pipeline.enable_shadows = False pipeline.verify_shaders()
def test_setup(showbase, use_normal_maps, enable_shadows, enable_fog, use_occlusion_maps, use_emission_maps, use_hardware_skinning): pipeline = simplepbr.init( render_node=showbase.render, window=showbase.win, camera_node=showbase.cam, use_normal_maps=use_normal_maps, enable_shadows=enable_shadows, enable_fog=enable_fog, use_occlusion_maps=use_occlusion_maps, use_emission_maps=use_emission_maps, use_hardware_skinning=use_hardware_skinning, ) pipeline.verify_shaders()
def test_setup(showbase): simplepbr.init( render_node=showbase.render, window=showbase.win, camera_node=showbase.cam, )
def run_game(game_module='game', module_name=None, simplepbr=False, simplepbr_kwargs=None, console=False, keybindings=False, debug_keys=False): """ This function... - starts a Panda3D instance, - sets it up for use with WECS, - imports the module ``game`` (or whatever name is passed as ``game_module``), - adds systems of types specified in ``game.system_types`` (if present) to ``base.ecs_world``, - runs Panda3D's main loop. :param game_module: The name of the game module :param simplepbr: Initialize ``panda3d-simplepbr``. :param simplepbr_kwargs: key word argument to pass to ``simplepbr.init()`` (if :param simplepbr: is True.) :param console: Set up the CEF-based console (``panda3d-cefconsole``). :param keybindings: Set up ``panda3d-keybindings`` listener. :param module_name: Passed as ``config_module`` to the keybinding listener's ``add_device_listener``. :param debug_keys: The boilerplate will use Panda3D's key press events to make four functions available: - ``Escape``: Close the application by calling ``sys.exit()``. - ``F9``: open / close the CEF console (if present). - ``F10``: show / hide the frame rate meter. - ``F11``: Start a ``pdb`` session in the underlying terminal. - ``F12``: Connect to ``pstats``. """ # Application Basics ECSShowBase() sky_color = (0.3, 0.5, 0.95, 1) base.win.setClearColor(sky_color) base.disable_mouse() if keybindings: from keybindings.device_listener import add_device_listener from keybindings.device_listener import SinglePlayerAssigner add_device_listener( config_module=module_name, config_file="keybindings.toml", debug=True, assigner=SinglePlayerAssigner(), ) if simplepbr is True: import simplepbr if simplepbr_kwargs is None: simplepbr_kwargs = {} # i.e. dict(max_lights=1) simplepbr.init(**simplepbr_kwargs) if console: from cefconsole import add_console from cefconsole import PythonSubconsole if debug_keys: add_console(subconsoles=[PythonSubconsole()], toggle="f9") else: add_console(subconsoles=[PythonSubconsole()]) if debug_keys: base.accept('escape', sys.exit) base.frame_rate_meter_visible = False base.set_frame_rate_meter(base.frame_rate_meter_visible) def toggle_frame_rate_meter(): base.frame_rate_meter_visible = not base.frame_rate_meter_visible base.set_frame_rate_meter(base.frame_rate_meter_visible) base.accept('f10', toggle_frame_rate_meter) def debug(): import pdb pdb.set_trace() base.accept('f11', debug) def pstats(): base.pstats = True PStatClient.connect() base.accept('f12', pstats) # Set up the world: game = importlib.import_module(game_module) # FIXME: system_types is a bad name, since the allowed specs are now # more complicated (see add_systems' code). system_specs would be # better. if hasattr(game, 'system_types'): add_systems(game.system_types) if console: base.console.render_console() # And here we go... base.run()
def __init__(self): if len(sys.argv) < 2: print("Missing input file") sys.exit(1) super().__init__() self.pipeline = simplepbr.init() gltf.patch_loader(self.loader) infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1])) p3d.get_model_path().prepend_directory(infile.get_dirname()) self.model_root = self.loader.load_model(infile, noCache=True) self.accept('escape', sys.exit) self.accept('q', sys.exit) self.accept('w', self.toggle_wireframe) self.accept('t', self.toggle_texture) self.accept('n', self.toggle_normal_maps) self.accept('e', self.toggle_emission_maps) self.accept('o', self.toggle_occlusion_maps) self.accept('a', self.toggle_ambient_light) self.accept('shift-l', self.model_root.ls) self.accept('shift-a', self.model_root.analyze) self.model_root.reparent_to(self.render) bounds = self.model_root.getBounds() center = bounds.get_center() if bounds.is_empty(): radius = 1 else: radius = bounds.get_radius() fov = self.camLens.get_fov() distance = radius / math.tan(math.radians(min(fov[0], fov[1]) / 2.0)) self.camLens.set_near(min(self.camLens.get_default_near(), radius / 2)) self.camLens.set_far(max(self.camLens.get_default_far(), distance + radius * 2)) trackball = self.trackball.node() trackball.set_origin(center) trackball.set_pos(0, distance, 0) trackball.setForwardScale(distance * 0.006) # Create a light if the model does not have one if not self.model_root.find('**/+Light'): self.light = self.render.attach_new_node(p3d.PointLight('light')) self.light.set_pos(0, -distance, distance) self.render.set_light(self.light) # Move lights to render self.model_root.clear_light() for light in self.model_root.find_all_matches('**/+Light'): light.parent.wrt_reparent_to(self.render) self.render.set_light(light) # Add some ambient light self.ambient = self.render.attach_new_node(p3d.AmbientLight('ambient')) self.ambient.node().set_color((.2, .2, .2, 1)) self.render.set_light(self.ambient) if self.model_root.find('**/+Character'): self.anims = p3d.AnimControlCollection() p3d.autoBind(self.model_root.node(), self.anims, ~0) if self.anims.get_num_anims() > 0: self.anims.get_anim(0).loop(True)
def run_game(module_name=None, simplepbr=False, simplepbr_kwargs=None, console=False, keybindings=False, debug_keys=False): # Application Basics ECSShowBase() base.win.setClearColor((0.5,0.7,0.9,1)) base.disable_mouse() if keybindings: import os from keybindings.device_listener import add_device_listener from keybindings.device_listener import SinglePlayerAssigner add_device_listener( config_module=module_name, config_file="keybindings.toml", debug=True, assigner=SinglePlayerAssigner(), ) if simplepbr is True: import simplepbr if simplepbr_kwargs is None: simplepbr_kwargs = {} # i.e. dict(max_lights=1) simplepbr.init(**simplepbr_kwargs) # Handy Helpers: # esc: quit # f 9: console # f10: frame rate meter # f11: pdb, during event loop # f12: pstats; connects to a running server if console: from cefconsole import add_console from cefconsole import PythonSubconsole if debug_keys: add_console(subconsoles=[PythonSubconsole()], toggle="f9") else: add_console(subconsoles=[PythonSubconsole()]) if debug_keys: base.accept('escape', sys.exit) base.frame_rame_meter_visible = False base.set_frame_rate_meter(base.frame_rame_meter_visible) def toggle_frame_rate_meter(): base.frame_rame_meter_visible = not base.frame_rame_meter_visible base.set_frame_rate_meter(base.frame_rame_meter_visible) base.accept('f10', toggle_frame_rate_meter) def debug(): import pdb; pdb.set_trace() base.accept('f11', debug) def pstats(): base.pstats = True PStatClient.connect() base.accept('f12', pstats) # Set up the world: import game # system_types is deprecated, because badly named. Do not use. if hasattr(game, 'system_types'): add_systems(game.system_types) if console: base.console.render_console() # And here we go... base.run()
def __init__(self): ShowBase.__init__(self) base.win.set_clear_color((0, 0, 0, 0)) simplepbr.init() self.multitex_reducer = MultitexReducer() #load textures self.textures = {} texture_files = "plaid", "shirtnjeans", "jacket" for file in texture_files: self.textures[file] = loader.loadTexture( "textures/{}.png".format(file)) # camera/control self.cam_pivot = NodePath("cam pivot") self.cam_pivot.reparentTo(render) base.cam.reparent_to(self.cam_pivot) base.cam.set_pos(0, -2.7, 1.8) self.cam_pivot.set_h(180) self.cam_pivot.set_y(0.2) self.move_speed = 0.5 self.zoom_speed = 0.5 self.last_mouse = [0, 0] self.accept("wheel_up", self.zoom_in) self.accept("wheel_down", self.zoom_out) self.taskMgr.add(self.update_camera) # sliders self.sliders = {} self.y_pos = 0.9 # jan model self.jan = Actor( { "body": "jan/jan.bam", "palisa": "jan/acc/palisa-mije.bam", "hair": "jan/acc/hair_raz.bam", "clothing": "jan/clothing.bam", }, { "body": {}, "palisa": {}, "hair": {}, "clothing": {}, }) self.jan.attach("hair", "body", "head") self.jan.attach("palisa", "body", "waist") self.jan.attach("clothing", "body", "root") self.jan.play("loop") self.jan.setTwoSided(True) self.jan.hide_part("palisa") self.make_sliders(self.jan) #self.jan.flatten_strong() #self.jan.post_flatten() #self.multitex_reducer.scan(self.jan) #self.multitex_reducer.flatten(base.win) self.jan.reparent_to(render) self.jan.set_transparency(True) # talk gender = "mije" #meli self.speech = Speech(loader.loadSfx("toki-{}-a.wav".format(gender))) self.speech.say("to ki") self.speech.say("mi to ki po na") self.speech.say("mi o li n si na") self.taskMgr.add(self.speech.update) self.light_scene() render.ls() render.analyze()
from direct.showbase.ShowBase import ShowBase import simplepbr from panda3d.core import DirectionalLight, AmbientLight ShowBase() pipeline = simplepbr.init() lightSun = DirectionalLight('light_sun') lightSun.setColorTemperature(5300) lightSun.setShadowCaster(True, 2048, 2048) lightSunNP = render.attachNewNode(lightSun) lightSunNP.setPos(2, 2, 2) lightSunNP.lookAt(0, 0, 0) render.setLight(lightSunNP) lightAmb = AmbientLight('light_ambient') lightAmb.setColor((0.1, 0.1, 0.1, 1)) lightAmbNP = render.attachNewNode(lightAmb) render.setLight(lightAmbNP) model = base.loader.loadModel("./warrior.bam") #model.setPos(0, 3, -0.5) model.setScale(50) model.reparentTo(render) run()
def __init__(self): load_prc_file_data( "", """ win-size 1920 1080 show-frame-rate-meter #t view-frustum-cull 0 textures-power-2 none gl-depth-zero-to-one true hardware-animated-vertices true basic-shaders-only false loader-num-threads 24 frame-rate-meter-milliseconds true window-title PBR Hardware Skinning Demo fullscreen #f """) # Initialize the showbase super().__init__() pipeline = simplepbr.init() pipeline.enable_shadows = False pipeline.max_lights = 10 gltf.patch_loader(self.loader) self.accept("escape", sys.exit, [0]) self.cam.setPos(-10, 10, 3) self.cam.lookAt(0, 0, 0) amb_light = AmbientLight('amblight') amb_light.setColor((0.2, 0.2, 0.2, 1)) amb_light_node = self.render.attachNewNode(amb_light) self.render.setLight(amb_light_node) p_light = Spotlight('p_light') p_light.setColor((1, 1, 1, 1)) p_light.setShadowCaster(True, 1024, 1024) lens = PerspectiveLens() p_light.setLens(lens) p_light_node = self.render.attachNewNode(p_light) p_light_node.setPos(-5, -5, 5) p_light_node.lookAt(0, 0, 0) self.render.setLight(p_light_node) ############################################# # reparent player character to render node char_body = actor_ai.tilter char_body.reparent_to(self.render) char_body.setScale(1) # prototype hardware skinning shader for Actor nodes actor_shader = Shader.load(Shader.SL_GLSL, "shaders/simplepbr_vert_mod_1.vert", "shaders/simplepbr_frag_mod_1.frag") actor_shader = ShaderAttrib.make(actor_shader) actor_shader = actor_shader.setFlag(ShaderAttrib.F_hardware_skinning, True) # char_body.setShaderAuto() char_body.setAttrib(actor_shader) # animate the Actor tilt_ctrl = actor_ai.tilter.getAnimControl('wave') if not tilt_ctrl.isPlaying(): actor_ai.tilter.loop('wave') actor_ai.tilter.setPlayRate(3.0, 'wave') def move(Task): # print('the scene is updating') return Task.cont self.task_mgr.add(move)
def __init__(self): ShowBase.__init__(self) pman.shim.init(self) base.enable_particles() gdb = gamedb.get_instance() # Render pipeline self.set_background_color((0, 0, 0, 1)) self.render.set_antialias(p3d.AntialiasAttrib.MAuto) self.render_pipeline = simplepbr.init( max_lights=4, msaa_samples=p3d.ConfigVariableInt('msaa-samples', 4).get_value(), enable_shadows=p3d.ConfigVariableBool('enable-shadows', True).get_value(), exposure=5, ) # Controls self.event_mapper = eventmapper.EventMapper() self.disable_mouse() self.accept('quit', sys.exit) self.accept('toggle-buffer-viewer', self.bufferViewer.toggleEnable) self.accept('toggle-oobe', self.oobe) self.accept('save-screenshot', self.screenshot) # Global storage self.blackboard = {} default_save = p3d.ConfigVariableString('mercury-default-save', '').get_value() if default_save: saveloc = os.path.join( pathutils.get_saves_dir(), default_save, ) if not saveloc.endswith('.sav'): saveloc += '.sav' if os.path.exists(saveloc): with open(saveloc) as savefile: self.blackboard['player'] = PlayerData.load(savefile) default_monster_id = p3d.ConfigVariableString( 'mercury-default-monster', '').get_value() if default_monster_id: default_monster = Monster(gdb['monsters'][default_monster_id]) else: default_form = p3d.ConfigVariableString('mercury-default-form', 'mine').get_value() default_monster = Monster.make_new('player_monster', form_id=default_form) if 'player' not in self.blackboard: self.blackboard['player'] = PlayerData() self.blackboard['player'].monsters = [default_monster] # UI default_font = self.loader.load_font('fonts/BalooThambi2-Medium.ttf', pixelsPerUnit=90) p3d.TextNode.set_default_font(default_font) # Game states initial_state = p3d.ConfigVariableString('mercury-initial-state', 'Title').get_value() self.gman = gamestates.StateManager(initial_state) def update_state(task): self.gman.update() return task.cont self.taskMgr.add(update_state, 'GameState Update') # Get volume levels from config self.musicManager.set_volume( p3d.ConfigVariableDouble('audio-music-volume', 1.0).get_value()) self.sfxManagerList[0].set_volume( p3d.ConfigVariableDouble('audio-sfx-volume', 1.0).get_value())
def run_game(path, simplepbr=False, simplepbr_kwargs=None, console=False, keybindings=False): # Application Basics ShowBase() base.win.setClearColor((0.5, 0.7, 0.9, 1)) base.disable_mouse() if keybindings: import os from keybindings.device_listener import add_device_listener from keybindings.device_listener import SinglePlayerAssigner config_file = os.path.join(path, "keybindings.toml") add_device_listener( config_file=config_file, debug=True, assigner=SinglePlayerAssigner(), ) if simplepbr is True: import simplepbr if simplepbr_kwargs is None: simplepbr_kwargs = {} # i.e. dict(max_lights=1) simplepbr.init(**simplepbr_kwargs) # Handy Helpers: # esc: quit # f 9: console # f10: frame rate meter # f11: pdb, during event loop # f12: pstats; connects to a running server base.accept('escape', sys.exit) if console: from cefconsole import add_console from cefconsole import PythonSubconsole add_console(subconsoles=[PythonSubconsole()]) base.frame_rame_meter_visible = False base.set_frame_rate_meter(base.frame_rame_meter_visible) def toggle_frame_rate_meter(): base.frame_rame_meter_visible = not base.frame_rame_meter_visible base.set_frame_rate_meter(base.frame_rame_meter_visible) base.accept('f10', toggle_frame_rate_meter) def debug(): import pdb pdb.set_trace() base.accept('f11', debug) def pstats(): base.pstats = True PStatClient.connect() base.accept('f12', pstats) # Set up the world: import game for sort, system_type in enumerate(game.system_types): base.add_system(system_type(), sort) if console: base.console.render_console() # And here we go... base.run()
import simplepbr ShowBase() base.accept('escape', sys.exit) def debug(): import pdb pdb.set_trace() base.accept('f11', debug) base.set_frame_rate_meter(True) base.cam.set_pos(0, -5, 0) base.cam.look_at(0, 0, 0) global pipeline pipeline = simplepbr.init( msaa_samples=1, max_lights=8, #enable_shadows=True, ) pipeline.use_normal_maps = False pipeline.use_emission_maps = True pipeline.use_occlusion_maps = True cm = CardMaker('card') cm.set_frame(-1, 1, -1, 1) card_np = base.render.attach_new_node(cm.generate()) mat = Material()