com.badlogic.gdx.assets.loaders.FileHandleResolver Java Examples

@Override
public FileHandleResolver newResolver (FileType fileType) {
	switch (fileType) {
	case Absolute:
		return new AbsoluteFileHandleResolver();
	case Classpath:
		return new ClasspathFileHandleResolver();
	case External:
		return new ExternalFileHandleResolver();
	case Internal:
		return new InternalFileHandleResolver();
	case Local:
		return new LocalFileHandleResolver();
	}
	return null; // Should never happen
}
 

public static Cubemap createCubemap(FileHandleResolver resolver, String baseName, String midName, String extension, int lods, String [] faceNames) {
	FileHandle [] files = new FileHandle[6 * lods];
	for(int level = 0 ; level<lods ; level++){
		for(int face = 0 ; face < 6 ; face++){
			files[level*6+face] = resolver.resolve(baseName + faceNames[face] + midName + level + extension);
		}
	}
	FacedMultiCubemapData data = new FacedMultiCubemapData(files, lods);
	Cubemap cubemap = new Cubemap(data);
	cubemap.setFilter(TextureFilter.MipMap, TextureFilter.Linear);
	return cubemap;
}
 

@Override
public FileHandleResolver newResolver (final FileType fileType) {
	return new FileHandleResolver() {

		@Override
		public FileHandle resolve (String fileName) {
			return new DesktopFileHandle(fileName, fileType);
		}
	};
}
 

@SuppressWarnings("rawtypes")
	private BehaviorTreeLibrary (FileHandleResolver resolver, AssetManager assetManager, int parseDebugLevel) {
		this.resolver = resolver;
//		this.assetManager = assetManager;
		this.repository = new ObjectMap<String, BehaviorTree<?>>();
		this.parser = new BehaviorTreeParser(parseDebugLevel);
	}
 

private Resolution[] getResolutions(FileHandleResolver resolver, int worldWidth, int worldHeight) {
	ArrayList<Resolution> rl = new ArrayList<>();

	String list[] = null;

	String configRes = Config.getInstance().getProperty(Config.RESOLUTIONS, null);

	if (configRes != null) {
		list = configRes.split(",");
	} else {
		list = listAssetFiles("ui");
	}

	for (String name : list) {

		try {
			float scale = Float.parseFloat(name);

			EngineLogger.debug("RES FOUND: " + scale);

			Resolution r = new Resolution((int) (worldWidth * scale), (int) (worldHeight * scale), name);

			rl.add(r);
		} catch (NumberFormatException e) {

		}
	}

	Collections.sort(rl, new Comparator<Resolution>() {
		@Override
		public int compare(Resolution a, Resolution b) {
			return a.portraitWidth - b.portraitWidth;
		}
	});

	return rl.toArray(new Resolution[rl.size()]);
}
 

protected EngineAssetManager(FileHandleResolver resolver) {
	super(resolver);

	resResolver = new EngineResolutionFileResolver(resolver);
	setLoader(Texture.class, new TextureLoader(resResolver));
	setLoader(TextureAtlas.class, new TextureAtlasLoader(resResolver));
	setLoader(FreeTypeFontGenerator.class, new FreeTypeFontGeneratorLoader(resolver));
	setLoader(BitmapFont.class, ".ttf", new FreetypeFontLoader(resolver));

	Texture.setAssetManager(this);
}
 

public static Cubemap createCubemap(FileHandleResolver resolver, String baseName, String extension, String [] faceNames) {
	Cubemap cubemap = new Cubemap(
			resolver.resolve(baseName + faceNames[0] + extension),  
			resolver.resolve(baseName + faceNames[1] + extension), 
			resolver.resolve(baseName + faceNames[2] + extension), 
			resolver.resolve(baseName + faceNames[3] + extension),
			resolver.resolve(baseName + faceNames[4] + extension),
			resolver.resolve(baseName + faceNames[5] + extension));
	cubemap.setFilter(TextureFilter.Linear, TextureFilter.Linear);
	return cubemap;
}
 

public BitmapFontLoader(FileHandleResolver resolver) {
  super(resolver);
}
 

public COFLoader(FileHandleResolver resolver) {
  super(resolver);
}
 

public TXTLoader(FileHandleResolver resolver) {
  super(resolver);
}
 

public GdxFileSuggester(@NonNull FileHandleResolver resolver) {
  this.RESOLVER = Validate.notNull(resolver, "resolver cannot be null");
  this.FILTER = null;
}
 

public GdxFileSuggester(@NonNull FileHandleResolver resolver, @NonNull FilenameFilter filter) {
  this.RESOLVER = Validate.notNull(resolver, "resolver cannot be null");
  this.FILTER = Validate.notNull(filter, "filter cannot be null");
}
 

public VolumeControlledSoundLoader(@NonNull FileHandleResolver resolver,
                                   @NonNull VolumeController<Sound> controller) {
  super(resolver);
  this.controller = Validate.notNull(controller, "VolumeController cannot be null");
}
 

public VolumeControlledMusicLoader(@NonNull FileHandleResolver resolver,
                                   @NonNull VolumeController<Music> controller) {
  super(resolver);
  this.controller = Validate.notNull(controller, "VolumeController cannot be null");
}
 

public MG3dModelLoader(BaseJsonReader reader, FileHandleResolver resolver) {
    super(resolver);
    this.reader = reader;
}
 

public EngineResolutionFileResolver(FileHandleResolver baseResolver) {
	this.baseResolver = baseResolver;
}
 

public FileHandleResolver getBaseResolver() {
	return baseResolver;
}
 

public MyNavTmxMapLoader(FileHandleResolver resolver){
	this(resolver, "navigation", "walkable", "0");
}
 

public UAtlasTmxMapLoader (FileHandleResolver resolver) {
	super(resolver);
}
 

public SkeletonDataLoader(FileHandleResolver resolver) {
	super(resolver);
}
 

public HeadlessG3dModelLoader(BaseJsonReader reader, FileHandleResolver resolver) {
	super(resolver);
	this.reader = reader;
}
 

public HeadlessModelLoader(FileHandleResolver resolver) {
	super(resolver);
}
 

public NavTmxMapLoader(FileHandleResolver resolver){
	this(resolver, "navigation", "walkable", "0");
}
 

public NavTmxMapLoader(FileHandleResolver handler, String navigationLayerName, String navigationProperty, String navigationClosedValue){
	super(handler);
	this.navigationLayerName = navigationLayerName;
	this.navigationProperty = navigationProperty;
	this.navigationClosedValue = navigationClosedValue;
}
 

public BehaviorTreeLoader (FileHandleResolver resolver) {
	super(resolver);
}
 

/** Creates a {@code BehaviorTreeLibrary} with the given resolver.
 * @param resolver the {@link FileHandleResolver} */
public BehaviorTreeLibrary (FileHandleResolver resolver) {
	this(resolver, BehaviorTreeParser.DEBUG_NONE);
}
 

/** Creates a {@code BehaviorTreeLibrary} with the given resolver and debug level.
 * @param resolver the {@link FileHandleResolver}
 * @param parseDebugLevel the debug level the parser will use */
public BehaviorTreeLibrary (FileHandleResolver resolver, int parseDebugLevel) {
	this(resolver, null, parseDebugLevel);
}
 

public GLBAssetLoader(FileHandleResolver resolver) {
	super(resolver);
}
 

public GLTFAssetLoader(FileHandleResolver resolver) {
	super(resolver);
}
 

public MidiSequenceLoader(FileHandleResolver resolver) {
	super(resolver);
}