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)
