com.aspose.threed

Class FileSystem

java.lang.Object

com.aspose.threed.FileSystem

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

public abstract class FileSystem
extends java.lang.Object
implements java.io.Closeable

File system encapsulation. Aspose.3D will use this to read/write dependencies. Example: The following code shows how to import file, and provide dependent files in a given directory

     var inputFile = "input.fbx";
     var format = FileFormat.detect(inputFile);
     //create a load options instance and specify a zip file system
     var opt = format.createLoadOptions();
     opt.setFileSystem(new LocalFileSystem("textures/"));
     //load the file
     var scene = Scene.fromFile(inputFile, opt);
 

Constructor Summary

Constructors

Constructor and Description
FileSystem()

Method Summary

Modifier and Type	Method and Description
void	close() Dispose the File system and release its resources.
static FileSystem	createDummyFileSystem() Create a dummy file system, read/write operations are dummy operations.
static FileSystem	createLocalFileSystem(java.lang.String directory) Initialize a new FileSystem that only access local directory.
static FileSystem	createMemoryFileSystem() Create a memory-based file system which will maps the read/write operations to memory.
static FileSystem	createMemoryFileSystem(java.util.HashMap<java.lang.String,MemoryStream> files) Create a memory-based file system which will maps the read/write operations to memory.
static FileSystem	createZipFileSystem(Stream stream) Create a file system to provide to the read-only access to speicified zip file or zip stream.
static FileSystem	createZipFileSystem(Stream stream, java.lang.String baseDir) Create a file system to provide to the read-only access to speicified zip file or zip stream.
static FileSystem	createZipFileSystem(java.lang.String fileName) File system to provide to the read-only access to speicified zip file or zip stream.
abstract Stream	readFile(java.lang.String fileName, IOConfig options) Create a stream for reading dependencies.
abstract Stream	writeFile(java.lang.String fileName, IOConfig options) Create a stream for writing dependencies.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FileSystem

public FileSystem()

Method Detail

readFile

public abstract Stream readFile(java.lang.String fileName,
                                IOConfig options)
                         throws java.io.IOException

Create a stream for reading dependencies.

Parameters:

fileName - File's name to open for reading

options - Save or load options

Returns:

Stream for reading the file.

Throws:

java.io.IOException - The implementation throws this exception when failed to open the file for reading.

writeFile

public abstract Stream writeFile(java.lang.String fileName,
                                 IOConfig options)
                          throws java.io.IOException

Create a stream for writing dependencies.

Parameters:

fileName - The file's name to open for writing

options - Save or load options

Returns:

Stream for writing the file

Throws:

java.io.IOException - Thrown when failed to open stream for writing

createLocalFileSystem

public static FileSystem createLocalFileSystem(java.lang.String directory)
                                        throws java.io.FileNotFoundException

Initialize a new FileSystem that only access local directory. All file read/write on this FileSystem instance will be mapped to specified directory.

Parameters:

directory - The directory in your physical file system as the virtual root directory.

Returns:

A new instance of file system to provide local file access

Throws:

java.io.FileNotFoundException - Thrown when directory cannot be found. Example: The following code shows how to import file, and provide dependent files in a given directory

     var inputFile = "input.fbx";
     var format = FileFormat.detect(inputFile);
     //create a load options instance and specify a local file system
     var opt = format.createLoadOptions();
     opt.setFileSystem(FileSystem.createLocalFileSystem("textures/"));
     //load the file
     var scene = Scene.fromFile(inputFile, opt);
 

createMemoryFileSystem

public static FileSystem createMemoryFileSystem(java.util.HashMap<java.lang.String,MemoryStream> files)

Create a memory-based file system which will maps the read/write operations to memory.

Parameters:

files - This allows you to read/write the virtual files.

Returns:

A memory-based file system Example: The following code shows how to export file to memory, includes the dependent file by using MemoryFileSystem.

     //create a scene with material
     Scene scene = new Scene();
     scene.getRootNode().createChildNode(new Box()).setMaterial(new LambertMaterial());
     //create a save option and specify the file system, so the dependent file will be written to memory
     var opt = FileFormat.WAVEFRONTOBJ.createSaveOptions();
     var mfs = new HashMap<String, MemoryStream>();
     opt.setFileSystem(FileSystem.createMemoryFileSystem(mfs));
     //obj's material file name is associated with the obj's file name, so we need a explicit name.
     opt.setFileName("test.obj");
     try (var ms = new MemoryStream())
     {
         scene.save(ms, opt);
     }
     //the test.obj was written to variable ms, and we can also get the test.mtl file content by
     var materialFile = mfs.get("test.mtl");
 

createMemoryFileSystem

public static FileSystem createMemoryFileSystem()

Create a memory-based file system which will maps the read/write operations to memory.

Returns:

A memory-based file system Example: The following code shows how to export file to memory, includes the dependent file by using MemoryFileSystem.

     //create a scene with material
     Scene scene = new Scene();
     scene.getRootNode().createChildNode(new Box()).setMaterial(new LambertMaterial());
     //create a save option and specify the file system, so the dependent file will be written to memory
     var opt = FileFormat.WAVEFRONTOBJ.createSaveOptions();
     var mfs = new HashMap<String, MemoryStream>();
     opt.setFileSystem(FileSystem.createMemoryFileSystem(mfs));
     //obj's material file name is associated with the obj's file name, so we need a explicit name.
     opt.setFileName("test.obj");
     try (var ms = new MemoryStream())
     {
         scene.save(ms, opt);
     }
     //the test.obj was written to variable ms, and we can also get the test.mtl file content by
     var materialFile = mfs.get("test.mtl");
 

createDummyFileSystem

public static FileSystem createDummyFileSystem()

Create a dummy file system, read/write operations are dummy operations.

Returns:

A dummy file system Example: The following code shows how to export file to memory, and ignore all dependent file generation.

     //create a scene with material
     Scene scene = new Scene();
     scene.getRootNode().createChildNode(new Box()).setMaterial(new LambertMaterial());
     //create a save option and specify the file system, so the dependent file will be written to memory
     var opt = FileFormat.WAVEFRONTOBJ.createSaveOptions();
     var dfs = FileSystem.CreateDummyFileSystem();
     opt.setFileSystem(dfs);
     //obj's material file name is associated with the obj's file name, so we need a explicit name.
     opt.setFileName("test.obj");
     try (var ms = new MemoryStream())
     {
         scene.save(ms, opt);
     }
 

createZipFileSystem

public static FileSystem createZipFileSystem(Stream stream,
                                             java.lang.String baseDir)
                                      throws java.io.IOException

Create a file system to provide to the read-only access to speicified zip file or zip stream. File system will be disposed after the open/save operation.

Parameters:

stream - The stream to access the zip file

baseDir - The base directory inside the zip file.

Returns:

A zip file system

Throws:

java.io.IOException - Thrown when failed to read from stream. Remarks: This is a read-only file system, so no write operations are supported. Example: The following code shows how to import file, and provide dependent files in a zip archive file.

     var inputFile = "input.fbx";
     var format = FileFormat.detect(inputFile);
     //create a load options instance and specify a zip file system
     var opt = format.createLoadOptions();
     opt.setFileSystem(FileSystem.createZipFileSystem("textures.zip"));
     //load the file
     var scene = Scene.fromFile(inputFile, opt);
 

createZipFileSystem

public static FileSystem createZipFileSystem(Stream stream)
                                      throws java.io.IOException

Create a file system to provide to the read-only access to speicified zip file or zip stream. File system will be disposed after the open/save operation.

Parameters:

stream - The stream to access the zip file

Returns:

A zip file system

Throws:

java.io.IOException - Thrown when failed to read from stream. Remarks: This is a read-only file system, so no write operations are supported. Example: The following code shows how to import file, and provide dependent files in a zip archive file.

     var inputFile = "input.fbx";
     var format = FileFormat.detect(inputFile);
     //create a load options instance and specify a zip file system
     var opt = format.createLoadOptions();
     opt.setFileSystem(FileSystem.createZipFileSystem("textures.zip"));
     //load the file
     var scene = Scene.fromFile(inputFile, opt);
 

createZipFileSystem

public static FileSystem createZipFileSystem(java.lang.String fileName)
                                      throws java.io.IOException

File system to provide to the read-only access to speicified zip file or zip stream. File system will be disposed after the open/save operation.

Parameters:

fileName - File name to the zip file.

Returns:

A zip file system

Throws:

java.io.IOException - Thrown when failed to read from stream. Example: The following code shows how to import file, and provide dependent files in a zip archive file.

     var inputFile = "input.fbx";
     var format = FileFormat.detect(inputFile);
     //create a load options instance and specify a zip file system
     var opt = format.createLoadOptions();
     opt.setFileSystem(FileSystem.createZipFileSystem("textures.zip"));
     //load the file
     var scene = Scene.fromFile(inputFile, opt);
 

close

public void close()
           throws java.io.IOException

Dispose the File system and release its resources.

Specified by:

close in interface java.io.Closeable

Specified by:

close in interface java.lang.AutoCloseable

Throws:

java.io.IOException