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()
