@awayjs/core/lib/library/LoaderContext.ts

AwayJS core classes

export class LoaderContext {
	public static UNDEFINED: number = 0;
	public static SINGLEPASS_MATERIALS: number = 1;
	public static MULTIPASS_MATERIALS: number = 2;

	public static ON_DEMAND: string = 'onDemand';
	public static PRELOADED: string = 'preloaded';

	private _includeDependencies: boolean;
	private _dependencyBaseUrl: string;
	private _embeddedDataByUrl: Object;
	private _remappedUrls: Object;
	private _materialMode: number;
	private _externalAssetMode: string;

	private _overrideAbsPath: boolean;
	private _overrideFullUrls: boolean;

	/**
	 * LoaderContext provides configuration for the Loader load() and parse()
	 * operations. Use it to configure how (and if) dependencies are loaded, or
	 * to map dependency URLs to embedded data.
	 *
	 * @see away.loading.Loader
	 */
	constructor(includeDependencies: boolean = true, dependencyBaseUrl: string = null) {
		this._includeDependencies = includeDependencies;
		this._dependencyBaseUrl = dependencyBaseUrl || '';
		this._embeddedDataByUrl = {};
		this._remappedUrls = {};
		this._materialMode = LoaderContext.UNDEFINED;
		this._externalAssetMode = LoaderContext.PRELOADED;
	}

	/**
	 * Defines whether dependencies (all files except the one at the URL given
	 * to the load() or parseData() operations) should be automatically loaded.
	 * Defaults to true.
	 */
	public get includeDependencies(): boolean {
		return this._includeDependencies;
	}

	public set includeDependencies(val: boolean) {
		this._includeDependencies = val;
	}

	/**
	 * MaterialMode defines, if the Parser should create SinglePass or MultiPass
	 * Materials Options: 0 (Default / undefined) - All Parsers will create
	 * SinglePassMaterials, but the AWD2.1parser will create Materials as they
	 * are defined in the file 1 (Force SinglePass) - All Parsers create
	 * SinglePassMaterials 2 (Force MultiPass) - All Parsers will create
	 * MultiPassMaterials
	 *
	 */
	public get materialMode(): number {
		return this._materialMode;
	}

	public set materialMode(value: number) {
		this._materialMode = value;
	}

	public get externalAssetMode(): string {
		return this._externalAssetMode;
	}

	public set externalAssetMode(value: string) {
		this._externalAssetMode = value;
	}

	/**
	 * A base URL that will be prepended to all relative dependency URLs found
	 * in a loaded resource. Absolute paths will not be affected by the value of
	 * this property.
	 */
	public get dependencyBaseUrl(): string {
		return this._dependencyBaseUrl;
	}

	public set dependencyBaseUrl(val: string) {
		this._dependencyBaseUrl = val;
	}

	/**
	 * Defines whether absolute paths (defined as paths that begin with a "/")
	 * should be overridden with the dependencyBaseUrl defined in this context.
	 * If this is true, and the base path is "base", /path/to/asset.jpg will be
	 * resolved as base/path/to/asset.jpg.
	 */
	public get overrideAbsolutePaths(): boolean {
		return this._overrideAbsPath;
	}

	public set overrideAbsolutePaths(val: boolean) {
		this._overrideAbsPath = val;
	}

	/**
	 * Defines whether "full" URLs (defined as a URL that includes a scheme,
	 * e.g. http://) should be overridden with the dependencyBaseUrl defined in
	 * this context. If this is true, and the base path is "base",
	 * http://example.com/path/to/asset.jpg will be resolved as
	 * base/path/to/asset.jpg.
	 */
	public get overrideFullURLs(): boolean {
		return this._overrideFullUrls;
	}

	public set overrideFullURLs(val: boolean) {
		this._overrideFullUrls = val;
	}

	/**
	 * Map a URL to another URL, so that files that are referred to by the
	 * original URL will instead be loaded from the new URL. Use this when your
	 * file structure does not match the one that is expected by the loaded
	 * file.
	 *
	 * @param originalUrl The original URL which is referenced in the loaded
	 * resource.
	 * @param newUrl The URL from which away.should load the resource instead.
	 *
	 * @see mapUrlToData()
	 */
	public mapUrl(originalUrl: string, newUrl: string): void {
		this._remappedUrls[originalUrl] = newUrl;
	}

	/**
	 * Map a URL to embedded data, so that instead of trying to load a
	 * dependency from the URL at which it's referenced, the dependency data
	 * will be retrieved straight from the memory instead.
	 *
	 * @param originalUrl The original URL which is referenced in the loaded
	 * resource.
	 * @param data The embedded data. Can be ByteArray or a export class which
	 * can be used to create a bytearray.
	 */
	public mapUrlToData(originalUrl: string, data: any): void {
		this._embeddedDataByUrl[originalUrl] = data;
	}

	/**
	 * @private
	 * Defines whether embedded data has been mapped to a particular URL.
	 */
	public _iHasDataForUrl(url: string): boolean {
		return this._embeddedDataByUrl.hasOwnProperty(url);
	}

	/**
	 * @private
	 * Returns embedded data for a particular URL.
	 */
	public _iGetDataForUrl(url: string): any {
		return this._embeddedDataByUrl[url];
	}

	/**
	 * @private
	 * Defines whether a replacement URL has been mapped to a particular URL.
	 */
	public _iHasMappingForUrl(url: string): boolean {
		return this._remappedUrls.hasOwnProperty(url);
	}

	/**
	 * @private
	 * Returns new (replacement) URL for a particular original URL.
	 */
	public _iGetRemappedUrl(originalUrl: string): string {
		return this._remappedUrls[originalUrl];
	}
}