def get_buffer(render_node, buff_size=None, clear_color=core.Vec4(0, 0, 0, 1)): buff_size = buff_size or core.ConfigVariableInt('portal-buffer-size', 1024).get_value() if _free_buffers: bobj = _free_buffers.pop() bobj.pipeline.render_node = render_node bobj.cam.reparent_to(render_node) return bobj basic = core.Filename.expand_from('$MAIN_DIR/assets/textures/basic_1.exr') basic = loader.load_texture(basic) buff = base.win.make_texture_buffer('Room Buffer', buff_size, buff_size) buff.set_clear_color(clear_color) buff.set_clear_color_active(True) buff.set_sort(-100) fog = core.Fog("Fog Name") fog.set_color(0, 0, 0) fog.set_exp_density(0.04) render_node.set_fog(fog) tex = buff.get_texture() cam = base.make_camera(buff) cam.reparent_to(render_node) pipeline = simplematcap.init(basic, render_node=render_node, light_dir=core.Vec3(-1, -1, 0.5).normalized(), hueshift=core.Vec3(random.uniform(-1.0, 1.0), random.uniform(-1.0, 1.0), 20)) return BufferObject(buff, tex, cam, pipeline)
def __init__(self, name, bases, dct): if self.name is None: host = p3d.ConfigVariableString('pstats-host', 'localhost').value port = p3d.ConfigVariableInt('pstats-port', 5185).value if not self.client.connect(host, port): if p3d.ConfigVariableBool('pstats-required', False).value: raise ConnectionError(f'failed to connect: {host}:{port}') else: self._trunk.setdefault(self.name, _PStatBranch(self))
def test_load_unload_page(): var = core.ConfigVariableInt("test-var", 1) assert var.value == 1 page = core.load_prc_file_data("test_load_unload_page", "test-var 2") assert page assert var.value == 2 assert core.unload_prc_file(page) assert var.value == 1
def __init__(self, queue_name, **kwargs): super().__init__() self.__queue_name = queue_name self.__poll_interval = kwargs.get( 'interval', core.ConfigVariableInt('sqs-default-poll', 30).value) self.__message_attribute_names = kwargs.get('message_attribute_names', []) self.__attribute_names = kwargs.get('attribute_names', []) self.__endpoint_url = kwargs.get('endpoint_url', None) self.__wait_time = kwargs.get( 'wait_time', core.ConfigVariableInt('sqs-default-wait-time', 0).value) self.__ssl = kwargs.get('ssl', True) self.__max_number_of_messages = kwargs.get( 'max_number_of_messages', core.ConfigVariableInt('sqs-default-max-msg', 1).value) self.__poll_task = None self.__session = boto3.session.Session() self.__region_name = kwargs.get('region_name', self.__session.region_name) self.__resource = None self.__queue = None
def _set_use_330(self, use_330): if use_330 is not None: self.use_330 = use_330 else: self.use_330 = False cvar = p3d.ConfigVariableInt('gl-version') gl_version = [ cvar.get_word(i) for i in range(cvar.get_num_words()) ] if len(gl_version ) >= 2 and gl_version[0] >= 3 and gl_version[1] >= 2: # Not exactly accurate, but setting this variable to '3 2' is common for disabling # the fixed-function pipeline and 3.2 support likely means 3.3 support as well. self.use_330 = True
def __buildInstallPlans(self): """ Sets up self.installPlans, a list of one or more "plans" to download and install the package. """ pc = PStatCollector(':App:PackageInstaller:buildInstallPlans') pc.start() self.hasPackage = False if self.host.appRunner and self.host.appRunner.verifyContents == self.host.appRunner.P3DVCNever: # We're not allowed to download anything. self.installPlans = [] pc.stop() return if self.asMirror: # If we're just downloading a mirror archive, we only need # to get the compressed archive file. # Build a one-item install plan to download the compressed # archive. downloadSize = self.compressedArchive.size func = lambda step, fileSpec=self.compressedArchive: self.__downloadFile( step, fileSpec, allowPartial=True) step = self.InstallStep(func, downloadSize, self.downloadFactor, 'download') installPlan = [step] self.installPlans = [installPlan] pc.stop() return # The normal download process. Determine what we will need to # download, and build a plan (or two) to download it all. self.installPlans = None # We know we will at least need to unpack the archive contents # at the end. unpackSize = 0 for file in self.extracts: unpackSize += file.size step = self.InstallStep(self.__unpackArchive, unpackSize, self.unpackFactor, 'unpack') planA = [step] # If the uncompressed archive file is good, that's all we'll # need to do. self.uncompressedArchive.actualFile = None if self.uncompressedArchive.quickVerify(self.getPackageDir(), notify=self.notify): self.installPlans = [planA] pc.stop() return # Maybe the compressed archive file is good. if self.compressedArchive.quickVerify(self.getPackageDir(), notify=self.notify): uncompressSize = self.uncompressedArchive.size step = self.InstallStep(self.__uncompressArchive, uncompressSize, self.uncompressFactor, 'uncompress') planA = [step] + planA self.installPlans = [planA] pc.stop() return # Maybe we can download one or more patches. We'll come back # to that in a minute as plan A. For now, construct plan B, # which will be to download the whole archive. planB = planA[:] uncompressSize = self.uncompressedArchive.size step = self.InstallStep(self.__uncompressArchive, uncompressSize, self.uncompressFactor, 'uncompress') planB = [step] + planB downloadSize = self.compressedArchive.size func = lambda step, fileSpec=self.compressedArchive: self.__downloadFile( step, fileSpec, allowPartial=True) step = self.InstallStep(func, downloadSize, self.downloadFactor, 'download') planB = [step] + planB # Now look for patches. Start with the md5 hash from the # uncompressedArchive file we have on disk, and see if we can # find a patch chain from this file to our target. pathname = Filename(self.getPackageDir(), self.uncompressedArchive.filename) fileSpec = self.uncompressedArchive.actualFile if fileSpec is None and pathname.exists(): fileSpec = FileSpec() fileSpec.fromFile(self.getPackageDir(), self.uncompressedArchive.filename) plan = None if fileSpec: plan = self.__findPatchChain(fileSpec) if plan: # We can download patches. Great! That means this is # plan A, and the full download is plan B (in case # something goes wrong with the patching). planA = plan + planA self.installPlans = [planA, planB] else: # There are no patches to download, oh well. Stick with # plan B as the only plan. self.installPlans = [planB] # In case of unexpected failures on the internet, we will retry # the full download instead of just giving up. retries = core.ConfigVariableInt('package-full-dl-retries', 1).getValue() for retry in range(retries): self.installPlans.append(planB[:]) pc.stop()
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())