def __init__(self,
frame_size=None,
force_hardware=True,
MSAA_samples=0,
CSAA_samples=0,
sRGB_color=False):
"""Renderer based on Panda3D
Keyword Arguments:
frame_size {tuple} -- frame size (default: {256, 256})
force_hardware {bool} -- force hardware rendering (default: {True})
MSAA_samples {int} -- MSAA (Multi-Sampling Anti-Aliasing) level (default: {0})
CSAA_samples {int} -- CSAA (Coverage Sampling Antialiasing) level (default: {0})
sRGB_color {bool} -- apply sRGB colorspace gamma correction (default: {False})
"""
BaseRenderer.__init__(self)
self.return_to_bullet = True
# renderer
loadPrcFileData(
"", f"""
gl-compile-and-execute 1
gl-use-bindless-texture 1
prefer-texture-buffer 1
""")
fbp = FrameBufferProperties(FrameBufferProperties.getDefault())
fbp.set_force_hardware(force_hardware)
fbp.set_force_software(not force_hardware)
fbp.set_multisamples(MSAA_samples)
fbp.set_coverage_samples(CSAA_samples)
fbp.set_srgb_color(sRGB_color)
self._renderer = OffscreenRenderer(frame_size, fbp)
self._loader = Loader.Loader(None)
# scene
self.scene = NodePath('render')
self.scene.setAttrib(RescaleNormalAttrib.makeDefault())
self.scene.setTwoSided(False)
self.scene.setAntialias(AntialiasAttrib.MAuto)
self.scene.setShaderAuto()
self._light = PbLightNode(self.scene)
self._camera = PbCameraNode(self.scene)
self._node_dict = {}
from AIBase import *
__builtins__['simbase'] = AIBase()
__builtins__['ostream'] = Notify.out()
__builtins__['run'] = simbase.run
__builtins__['taskMgr'] = simbase.taskMgr
__builtins__['jobMgr'] = simbase.jobMgr
__builtins__['eventMgr'] = simbase.eventMgr
__builtins__['messenger'] = simbase.messenger
__builtins__['bboard'] = simbase.bboard
__builtins__['config'] = simbase.config
__builtins__['directNotify'] = directNotify
from direct.showbase import Loader
simbase.loader = Loader.Loader(simbase)
__builtins__['loader'] = simbase.loader
directNotify.setDconfigLevels()
def inspect(anObject):
from direct.tkpanels import Inspector
Inspector.inspect(anObject)
__builtins__['inspect'] = inspect
taskMgr.finalInit()
from AIBase import AIBase
from direct.directnotify.DirectNotifyGlobal import directNotify
from panda3d.core import RescaleNormalAttrib, NodePath, Notify
__builtins__['base'] = AIBase()
__builtins__['ostream'] = Notify.out()
__builtins__['run'] = base.run
__builtins__['taskMgr'] = base.taskMgr
__builtins__['jobMgr'] = base.jobMgr
__builtins__['eventMgr'] = base.eventMgr
__builtins__['messenger'] = base.messenger
__builtins__['bboard'] = base.bboard
__builtins__['config'] = base.config
__builtins__['directNotify'] = directNotify
render = NodePath('render')
render.setAttrib(RescaleNormalAttrib.makeDefault())
render.setTwoSided(0)
__builtins__['render'] = render
from direct.showbase import Loader
base.loader = Loader.Loader(base)
__builtins__['loader'] = base.loader
directNotify.setDconfigLevels()
def inspect(anObject):
from direct.tkpanels import Inspector
Inspector.inspect(anObject)
__builtins__['inspect'] = inspect
taskMgr.finalInit()
[ # two-player
"phase_4/models/minigames/maze_2player",
],
[ # three-player
"phase_4/models/minigames/maze_3player",
],
[ # four-player
"phase_4/models/minigames/maze_4player",
],
]
CELL_WIDTH = 2 # feet
CollideMask = BitMask32(1)
loader = Loader.Loader(None)
root = NodePath('root')
def fwrite(file, str):
file.write(str)
file.write("\n")
def fwritelines(file, strs):
for str in strs:
fwrite(file, str)
def calcMazeTopology(mazeNode):
cRay = CollisionRay(0, 0, 50, 0, 0, -1)
def __init__(self):
# This contains the global appRunner instance, as imported from
# AppRunnerGlobal. This will be None if we are not running in the
# runtime environment (ie. from a .p3d file).
self.app_runner = AppRunnerGlobal.appRunner
#store the Config class, it's nice, use it
self.config = Config
#Set the default loader... for some reason
self.graphics_engine = GraphicsEngine.get_global_ptr()
self.loader = Loader.Loader(self)
# This is the DataGraph traverser, which we might as well
# create now.
self.data_graph_trav = DataGraphTraverser()
self.data_root = NodePath('data_root')
self.data_root_node = self.data_root.node()
#Disable sticky keys
if Config['disable-sticky-keys']:
storeAccessibilityShortcutKeys()
allowAccessibilityShortcutKeys(False)
#Make render, render2d and pixel2d nodes
self.render = NodePath('render')
self.render2d = NodePath('render2d')
self.render2d.set_depth_test(0)
self.render2d.set_depth_write(0)
self.render2d.set_material_off(1)
self.render2d.set_two_sided(1)
self.aspect2d = self.render2d.attach_new_node(PGTop("aspect2d"))
aspectRatio = self.get_aspect_ratio()
self.aspect2d.set_scale(1.0 / aspectRatio, 1.0, 1.0)
self.pixel2d = self.render2d.attach_new_node(PGTop("pixel2d"))
self.pixel2d.set_pos(-1, 0, 1)
xsize, ysize = self.get_size()
if xsize > 0 and ysize > 0:
self.pixel2d.set_scale(2.0 / xsize, 1.0, 2.0 / ysize)
#Open default window
self._open_main_window()
# The global event manager, as imported from EventManagerGlobal.
self.event_mgr = eventMgr
# The global messenger, as imported from MessengerGlobal.
self.messenger = messenger
# The global task manager, as imported from TaskManagerGlobal.
self.task_mgr = taskMgr
# Get a pointer to Panda's global ClockObject, used for
# synchronizing events between Python and C.
self.global_clock = ClockObject.getGlobalClock()
#Make sure the globalClock object is in sync with the TrueClock.
self.global_clock.setRealTime(TrueClock.getGlobalPtr().getShortTime())
self.global_clock.tick()
#Make the TaskManager start using the new globalClock.
self.task_mgr.globalClock = self.global_clock
#Listen for window shape, size and focus change events
self.accept('window-event', self._on_window_event)
# Start render_frame_loop
self.restart()
