def create(self): """ This creates the pipeline, and setups all buffers. It also constructs the showbase. The settings should have been loaded before calling this, and also the base and write path should have been initialized properly (see MountManager). """ start_time = time.time() if not self._mount_mgr.is_mounted: self.debug("Mount manager was not mounted, mounting now ...") self._mount_mgr.mount() if not self._settings.is_file_loaded(): self.debug("No settings loaded, loading from default location") self._settings.load_from_file("$$Config/pipeline.yaml") # Check if the pipeline was properly installed, before including anything else if not isfile("Data/install.flag"): DebugObject.global_error("CORE", "You didn't setup the pipeline yet! Please run setup.py.") sys.exit(1) # Load the default prc config load_prc_file("$$Config/configuration.prc") # Construct the showbase and init global variables ShowBase.__init__(self._showbase) self._init_globals() # Create the loading screen self._loading_screen.create() self._adjust_camera_settings() self._create_managers() # Init the onscreen debugger self._init_debugger() # Load plugins and daytime settings self._plugin_mgr.load_plugins() self._daytime_mgr.load_settings() self._com_resources.write_config() # Setup common defines self._create_common_defines() # Let the plugins setup their stages self._plugin_mgr.trigger_hook("on_stage_setup") self._setup_managers() self._plugin_mgr.trigger_hook("on_pipeline_created") # Set the default effect on render self.set_effect(Globals.render, "Effects/Default.yaml", {}, -10) # Hide the loading screen self._loading_screen.remove() self._start_listener() # Measure how long it took to initialize everything init_duration = int((time.time() - start_time) * 1000.0) self.debug("Finished initialization in {} ms".format(init_duration))
def pre_showbase_init(self): """ Setups all required pipeline settings and configuration which have to be set before the showbase is setup. This is called by create(), in case the showbase was not initialized, however you can (and have to) call it manually before you init your custom showbase instance. See the 00-Loading the pipeline sample for more information.""" if not self.mount_mgr.is_mounted: self.debug("Mount manager was not mounted, mounting now ...") self.mount_mgr.mount() if not self.settings: self.debug("No settings loaded, loading from default location") self.load_settings("/$$rpconfig/pipeline.yaml") # Check if the pipeline was properly installed, before including anything else if not isfile("/$$rp/data/install.flag"): self.fatal( "You didn't setup the pipeline yet! Please run setup.py.") # Load the default prc config load_prc_file("/$$rpconfig/panda3d-config.prc") # Set the initialization flag self._pre_showbase_initialized = True
def _initalizeApplication(self, dev: bool) -> None: """ Performs application intialization steps """ # Configure our PyQt5 environment if has_dark: self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5()) self.setApplicationDisplayName('Painter') self.setApplicationName('Painter') self.setApplicationVersion(__version__) runtime.app = self # Mount our application virtual file system if dev: vfs.vfs_mount_subdirectories('.', 'assets') vfs.vfs_mount_subdirectories('.', 'items') else: self._mountMultifile('assets.mf') self._mountMultifile('items.mf') # Initialize Panda3D environment variables p3d.load_prc_file('config/painter.prc') # Initialize our editor window self._window = editor.QEditorWindow() self._window.show()
def pre_showbase_init(self): """ Setups all required pipeline settings and configuration which have to be set before the showbase is setup. This is called by create(), in case the showbase was not initialized, however you can (and have to) call it manually before you init your custom showbase instance. See the 00-Loading the pipeline sample for more information. """ if not self.mount_mgr.is_mounted: self.debug("Mount manager was not mounted, mounting now ...") self.mount_mgr.mount() if not self.settings: self.debug("No settings loaded, loading from default location") self.load_settings("/$$rp/config/pipeline.yaml") load_prc_file("/$$rp/config/panda3d-config.prc") self._pre_showbase_initialized = True
def pre_showbase_init(self): """ Setups all required pipeline settings and configuration which have to be set before the showbase is setup. This is called by create(), in case the showbase was not initialized, however you can (and have to) call it manually before you init your custom showbase instance. See the 00-Loading the pipeline sample for more information. """ if not self.mount_mgr.is_mounted: self.debug("Mount manager was not mounted, mounting now ...") self.mount_mgr.mount() if not self.settings: self.debug("No settings loaded, loading from default location") self.load_settings("/$$rpconfig/pipeline.yaml") if not isfile("/$$rp/data/install.flag"): self.fatal("You didn't setup the pipeline yet! Please run setup.py.") load_prc_file("/$$rpconfig/panda3d-config.prc") self._pre_showbase_initialized = True
def __init__(self) -> None: load_prc_file(Path("config") / "config.prc") super().__init__() self.control = Control(self, Path("config") / "controls.ini") self.slicer = Slicer(self, Path("slicer")) self.world = World(self) self.camera = Camera(self) setup_light(self) self.task_mgr.add(self.world.update, "update_world") self.task_mgr.add(self.slicer.update, "update_slicer") self.task_mgr.add(self.camera.update, "update_camera") self.accept("exit", sys.exit)
def __init__(self): main_dir = core.ExecutionEnvironment.get_environment_variable( "MAIN_DIR") main_dir = core.Filename.from_os_specific(main_dir) core.load_prc_file(core.Filename(main_dir, "settings.prc")) ShowBase.__init__(self) self.disable_mouse() # Workaround for failure to load simplepbr shaders on macOS if getattr(sys, 'frozen', False) and sys.platform == 'darwin': simplepbr.__file__ = self.main_dir + '/' self.assume_gamepad = False DGG.setDefaultRolloverSound(loader.load_sfx('sfx/ui-a.ogg')) DGG.setDefaultClickSound(loader.load_sfx('sfx/ui-b.ogg')) base.setBackgroundColor((0, 0, 0, 1)) self.quality_menu = Menu('quality.', [ ('high.', self.setup_high), ('medium.', self.setup_medium), ('low.', self.setup_low), ('none.', self.setup_potato), ]) self.quality_menu.show() self.gamepads = set() for dev in self.devices.get_devices( core.InputDevice.DeviceClass.gamepad): self._device_connected(dev) self.assume_gamepad = False self.accept('connect-device', self._device_connected) self.accept('disconnect-device', self._device_disconnected)
def init(): """Initialize ShowBase and Panda3D globals.""" # pylint: disable=global-statement global base, cam, cam_node, camera, lens, loader, messenger, \ mouse_watcher, render, render2d, aspect2d, pixel2d, task_mgr, \ win, ttf load_prc_file(resource_filename('tsim', 'data/config.prc')) base = ShowBase.ShowBase() cam = base.cam cam_node = base.camNode camera = base.camera lens = base.cam.node().get_lens() loader = base.loader messenger = base.messenger mouse_watcher = base.mouseWatcherNode render = base.render render2d = base.render2d aspect2d = base.aspect2d pixel2d = base.pixel2d task_mgr = base.task_mgr win = base.win ttf = loader.load_font('cmtt12.egg')
def __init__(self): if not hasattr(builtins, 'base'): # noinspection PyCallByClass,PyArgumentList self.settings = core.load_prc_file( core.Filename.expand_from('$MAIN_DIR/settings.prc')) ShowBase.__init__(self) # noinspection PyArgumentList self.global_clock = core.ClockObject.get_global_clock() self.keyboard_map = self.win.get_keyboard_map() # onscreen hint text self.__hints = self.aspect2d.attach_new_node('hints') self.__hints.set_transparency(core.TransparencyAttrib.M_alpha) self.__hints.set_alpha_scale(0.6) self.__hint_queue = [] self.__hint_hidden = True self.__text_node = None self.__next_txt_change = 0 self.task_mgr.add(self.__update) self.no_movement = True
#encoding: utf8 import sys reload(sys) sys.setdefaultencoding('utf8') from panda3d.core import load_prc_file load_prc_file("./config.prc") from variable.global_vars import G from common import game_states, config_manager, spawner, resource_manager, context, post_effects from assets.map_generators.perlin import PerlinMapGenerator import gui_system from hero import create from panda3d.core import * from storage_system import storage_manager from objects import ground, box, lights from util import states, log from operation import operation from direct.filter.CommonFilters import CommonFilters class Game(object): def __init__(self): G.post_effects = post_effects.PostEffects() def f(): G.post_effects.turn_on() G.accept('z', f) if False: model = G.loader.loadModel("assets/blender/box.egg") model.reparent_to(G.render) G.run() return
from panda3d.core import WindowProperties from panda3d.core import GraphicsPipe from panda3d.core import SamplerState from panda3d.core import DepthOffsetAttrib from keybindings.device_listener import add_device_listener from keybindings.device_listener import SinglePlayerAssigner from text import Texts from map import Map, Room from sound import SoundManager from creature import Interface, Player load_prc_file( Filename.expand_from('$MAIN_DIR/settings.prc') ) class LineEffects(): def __init__(self): self.linesegs = LineSegs("lines") self.bullet = None def remove_bullet(self): if self.bullet: self.bullet.detach_node() def draw_bullet(self, a, b, color): if color == 1: color = (1,0,1,1)
import sys from direct.showbase.ShowBase import ShowBase from direct.filter.FilterManager import FilterManager from panda3d import core import pman.shim from gamelib import simplematcap from gamelib import util from gamelib.world import World from gamelib.input import Input core.load_prc_file(core.Filename.expand_from('$MAIN_DIR/settings.prc')) USER_CONFIG_PATH = core.Filename.expand_from('$MAIN_DIR/user.prc') if USER_CONFIG_PATH.exists(): core.load_prc_file(USER_CONFIG_PATH) def load_shader_str(shadername, defines=None): shaderpath = core.Filename.expand_from( f'$MAIN_DIR/shaders/{shadername}').to_os_specific() with open(shaderpath) as shaderfile: shaderstr = shaderfile.read() return shaderstr class GameApp(ShowBase): def __init__(self):
from direct.showbase.ShowBase import ShowBase import panda3d.core as p3d import blenderpanda from bamboo.inputmapper import InputMapper import gamestates p3d.load_prc_file_data( '', 'model-path {}\n'.format('assets') + \ 'textures-power-2 none\n' ) # Load config files p3d.load_prc_file('config/game.prc') if os.path.exists('config/user.prc'): print("Loading user.prc") p3d.load_prc_file('config/user.prc') else: print("Did not find a user config") class GameApp(ShowBase): def __init__(self): ShowBase.__init__(self) blenderpanda.init(self) base.disableMouse() self.accept('quit', sys.exit)
from direct.showbase.ShowBase import ShowBase from direct.interval import IntervalGlobal as intervals import panda3d.core as p3d import pman.shim import eventmapper import simplepbr from game import gamedb from game import gamestates from game import pathutils from game.playerdata import PlayerData from game.monster import Monster # Load config files before ShowBase is initialized p3d.load_prc_file(p3d.Filename(pathutils.CONFIG_DIR, 'game.prc')) p3d.load_prc_file(p3d.Filename(pathutils.CONFIG_DIR, 'inputs.prc')) p3d.load_prc_file(p3d.Filename(pathutils.USER_CONFIG_DIR, 'user.prc')) p3d.load_prc_file(p3d.Filename(pathutils.CONFIG_DIR, 'user.prc')) class GameApp(ShowBase): 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)
import os import sys import pman.shim from direct.showbase.ShowBase import ShowBase from panda3d.core import load_prc_file, Filename from panda3d.core import NodePath from panda3d.core import OrthographicLens from debugmode import debugMove from inputs import Inputs from tiledpanda import importTiledMap, loadTSX load_prc_file( Filename.expand_from('$MAIN_DIR/settings.prc') ) class Creature(): def __init__(self): self.node = NodePath("creature") self.node.reparentTo(render) class Player(Creature): def __init__(self): Creature.__init__(self) self.sprite = loadTSX("data/tiled/creatures/human_normal.tsx") self.current_animation = self.sprite[0] self.node.attachNewNode(self.current_animation[0].node()) self.node.setPos(0,0,0.2)
#!/usr/bin/env python import math import sys import os import subprocess import time import atexit from direct.showbase.ShowBase import ShowBase import panda3d.core as p3d p3d.load_prc_file('config/engine.prc') if os.path.exists(os.path.join('config', 'user.prc')): p3d.load_prc_file('config/user.prc') if 'server' in sys.argv: p3d.load_prc_file_data('', 'window-type none') import inputmapper import game_modes import network from player import * from effects import EffectSystem from physics import PhysicsSystem class Sigurd(ShowBase): def __init__(self): ShowBase.__init__(self) self.render.set_shader_auto()
import sys from enum import Enum from panda3d.core import load_prc_file from panda3d.core import Filename from panda3d.core import InputDevice from panda3d.core import ConfigVariableString from panda3d.core import KeyboardButton from panda3d.core import ButtonRegistry from direct.showbase.ShowBase import ShowBase from direct.showbase.DirectObject import DirectObject load_prc_file(Filename.expand_from('$MAIN_DIR/keybindings.prc')) class Methods(Enum): FLIGHTSTICK = InputDevice.DeviceClass.flight_stick GAMEPAD = InputDevice.DeviceClass.gamepad KEYBOARD = InputDevice.DeviceClass.keyboard priorities = {cls.value: priority for priority, cls in enumerate(Methods)} event_prefixes = { InputDevice.DeviceClass.keyboard: '', InputDevice.DeviceClass.gamepad: 'gamepad', InputDevice.DeviceClass.flight_stick: 'flight_stick', } UNBOUND = 'none'
from direct.showbase.ShowBase import ShowBase from panda3d.core import WindowProperties from panda3d.core import load_prc_file import simplepbr load_prc_file('myConfig.prc') class Slugrace3D(ShowBase): 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) app = Slugrace3D() app.run()
if not APP_ROOT_DIR: print("empty app_root_dir") sys.exit() # prc files to load sorted by load order CONFIG_ROOT_DIR = os.path.join(APP_ROOT_DIR, 'config') CONFIG_FILES = [ os.path.join(CONFIG_ROOT_DIR, 'game.prc'), os.path.join(CONFIG_ROOT_DIR, 'user.prc'), ] for config_file in CONFIG_FILES: if os.path.exists(config_file): print("Loading config file:", config_file) config_file = p3d.Filename.from_os_specific(config_file) p3d.load_prc_file(config_file) else: print("Could not find config file", config_file) class GameApp(ShowBase): def __init__(self): ShowBase.__init__(self) blenderpanda.init(self) self.input_mapper = inputmapper.InputMapper( os.path.join(CONFIG_ROOT_DIR, 'input.conf')) self.accept('quit', sys.exit) self.disableMouse()
def __init__(self): self.settings = core.load_prc_file(core.Filename.expand_from("$MAIN_DIR/settings.prc")) ShowBase.__init__(self, windowType='none') # Try opening "gl-version 3 2" window props = core.WindowProperties.get_default() have_window = False try: self.open_default_window(props=props) have_window = True except Exception: pass if not have_window: print("Failed to open window with OpenGL 3.2; falling back to older OpenGL.") core.load_prc_file_data("", "gl-version") self.open_default_window(props=props) print("The window seemed to have opened this time around.") gsg = self.win.gsg gl_version = (gsg.driver_version_major, gsg.driver_version_minor) self.has_fixed_function = gl_version < (3, 0) or gsg.max_lights > 0 print("OpenGL version: {0}.{1} ({2})".format(*gl_version, 'compat' if self.has_fixed_function else 'core')) print("OpenGL renderer: {0}".format(gsg.driver_renderer)) self.accept('escape', sys.exit) self.accept('f12', self.screenshot) self.disable_mouse() self.camLens.set_far(50) # Load in background self.set_background_color((0.31, 0.42, 0.53)) if not self.win.get_fb_properties().srgb_color: print("Did not get an sRGB framebuffer. The game may appear too dark.") # Load fonts self.symbol_font = loader.load_font("font/FreeSerif.otf") self.symbol_font.set_pixels_per_unit(64) self.regular_font = loader.load_font("font/Quicksand-Regular.otf") self.regular_font.set_pixels_per_unit(64) self.title_font = loader.load_font("font/Quicksand-Light.otf") self.title_font.set_pixels_per_unit(128) self.icon_fonts = { 'solid': loader.load_font("font/font-awesome5-solid.otf"), 'regular': loader.load_font("font/font-awesome5-regular.otf"), } for font in self.icon_fonts.values(): font.set_pixels_per_unit(64) # Load sounds DGG.setDefaultClickSound(loader.load_sfx('sfx/menu-interact.wav')) DGG.setDefaultRolloverSound(loader.load_sfx('sfx/menu-focus.wav')) self.endtile_sound = loader.load_sfx('sfx/endtile.wav') self.move_sound = loader.load_sfx('sfx/die-move.wav') self.impassable_sound = loader.load_sfx('sfx/impassable.wav') self.button_sound = loader.load_sfx('sfx/button-press.wav') self.transport_sound = loader.load_sfx('sfx/transport-engage.wav') self.slide_sound = loader.load_sfx('sfx/ice-slide.wav') self.wind_sound = loader.load_sfx('sfx/wind.ogg') self.crack_sound = loader.load_sfx('sfx/tile-crack.wav') self.collapse_sound = loader.load_sfx('sfx/tile-collapse.wav') self.restart_sound = loader.load_sfx('sfx/menu-interact.wav') self.music = { 'menu': loader.load_music('music/theme.ogg'), 'one': loader.load_music('music/world1.ogg'), 'two': loader.load_music('music/world2.ogg'), 'three': loader.load_music('music/world3.ogg'), 'four': loader.load_music('music/world4.ogg'), 'five': loader.load_music('music/world5.ogg'), 'six': loader.load_music('music/world6.ogg'), } self.playing_music = None self.music_on = True self.blur_shader = core.Shader.load(core.Shader.SL_GLSL, "shader/blur.vert", "shader/blur.frag") self.blur_scale = core.PTA_float([1.0]) self.blurred_tex = None self.quality = None screen = ui.Screen("select quality") ui.Button(screen, 'sublime', pos=(0.0, 0), command=self.setup_game, extraArgs=[3]) ui.Button(screen, 'mediocre', pos=(0.0, -0.15), command=self.setup_game, extraArgs=[2]) ui.Button(screen, 'terrible', pos=(0.0, -0.3), command=self.setup_game, extraArgs=[1]) self.quality_screen = screen screen.show_now() self.game_setup = False self.have_save = False self.blurred = True self.accept('connect-device', self.on_connect_device) self.accept('disconnect-device', self.on_disconnect_device) self.gamepads = set() dev_mgr = core.InputDeviceManager.get_global_ptr() for device in dev_mgr.get_devices(core.InputDevice.DeviceClass.gamepad): self.on_connect_device(device) self.gamepad_lstick_angle = None self.win_input = self.win.get_input_device(0) self.task_mgr.add(self.process_input) sys.stdout.flush() sys.stderr.flush()
import panda3d.core as p3d import blenderpanda from bamboo.inputmapper import InputMapper import gamestates p3d.load_prc_file_data( '', 'model-path {}\n'.format('assets') + \ 'textures-power-2 none\n' ) # Load config files p3d.load_prc_file('config/game.prc') if os.path.exists('config/user.prc'): print("Loading user.prc") p3d.load_prc_file('config/user.prc') else: print("Did not find a user config") class GameApp(ShowBase): def __init__(self): ShowBase.__init__(self) blenderpanda.init(self) base.disableMouse() self.accept('quit', sys.exit)