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)