コード例 #1
0
def optimize_bam(path):
    path = core.Filename.from_os_specific(path)
    loader = core.Loader.get_global_ptr()
    node = loader.load_sync(path)
    model = core.NodePath(node)

    print("Before:")
    analyze_node(node)

    any_changed = False

    for child in model.find_all_matches('**/+GeomNode'):
        gnode = child.node()
        for i in range(gnode.get_num_geoms()):
            if optimize_geom(gnode, i):
                any_changed = True

    for tex in model.find_all_textures():
        if tex.name and not tex.filename:
            rel_path = 'layers/' + tex.name + '.png'
            dir = core.Filename(path.get_dirname())
            fn = core.Filename(dir, rel_path)
            if tex.write(fn):
                print(f"{tex.name}: wrote to {fn}")
                tex.filename = 'assets/' + dir.get_basename() + '/' + rel_path
                tex.fullpath = fn
            any_changed = True

    if any_changed:
        model.write_bam_file(path)

        print("After:")
        analyze_node(node)
    else:
        print("File is already optimized, no changes needed.")
コード例 #2
0
ファイル: AssetBrowser.py プロジェクト: tsp-team/panda3d
    def __init__(self, filename, parent = None):
        self.filename = filename
        self.absFilename = core.Filename(self.filename)
        self.absFilename.makeAbsolute()
        self.parent = parent
        self.assetFiles = []
        self.children = []
        self.item = None

        if parent:
            self.parentRelativeFilename = core.Filename(self.absFilename)
            self.parentRelativeFilename.makeRelativeTo(parent.absFilename)
        else:
            self.parentRelativeFilename = None
コード例 #3
0
def init(_base):
    assetdir_rel = p3d.Filename('assets')
    config = None

    if not pman.is_frozen():
        config = pman.get_config()
        if config['run']['auto_build']:
            pman.build(config)
        assetdir_rel = p3d.Filename.from_os_specific(
            config['build']['export_dir'])

    # Add assets directory to model path
    assetdir = p3d.Filename(p3d.Filename.expand_from('$MAIN_DIR'),
                            assetdir_rel)
    p3d.get_model_path().prepend_directory(assetdir)
コード例 #4
0
    def __resolve_vfs_relative_path(self,
                                    file_path,
                                    okMissing=False,
                                    file_type=''):
        """
        Resolves a file path to a VFS relative Filename object
        for use in resource loading
        """

        if not isinstance(file_path, core.Filename):
            file_name = core.Filename(file_path)
        else:
            file_name = file_path

        vfs = core.VirtualFileSystem.get_global_ptr()
        search_path = core.get_model_path().get_value()

        # Verify the file exists
        found = vfs.resolve_filename(file_name, search_path)
        if not found:
            # Notify the user
            message = 'Failed to load %s file: %s' % (file_type,
                                                      file_name.c_str())
            sprite_notify.warning('Search Path: %s' %
                                  str(search_path.get_directories()))

            if not okMissing:
                sprite_notify.error(message)
            else:
                sprite_notify.warning(message)

            return None

        return file_name
コード例 #5
0
        def create_runtime(appname, mainscript, use_console):
            freezer = FreezeTool.Freezer(platform=platform, path=path)
            freezer.addModule('__main__', filename=mainscript)
            for incmod in self.include_modules.get(appname, []) + self.include_modules.get('*', []):
                freezer.addModule(incmod)
            for exmod in self.exclude_modules.get(appname, []) + self.exclude_modules.get('*', []):
                freezer.excludeModule(exmod)
            freezer.done(addStartupModules=True)

            stub_name = 'deploy-stub'
            if platform.startswith('win'):
                if not use_console:
                    stub_name = 'deploy-stubw'
                stub_name += '.exe'

            if use_wheels:
                stub_file = p3dwhl.open('panda3d_tools/{0}'.format(stub_name))
            else:
                dtool_path = p3d.Filename(p3d.ExecutionEnvironment.get_dtool_name()).to_os_specific()
                stub_path = os.path.join(os.path.dirname(dtool_path), '..', 'bin', stub_name)
                stub_file = open(stub_path, 'rb')

            freezer.generateRuntimeFromStub(os.path.join(builddir, appname), stub_file)
            stub_file.close()

            freezer_extras.update(freezer.extras)
            freezer_modules.update(freezer.getAllModuleNames())
コード例 #6
0
ファイル: app.py プロジェクト: rdb/hexima
 def _get_save_path(self):
     if not __file__.endswith('.py'):
         save_file = core.Filename(core.Filename.get_user_appdata_directory(), 'hexima/save.json')
         save_file.make_dir()
         return save_file.to_os_specific()
     else:
         return os.path.join(self.mainDir, 'save.json')
コード例 #7
0
 def new_load_model(self, model_path, **kwargs):
     fname = p3d.Filename(model_path)
     if fname.get_extension() in 'gltf, glb':
         return load_model(self,
                           model_path,
                           gltf_settings=gltf_settings,
                           **kwargs)
     else:
         return _load_model(model_path, **kwargs)
コード例 #8
0
    def __init__(self, filename, parent=None):
        self.filename = filename
        self.absFilename = core.Filename(self.filename)
        self.absFilename.makeAbsolute()
        self.parent = parent
        self.assetFiles = []
        self.children = []
        self.item = None

        # Custom name for the folder.  Used for the top-level folder of a tree,
        # like $DMODELS.
        self.alias = None

        if parent:
            self.parentRelativeFilename = core.Filename(self.absFilename)
            self.parentRelativeFilename.makeRelativeTo(parent.absFilename)
        else:
            self.parentRelativeFilename = None
コード例 #9
0
    def export(self, scene_root, filepath):
        '''Export the given scene root to the given filepath'''
        filepath = p3d.Filename().from_os_specific(filepath)
        ext = filepath.get_extension()

        if ext == 'bam':
            scene_root.write_bam_file(filepath)
        else:
            raise Exception(f'Unsupported export format: {ext}')
コード例 #10
0
ファイル: assetlibrary.py プロジェクト: Moguri/gestalt-editor
    def import_file(self, filepath):
        '''Import the given filepath as a library'''
        filepath = p3d.Filename().from_os_specific(filepath)
        lib = self._loader.load_sync(filepath, self._loader_opts)

        if not lib:
            raise Exception(f'Failed to load {filepath}')

        self.libraries.append(lib)
コード例 #11
0
    def init_music(self, entity):
        music = entity[Music]
        music._songs = {}
        music._prev_songs = set()

        for song in music.songs:
            music._songs[song] = loader.load_music(
                core.Filename('music', song + '.ogg'))
            music._songs[song].set_loop(True)
            music._songs[song].set_volume(0)
コード例 #12
0
def parse_path(path):
    path = str(path)
    path_parts = path.split('/')

    path_parts = [
        _PATH_VARS.get(i, i)
        for i in path_parts
    ]

    return p3d.Filename('/'.join(path_parts))
コード例 #13
0
ファイル: part.py プロジェクト: janEntikan/Badge-Blaster-2112
def get_bounds(need_reload, key, np):
    h = sha384(f'{key}-road-{np.name}'.encode()).hexdigest()
    fname = core.Filename(base.main_dir, f'assets/cache/{h}')
    if need_reload:
        bounds = pp.get_model_bounds(np)
        with open(fname.to_os_specific(), 'wb') as f:
            pickle.dump(bounds, f)
    else:
        with open(fname.to_os_specific(), 'rb') as f:
            bounds = pickle.load(f)
    return bounds
コード例 #14
0
ファイル: part.py プロジェクト: janEntikan/Badge-Blaster-2112
def chk_timestamp(key, base_type):
    h = sha384(f'{key}-{base_type}'.encode()).hexdigest()
    lvl_fname = core.Filename(base.main_dir, f'assets/cache/{h}')
    bam_fname = core.Filename(base.main_dir, f'assets/models/{key}.bam')
    timestamp = 0
    need_reload = True
    if lvl_fname.exists():
        with open(lvl_fname.to_os_specific(), 'r') as f:
            try:
                timestamp = int(f.read())
            except ValueError:
                pass
    else:
        lvl_fname.make_dir()
        need_reload = True
    bts = bam_fname.get_timestamp()
    if bts == timestamp:
        need_reload = False
    with open(lvl_fname.to_os_specific(), 'w') as f:
        f.write(str(bts))
    return need_reload, lvl_fname
コード例 #15
0
 def new_load_model(self, model_path, **kwargs):
     if not isinstance(model_path, (tuple, list, set)):
         model_path = [model_path]
     for model in model_path:
         fname = p3d.Filename(model)
         if fname.get_extension() in ('gltf', 'glb'):
             return load_model(self,
                               model,
                               gltf_settings=gltf_settings,
                               **kwargs)
         else:
             return _load_model(model_path, **kwargs)
コード例 #16
0
ファイル: AssetBrowser.py プロジェクト: tsp-team/panda3d
    def createNextAsset(self):
        if self.isPaused:
            return

        if len(self.files) > 0:
            filename = core.Filename(self.files.pop(0))
            self.createAssetItem(filename)
        else:
            if not self.dlg.PreloadItems:
                self.addQueuedItems()
            self.done = True
            if self.callback:
                self.callback()
            self.cleanup()
コード例 #17
0
    def init_sfx(self, entity):
        player = entity[SfxPlayer]
        player._sfx = {}

        if TerrainObject in entity:
            root = entity[TerrainObject]._root
        else:
            root = None

        for sound in player.sounds:
            path = core.Filename('sfx', sound + '.ogg')
            sfx = self.audio3d.audio_manager.get_sound(
                path, positional=(root is not None))
            if player.loop:
                sfx.set_loop(True)
            player._sfx[sound] = sfx
            player._root = root
コード例 #18
0
    def setup(self, showbase):
        self.viewport_widgets.reparent_to(showbase.render)
        self.scene_root.reparent_to(showbase.render)

        # Add a better starting camera position
        self.camera = showbase.cam
        self.camera.set_pos(10, -10, 10)
        self.camera.look_at(0, 0, 0)

        # Try to load a model
        modelpath = None
        if len(sys.argv) > 1:
            modelpath = sys.argv[1]
            self.assetlib.import_file(modelpath)
            model_root = self.assetlib.libraries[0]
            self.scene_root.attach_new_node(model_root)

        if modelpath is not None:
            exportpath = p3d.Filename().from_os_specific(modelpath)
            exportpath = exportpath.get_fullpath_wo_extension() + '.bam'
            self.accept('x', self.save_scene_to_bam, [exportpath])
コード例 #19
0
ファイル: AssetBrowser.py プロジェクト: tsp-team/panda3d
    def createAssets(self):
        # First, create all of the items up front with temporary icons.
        # This is so all of the assets are available for selecting even before
        # we create the thumbnails.
        if self.dlg.PreloadItems:
            text = self.dlg.ui.leFileFilter.text().lower()

            tempThumb = QtGui.QIcon(getNotFoundImage())
            for filename in self.files:
                fn = core.Filename(filename)
                itemText = fn.getBasename()
                item = QtWidgets.QListWidgetItem(tempThumb, itemText)
                item.setSizeHint(QtCore.QSize(128, 128))
                item.setToolTip(itemText)
                item.filename = fn
                self.listView.addItem(item)
                if self.canFilter and len(text) > 0 and text not in item.text().lower():
                    self.listView.setRowHidden(self.listView.row(item), True)
                self.items[fn] = item

        # Now load actual thumbnails
        self.createNextAsset()
コード例 #20
0
    def __init__(self):
        main_dir = core.ExecutionEnvironment.get_environment_variable(
            "MAIN_DIR")
        main_dir = core.Filename.from_os_specific(main_dir)
        core.load_prc_file(core.Filename(main_dir, "settings.prc"))

        ShowBase.__init__(self)
        self.disable_mouse()

        # Workaround for failure to load simplepbr shaders on macOS
        if getattr(sys, 'frozen', False) and sys.platform == 'darwin':
            simplepbr.__file__ = self.main_dir + '/'

        self.assume_gamepad = False

        DGG.setDefaultRolloverSound(loader.load_sfx('sfx/ui-a.ogg'))
        DGG.setDefaultClickSound(loader.load_sfx('sfx/ui-b.ogg'))

        base.setBackgroundColor((0, 0, 0, 1))

        self.quality_menu = Menu('quality.', [
            ('high.', self.setup_high),
            ('medium.', self.setup_medium),
            ('low.', self.setup_low),
            ('none.', self.setup_potato),
        ])
        self.quality_menu.show()

        self.gamepads = set()

        for dev in self.devices.get_devices(
                core.InputDevice.DeviceClass.gamepad):
            self._device_connected(dev)
        self.assume_gamepad = False

        self.accept('connect-device', self._device_connected)
        self.accept('disconnect-device', self._device_disconnected)
コード例 #21
0
    def setup_terrain(self):
        self.heightfield = self.noise.terrain()
        f = sdf.circle((30, 30), 15)
        avg = np.max(self.heightfield[713:743, 713:743])
        self.heightfield[713:743, 713:743][f] = avg

        # self.heightfield[self.__bounds] -= 0.1
        # self.heightfield = np.clip(self.heightfield, 0, 1)
        hf = (self.heightfield * 255).astype(np.uint8)
        f = core.TemporaryFile(core.Filename('assets', 'terrain.png'))
        im = Image.fromarray(hf)
        im.save(f.get_filename().get_fullpath())
        self.terrain = core.GeoMipTerrain('terrain')
        self.terrain.set_heightfield(f.get_filename())
        self.terrain.set_block_size(32)
        self.terrain.set_near(2)
        self.terrain.set_far(100)
        self.terrain.set_focal_point(self.camera)
        self.terrain_root = self.terrain.get_root()
        self.terrain_root.reparent_to(self.render)
        self.terrain_root.set_scale(common.T_XY_SCALE, common.T_XY_SCALE,
                                    common.T_Z_SCALE)
        offset = common.T_XY * common.T_XY_SCALE / 2
        self.terrain_offset = core.Vec3(-offset, -offset, 0)
        self.terrain_root.set_pos(self.terrain_offset)
        tex = self.loader.load_texture('grass.jpg')
        tex.set_minfilter(core.SamplerState.FT_linear_mipmap_linear)
        tex.set_anisotropic_degree(2)
        self.terrain_root.set_texture(tex, 1)
        self.terrain_root.set_tex_scale(core.TextureStage.get_default(), 50)
        self.terrain.generate()

        # Stones where the tower is...
        rot = self.render.attach_new_node('rot')
        d = rot.attach_new_node('d')
        for i in range(40):
            d.set_y(random.uniform(common.T_ST_Y_MIN, common.T_ST_Y_MAX))
            rot.set_h(360 / 40 * (i + random.random() - 0.5))
            node_path = modelgen.stone(
                core.Vec2(
                    random.uniform(common.T_ST_MIN_SIZE, common.T_ST_MAX_SIZE),
                    random.uniform(common.T_ST_MIN_SIZE,
                                   common.T_ST_MAX_SIZE)))
            node_path.reparent_to(self.render)
            node_path.set_pos(d.get_pos(self.render))
            node_path.set_hpr(random.uniform(0, 360), random.uniform(0, 360),
                              random.uniform(0, 360))
            node_path.set_z(
                self.sample_terrain_z(*tuple(node_path.get_pos().xy)) - 1)

        # Obelisks
        mat = core.Material('mat')
        mat.set_emission(core.Vec4(0.2, 0.4, 0.1, 1))
        for i, (x, y) in enumerate(self.ob_coords):
            stone_circle = modelgen.stone_circle(20, 30)
            node_path = modelgen.obelisk()
            node_path.reparent_to(stone_circle)
            stone_circle.reparent_to(self.render)
            node_path.set_material(mat)
            hs = common.T_XY * common.T_XY_SCALE / 2
            wx = x * common.T_XY_SCALE - hs
            stone_circle.set_x(wx)
            wy = y * common.T_XY_SCALE - hs
            stone_circle.set_y(wy)
            stone_circle.set_z(self.sample_terrain_z(wx, wy))
            self.collision.add(
                collision.CollisionCircle(
                    core.Vec2(wx, wy),
                    2,
                ))
            self.collision.add(
                collision.CollisionCircle(core.Vec2(wx, wy),
                                          30,
                                          (self.__obelisk_found_event, (i, )),
                                          ghost=True))
            self.collision.add(
                collision.CollisionCircle(core.Vec2(wx, wy),
                                          12, (self.__toggle_nonogram, (i, )),
                                          ghost=True))
        self.task_mgr.add(self.__update_terrain, 'update_task')
コード例 #22
0
ファイル: file.py プロジェクト: OyunMotorlari/panda3d
def open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True):
    if sys.version_info >= (3, 0):
        # Python 3 is much stricter than Python 2, which lets
        # unknown flags fall through.
        for ch in mode:
            if ch not in 'rwxabt+U':
                raise ValueError("invalid mode: '%s'" % (mode))

    creating = 'x' in mode
    writing = 'w' in mode
    appending = 'a' in mode
    updating = '+' in mode
    binary = 'b' in mode
    universal = 'U' in mode
    reading = universal or 'r' in mode

    if binary and 't' in mode:
        raise ValueError("can't have text and binary mode at once")

    if creating + reading + writing + appending > 1:
        raise ValueError("must have exactly one of create/read/write/append mode")

    if binary:
        if encoding:
            raise ValueError("binary mode doesn't take an encoding argument")
        if errors:
            raise ValueError("binary mode doesn't take an errors argument")
        if newline:
            raise ValueError("binary mode doesn't take a newline argument")

    if isinstance(file, core.Istream) or isinstance(file, core.Ostream):
        # If we were given a stream instead of a filename, assign
        # it directly.
        raw = StreamIOWrapper(file)
        raw.mode = mode

    else:
        vfile = None

        if isinstance(file, core.VirtualFile):
            # We can also "open" a VirtualFile object for reading.
            vfile = file
            filename = vfile.getFilename()
        elif isinstance(file, unicodeType):
            # If a raw string is given, assume it's an os-specific
            # filename.
            filename = core.Filename.fromOsSpecificW(file)
        elif isinstance(file, strType):
            filename = core.Filename.fromOsSpecific(file)
        else:
            # It's either a Filename object or an os.PathLike.
            # If a Filename is given, make a writable copy anyway.
            filename = core.Filename(file)

        if binary or sys.version_info >= (3, 0):
            filename.setBinary()
        else:
            filename.setText()

        if not vfile:
            vfile = _vfs.getFile(filename)

        if not vfile:
            if reading:
                raise FileNotFoundError("No such file or directory: '%s'" % (filename))

            vfile = _vfs.createFile(filename)
            if not vfile:
                raise IOError("Failed to create file: '%s'" % (filename))

        elif creating:
            # In 'creating' mode, we have to raise FileExistsError
            # if the file already exists.  Otherwise, it's the same
            # as 'writing' mode.
            raise FileExistsError("File exists: '%s'" % (filename))

        elif vfile.isDirectory():
            raise IsADirectoryError("Is a directory: '%s'" % (filename))

        # Actually open the streams.
        if reading:
            if updating:
                stream = vfile.openReadWriteFile(False)
            else:
                stream = vfile.openReadFile(False)

            if not stream:
                raise IOError("Could not open %s for reading" % (filename))

        elif writing or creating:
            if updating:
                stream = vfile.openReadWriteFile(True)
            else:
                stream = vfile.openWriteFile(False, True)

            if not stream:
                raise IOError("Could not open %s for writing" % (filename))

        elif appending:
            if updating:
                stream = vfile.openReadAppendFile()
            else:
                stream = vfile.openAppendFile()

            if not stream:
                raise IOError("Could not open %s for appending" % (filename))

        else:
            raise ValueError("Must have exactly one of create/read/write/append mode and at most one plus")

        raw = StreamIOWrapper(stream, needsVfsClose=True)
        raw.mode = mode
        raw.name = vfile.getFilename().toOsSpecific()

    # If a binary stream was requested, return the stream we've created.
    if binary:
        return raw

    # If we're in Python 2, we don't decode unicode strings by default.
    if not encoding and sys.version_info < (3, 0):
        return raw

    line_buffering = False
    if buffering == 1:
        line_buffering = True
    elif buffering == 0:
        raise ValueError("can't have unbuffered text I/O")

    # Otherwise, create a TextIOWrapper object to wrap it.
    wrapper = io.TextIOWrapper(raw, encoding, errors, newline, line_buffering)
    wrapper.mode = mode
    return wrapper
コード例 #23
0
 def load_file(self, filepath):
     filepath = p3d.Filename(filepath)
     filepath.make_absolute()
     filepath = filepath.to_os_specific()
     url = f'file://{filepath}'
     self.load_url(url)
コード例 #24
0
ファイル: AssetBrowser.py プロジェクト: tsp-team/panda3d
 def generateAssetTree(self):
     self.rootFilename = core.Filename("resources")
     self.rootFilenameAbs = core.Filename(self.rootFilename)
     self.rootFilenameAbs.makeAbsolute()
     self.rootFolder = self.r_generateAssets(self.rootFilename, None)[0]
コード例 #25
0
ファイル: installers.py プロジェクト: zj2089/panda3d
def create_nsis(command, basename, build_dir):
    platform = command.get_current_platform()
    if not platform.startswith('win'):
        command.announce(
            '\tNSIS installer not supported for platform: {}'.format(platform),
            distutils.log.ERROR)
        return
    try:
        subprocess.call(['makensis', '--version'])
    except OSError:
        command.announce(
            '\tCould not find makensis tool that is required to build NSIS installers',
            distutils.log.ERROR)
        return

    is_64bit = platform == 'win_amd64'
    # Get a list of build applications
    build_cmd = command.get_finalized_command('build_apps')
    apps = build_cmd.gui_apps.copy()
    apps.update(build_cmd.console_apps)
    apps = ['{}.exe'.format(i) for i in apps]

    shortname = command.distribution.get_name()

    # Create the .nsi installer script
    nsifile = p3d.Filename(build_cmd.build_base, shortname + ".nsi")
    nsifile.unlink()
    nsi = open(nsifile.to_os_specific(), "w")

    # Some global info
    nsi.write('Name "%s"\n' % shortname)
    nsi.write('OutFile "%s"\n' %
              os.path.join(command.dist_dir, basename + '.exe'))
    if is_64bit:
        nsi.write('InstallDir "$PROGRAMFILES64\\%s"\n' % shortname)
    else:
        nsi.write('InstallDir "$PROGRAMFILES\\%s"\n' % shortname)
    nsi.write('SetCompress auto\n')
    nsi.write('SetCompressor lzma\n')
    nsi.write('ShowInstDetails nevershow\n')
    nsi.write('ShowUninstDetails nevershow\n')
    nsi.write('InstType "Typical"\n')

    # Tell Vista that we require admin rights
    nsi.write('RequestExecutionLevel admin\n')
    nsi.write('\n')

    # TODO offer run and desktop shortcut after we figure out how to deal
    # with multiple apps

    nsi.write('!include "MUI2.nsh"\n')
    nsi.write('!define MUI_ABORTWARNING\n')
    nsi.write('\n')
    nsi.write('Var StartMenuFolder\n')
    nsi.write('!insertmacro MUI_PAGE_WELCOME\n')
    # TODO license file
    nsi.write('!insertmacro MUI_PAGE_DIRECTORY\n')
    nsi.write('!insertmacro MUI_PAGE_STARTMENU Application $StartMenuFolder\n')
    nsi.write('!insertmacro MUI_PAGE_INSTFILES\n')
    nsi.write('!insertmacro MUI_PAGE_FINISH\n')
    nsi.write('!insertmacro MUI_UNPAGE_WELCOME\n')
    nsi.write('!insertmacro MUI_UNPAGE_CONFIRM\n')
    nsi.write('!insertmacro MUI_UNPAGE_INSTFILES\n')
    nsi.write('!insertmacro MUI_UNPAGE_FINISH\n')
    nsi.write('!insertmacro MUI_LANGUAGE "English"\n')

    # This section defines the installer.
    nsi.write('Section "" SecCore\n')
    nsi.write('  SetOutPath "$INSTDIR"\n')
    curdir = ""
    nsi_dir = p3d.Filename.fromOsSpecific(build_cmd.build_base)
    build_root_dir = p3d.Filename.fromOsSpecific(build_dir)
    for root, dirs, files in os.walk(build_dir):
        dirs.sort()
        for name in files:
            basefile = p3d.Filename.fromOsSpecific(os.path.join(root, name))
            file = p3d.Filename(basefile)
            file.makeAbsolute()
            file.makeRelativeTo(nsi_dir)
            outdir = p3d.Filename(basefile)
            outdir.makeAbsolute()
            outdir.makeRelativeTo(build_root_dir)
            outdir = outdir.getDirname().replace('/', '\\')
            if curdir != outdir:
                nsi.write('  SetOutPath "$INSTDIR\\%s"\n' % outdir)
                curdir = outdir
            nsi.write('  File "%s"\n' % (file.toOsSpecific()))
    nsi.write('  SetOutPath "$INSTDIR"\n')
    nsi.write('  WriteUninstaller "$INSTDIR\\Uninstall.exe"\n')
    nsi.write('  ; Start menu items\n')
    nsi.write('  !insertmacro MUI_STARTMENU_WRITE_BEGIN Application\n')
    nsi.write('    CreateDirectory "$SMPROGRAMS\\$StartMenuFolder"\n')
    for app in apps:
        nsi.write(
            '    CreateShortCut "$SMPROGRAMS\\$StartMenuFolder\\%s.lnk" "$INSTDIR\\%s"\n'
            % (shortname, app))
    nsi.write(
        '    CreateShortCut "$SMPROGRAMS\\$StartMenuFolder\\Uninstall.lnk" "$INSTDIR\\Uninstall.exe"\n'
    )
    nsi.write('  !insertmacro MUI_STARTMENU_WRITE_END\n')
    nsi.write('SectionEnd\n')

    # This section defines the uninstaller.
    nsi.write('Section Uninstall\n')
    nsi.write('  RMDir /r "$INSTDIR"\n')
    nsi.write('  ; Desktop icon\n')
    nsi.write('  Delete "$DESKTOP\\%s.lnk"\n' % shortname)
    nsi.write('  ; Start menu items\n')
    nsi.write(
        '  !insertmacro MUI_STARTMENU_GETFOLDER Application $StartMenuFolder\n'
    )
    nsi.write('  RMDir /r "$SMPROGRAMS\\$StartMenuFolder"\n')
    nsi.write('SectionEnd\n')
    nsi.close()

    cmd = ['makensis']
    for flag in ["V2"]:
        cmd.append('{}{}'.format(
            '/' if sys.platform.startswith('win') else '-', flag))
    cmd.append(nsifile.to_os_specific())
    subprocess.check_call(cmd)
コード例 #26
0
def test_cg_from_file(gsg):
    """Test compiling Cg shaders from files"""
    shader_path = core.Filename(SHADERS_DIR, 'cg_simple.sha')
    run_cg_compile_check(gsg, shader_path)
コード例 #27
0
def test_load_sdr_lut():
    filepath = p3d.Filename(os.path.dirname(__file__), 'lut.png')
    simplepbr.load_sdr_lut(filepath)
コード例 #28
0
import appdirs
import panda3d.core as p3d


_APPNAME = 'mercury'
_APPAUTHOR = False
_APPDIRS = appdirs.AppDirs(appname=_APPNAME, appauthor=_APPAUTHOR, roaming=True)


APP_ROOT_DIR = p3d.Filename.expand_from('$MAIN_DIR')
CONFIG_DIR = p3d.Filename(APP_ROOT_DIR, 'config')
USER_CONFIG_DIR = p3d.Filename.from_os_specific(_APPDIRS.user_config_dir)


_PATH_VARS = {
    '$USER_APPDATA': _APPDIRS.user_data_dir,
    '$MAIN_DIR': str(APP_ROOT_DIR),
}


def parse_path(path):
    path = str(path)
    path_parts = path.split('/')

    path_parts = [
        _PATH_VARS.get(i, i)
        for i in path_parts
    ]

    return p3d.Filename('/'.join(path_parts))
コード例 #29
0
def write(filename: str, egg_data: egg.EggData) -> None:
    """write egg data to a file"""

    egg_data.writeEgg(core.Filename(filename))
コード例 #30
0
def test_cg_compile_error(gsg):
    """Test getting compile errors from bad Cg shaders"""
    shader_path = core.Filename(SHADERS_DIR, 'cg_bad.sha')
    run_cg_compile_check(gsg, shader_path, expect_fail=True)