def toggle_fullscreen(self, fullscreen):
if fullscreen:
print("Switching to fullscreen mode")
size = self.pipe.get_display_width(), self.pipe.get_display_height()
self.win.request_properties(core.WindowProperties(fullscreen=True, size=size))
else:
print("Switching to windowed mode")
size = core.WindowProperties.get_default().size
self.win.request_properties(core.WindowProperties(fullscreen=False, size=size, origin=(-2, -2)))
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()
winprops = self.win.get_properties()
self.win.move_pointer(0,
winprops.get_x_size() // 2,
winprops.get_y_size() // 2)
winprops = p3d.WindowProperties()
winprops.set_mouse_mode(p3d.WindowProperties.M_confined)
self.win.request_properties(winprops)
self.current_state = gamestates.MainState()
def update_gamestate(task):
self.current_state.update(
p3d.ClockObject.get_global_clock().get_dt())
return task.cont
self.taskMgr.add(update_gamestate, 'GameState')
def _make_buffer(self, width, height):
"""Make an offscreen buffer.
Arguments:
width {int} -- target buffer width
height {int} -- target buffer height
"""
fb_prop = p3d.FrameBufferProperties(
p3d.FrameBufferProperties.get_default())
fb_prop.set_multisamples(self._multisamples)
fb_prop.set_srgb_color(self._srgb_color)
self._buffer = self._engine.make_output(
self._pipe,
name="offscreen",
sort=0,
fb_prop=p3d.FrameBufferProperties.get_default(),
win_prop=p3d.WindowProperties(size=(width, height)),
flags=p3d.GraphicsPipe.BFRefuseWindow)
self._region = self._buffer.make_display_region()
self._depth_tex = p3d.Texture()
self._depth_tex.setFormat(p3d.Texture.FDepthComponent)
self._buffer.addRenderTexture(self._depth_tex,
p3d.GraphicsOutput.RTMCopyRam,
p3d.GraphicsOutput.RTPDepth)
self._color_tex = p3d.Texture()
self._color_tex.setFormat(p3d.Texture.FRgba8)
self._buffer.addRenderTexture(self._color_tex,
p3d.GraphicsOutput.RTMCopyRam,
p3d.GraphicsOutput.RTPColor)
def forceResize(self) -> None:
"""
"""
wp = p3d.WindowProperties()
wp.set_origin(0, 0)
wp.set_size(self.width(), self.height())
self.base.win.requestProperties(wp)
def toggle_fullscreen(self):
is_fullscreen = self.win.get_properties().fullscreen
if is_fullscreen:
print("Disabling fullscreen")
size = core.WindowProperties.get_default().size
self.win.request_properties(
core.WindowProperties(fullscreen=False,
origin=(-2, -2),
size=size))
self.main_menu.buttons[2]['text'] = 'fullscreen.'
else:
print("Enabling fullscreen")
size = self.pipe.get_display_width(), self.pipe.get_display_height(
)
self.win.request_properties(
core.WindowProperties(fullscreen=True, size=size))
self.main_menu.buttons[2]['text'] = 'window.'
def update_options(self, options):
wp = p3d.WindowProperties()
resx, resy = [
int(i) for i in options['selected_resolution'].split(' x ')
]
wp.set_size(resx, resy)
wp.set_fullscreen(options['fullscreen'])
self.win.request_properties(wp)
def resizeEvent(self, evt: object) -> None:
"""
"""
size = evt.size()
wp = p3d.WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(size.width(), size.height())
self.base.win.requestProperties(wp)
def registerWindow(self, window):
self.MainWindow = window
self.accept("f11", self.MainWindow.toggleFullscreen)
self.accept("f12", lambda: age.App().MakeScreenshot(self.MainWindow))
wp = p3dc.WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(P3D_WIN_WIDTH, P3D_WIN_HEIGHT)
wp.set_parent_window(int(self.MainWindow.pandaContainer.winId()))
#wp.
self.openDefaultWindow(props=wp)
def pause(self):
if self.paused:
return
self.world.music[Music].play('pause')
self.paused = True
self.pause_menu.show()
self.win.request_properties(
core.WindowProperties(
mouse_mode=core.WindowProperties.M_absolute,
cursor_hidden=False,
))
def _window_props(self):
self.tkRoot.update()
window_id = self.tkRoot.winfo_id()
width = self.tkRoot.winfo_width()
height = self.tkRoot.winfo_height()
props = core.WindowProperties()
props.set_parent_window(window_id)
props.set_origin(0, 50)
props.set_size(width, height - 80)
return props
def render_frame(self, context):
window = context.window
region = context.region
view = context.region_data
# Calculate dimensions of the display region.
pixel_scale = p3d.LVecBase2(1.0 / window.width, 1.0 / window.height)
dimensions = p3d.LVecBase4(region.x, region.x + region.width,
region.y, region.y + region.height)
dimensions.x *= pixel_scale.x
dimensions.y *= pixel_scale.x
dimensions.z *= pixel_scale.y
dimensions.w *= pixel_scale.y
self.view_region.set_dimensions(dimensions)
# Save GL State
glPushAttrib(GL_ALL_ATTRIB_BITS)
glPushClientAttrib(~0)
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glMatrixMode(GL_PROJECTION)
glPushMatrix()
try:
# update window
wp = p3d.WindowProperties()
wp.set_origin(window.x, window.y)
wp.set_size(window.width, window.height)
self.win.request_properties(wp)
self.engine.open_windows()
# update camera
proj_mat = p3d.LMatrix4()
for i, v in enumerate(view.perspective_matrix):
proj_mat.set_col(i, p3d.LVecBase4(*v))
self.view_lens.set_user_mat(proj_mat)
self.view_lens.set_view_mat(p3d.LMatrix4.ident_mat())
#draw
self.fix_gl_state()
self.engine.render_frame()
finally:
# Restore GL State
glMatrixMode(GL_PROJECTION)
glPopMatrix()
glMatrixMode(GL_MODELVIEW)
glPopMatrix()
glPopClientAttrib()
glPopAttrib()
def stop(self):
self.gameApp.taskMgr.remove("HxMouseLook::cameraTask")
mat = pcore.LMatrix4f(self.camera.getTransform(self.refNode).getMat())
mat.invertInPlace()
self.camera.setMat(pcore.LMatrix4f.identMat())
self.gameApp.mouseInterfaceNode.setMat(mat)
self.gameApp.enableMouse()
props = pcore.WindowProperties()
props.setCursorHidden(False)
self.gameApp.win.requestProperties(props)
self.forward = False
self.backward = False
self.left = False
self.right = False
self.up = False
self.down = False
self.rollLeft = False
self.ignore("w")
self.ignore("shift-w")
self.ignore("w-up")
self.ignore("s")
self.ignore("shift-s")
self.ignore("s-up")
self.ignore("a")
self.ignore("shift-a")
self.ignore("a-up")
self.ignore("d")
self.ignore("shift-d")
self.ignore("d-up")
self.ignore("r")
self.ignore("shift-r")
self.ignore("r-up")
self.ignore("f")
self.ignore("shift-f")
self.ignore("f-up")
self.ignore("q")
self.ignore("q-up")
self.ignore("e")
self.ignore("e-up")
self.ignore("shift")
self.ignore("shift-up")
# un-setup collisions
if self.collisionHandler != None:
# remove camera from the collision system
self.gameApp.cTrav.removeCollider(self.collisionNP)
# remove from collisionHandler (Pusher)
self.collisionHandler.removeCollider(self.collisionNP)
# remove the collision node
self.collisionNP.removeNode()
def __init__(self):
System.__init__(self)
self.last_ptr = None
base.win.request_properties(core.WindowProperties(mouse_mode=core.WindowProperties.M_confined))
self._control_mode = 'mouse'
self._current_vec = core.Vec2(0)
self._speed_target = 0.0
self.accept('switch-mouse-controls', self.ensure_control_mode, ['mouse', True])
self.accept('switch-gamepad-controls', self.ensure_control_mode, ['gamepad', True])
def ensure_control_mode(self, mode, force=False):
if mode == self._control_mode and not force:
return
if mode != self._control_mode:
print("Switched to", mode, "controls")
self._control_mode = mode
base.win.move_pointer(0, base.win.get_x_size() // 2, base.win.get_y_size() // 2)
if mode == 'mouse':
base.assume_gamepad = False
base.win.request_properties(core.WindowProperties(
mouse_mode=core.WindowProperties.M_confined,
cursor_hidden=False,
))
else:
base.assume_gamepad = True
base.win.request_properties(core.WindowProperties(
mouse_mode=core.WindowProperties.M_absolute,
cursor_hidden=True,
))
def start(self):
self.gameApp.disableMouse()
self.camera.setP(self.refNode, 0)
self.camera.setR(self.refNode, 0)
# hide mouse cursor, comment these 3 lines to see the cursor
props = pcore.WindowProperties()
props.setCursorHidden(True)
self.gameApp.win.requestProperties(props)
# reset mouse to start position:
self.gameApp.win.movePointer(0, int(self.centX), int(self.centY))
self.gameApp.taskMgr.add(self.cameraTask, 'HxMouseLook::cameraTask')
#Task for changing direction/position
self.accept("w", setattr, [self, "forward", True])
self.accept("shift-w", setattr, [self, "forward", True])
self.accept("w-up", setattr, [self, "forward", False])
self.accept("s", setattr, [self, "backward", True])
self.accept("shift-s", setattr, [self, "backward", True])
self.accept("s-up", setattr, [self, "backward", False])
self.accept("a", setattr, [self, "left", True])
self.accept("shift-a", setattr, [self, "left", True])
self.accept("a-up", setattr, [self, "left", False])
self.accept("d", setattr, [self, "right", True])
self.accept("shift-d", setattr, [self, "right", True])
self.accept("d-up", setattr, [self, "right", False])
self.accept("q", setattr, [self, "rollLeft", True])
self.accept("q-up", setattr, [self, "rollLeft", False])
self.accept("e", setattr, [self, "rollRight", True])
self.accept("e-up", setattr, [self, "rollRight", False])
self.accept("shift", setattr, [self, "fast", 10.0])
self.accept("shift-up", setattr, [self, "fast", 1.0])
# setup collisions
if self.collisionHandler != None:
#setup collisions
nearDist = self.camera.node().getLens().getNear()
# Create a collision node for this camera.
# and attach it to the camera.
self.collisionNP = self.camera.attachNewNode(CollisionNode("firstPersonCamera"))
# Attach a collision sphere solid to the collision node.
self.collisionNP.node().addSolid(CollisionSphere(0, 0, 0, nearDist * 1.1))
# self.collisionNP.show()
# setup camera "from" bit-mask
self.collisionNP.node().setFromCollideMask(self.collideMask)
# add to collisionHandler (Pusher)
self.collisionHandler.addCollider(self.collisionNP, self.camera)
#add camera to collision system
self.gameApp.cTrav.addCollider(self.collisionNP, self.collisionHandler)
def __init__(self, parent):
AssetBrowser.__init__(self, parent)
self.currentLoadContext = None
# Set up an offscreen buffer to render the thumbnails of our models.
props = core.WindowProperties()
props.setSize(96, 96)
fbprops = core.FrameBufferProperties()
fbprops.setSrgbColor(True)
fbprops.setRgbaBits(8, 8, 8, 0)
flags = (core.GraphicsPipe.BFRefuseWindow
| core.GraphicsPipe.BFSizeSquare)
self.buffer = base.graphicsEngine.makeOutput(base.pipe,
"modelBrowserBuffer", 0,
fbprops, props, flags,
None, None)
gsg = self.buffer.getGsg()
self.buffer.setClearColor(
BSPUtils.vec3GammaToLinear(
core.Vec4(82 / 255.0, 82 / 255.0, 82 / 255.0, 1.0)))
self.buffer.setActive(False)
self.displayRegion = self.buffer.makeDisplayRegion()
self.render = core.NodePath("modelBrowserRoot")
self.render.setShaderAuto()
camNode = core.Camera("modelBrowserRenderCam")
lens = core.PerspectiveLens()
lens.setFov(40)
camNode.setLens(lens)
self.lens = lens
self.camera = self.render.attachNewNode(camNode)
# Isometric camera angle
self.camera.setHpr(225, -30, 0)
self.displayRegion.setCamera(self.camera)
shgen = BSPShaderGenerator(self.buffer, gsg, self.camera, self.render)
gsg.setShaderGenerator(shgen)
for shader in ShaderGlobals.getShaders():
shgen.addShader(shader)
self.shaderGenerator = shgen
base.graphicsEngine.openWindows()
def makeFBO(self, name, auxrgba):
# This routine creates an offscreen buffer. All the complicated
# parameters are basically demanding capabilities from the offscreen
# buffer - we demand that it be able to render to texture on every
# bitplane, that it can support aux bitplanes, that it track
# the size of the host window, that it can render to texture
# cumulatively, and so forth.
winprops = p3dc.WindowProperties()
props = p3dc.FrameBufferProperties()
props.setRgbColor(True)
props.setRgbaBits(8, 8, 8, 8)
props.setDepthBits(1)
props.setAuxRgba(auxrgba)
return self.graphicsEngine.makeOutput(
self.pipe, "model buffer", -2, props, winprops,
p3dc.GraphicsPipe.BFSizeTrackHost
| p3dc.GraphicsPipe.BFCanBindEvery
| p3dc.GraphicsPipe.BFRttCumulative
| p3dc.GraphicsPipe.BFRefuseWindow, self.win.getGsg(), self.win)
def setup(self):
self.props = core.WindowProperties()
self.props.setSize(self.pipe.getDisplayWidth(),
self.pipe.getDisplayHeight())
self.props.setFullscreen(self.Fullscreen)
self.props.setCursorHidden(True)
self.props.setUndecorated(True)
self.win.requestProperties(self.props)
self.graphicsEngine.openWindows()
self.set_background_color(0, 0, 0)
self.disableMouse()
self.isrunning = False
self.movie = False
#info = self.pipe.getDisplayInformation()
#print(info.getTotalDisplayModes())
#print(info.getDisplayModeWidth(0), info.getDisplayModeHeight(0))
#print(self.pipe.getDisplayWidth(), self.pipe.getDisplayHeight())
# Create Ambient Light
self.ambientLight = core.AmbientLight('ambientLight')
self.ambientLightNP = self.render.attachNewNode(self.ambientLight)
self.render.setLight(self.ambientLightNP)
def set_window_title(self, title):
'''Change the title of the window'''
win_props = p3d.WindowProperties()
win_props.set_title(title)
self.win.request_properties(win_props)
def _make_buffer(self, fb_props):
return self._engine.make_output(
self._pipe, self.name, 0, fb_props, p3d.WindowProperties(),
p3d.GraphicsPipe.BF_refuse_window
| p3d.GraphicsPipe.BF_size_track_host, self._window.get_gsg(),
self._window)
def __init__(self):
# Setup a space to work with
base.ecsmanager.space = Entity(None)
base.ecsmanager.space.add_component(components.NodePathComponent())
spacenp = base.ecsmanager.space.get_component('NODEPATH').nodepath
spacenp.reparent_to(base.render)
# Load assets
self.level_entity = base.ecsmanager.create_entity()
self.level = loader.load_model('cathedral.bam')
level_start = self.level.find('**/PlayerStart')
self.level.reparent_to(spacenp)
for phynode in self.level.find_all_matches('**/+BulletBodyNode'):
if not phynode.is_hidden():
self.level_entity.add_component(
components.PhysicsStaticMeshComponent(phynode.node()))
else:
print("Skipping hidden node", phynode)
self.player = base.template_factory.make_character(
'character.bam', self.level, level_start.get_pos())
# Attach camera to player
playernp = self.player.get_component('NODEPATH').nodepath
self.camera = base.ecsmanager.create_entity()
self.camera.add_component(
components.Camera3PComponent(base.camera, playernp))
# Player movement
self.player_movement = p3d.LVector3(0, 0, 0)
def update_movement(direction, activate):
move_delta = p3d.LVector3(0, 0, 0)
if direction == 'forward':
move_delta.set_y(1)
elif direction == 'backward':
move_delta.set_y(-1)
elif direction == 'left':
move_delta.set_x(-1)
elif direction == 'right':
move_delta.set_x(1)
if not activate:
move_delta *= -1
self.player_movement += move_delta
self.accept('move-forward', update_movement, ['forward', True])
self.accept('move-forward-up', update_movement, ['forward', False])
self.accept('move-backward', update_movement, ['backward', True])
self.accept('move-backward-up', update_movement, ['backward', False])
self.accept('move-left', update_movement, ['left', True])
self.accept('move-left-up', update_movement, ['left', False])
self.accept('move-right', update_movement, ['right', True])
self.accept('move-right-up', update_movement, ['right', False])
def jump():
char = self.player.get_component('CHARACTER')
char.jump = True
self.accept('jump', jump)
# Mouse look
props = p3d.WindowProperties()
props.set_cursor_hidden(True)
props.set_mouse_mode(p3d.WindowProperties.M_confined)
base.win.request_properties(props)
def __init__(self):
# Preliminary capabilities check.
if not ape.base().win.getGsg().getSupportsBasicShaders():
self.t = addTitle(
"Shadow Demo: Video driver reports that shaders are not supported."
)
return
if not ape.base().win.getGsg().getSupportsDepthTexture():
self.t = addTitle(
"Shadow Demo: Video driver reports that depth textures are not supported."
)
return
# creating the offscreen buffer.
winprops = p3dc.WindowProperties(size=(512, 512))
props = p3dc.FrameBufferProperties()
props.setRgbColor(1)
props.setAlphaBits(1)
props.setDepthBits(1)
LBuffer = ape.base().graphicsEngine.makeOutput(
ape.base().pipe, "offscreen buffer", -2, props, winprops,
p3dc.GraphicsPipe.BFRefuseWindow,
ape.base().win.getGsg(),
ape.base().win)
self.buffer = LBuffer
if not LBuffer:
self.t = addTitle(
"Shadow Demo: Video driver cannot create an offscreen buffer.")
return
Ldepthmap = p3dc.Texture()
LBuffer.addRenderTexture(Ldepthmap, p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPDepthStencil)
if ape.base().win.getGsg().getSupportsShadowFilter():
Ldepthmap.setMinfilter(p3dc.Texture.FTShadow)
Ldepthmap.setMagfilter(p3dc.Texture.FTShadow)
# Adding a color texture is totally unnecessary, but it helps with
# debugging.
Lcolormap = p3dc.Texture()
LBuffer.addRenderTexture(Lcolormap, p3dc.GraphicsOutput.RTMBindOrCopy,
p3dc.GraphicsOutput.RTPColor)
self.inst_p = addInstructions(0.06,
'P : stop/start the Panda Rotation')
self.inst_w = addInstructions(0.12, 'W : stop/start the Walk Cycle')
self.inst_t = addInstructions(0.18, 'T : stop/start the Teapot')
self.inst_l = addInstructions(0.24,
'L : move light source far or close')
self.inst_v = addInstructions(0.30,
'V : View the Depth-Texture results')
self.inst_u = addInstructions(0.36,
'U : toggle updating the shadow map')
self.inst_x = addInstructions(
0.42, 'Left/Right Arrow : switch camera angles')
self.inst_a = addInstructions(0.48,
'Something about A/Z and push bias')
ape.base().setBackgroundColor(0, 0, 0.2, 1)
ape.base().camLens.setNearFar(1.0, 10000)
ape.base().camLens.setFov(75)
ape.base().disableMouse()
# Load the scene.
floorTex = ape.loader().loadTexture('maps/envir-ground.jpg')
cm = p3dc.CardMaker('')
cm.setFrame(-2, 2, -2, 2)
floor = ape.render().attachNewNode(p3dc.PandaNode("floor"))
for y in range(12):
for x in range(12):
nn = floor.attachNewNode(cm.generate())
nn.setP(-90)
nn.setPos((x - 6) * 4, (y - 6) * 4, 0)
floor.setTexture(floorTex)
floor.flattenStrong()
self.pandaAxis = ape.render().attachNewNode('panda axis')
self.pandaModel = Actor('panda-model', {'walk': 'panda-walk4'})
self.pandaModel.reparentTo(self.pandaAxis)
self.pandaModel.setPos(9, 0, 0)
self.pandaModel.setShaderInput("scale", (0.01, 0.01, 0.01, 1.0))
self.pandaWalk = self.pandaModel.actorInterval('walk', playRate=1.8)
self.pandaWalk.loop()
self.pandaMovement = self.pandaAxis.hprInterval(
20.0, p3dc.LPoint3(-360, 0, 0), startHpr=p3dc.LPoint3(0, 0, 0))
self.pandaMovement.loop()
self.teapot = ape.loader().loadModel('teapot')
self.teapot.reparentTo(ape.render())
self.teapot.setPos(0, -20, 10)
self.teapot.setShaderInput("texDisable", (1, 1, 1, 1))
self.teapotMovement = self.teapot.hprInterval(
50, p3dc.LPoint3(0, 360, 360))
self.teapotMovement.loop()
self.accept('escape', sys.exit)
self.accept("arrow_left", self.incrementCameraPosition, [-1])
self.accept("arrow_right", self.incrementCameraPosition, [1])
self.accept("p", self.toggleInterval, [self.pandaMovement])
self.accept("t", self.toggleInterval, [self.teapotMovement])
self.accept("w", self.toggleInterval, [self.pandaWalk])
self.accept("v", ape.base().bufferViewer.toggleEnable)
self.accept("u", self.toggleUpdateShadowMap)
self.accept("l", self.incrementLightPosition, [1])
self.accept("o", ape.base().oobe)
self.accept('a', self.adjustPushBias, [1.1])
self.accept('z', self.adjustPushBias, [0.9])
self.LCam = ape.base().makeCamera(LBuffer)
self.LCam.node().setScene(ape.render())
self.LCam.node().getLens().setFov(40)
self.LCam.node().getLens().setNearFar(10, 100)
# default values
self.pushBias = 0.04
self.ambient = 0.2
self.cameraSelection = 0
self.lightSelection = 0
# setting up shader
ape.render().setShaderInput('light', self.LCam)
ape.render().setShaderInput('Ldepthmap', Ldepthmap)
ape.render().setShaderInput('ambient', (self.ambient, 0, 0, 1.0))
ape.render().setShaderInput('texDisable', (0, 0, 0, 0))
ape.render().setShaderInput('scale', (1, 1, 1, 1))
# Put a shader on the Light camera.
lci = p3dc.NodePath(p3dc.PandaNode("Light Camera Initializer"))
lci.setShader(ape.loader().loadShader('shadows_caster.sha'))
self.LCam.node().setInitialState(lci.getState())
# Put a shader on the Main camera.
# Some video cards have special hardware for shadow maps.
# If the card has that, use it. If not, use a different
# shader that does not require hardware support.
mci = p3dc.NodePath(p3dc.PandaNode("Main Camera Initializer"))
if ape.base().win.getGsg().getSupportsShadowFilter():
mci.setShader(ape.loader().loadShader('shadows_shadow.sha'))
else:
mci.setShader(
ape.loader().loadShader('shadows_shadow-nosupport.sha'))
ape.base().cam.node().setInitialState(mci.getState())
self.incrementCameraPosition(0)
self.incrementLightPosition(0)
self.adjustPushBias(1.0)
def moveEvent(self, evt):
wp = p3dc.WindowProperties()
wp.setSize(self.width(), self.height())
base().win.requestProperties(wp)
def resizeEvent(self, evt):
wp = p3dc.WindowProperties()
wp.setSize(self.width(), self.height())
wp.setOrigin(0, 0)
base().win.requestProperties(wp)
def setup_fafnir(self):
self.fafnir_np = p3d.NodePath(p3d.PandaNode("Fafnir"))
global_shader = p3d.Shader.load(
p3d.Shader.SL_GLSL,
vertex="shaders/build_mesh_cache.vs",
geometry="shaders/build_mesh_cache.gs",
fragment="shaders/generate_primary_intersections.fs",
)
self.fafnir_np.set_shader(global_shader)
self.mesh_cache = MeshCache(1, 1)
self.material_cache = MaterialCache()
self.draw_manager = DrawManager(self.fafnir_np)
win_width = self.win.get_x_size()
win_height = self.win.get_y_size()
rtt_fb_prop = p3d.FrameBufferProperties()
rtt_fb_prop.set_rgba_bits(32, 32, 32, 32)
rtt_fb_prop.set_float_color(True)
rtt_fb_prop.set_depth_bits(32)
rtt_win_prop = p3d.WindowProperties().size(win_width, win_height)
rtt_buffer = base.graphics_engine.make_output(
base.pipe, 'Fafnir RTT Buffer', -100, rtt_fb_prop, rtt_win_prop,
p3d.GraphicsPipe.BF_refuse_window, base.win.get_gsg(), base.win)
intersection_texture = p3d.Texture()
rtt_buffer.add_render_texture(intersection_texture,
p3d.GraphicsOutput.RTM_bind_or_copy,
p3d.GraphicsOutput.RTP_color)
rtt_cam = base.make_camera(rtt_buffer)
rtt_cam.reparent_to(self.fafnir_np)
vdata = p3d.GeomVertexData('empty', p3d.GeomVertexFormat.get_empty(),
p3d.GeomEnums.UH_static)
resolve_shader = p3d.Shader.load(
p3d.Shader.SL_GLSL,
vertex='shaders/resolve_intersections.vs',
fragment='shaders/resolve_intersections.fs')
self.int_texture = intersection_texture
self.draw_manager.set_inputs(self.int_texture,
self.material_cache.count_texture)
self.temp_nps = []
def cb_update_draw_calls(cbdata):
for np in self.temp_nps:
np.remove_node()
self.temp_nps = []
tex = self.draw_manager._indirect_buffer
gsg = self.win.get_gsg()
if self.graphics_engine.extract_texture_data(tex, gsg):
tex_view = memoryview(tex.get_ram_image()).cast('i')
for call_idx in range(tex.get_x_size()):
i = call_idx * 4
primcount = tex_view[i + 1]
first = tex_view[i + 2]
prims = p3d.GeomPoints(p3d.GeomEnums.UH_dynamic)
prims.add_next_vertices(primcount)
geom = p3d.Geom(vdata)
geom.add_primitive(prims)
geom.set_bounds(p3d.OmniBoundingVolume())
node = p3d.GeomNode('Draw Call {}'.format(call_idx))
node.add_geom(geom)
path = p3d.NodePath(node)
path.set_bin('fixed', 50)
path.set_depth_test(False)
path.set_depth_write(False)
path.set_shader(resolve_shader)
path.set_shader_input('first', first)
window_size = p3d.LVector2i(win_width, win_height)
path.set_shader_input('window_size', window_size)
path.set_shader_input('vertex_cache',
self.mesh_cache.vert_texture)
path.set_shader_input('index_cache',
self.mesh_cache.index_texture)
path.set_shader_input('intersections', self.int_texture)
self.material_cache.bind(path)
path.reparent_to(self.render)
self.temp_nps.append(path)
cbdata.upcall()
cbnode = p3d.CallbackNode('UpdateDrawCalls')
cbnode.set_draw_callback(
p3d.PythonCallbackObject(cb_update_draw_calls))
cb_np = self.render.attach_new_node(cbnode)
cb_np.set_bin('fixed', 45)
# taskMgr.add(task_update_draw_calls, 'Update Draw Calls', sort=55)
def task_fafnir(task):
# node_paths = self.fafnir_np.find_all_matches('**/+GeomNode')
# self.material_list = self.fafnir_np.find_all_materials()
# self.mesh_cache.update(self.node_paths)
# self.mesh_cache.bind(self.fafnir_np)
self.material_cache.update(self.material_list, self.node_paths)
win_width = self.win.get_x_size()
win_height = self.win.get_y_size()
self.draw_manager.update(len(self.material_list), win_width,
win_height)
return task.cont
taskMgr.add(task_fafnir, 'Gather mesh data')
def read_texture():
tex = self.draw_manager._indirect_buffer
gsg = self.win.get_gsg()
if self.graphics_engine.extract_texture_data(
tex, self.win.get_gsg()):
view = memoryview(tex.get_ram_image()).cast('i')
for i in range(16):
if i % 4 == 0:
print()
print(view[i])
# success = tex.write(p3d.Filename('vertex_cache.png'))
# print('Texture write: ', success)
else:
print('texture has no RAM image')
self.accept('f1', read_texture)
def __init__(self):
ShowBase.__init__(self)
wp = core.WindowProperties()
wp.setTitle("Dorfdelf")
self.win.requestProperties(wp)
self.render.setAntialias(core.AntialiasAttrib.MAuto)
self.setBackgroundColor(0.5, 0.5, 0.5)
self.disableMouse()
self.enableParticles()
font = self.loader.loadFont('media/calibri.ttf')
font.setPixelsPerUnit(120)
font.setPageSize(512, 1024)
loading = OnscreenText(text='Loading...',
scale=0.2,
pos=(0.0, 0.0),
fg=(1, 1, 1, 1),
shadow=(0.3, 0.3, 0.3, 1.0),
align=core.TextNode.ACenter,
mayChange=True,
font=font,
parent=self.aspect2d)
self.graphicsEngine.renderFrame()
self.graphicsEngine.renderFrame()
loading.setText('Generating world')
self.graphicsEngine.renderFrame()
self.graphicsEngine.renderFrame()
self.world = world.World(128, 128, 100)
self.world.generate()
loading.setText('Creating world geometry')
self.graphicsEngine.renderFrame()
self.graphicsEngine.renderFrame()
self.world_geometry = geometry.WorldGeometry(self.world)
self.camLens.setFocalLength(1)
self.camera.setPos(0, 0, 100)
self.camera.lookAt(self.world.midpoint.x, self.world.midpoint.y, 100)
self.cam.setPos(0, 0, 0)
self.cam.setHpr(0, -45, 0)
self.cc = camera.CameraController(self.world.size,
self.mouseWatcherNode, self.camera,
self.cam)
self.gui = gui.GUI(self.pixel2d, font)
self.world_geometry.node.setPos(0, 0, 0)
self.world_geometry.node.reparentTo(self.render)
self.explore_mode = True
self.current_slice = int(self.world.midpoint.z)
self.accept_keyboard()
self.accept('mouse1', self.toggle_block)
self.accept('console-command', self.console_command)
self.designation = designation.Designation()
self.dorfs = []
self.tool = lambda w, x, y, z: None
self.toolargs = ()
self.tools = {
'bomb': tools.bomb,
'block': tools.block,
'd': self.designation.add
}
self.console = console.Console(self)
self.picker = block_picker.BlockPicker(self.world, self)
self.zmap = zmap.ZMap(self.world, self)
self.change_slice(0)
arrow = LineNodePath()
arrow.reparentTo(self.render)
arrow.drawArrow2d(Vec3(-5, -5, self.world.midpoint.z),
Vec3(15, -5, self.world.midpoint.z), 30, 3)
arrow.create()
loading.hide()
def __init__(self):
ShowBase.__init__(self)
self.render.set_shader_auto()
light = p3d.DirectionalLight('sun')
light.set_color(p3d.VBase4(1.0, 0.94, 0.84, 1.0))
light_np = self.render.attach_new_node(light)
light_np.set_hpr(p3d.VBase3(0, -45, 0))
self.render.set_light(light_np)
light = p3d.DirectionalLight('indirect')
light.set_color(p3d.VBase4(0.15, 0.15, 0.15, 1.0))
light_np = self.render.attach_new_node(light)
light_np.set_hpr(p3d.VBase3(0, 45, 0))
self.render.set_light(light_np)
if base.win:
wp = p3d.WindowProperties()
wp.set_cursor_hidden(True)
wp.set_mouse_mode(p3d.WindowProperties.MRelative)
base.win.requestProperties(wp)
self.disableMouse()
self.inputmapper = inputmapper.InputMapper('input.conf')
self.ecsmanager = ecs.ECSManager()
self.ecsmanager.add_system(CharacterSystem())
self.ecsmanager.add_system(PhysicsSystem())
self.ecsmanager.add_system(EffectSystem())
self.ecsmanager.add_system(AiSystem())
port = int(sys.argv[2]) if len(sys.argv) > 2 else 9999
host = sys.argv[3] if len(sys.argv) > 3 else 'localhost'
if len(sys.argv) == 1 or sys.argv[1] == 'stand-alone':
is_server = False
proc = subprocess.Popen([sys.argv[0], 'server', str(port), str(host)])
def kill_server():
if proc:
print('Terminating stand-alone server')
proc.terminate()
atexit.register(kill_server)
time.sleep(1)
elif sys.argv[1] == 'server':
is_server = True
# No need to run at full speed
globalClock.set_mode(p3d.ClockObject.MLimited)
globalClock.set_frame_rate(60)
elif sys.argv[1] == 'client':
is_server = False
else:
raise RuntimeError('Unrecognized mode: {}'.format(sys.argv[1]))
self.network_manager = network.NetworkManager(self.ecsmanager, network.PandaTransportLayer, is_server)
if is_server:
self.network_manager.start_server(port)
else:
self.network_manager.start_client(host, port)
self.game_mode = game_modes.ClassicGameMode()
def run_ecs(task):
self.ecsmanager.update(globalClock.get_dt())
if self.game_mode.is_game_over():
print("Game over, restarting")
messenger.send('restart-game')
return task.cont
self.taskMgr.add(run_ecs, 'ECS')
def run_net(task):
self.network_manager.update(globalClock.get_dt())
return task.cont
self.taskMgr.add(run_net, 'Network')
def run_gamemode(task):
self.game_mode.update(globalClock.get_dt())
return task.cont
self.taskMgr.add(run_gamemode, 'Game Mode')
def restart_game():
self.game_mode.end_game()
self.game_mode.start_game()
restart_game()
self.accept('restart-game', restart_game)
self.accept('quit-up', sys.exit)
self.accept('aspectRatioChanged', self.cb_resize)
