TriLib - Contribuições do usuário [pt-br]

Supported File Formats

2025-01-26T01:34:59Z

Trilib:

TriLib 2.0 works with a smaller file-formats subset compared with the first version. This decision has been taken to focus on the most used file-formats and offer a more stable and feature-rich experience with these formats.
==Model file formats:==
FBX (Accepts version 7.0 onwards)

OBJ

GLTF 2 (Accepts Draco decompression using an experimental feature)

STL

PLY

3MF (No extension supported)

ZIP

DAE (Collada) support is experimental. The full Collada support is in the works.
==Texture file formats:==
BMP

GIF

JPG

PNG

PSD

TGA

HDR (Used to load Skyboxes, not ready for common Texture usage)

TIFF

Supported File Formats

2025-01-21T21:14:23Z

Trilib: /* Texture file formats: */

TriLib 2.0 works with a smaller file-formats subset compared with the first version. This decision has been taken to focus on the most used file-formats and offer a more stable and feature-rich experience with these formats.
==Model file formats:==
FBX (Accepts version 7.0 onwards)

OBJ

GLTF 2 (Accepts Draco decompression using an experimental feature)

STL

PLY

3MF

ZIP

DAE (Collada) support is experimental. The full Collada support is in the works.
==Texture file formats:==
BMP

GIF

JPG

PNG

PSD

TGA

HDR (Used to load Skyboxes, not ready for common Texture usage)

TIFF

Basic Usage

2025-01-21T19:26:43Z

Trilib:

There are three main methods to load models and their dependencies in TriLib:

* Local File-System Loading
* URL Loading
* Custom Source Loading

The user can adapt other loading mechanisms as the core loading methods accept Streams as data input and Scriptable Objects called Mappers, used to load Textures and external data from custom data Streams.

==Local File-System Loading==

=== Using File Picker ===
Loading models from the local file-system is simplified by using the StandaloneFileBrowser classes that come with TriLib.

Let's create an empty Unity project in this example and import the TriLib Unity package. Make sure you include the StandaloneFileBrowser folder when extracting.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Use the following code in your "TestLoader.cs" and hit the play button to test it:

<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from File"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Creates the AssetLoaderFilePicker instance.
// AssetLoaderFilePicker is a class that allows users to select models from the local file system.
var assetLoaderFilePicker = AssetLoaderFilePicker.Create();

// Shows the model selection file-picker.
assetLoaderFilePicker.LoadModelFromFilePickerAsync("Select a File", OnLoad, OnMaterialsLoad, OnProgress, OnBeginLoad, OnError, null, assetLoaderOptions);
}
}

// This event is called when the model is about to be loaded.
// You can use this event to do some loading preparation, like showing a loading screen in platforms without threading support.
// This event receives a Boolean indicating if any file has been selected on the file-picker dialog.
private void OnBeginLoad(bool anyModelSelected)
{

}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

=== Using the Model Filename ===
You can also load your Models, passing the Model Filename to the AssetLoader methods.

Let's create an empty Unity project in this example and import the TriLib Unity package.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Use the following code in your "TestLoader.cs" and hit the play button to test it:
<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from File"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Loads the model from the "PATH_TO_MY_FILE.FBX" path
AssetLoader.LoadModelFromFile("PATH_TO_MY_FILE.FBX", OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
}
}

// This event is called when the model is about to be loaded.
// You can use this event to do some loading preparation, like showing a loading screen in platforms without threading support.
// This event receives a Boolean indicating if any file has been selected on the file-picker dialog.
private void OnBeginLoad(bool anyModelSelected)
{

}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

== URL Loading ==

You can use the AssetDownloader class to load models from URLs (network). The usage is relatively simple and similar to the local file-system loading.

Let's create an empty Unity project in this example and import the TriLib Unity package. Make sure you include the StandaloneFileBrowser folder when extracting.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Important: If you're downloading models from files that are not Zipped, you must pass the model extension as the last parameter from the <code>AssetDownloader.LoadModelFromUri</code> call (Eg: "fbx")

Use the following code in your "TestLoader.cs" and hit the play button to test it:

<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from URL"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Creates the web-request.
// The web-request contains information on how to download the model.
// Let's download a model from the TriLib website.
var webRequest = AssetDownloader.CreateWebRequest("https://ricardoreis.net/trilib/demos/avatars/003/003_visemes.zip");

// Important: If you're downloading models from files that are not Zipped, you must pass the model extension as the last parameter from this call (Eg: "fbx")
// Begins the model downloading.
AssetDownloader.LoadModelFromUri(webRequest, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions, null, null);
}
}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

Transparent Materials

2024-09-04T14:42:44Z

Trilib:

TriLib can handle transparent materials differently, so if your material is not loaded correctly, you could try changing your <code>AssetLoaderOptions</code> instance <code>AlphaMaterialMode</code> field.

There are three possible values for this field:

* Cutout:[[Arquivo:Cutout Material Mode.png|nenhum|miniaturadaimagem|In "Cutout" material mode, TriLib will set the material Rendering Mode to "Cutout" whenever an alpha texture/material is found. Cutout materials can cast shadows, and uses depth test.]]
* Transparent:[[Arquivo:Transparent Material Mode.png|nenhum|miniaturadaimagem|In "Transparent" material mode, TriLib will set the material Rendering Mode to "Transparent" whenever an alpha texture/material is found. Transparent materials can't cast shadows and don't uses depth pass.]]
* CutoutAndTransparent:[[Arquivo:Cutout and Transparent Material Mode.png|nenhum|miniaturadaimagem|In "CutoutAndTransparent" alpha material mode, TriLib will create an extra mesh whenever an alpha texture/material is found. The underlying mesh will use a material with the "Transparent" Rendering Mode, and the overlying mesh will use the "Cutout" Rendering Mode. This alpha material mode is suitable when your object is composed of textures that are partially transparent, but should cast shadows and be use depth test. *You can control the ratio between what is considered opaque/transparent modifying the included TriLib materials.]]

<nowiki>*</nowiki>Included TriLib materials can be found in the following folders:

* TriLib/Resources/Materials/Standard/Standard
* TriLibHDRP/Resources/Materials/HDRP/Standard
* TriLibUniversalRP/Resources/Materials/UniversalRP/Standard

Running TriLib in Headless Mode

2024-05-18T12:19:37Z

Trilib:

When running Unity Editor in Headless Mode, you must define the Material Mapper TriLib is going to use.

To do that, pass it with the "-'''trilib_mappers'''" command-line argument.

Ex:
UnityEditor.exe -batchmode -trilib_mappers StandardMaterialMapper
Possible values are:

* StandardMaterialMapper
* HDRPMaterialMapper
* UniversalRPMaterialMapper
* Or any other Material Mapper asset you included in your Project.

Main Page

2024-05-18T12:19:12Z

Trilib: /* Info */

{{DISPLAYTITLE:Main page}}

==Getting started==
[[Basic Usage]]

[[Avatar Importing]]

[[Migrating from TriLib 1 to TriLib 2]]

[[Video Tutorials]]

[[How to track loaded resources]]
==Troubleshooting==
[[Missing Materials (Pink color)]]

[[Missing Materials]]

[[Material Color Inconsistencies]]

[[Transparent Materials]]

[[Measurement Units]]

[[Scripted Importers Conflict]]

[[StandaloneFileBrowser can't be found]]

[[SharpZipLib conflicts]]

[[Loading models from URI]]

[[Error saving TLC files]]

[[Importing Humanoid Animations]]
==Info==
[[Supported File Formats‎]]

[[Known Issues/Limitations]]

[[File Format specific Options]]

[[Running TriLib in Headless Mode]]
==API Docs==
https://ricardoreis.net/trilib/trilib2/docs/

How to track loaded resources

2024-05-18T12:18:54Z

Trilib:

You can use the following snippet on your loading methods <code>'''onMaterialsLoad'''</code> callback to track the loaded resources if you need to copy/move them elsewhere:
<pre>
//ModelPath contains the loaded model path
var modelPath = assetLoaderContext.Filename;
if (!string.IsNullOrEmpty(modelPath))
{
//Do stuff
}

//Iterate the loaded textures list
foreach (var kvp in assetLoaderContext.LoadedCompoundTextures)
{
//FinalPath contains the loaded texture filename
string finalPath = kvp.Key.ResolvedFilename;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}

//Iterate the loaded resources list
foreach (var kvp in assetLoaderContext.LoadedExternalData)
{
//FinalPath contains the loaded resource filename
string finalPath = kvp.Value;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}
</pre>

How to track loaded resources

2024-05-18T12:17:53Z

Trilib:

On your loading methods <code>onMaterialsLoad</code> callback, you can use the following snippet to track the loaded resources, in case you need to copy/move them elsewhere:
<pre>
//ModelPath contains the loaded model path
var modelPath = assetLoaderContext.Filename;
if (!string.IsNullOrEmpty(modelPath))
{
//Do stuff
}

//Iterate the loaded textures list
foreach (var kvp in assetLoaderContext.LoadedCompoundTextures)
{
//FinalPath contains the loaded texture filename
string finalPath = kvp.Key.ResolvedFilename;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}

//Iterate the loaded resources list
foreach (var kvp in assetLoaderContext.LoadedExternalData)
{
//FinalPath contains the loaded resource filename
string finalPath = kvp.Value;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}
</pre>

How to track loaded resources

2024-05-18T12:17:07Z

Trilib:

On your loading methods <code>onMaterialsLoad</code> callback, you can use the following snippet to track the loaded resources, in case you need to copy/move them elsewhere:
<pre>
//ModelPath contains the loaded model path
var modelPath = assetLoaderContext.Filename;
if (!string.IsNullOrEmpty(modelPath))
{
//Do stuff
}

//Iterate the loaded textures list
foreach (var kvp in assetLoaderContext.LoadedTextures)
{
//FinalPath contains the loaded texture filename
string finalPath = kvp.Key.ResolvedFilename;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}

//Iterate the loaded resources list
foreach (var kvp in assetLoaderContext.LoadedExternalData)
{
//FinalPath contains the loaded resource filename
string finalPath = kvp.Value;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}
</pre>

Importing Humanoid Animations

2024-05-18T12:16:27Z

Trilib:

TriLib offers a versatile range of animation importing options, all of which can be easily configured using the <code>'''AssetLoaderOptions.AnimationType'''</code> field:

* '''<code>Legacy</code>''': Using this animation importing type, TriLib will create Animation Clips for the loaded model (if it contains animations) and add an "Animation" component to the loaded Game Object.
* '''<code>Generic</code>''': Using this animation importing type, TriLib does not create Animation Clips, but it does the following, depending on the <code>'''AssetLoaderOptionss.AvatarDefinition'''</code> value:
** '''<code>CreateFromThisModel</code>''': TriLib adds an "Animator" component to the loaded Game Object, creates a generic avatar for the loaded model, and uses it at the "Animator" component.
** '''<code>CopyFromOtherAvatar</code>''': TriLib adds an "Animator" component to the loaded Game Object and uses the avatar at <code>'''AssetLoaderOptions.Avatar'''</code> at the "Animator" component.
* '''<code>Humanoid</code>''': Using this animation importing type, TriLib does not create Animation Clips, but it does the following, depending on the <code>'''AssetLoaderOptionss.AvatarDefinition'''</code> value:
** '''<code>CreateFromThisModel</code>''': TriLib adds an "Animator" component to the loaded Game Object, creates a humanoid avatar for the loaded model using the Avatar Mapper set at the <code>'''AssetLoaderOptions.HumanoidAvatarMapper'''</code> field, and uses it at the "Animator" component.
** '''<code>CopyFromOtherAvatar</code>''': TriLib adds an "Animator" component to the loaded Game Object and uses the avatar at <code>'''AssetLoaderOptions.Avatar'''</code> at the "Animator" component.

TriLib cannot import generic or humanoid animations due to a Unity engine limitation. However, we are actively working on a side project that will soon enable humanoid animation importing.

Importing Humanoid Animations

2024-05-18T12:16:05Z

Trilib:

TriLib offers a versatile range of animation importing options, all of which can be easily configured using the <code>AssetLoaderOptions.AnimationType</code> field:

* '''<code>Legacy</code>''': Using this animation importing type, TriLib will create Animation Clips for the loaded model (if it contains animations) and add an "Animation" component to the loaded Game Object.
* '''<code>Generic</code>''': Using this animation importing type, TriLib does not create Animation Clips, but it does the following, depending on the <code>AssetLoaderOptionss.AvatarDefinition</code> value:
** '''<code>CreateFromThisModel</code>''': TriLib adds an "Animator" component to the loaded Game Object, creates a generic avatar for the loaded model, and uses it at the "Animator" component.
** '''<code>CopyFromOtherAvatar</code>''': TriLib adds an "Animator" component to the loaded Game Object and uses the avatar at <code>AssetLoaderOptions.Avatar</code> at the "Animator" component.
* '''<code>Humanoid</code>''': Using this animation importing type, TriLib does not create Animation Clips, but it does the following, depending on the <code>AssetLoaderOptionss.AvatarDefinition</code> value:
** '''<code>CreateFromThisModel</code>''': TriLib adds an "Animator" component to the loaded Game Object, creates a humanoid avatar for the loaded model using the Avatar Mapper set at the <code>AssetLoaderOptions.HumanoidAvatarMapper</code> field, and uses it at the "Animator" component.
** '''<code>CopyFromOtherAvatar</code>''': TriLib adds an "Animator" component to the loaded Game Object and uses the avatar at <code>AssetLoaderOptions.Avatar</code> at the "Animator" component.

TriLib cannot import generic or humanoid animations due to a Unity engine limitation. However, we are actively working on a side project that will soon enable humanoid animation importing.

Error saving TLC files

2024-05-18T12:14:27Z

Trilib:

TriLib has a cache system that extracts FBX embedded files data to disk to save loading times.

Sometimes, the platform you're targeting needs to give access to the temporary folder where the files are extracted.

If you encounter a "System.UnauthorizedAccessException" error when loading a model with TriLib, you could try turning off this behavior by setting <code>AssetLoaderOptions</code> instance <code>ExtractEmbeddedData</code> field value to <code>false</code>.

Loading models from URI

2024-05-18T12:13:34Z

Trilib:

A recurrent issue when loading models from URI is caused by Cross-Origin Resource Sharing restrictions, resulting in the error message "TriLib is unable to load the given file."

For instance, web servers can use these restrictions to prevent unauthorized websites from making requests to the server.

This issue should not happen when loading models using TriLib from a desktop or a mobile application.

To get more information on Cross-Origin Resource Sharing, please refer to:

https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS

SharpZipLib conflicts

2024-05-18T12:12:39Z

Trilib:

TriLib uses SharpZipLib (https://github.com/icsharpcode/SharpZipLib) to handle Zip files.

When importing TriLib to your project, you might get conflicts saying '''"ICSharpCode.SharpZipLib.dll"''' has been found in multiple places in the solution.

This happens because your solution already has a SharpZipLib library.

You can fix that by keeping only the most up-to-date SharpZipLib version. TriLib uses SharpZipLib version '''1.2.0.7'''.

You can find the library in the '''"Assets/TriLib/TriLibCore/Plugins/Dependencies"''' folder.

SharpZipLib conflicts

2024-05-18T12:12:10Z

Trilib:

TriLib uses SharpZipLib (https://github.com/icsharpcode/SharpZipLib) to handle Zip files.

When importing TriLib to your project, you might get conflicts saying '''"ICSharpCode.SharpZipLib.dll"''' has been found in multiple places in the solution.

This happens because your solution already has a SharpZipLib library on it.

You can fix that by keeping only the most up-to-date SharpZipLib version. TriLib uses SharpZipLib version '''1.2.0.7'''.

You can find the library in the '''"Assets/TriLib/TriLibCore/Plugins/Dependencies"''' folder.

StandaloneFileBrowser can't be found

2024-05-18T12:11:50Z

Trilib:

TriLib comes with a custom version of '''StandaloneFileBrowser''' (the original can be found here: https://github.com/gkngkc/UnityStandaloneFileBrowser)

It is an optional package, and if you don't want to use it, you can import only the "'''TriLibCore'''" (and the folder from your rendering pipeline, in case you're using anything other than the Standard rendering pipeline) folder from the TriLib package.

When building/running your application, you may get a message saying "StandaloneFileBrowse can't be found" or something similar.

Generally, this happens because the appropriate StandaloneFileBrowser plugin hasn't been included in your build project.

You can fix these issues by doing the following:

[[Arquivo:Step1.png|commoldura|To make sure StandaloneFileBrowser is included in your build project, head to the '''"Assets/TriLib/TriLibStandaloneFileBrowser/Plugins"''' directory and look for the plugin file according to the platform you will deploy to.

In this case, I'm selecting the '''"x64"''' StandaloneFileBrowser plugin inside the '''"Windows"''' folder, as I will deploy my application to Windows x64 devices.]]

[[Arquivo:Step2.png|commoldura|You can then select the appropriate architecture you want the selected plugin to be used, then click '''"Apply"'''.]]
{| class="wikitable"
|+Plugin directories
!Platform
!Directory
|-
|Android
|Android
|-
|iOS
|iOS
|-
|Linux
|Linux
|-
|OSX
|StandaloneFileBrowser.bundle
|-
|Windows
|Windows
|-
|WebGL
|StandaloneFileBrowser.jslib
|}

Scripted Importers Conflict

2024-05-18T12:11:08Z

Trilib:

TriLib 2.0 uses Scripted Importers to allow users to import models inside Unity Editor and not only in the Runtime.

If you're getting any Scripted Importer conflict error message when adding TriLib to your project, please head to the "'''Project Settings->TriLib'''" area where you can disable individual In-Editor Importers.
[[Arquivo:Image.png|alt=TriLib Project Settings|miniaturadaimagem|TriLib Project Settings]]

Measurement Units

2024-05-18T12:10:41Z

Trilib:

3D authoring software has its own measurement units. TriLib has some options to convert between these units and Unity units.

<nowiki>*</nowiki>By default, 1 Unity unit is 1 Meter.

To keep the original measurement unit used when exporting your models, make sure your <code>AssetLoaderOptions</code> instance <code>UseFileScale</code> field is set to <code>true</code> .This way, TriLib will try to use the measurement unit used when your model has been exported.

If the default Unity measurement units is unsuitable, you can multiply the scale with any factor using the <code>AssetLoaderOptions.ScaleFactor</code> field. By default, this value is <code>1.0</code>, which keeps the original measurement unit used when exporting your model.

<nowiki>*</nowiki>Only FBX and DAE files have options to export the measurement unit used when authoring the models. TriLib keeps the original units when loading models created in any other file format.

Transparent Materials

2024-05-18T12:08:36Z

Trilib:

TriLib can handle transparent materials differently, so if your material is not loaded correctly, you could try changing your <code>AssetLoaderOptions</code> instance <code>AlphaMaterialMode</code> field.

There are three possible values for this field:

* Cutout:[[Arquivo:Cutout Material Mode.png|nenhum|miniaturadaimagem|In "Cutout" material mode, TriLib will set the material Rendering Mode to "Transparent" whenever an alpha texture/material is found. Cutout materials can cast shadows, and uses depth test.]]
* Transparent:[[Arquivo:Transparent Material Mode.png|nenhum|miniaturadaimagem|In "Transparent" material mode, TriLib will set the material Rendering Mode to "Transparent" whenever an alpha texture/material is found. Transparent materials can't cast shadows and don't uses depth pass.]]
* CutoutAndTransparent:[[Arquivo:Cutout and Transparent Material Mode.png|nenhum|miniaturadaimagem|In "CutoutAndTransparent" alpha material mode, TriLib will create an extra mesh whenever an alpha texture/material is found. The underlying mesh will use a material with the "Transparent" Rendering Mode, and the overlying mesh will use the "Cutout" Rendering Mode. This alpha material mode is suitable when your object is composed of textures that are partially transparent, but should cast shadows and be use depth test. *You can control the ratio between what is considered opaque/transparent modifying the included TriLib materials.]]

<nowiki>*</nowiki>Included TriLib materials can be found in the following folders:

* TriLib/Resources/Materials/Standard/Standard
* TriLibHDRP/Resources/Materials/HDRP/Standard
* TriLibUniversalRP/Resources/Materials/UniversalRP/Standard

Material Color Inconsistencies

2024-05-18T12:07:35Z

Trilib:

Sometimes, when loading model materials, the color might differ from what other viewers are showing.

TriLib will convert material color values and texture colors by default to the gamma (sRGB) representation.

If you don't want this to happen, disable these behaviors by turning off your '''<code>AssetLoaderOptions</code> <code>ApplyGammaCurveToMaterialColors</code>''' and '''<code>LoadTexturesAsSRGB</code>''' fields.

Another reason for colors to differ is when TriLib does not apply ambient color to FBX materials.

You can enable the '''<code>FBXReader.ApplyAbientColor</code>''' static field so TriLib can apply ambient color to FBX materials.

Missing Materials

2024-05-18T12:06:00Z

Trilib:

Sometimes, TriLib might not load your model with the original colors or textures.

There are a few reasons this might happen:

If your model uses textures, they must be located in the same folder as the model or inside the model Zip file if you're loading your model from Zip files.

Depending on your exporting options, model textures can be embedded in the model itself. (glTF2 and FBX files accept this feature)

If your model doesn't use textures, make sure the resource files it uses are located in the same folder as the model or inside the model Zip file if you're loading your model from Zip files.

glTF2 files sometimes contain ".bin" resource files, and OBJ (Wavefront) files sometimes contain ".mtl" (material library) files.

Missing Materials (Pink color)

2024-05-18T12:04:38Z

Trilib:

Sometimes, TriLib may be unable to figure out the best Material Mapper for your rendering pipeline.

If you're getting pink (missing) materials when loading your model, please head to the '''"Edit->Project Settings->TriLib'''" area.

There, you can enable the right Material Mapper for the rendering pipeline your project is using:[[Arquivo:Image.png|miniaturadaimagem|TriLib Project Settings]]

Migrating from TriLib 1 to TriLib 2

2024-05-18T12:04:03Z

Trilib:

The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
==Loading a Model from a File==
When loading a model from a file in TriLib 1, the following snippets are used:

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.
var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
}
</pre>

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoaderAsync = new AssetLoaderAsync()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.

var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
var thread = assetLoaderAsync.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject, delegate(GameObject myGameObject) {
//Here you can get the reference to the loaded model using myGameObject.
}); //Loads the model asynchronously and returns the reference to the created Task/Thread.
}
</pre>

The first difference with TriLib 2 is that we don't have to specify whether we want to sync or async load our models. TriLib 2 will use async on platforms that support it and sync loading when there is no async support.

* On TriLib 2, we don't have to instantiate an <code>AssetLoader</code> or <code>AssetLoaderAsync</code> class. All loading is now done using the <code>AssetLoader</code> static class.
* TriLib 2 no longer returns a Game Object or a Thread. Instead, it will produce an <code>AssetLoaderContext</code> object containing the loaded Game Object as the <code>RootGameObject</code> field and much more information regarding the model loading.
* TriLib 2 also uses <code>AssetLoaderOptions</code>, but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the <code>AssetLoaderOptions</code> remains the same.

Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
AssetLoader.LoadModelFromFile("PATH TO MY FILE.FBX", null, delegate(AssetLoaderContext assetLoaderContext) {
var myGameObject = assetLoaderContext.RootGameObject;
}, null, null, null, null, assetLoaderOptions);
</pre>

==Loading a Model from a Custom Source==
TriLib 1 allows loading models from byte arrays using a callback to retrieve the custom data, a callback to check if such data exists, and a callback to return custom external textures data from any external resource the model uses:

<pre>
// TriLib 1 Code
// --------------------
var modelData = File.ReadAllBytes("PATH_TO_MY_FILE.OBJ");
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance();
var myGameObject = assetLoader.LoadFromMemory(modelData, "MY_FILE.OBJ", assetLoaderOptions, null, "PATH_TO",
delegate(string path, int fileId, ref int fileSize) { //External data reading callback
var resourceData = File.ReadAllBytes(path); //Reads all external file data
fileSize = resourceData.Length; //Retrieves the external file size
return resourceData; //Returns the external file data
},
delegate(string path, int fileId) { //External data checking callback
return File.Exists(path); //Returns true when the external file exists
},
delegate (string path, string basePath) { //External texture data reading callback
var finalPath = Path.Combine(basePath, path); //Combines the model base path with the texture path
if (File.Exists(finalPath)) { //Checks if there is a file on the combined path
return File.ReadAllBytes(finalPath); //Returns the file data
}
return null; //Returns null when the given file could not be found
},
delegate (float progress) { //Progress handling callback
Debug.Log("Loaded:" + progress); //Writes the model loading progress to the console
});
}
</pre>

TriLib 2 uses different approaches to load models from custom data sources:

* First, TriLib 2 works with <code>Stream</code> data reading.
* Second, any external resource the model uses has to be loaded using a class inheriting the <code>ExternalDataMapper</code> class.
* Third, any external texture the model uses has to be loaded using a class inheriting the <code>TextureMapper</code> class.

The example below loads a model from a custom Stream and handles its external resources with custom <code>ExternalDataMapper</code> and <code>TextureMapper</code> classes.<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
assetLoaderOptions.ExternalDataMapper = ScriptableObject.CreateInstance<ExternalDataMapperSample>();
assetLoaderOptions.TextureMapper = ScriptableObject.CreateInstance<TextureMapperSample>();
var modelPath = "PATH_TO_MY_MODEL.FBX";
AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
</pre>

Here are the Mappers used on the code above. One creates a <code>Steam</code> from external resource files, and the other creates a <code>TextureLoadingContext</code> from files:

<pre>
// TriLib 2 Code
// --------------------
public class ExternalDataMapperSample : ExternalDataMapper
{
public override Stream Map(AssetLoaderContext assetLoaderContext, string originalFilename, out string finalPath)
{
finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(originalFilename)}";
if (File.Exists(finalPath))
{
Debug.Log($"Found external file at: {finalPath}");
return File.OpenRead(finalPath);
}
throw new Exception($"File {originalFilename} not found.");
}
}
</pre>

<pre>
// TriLib 2 Code
// --------------------
public class TextureMapperSample : TextureMapper
{
public override TextureLoadingContext Map(AssetLoaderContext assetLoaderContext, ITexture texture)
{
var finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(texture.Filename)}";
if (File.Exists(finalPath))
{
var textureLoadingContext = new TextureLoadingContext
{
Context = assetLoaderContext,
Stream = File.OpenRead(finalPath),
Texture = texture
};
Debug.Log($"Found texture at: {finalPath}");
return textureLoadingContext;
}
throw new Exception($"Texture {texture.Filename} not found.");
}
}
</pre>

Avatar Importing

2024-05-18T11:57:49Z

Trilib:

[[Arquivo:Avatar Importing Banner.png|alt=]]

TriLib allows importing characters to use as Unity Avatars.

To achieve this, TriLib uses classes that inherit the <code>HumanoidAvatarMapper</code> class, which are responsible for mapping the character bones with Unity Avatar Humanoid Muscles.

TriLib comes with the Mixamo and Biped Humanoid Avatar Mapper, which contains the settings to load characters rigged in Mixamo or created using 3Ds Max Biped, among other standard bone hierarchies.

You can easily include your bone-mapping schemes by inheriting the <code>ByNameHumanoidAvatarMapper</code> class or simply creating an instance from the class in your Assets and manually adding name-mapping.

If you have a different bone-hierarchy and you don't want to build one Avatar Mapper programatically, you can use the Mixamo and Biped Avatar Mapper as a template.

Just click with the right mouse button in your "Project Explorer" inside Unity and select "'''Create->TriLib->Mappers->Humanoid-> Mixamo and Biped by Name Humanoid Avatar Mapper'''".

[[Arquivo:By Name Avatar Humanoid Avatar Mapper Editor.png|alt=]]

When creating the Avatar Mapper, you can set up the name matching by editing the generated Prefab:

1) This is the list of the bones name-matching.

2) The "Human Bone" dropdown lets you select the Unity Humanoid Bone to be mapped on the given item.

3) The "Bone Names" list lets you add multiple Transform names to be matched when TriLib is trying to find the right Transform for the given item.

You can then use the generated Prefab into your <code>AssetLoaderOptions.AvatarMapper</code> field.

Here is a sample with all bone names accepted by the Mixamo and Biped Humanoid Avatar Mapper:

[[Arquivo:Avatar Importing Bone Scheme.png|alt=]]

Notes:

* Your model must be in T-Pose or Star-Pose.
* Only FBX and GLTF file formats work as Avatars.

You can test your Avatars at:

https://ricardoreis.net/trilib/trilib2demo/avatarloader/

Basic Usage

2024-05-18T11:55:58Z

Trilib: /* URL Loading */

There are three main methods to load models and their dependencies in TriLib:

* Local File-System Loading
* URL Loading
* Custom Source Loading

The user can adapt other loading mechanisms as the core loading methods accept Streams as data input and Scriptable Objects called [https://ricardoreis.net/trilib/trilib2/docs/namespace_tri_lib_core_1_1_mappers.html Mappers], used to load Textures and external data from custom data Streams.

==Local File-System Loading==

=== Using File Picker ===
Loading models from the local file-system is simplified by using the StandaloneFileBrowser classes that come with TriLib.

Let's create an empty Unity project in this example and import the TriLib Unity package. Make sure you include the StandaloneFileBrowser folder when extracting.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Use the following code in your "TestLoader.cs" and hit the play button to test it:

<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from File"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Creates the AssetLoaderFilePicker instance.
// AssetLoaderFilePicker is a class that allows users to select models from the local file system.
var assetLoaderFilePicker = AssetLoaderFilePicker.Create();

// Shows the model selection file-picker.
assetLoaderFilePicker.LoadModelFromFilePickerAsync("Select a File", OnLoad, OnMaterialsLoad, OnProgress, OnBeginLoad, OnError, null, assetLoaderOptions);
}
}

// This event is called when the model is about to be loaded.
// You can use this event to do some loading preparation, like showing a loading screen in platforms without threading support.
// This event receives a Boolean indicating if any file has been selected on the file-picker dialog.
private void OnBeginLoad(bool anyModelSelected)
{

}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

=== Using the Model Filename ===
You can also load your Models, passing the Model Filename to the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader.html AssetLoader] methods.

Let's create an empty Unity project in this example and import the TriLib Unity package.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Use the following code in your "TestLoader.cs" and hit the play button to test it:
<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from File"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Loads the model from the "PATH_TO_MY_FILE.FBX" path
AssetLoader.LoadModelFromFile("PATH_TO_MY_FILE.FBX", OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
}
}

// This event is called when the model is about to be loaded.
// You can use this event to do some loading preparation, like showing a loading screen in platforms without threading support.
// This event receives a Boolean indicating if any file has been selected on the file-picker dialog.
private void OnBeginLoad(bool anyModelSelected)
{

}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

== URL Loading ==

You can use the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_downloader.html AssetDownloader] class to load models from URLs (network). The usage is relatively simple and similar to the local file-system loading.

Let's create an empty Unity project in this example and import the TriLib Unity package. Make sure you include the StandaloneFileBrowser folder when extracting.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Important: If you're downloading models from files that are not Zipped, you must pass the model extension as the last parameter from the <code>AssetDownloader.LoadModelFromUri</code> call (Eg: "fbx")

Use the following code in your "TestLoader.cs" and hit the play button to test it:

<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from URL"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Creates the web-request.
// The web-request contains information on how to download the model.
// Let's download a model from the TriLib website.
var webRequest = AssetDownloader.CreateWebRequest("https://ricardoreis.net/trilib/demos/avatars/003/003_visemes.zip");

// Important: If you're downloading models from files that are not Zipped, you must pass the model extension as the last parameter from this call (Eg: "fbx")
// Begins the model downloading.
AssetDownloader.LoadModelFromUri(webRequest, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions, null, null);
}
}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

File Format specific Options

2024-05-18T11:54:55Z

Trilib:

Some file formats TriLib accepts have unique options you can set with static reader properties:

== FBX ==
'''<code>TriLibCore.Fbx.Reader.FbxReader.PivotMode</code>:''' Change field to define how TriLib will handle FBX object pivots. The "legacy" (default) option don't use pivots.

'''<code>TriLibCore.Fbx.Reader.FbxReader.FBXConversionPrecision</code>:''' Floating point data on FBX files is stored as 16-bits (double) precision. You can define a multiplier on this static field applied to all FBX floating-point data when loading the model.

'''<code>TriLibCore.Fbx.Reader.FbxReader.ApplyAmbientColor</code>:''' Turn on this field to apply ambient color to Phong materials.

== GLTF ==
'''<code>TriLibCore.Gltf.Reader.GltfReader.DracoDecompressorCallback</code>:''' You can pass a custom callback to decompress Draco meshes using this static field. If you turn on Draco Decompression on the Project Settings->TriLib area, TriLib will automatically set this field value to use a built-in Draco decoder.

'''<code>TriLibCore.Gltf.Reader.GltfReader.SpotLightDistance</code>:''' glTF2 lights using KHR_lights_punctual don't have a configurable distance. Change this value to set the default punctual lights distance.

== STL ==
'''<code>TriLibCore.Stl.Reader.StlReader.FixInfacingNormals</code>:''' Some STL files may contain normals facing the opposite direction. If you turn on this static field, TriLib will re-align the model normals when loading.

'''<code>TriLibCore.Stl.Reader.StlReader.ImportNormals</code>:''' Turn on this field to enable STL normal importing.

'''<code>TriLibCore.Stl.Reader.StlReader.LoadWithYUp</code>:'''Turn on this field to load your model with the Z axis pointing up.

'''<code>TriLibCore.Stl.Reader.StlReader.StoreTriangleIndexInTexCoord0</code>:''' Turn off this field to stop storing the index of the triangle in the X component of the mesh texture coordinates.

== PLY ==
'''<code>TriLibCore.Ply.Reader.PlyReader.PlyConversionPrecision</code>:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

== OBJ ==
'''<code>TriLibCore.Obj.Reader.ObjReader.ParseNumbersAsDouble</code>:''' Turn on this field to parse OBJ file number data as doubles and improve precision.

'''<code>TriLibCore.Obj.Reader.ObjReader.ObjConversionPrecision</code>:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

'''<code>TriLibCore.Obj.Reader.ObjReader.ParseVertexColors</code>:''' Turn off this field to disable OBJ vertex color reading.

File Format specific Options

2024-05-18T11:53:50Z

Trilib:

Some file formats TriLib accepts have unique options you can set with static reader properties:

== FBX ==
'''TriLibCore.Fbx.Reader.FbxReader.PivotMode:''' Change field to define how TriLib will handle FBX object pivots. The "legacy" (default) option don't use pivots.

'''TriLibCore.Fbx.Reader.FbxReader.FBXConversionPrecision:''' Floating point data on FBX files is stored as 16-bits (double) precision. You can define a multiplier on this static field applied to all FBX floating-point data when loading the model.

'''TriLibCore.Fbx.Reader.FbxReader.ApplyAmbientColor: Tu'''rn on this field to apply ambient color to Phong materials.

== GLTF ==
'''TriLibCore.Gltf.Reader.GltfReader.DracoDecompressorCallback:''' You can pass a custom callback to decompress Draco meshes using this static field. If you turn on Draco Decompression on the Project Settings->TriLib area, TriLib will automatically set this field value to use a built-in Draco decoder.

'''TriLibCore.Gltf.Reader.GltfReader.SpotLightDistance:''' glTF2 lights using KHR_lights_punctual don't have a configurable distance. Change this value to set the default punctual lights distance.

== STL ==
'''TriLibCore.Stl.Reader.StlReader.FixInfacingNormals:''' Some STL files may contain normals facing the opposite direction. If you turn on this static field, TriLib will re-align the model normals when loading.

'''TriLibCore.Stl.Reader.StlReader.ImportNormals:''' Turn on this field to enable STL normal importing.

'''TriLibCore.Stl.Reader.StlReader.LoadWithYUp:'''Turn on this field to load your model with the Z axis pointing up.

'''TriLibCore.Stl.Reader.StlReader.StoreTriangleIndexInTexCoord0:''' Turn off this field to stop storing the index of the triangle in the X component of the mesh texture coordinates.

== PLY ==
'''TriLibCore.Ply.Reader.PlyReader.PlyConversionPrecision:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

== OBJ ==
'''TriLibCore.Obj.Reader.ObjReader.ParseNumbersAsDouble:''' Turn on this field to parse OBJ file number data as doubles and improve precision.

'''TriLibCore.Obj.Reader.ObjReader.ObjConversionPrecision:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

'''TriLibCore.Obj.Reader.ObjReader.ParseVertexColors:''' Turn off this field to disable OBJ vertex color reading.

File Format specific Options

2024-05-18T11:53:18Z

Trilib:

Some file formats TriLib accepts have unique options you can set with static reader properties:

== FBX ==
'''TriLibCore.Fbx.Reader.FbxReader.PivotMode:''' Change field to define how TriLib will handle FBX object pivots. The "legacy" (default) option don't use pivots.

'''TriLibCore.Fbx.Reader.FbxReader.FBXConversionPrecision:''' Floating point data on FBX files is stored as 16-bits (double) precision. You can define a multiplier on this static field applied to all FBX floating-point data when loading the model.

'''TriLibCore.Fbx.Reader.FbxReader.ApplyAmbientColor: Tu'''rn on this field to apply ambient color to Phong materials.

== GLTF ==
'''TriLibCore.Gltf.Reader.GltfReader.DracoDecompressorCallback:''' You can pass a custom callback to decompress Draco meshes using this static field. If you turn on Draco Decompression on the Project Settings->TriLib area, TriLib will automatically set this field value to use a built-in Draco decoder.

'''TriLibCore.Gltf.Reader.GltfReader.SpotLightDistance:''' glTF2 lights using KHR_lights_punctual don't have a configurable distance. Change this value to set the default punctual lights distance.

== STL ==
'''TriLibCore.Stl.Reader.StlReader.FixInfacingNormals:''' Some STL files may contain normals facing the opposite direction. If you turn on this static field, TriLib will re-align the model normals when loading.

'''TriLibCore.Stl.Reader.StlReader.ImportNormals:''' Turn on this field to enable STL normal importing.

'''TriLibCore.Stl.Reader.StlReader.LoadWithYUp:'''Turn on this field to load your model with the Z axis pointing up.

'''TriLibCore.Stl.Reader.StlReader.StoreTriangleIndexInTexCoord0:''' Turn off this field to stop storing the index of the triangle in the X component of the mesh texture coordinates.

== PLY ==
'''TriLibCore.Ply.Reader.PlyReader.PlyConversionPrecision:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

== OBJ ==
'''TriLibCore.Obj.Reader.ObjReader.ParseNumbersAsDouble:''' Turn on this field to parse OBJ file number data as doubles and improve precision.

'''TriLibCore.Obj.Reader.ObjReader.ObjConversionPrecision:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

'''TriLibCore.Obj.Reader.ObjReader.ParseVertexColors:''' Turn off this field to disable OBJ vertex color reading.

File Format specific Options

2024-05-18T11:52:14Z

Trilib: /* FBX */

Some file formats TriLib accepts have unique options you can set with static reader properties:

== FBX ==
'''TriLibCore.Fbx.Reader.FbxReader.PivotMode:''' Change field to define how TriLib will handle FBX object pivots. The "legacy" (default) option don't use pivots.

'''TriLibCore.Fbx.Reader.FbxReader.FBXConversionPrecision:''' Floating point data on FBX files is stored as 16-bits (double) precision. You can define a multiplier on this static field applied to all FBX floating-point data when loading the model.

'''TriLibCore.Fbx.Reader.FbxReader.ApplyAmbientColor: Tu'''rn on this field to apply ambient color to Phong materials.

== GLTF ==
'''TriLibCore.Gltf.Reader.GltfReader.DracoDecompressorCallback:''' You can pass a custom callback to decompress Draco meshes using this static field. If you turn on Draco Decompression on the Project Settings->TriLib area, TriLib will automatically set this field value to use a built-in Draco decoder.

'''TriLibCore.Gltf.Reader.GltfReader.SpotLightDistance:''' glTF2 lights using KHR_lights_punctual don't have a configurable distance. Change this value to set the default Spot Lights distance.

== STL ==
'''TriLibCore.Stl.Reader.StlReader.FixInfacingNormals:''' Some STL files may contain normals facing the opposite direction. If you turn on this static field, TriLib will re-align the model normals when loading.

'''TriLibCore.Stl.Reader.StlReader.ImportNormals:''' Turn on this field to enable STL normal importing.

'''TriLibCore.Stl.Reader.StlReader.LoadWithYUp:'''Turn on this field to load your model with the Z axis pointing up.

'''TriLibCore.Stl.Reader.StlReader.StoreTriangleIndexInTexCoord0:''' Turn off this field to stop storing the index of the triangle in the X component of the mesh texture coordinates.

== PLY ==
'''TriLibCore.Ply.Reader.PlyReader.PlyConversionPrecision:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

== OBJ ==
'''TriLibCore.Obj.Reader.ObjReader.ParseNumbersAsDouble:''' Turn on this field to parse OBJ file number data as doubles and improve precision.

'''TriLibCore.Obj.Reader.ObjReader.ObjConversionPrecision:''' Experimental: Any value passed here will be multiplied with any "double precision" data when converting them to floats.

'''TriLibCore.Obj.Reader.ObjReader.ParseVertexColors:''' Turn off this field to disable OBJ vertex color reading.

Main Page

2024-05-18T11:41:22Z

Trilib: /* Troubleshooting */

{{DISPLAYTITLE:Main page}}

==Getting started==
[[Basic Usage]]

[[Avatar Importing]]

[[Migrating from TriLib 1 to TriLib 2]]

[[Video Tutorials]]
==Troubleshooting==
[[Missing Materials (Pink color)]]

[[Missing Materials]]

[[Material Color Inconsistencies]]

[[Transparent Materials]]

[[Measurement Units]]

[[Scripted Importers Conflict]]

[[StandaloneFileBrowser can't be found]]

[[SharpZipLib conflicts]]

[[Loading models from URI]]

[[Error saving TLC files]]

[[Importing Humanoid Animations]]
==Info==
[[Supported File Formats‎]]

[[Known Issues/Limitations]]

[[File Format specific Options]]

[[How to track loaded resources]]

[[Running TriLib in Headless Mode]]
==API Docs==
https://ricardoreis.net/trilib/trilib2/docs/

Importing Humanoid Animations

2024-05-18T11:41:04Z

Trilib: Criou página com 'TriLib offers a versatile range of animation importing options, all of which can be easily configured using the "'''AssetLoaderOptions.AnimationType'''" field: * '''Legacy''': Using this animation importing type, TriLib will create Animation Clips for the loaded model (if it contains animations) and add an "Animation" component to the loaded Game Object. * '''Generic''': Using this animation importing type, TriLib does not create Animation Clips, but it does the followi...'

TriLib offers a versatile range of animation importing options, all of which can be easily configured using the "'''AssetLoaderOptions.AnimationType'''" field:

* '''Legacy''': Using this animation importing type, TriLib will create Animation Clips for the loaded model (if it contains animations) and add an "Animation" component to the loaded Game Object.
* '''Generic''': Using this animation importing type, TriLib does not create Animation Clips, but it does the following, depending on the "'''AssetLoaderOptionss.AvatarDefinition'''" value:
** '''CreateFromThisModel''': TriLib adds an "Animator" component to the loaded Game Object, creates a generic avatar for the loaded model, and uses it at the "Animator" component.
** '''CopyFromOtherAvatar''': TriLib adds an "Animator" component to the loaded Game Object and uses the avatar at "'''AssetLoaderOptions.Avatar'''" at the "Animator" component.
* '''Humanoid''': Using this animation importing type, TriLib does not create Animation Clips, but it does the following, depending on the "'''AssetLoaderOptionss.AvatarDefinition'''" value:
** '''CreateFromThisModel''': TriLib adds an "Animator" component to the loaded Game Object, creates a humanoid avatar for the loaded model using the Avatar Mapper set at the "'''AssetLoaderOptions.HumanoidAvatarMapper'''" field, and uses it at the "Animator" component.
** '''CopyFromOtherAvatar''': TriLib adds an "Animator" component to the loaded Game Object and uses the avatar at "'''AssetLoaderOptions.Avatar'''" at the "Animator" component.

TriLib cannot import generic or humanoid animations due to a Unity engine limitation. However, we are actively working on a side project that will soon enable humanoid animation importing.

Main Page

2024-05-18T10:25:19Z

Trilib:

{{DISPLAYTITLE:Main page}}

==Getting started==
[[Basic Usage]]

[[Avatar Importing]]

[[Migrating from TriLib 1 to TriLib 2]]

[[Video Tutorials]]
==Troubleshooting==
[[Missing Materials (Pink color)]]

[[Missing Materials]]

[[Material Color Inconsistencies]]

[[Transparent Materials]]

[[Measurement Units]]

[[Scripted Importers Conflict]]

[[StandaloneFileBrowser can't be found]]

[[SharpZipLib conflicts]]

[[Loading models from URI]]

[[Error saving TLC files]]
==Info==
[[Supported File Formats‎]]

[[Known Issues/Limitations]]

[[File Format specific Options]]

[[How to track loaded resources]]

[[Running TriLib in Headless Mode]]
==API Docs==
https://ricardoreis.net/trilib/trilib2/docs/

Error saving TLC files

2024-05-18T10:24:56Z

Trilib: Criou página com 'TriLib has a cache system that extracts FBX embedded files data to disk to save loading times. Sometimes, the platform you're targeting needs to give access to the temporary folder where the files are extracted. If you encounter a "System.UnauthorizedAccessException" error when loading a model with TriLib, you could try turning off this behavior by setting 'AssetLoaderOptions.ExtractEmbeddedData' to 'false'.'

TriLib has a cache system that extracts FBX embedded files data to disk to save loading times.

Sometimes, the platform you're targeting needs to give access to the temporary folder where the files are extracted.

If you encounter a "System.UnauthorizedAccessException" error when loading a model with TriLib, you could try turning off this behavior by setting 'AssetLoaderOptions.ExtractEmbeddedData' to 'false'.

How to track loaded resources

2024-05-06T13:40:51Z

Trilib:

On your "onMaterialsLoad" callback, you can use the following snippet to track the loaded resources, in case you need to copy/move them elsewhere:
<pre>
//ModelPath contains the loaded model path
var modelPath = assetLoaderContext.Filename;
if (!string.IsNullOrEmpty(modelPath))
{
//Do stuff
}

//Iterate the loaded textures list
foreach (var kvp in assetLoaderContext.LoadedTextures)
{
//FinalPath contains the loaded texture filename
string finalPath = kvp.Key.ResolvedFilename;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}

//Iterate the loaded resources list
foreach (var kvp in assetLoaderContext.LoadedExternalData)
{
//FinalPath contains the loaded resource filename
string finalPath = kvp.Value;
if (!string.IsNullOrEmpty(finalPath))
{
//Do stuff
}
}
</pre>

Known Issues/Limitations

2024-04-30T16:20:15Z

Trilib:

TriLib is not a model exporter.

The FBX importer does not import multiple texture layers yet.

Some FBX files may present incompatibilities.

3MF beam lattice format is not supported yet.

3MF PBR specular materials are not supported yet.

Blend-shape normals and tangents are not imported yet.

DAE (Collada) support is experimental. The full Collada support is in the works.

Known Issues/Limitations

2024-04-30T16:19:34Z

Trilib:

TriLib is not a Model exporter.

The FBX Importer does not import multiple texture layers yet.

Some FBX files may present incompatibilities.

3MF Beam Lattice format is not supported yet.

3MF PBR Specular materials are not supported yet.

Blend-shape normals and tangents are not imported yet.

DAE (Collada) support is experimental. The full Collada support is in the works.

Supported File Formats

2024-04-30T16:19:17Z

Trilib: /* Model file formats: */

TriLib 2.0 works with a smaller file-formats subset compared with the first version. This decision has been taken to focus on the most used file-formats and offer a more stable and feature-rich experience with these formats.
==Model file formats:==
FBX (Accepts version 7.0 onwards)

OBJ

GLTF 2 (Accepts Draco decompression using an experimental feature)

STL

PLY

3MF

ZIP

DAE (Collada) support is experimental. The full Collada support is in the works.
==Texture file formats:==
BMP

GIF

JPG

PNG

PSD

TGA

HDR (Used to load Skyboxes, not ready for common Texture usage)

Migrating from TriLib 1 to TriLib 2

2024-04-30T16:16:30Z

Trilib:

The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
==Loading a Model from a File==
When loading a model from a file in TriLib 1, the following snippets are used:

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.
var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
}
</pre>

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoaderAsync = new AssetLoaderAsync()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.

var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
var thread = assetLoaderAsync.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject, delegate(GameObject myGameObject) {
//Here you can get the reference to the loaded model using myGameObject.
}); //Loads the model asynchronously and returns the reference to the created Task/Thread.
}
</pre>

The first difference on TriLib 2 is that we don't have to specify if we want to sync or async load our models since TriLib 2 will use async on platforms that support it and fallback to sync loading when there is no support.

* On TriLib 2, we don't have to instantiate an AssetLoader or AssetLoaderAsync class. All loading is done using the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader.html AssetLoader] static class now.
* TriLib 2 no longer returns a GameObject or a Thread when loading a model. Instead, it will produce an [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_context.html AssetLoaderContext] object containing the loaded GameObject as the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_context.html#a2dd4cc3184e8ef2787f20d31dcad7c67 RootGameObject] field and much more information regarding the model loading.
* TriLib 2 also uses [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_options.html AssetLoaderOptions], but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_options.html AssetLoaderOptions] remains the same.

Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:

<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
AssetLoader.LoadModelFromFile("PATH TO MY FILE.FBX", null, delegate(AssetLoaderContext assetLoaderContext) {
var myGameObject = assetLoaderContext.RootGameObject;
}, null, null, null, null, assetLoaderOptions);
</pre>

==Loading a Model from a Custom Source==
TriLib 1 allows loading models from byte arrays using a callback to retrieve the custom data, a callback to check if such data exists, and a callback to return custom external textures data from any external resource the model uses:

<pre>
// TriLib 1 Code
// --------------------
var modelData = File.ReadAllBytes("PATH_TO_MY_FILE.OBJ");
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance();
var myGameObject = assetLoader.LoadFromMemory(modelData, "MY_FILE.OBJ", assetLoaderOptions, null, "PATH_TO",
delegate(string path, int fileId, ref int fileSize) { //External data reading callback
var resourceData = File.ReadAllBytes(path); //Reads all external file data
fileSize = resourceData.Length; //Retrieves the external file size
return resourceData; //Returns the external file data
},
delegate(string path, int fileId) { //External data checking callback
return File.Exists(path); //Returns true when the external file exists
},
delegate (string path, string basePath) { //External texture data reading callback
var finalPath = Path.Combine(basePath, path); //Combines the model base path with the texture path
if (File.Exists(finalPath)) { //Checks if there is a file on the combined path
return File.ReadAllBytes(finalPath); //Returns the file data
}
return null; //Returns null when the given file could not be found
},
delegate (float progress) { //Progress handling callback
Debug.Log("Loaded:" + progress); //Writes the model loading progress to the console
});
}
</pre>

TriLib 2 uses different approaches to load models from custom data sources:

* First, it doesn't work with byte arrays, specifically anymore. TriLib 2 works with Stream data reading.
* Second, any external resource the model uses has to be loaded using a class inheriting the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_external_data_mapper.html ExternalDataMapper] class.
* Third, any external texture the model uses has to be loaded using a class inheriting the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_texture_mapper.html TextureMapper] class.

The example below loads a model from a custom Stream and handles its external resources with custom [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_external_data_mapper.html ExternalDataMapper] and [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_texture_mapper.html TextureMapper] classes.

<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
assetLoaderOptions.ExternalDataMapper = ScriptableObject.CreateInstance<ExternalDataMapperSample>();
assetLoaderOptions.TextureMapper = ScriptableObject.CreateInstance<TextureMapperSample>();
var modelPath = "PATH_TO_MY_MODEL.FBX";
AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
</pre>

Here are the [https://ricardoreis.net/trilib/trilib2/docs/namespace_tri_lib_core_1_1_mappers.html Mappers] used on the code above. One creates Steams from external resource files and the other creates [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_texture_loading_context.html TextureLoadingContexts] from files:

<pre>
// TriLib 2 Code
// --------------------
public class ExternalDataMapperSample : ExternalDataMapper
{
public override Stream Map(AssetLoaderContext assetLoaderContext, string originalFilename, out string finalPath)
{
finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(originalFilename)}";
if (File.Exists(finalPath))
{
Debug.Log($"Found external file at: {finalPath}");
return File.OpenRead(finalPath);
}
throw new Exception($"File {originalFilename} not found.");
}
}
</pre>

<pre>
// TriLib 2 Code
// --------------------
public class TextureMapperSample : TextureMapper
{
public override TextureLoadingContext Map(AssetLoaderContext assetLoaderContext, ITexture texture)
{
var finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(texture.Filename)}";
if (File.Exists(finalPath))
{
var textureLoadingContext = new TextureLoadingContext
{
Context = assetLoaderContext,
Stream = File.OpenRead(finalPath),
Texture = texture
};
Debug.Log($"Found texture at: {finalPath}");
return textureLoadingContext;
}
throw new Exception($"Texture {texture.Filename} not found.");
}
}
</pre>

Migrating from TriLib 1 to TriLib 2

2024-04-30T16:14:58Z

Trilib:

The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
==Loading a Model from a File==
When loading a model from a file in TriLib 1, the following snippets are used:

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.
//AssetLoaderOptions let you specify options to load your model.
//(Optional) You can skip this object creation and it's parameter or pass null.

//You can modify assetLoaderOptions before passing it to LoadFromFile method. You can check the AssetLoaderOptions API reference at:
//https://ricardoreis.net/trilib/manual/html/class_tri_lib_1_1_asset_loader_options.html

var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
//(Optional) You can skip this object creation and it's parameter or pass null.

var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
}
</pre>

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoaderAsync = new AssetLoaderAsync()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.
//AssetLoaderOptions let you specify options to load your model.
//(Optional) You can skip this object creation and it's parameter or pass null.

//You can modify assetLoaderOptions before passing it to LoadFromFile method. You can check the AssetLoaderOptions API reference at:
//https://ricardoreis.net/trilib/manual/html/class_tri_lib_1_1_asset_loader_options.html

var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
//(Optional) You can skip this object creation and it's parameter or pass null.

var thread = assetLoaderAsync.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject, delegate(GameObject myGameObject) {
//Here you can get the reference to the loaded model using myGameObject.
}); //Loads the model asynchronously and returns the reference to the created Task/Thread.
}
</pre>

The first difference on TriLib 2 is that we don't have to specify if we want to sync or async load our models since TriLib 2 will use async on platforms that support it and fallback to sync loading when there is no support.

* On TriLib 2, we don't have to instantiate an AssetLoader or AssetLoaderAsync class. All loading is done using the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader.html AssetLoader] static class now.
* TriLib 2 no longer returns a GameObject or a Thread when loading a model. Instead, it will produce an [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_context.html AssetLoaderContext] object containing the loaded GameObject as the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_context.html#a2dd4cc3184e8ef2787f20d31dcad7c67 RootGameObject] field and much more information regarding the model loading.
* TriLib 2 also uses [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_options.html AssetLoaderOptions], but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_options.html AssetLoaderOptions] remains the same.

Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:

<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
AssetLoader.LoadModelFromFile("PATH TO MY FILE.FBX", null, delegate(AssetLoaderContext assetLoaderContext) {
var myGameObject = assetLoaderContext.RootGameObject;
}, null, null, null, null, assetLoaderOptions);
</pre>

==Loading a Model from a Custom Source==
TriLib 1 allows loading models from byte arrays using a callback to retrieve the custom data, a callback to check if such data exists, and a callback to return custom external textures data from any external resource the model uses:

<pre>
// TriLib 1 Code
// --------------------
var modelData = File.ReadAllBytes("PATH_TO_MY_FILE.OBJ");
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance();
var myGameObject = assetLoader.LoadFromMemory(modelData, "MY_FILE.OBJ", assetLoaderOptions, null, "PATH_TO",
delegate(string path, int fileId, ref int fileSize) { //External data reading callback
var resourceData = File.ReadAllBytes(path); //Reads all external file data
fileSize = resourceData.Length; //Retrieves the external file size
return resourceData; //Returns the external file data
},
delegate(string path, int fileId) { //External data checking callback
return File.Exists(path); //Returns true when the external file exists
},
delegate (string path, string basePath) { //External texture data reading callback
var finalPath = Path.Combine(basePath, path); //Combines the model base path with the texture path
if (File.Exists(finalPath)) { //Checks if there is a file on the combined path
return File.ReadAllBytes(finalPath); //Returns the file data
}
return null; //Returns null when the given file could not be found
},
delegate (float progress) { //Progress handling callback
Debug.Log("Loaded:" + progress); //Writes the model loading progress to the console
});
}
</pre>

TriLib 2 uses different approaches to load models from custom data sources:

* First, it doesn't work with byte arrays, specifically anymore. TriLib 2 works with Stream data reading.
* Second, any external resource the model uses has to be loaded using a class inheriting the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_external_data_mapper.html ExternalDataMapper] class.
* Third, any external texture the model uses has to be loaded using a class inheriting the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_texture_mapper.html TextureMapper] class.

The example below loads a model from a custom Stream and handles its external resources with custom [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_external_data_mapper.html ExternalDataMapper] and [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_texture_mapper.html TextureMapper] classes.

<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
assetLoaderOptions.ExternalDataMapper = ScriptableObject.CreateInstance<ExternalDataMapperSample>();
assetLoaderOptions.TextureMapper = ScriptableObject.CreateInstance<TextureMapperSample>();
var modelPath = "PATH_TO_MY_MODEL.FBX";
AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
</pre>

Here are the [https://ricardoreis.net/trilib/trilib2/docs/namespace_tri_lib_core_1_1_mappers.html Mappers] used on the code above. One creates Steams from external resource files and the other creates [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_texture_loading_context.html TextureLoadingContexts] from files:

<pre>
// TriLib 2 Code
// --------------------
public class ExternalDataMapperSample : ExternalDataMapper
{
public override Stream Map(AssetLoaderContext assetLoaderContext, string originalFilename, out string finalPath)
{
finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(originalFilename)}";
if (File.Exists(finalPath))
{
Debug.Log($"Found external file at: {finalPath}");
return File.OpenRead(finalPath);
}
throw new Exception($"File {originalFilename} not found.");
}
}
</pre>

<pre>
// TriLib 2 Code
// --------------------
public class TextureMapperSample : TextureMapper
{
public override TextureLoadingContext Map(AssetLoaderContext assetLoaderContext, ITexture texture)
{
var finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(texture.Filename)}";
if (File.Exists(finalPath))
{
var textureLoadingContext = new TextureLoadingContext
{
Context = assetLoaderContext,
Stream = File.OpenRead(finalPath),
Texture = texture
};
Debug.Log($"Found texture at: {finalPath}");
return textureLoadingContext;
}
throw new Exception($"Texture {texture.Filename} not found.");
}
}
</pre>

Migrating from TriLib 1 to TriLib 2

2024-04-30T16:14:30Z

Trilib:

The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
==Loading a Model from a File==
When loading a model from a file in TriLib 1, the following snippets are used:

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.
//AssetLoaderOptions let you specify options to load your model.
//(Optional) You can skip this object creation and it's parameter or pass null.

//You can modify assetLoaderOptions before passing it to LoadFromFile method. You can check the AssetLoaderOptions API reference at:
//https://ricardoreis.net/trilib/manual/html/class_tri_lib_1_1_asset_loader_options.html

var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
//(Optional) You can skip this object creation and it's parameter or pass null.

var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
}
</pre>

<pre>
// TriLib 1 Code
// --------------------
using (var assetLoaderAsync = new AssetLoaderAsync()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.
//AssetLoaderOptions let you specify options to load your model.
//(Optional) You can skip this object creation and it's parameter or pass null.

//You can modify assetLoaderOptions before passing it to LoadFromFile method. You can check the AssetLoaderOptions API reference at:
//https://ricardoreis.net/trilib/manual/html/class_tri_lib_1_1_asset_loader_options.html

var wrapperGameObject = gameObject; //Sets the game object where your model will be loaded into.
//(Optional) You can skip this object creation and it's parameter or pass null.

var thread = assetLoaderAsync.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject, delegate(GameObject myGameObject) {
//Here you can get the reference to the loaded model using myGameObject.
}); //Loads the model asynchronously and returns the reference to the created Task/Thread.
}
</pre>

The first difference on TriLib 2 is that we don't have to specify if we want to sync or async load our models since TriLib 2 will use async on platforms that support it and fallback to sync loading when there is no support.

* On TriLib 2, we don't have to instantiate an AssetLoader or AssetLoaderAsync class. All loading is done using the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader.html AssetLoader] static class now.
* TriLib 2 no longer returns a GameObject or a Thread when loading a model. Instead, it will produce an [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_context.html AssetLoaderContext] object containing the loaded GameObject as the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_context.html#a2dd4cc3184e8ef2787f20d31dcad7c67 RootGameObject] field and much more information regarding the model loading.
* TriLib 2 also uses [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_options.html AssetLoaderOptions], but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader_options.html AssetLoaderOptions] remains the same.

Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:

<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
AssetLoader.LoadModelFromFile("PATH TO MY FILE.FBX", null, delegate(AssetLoaderContext assetLoaderContext) {
var myGameObject = assetLoaderContext.RootGameObject;
}, null, null, null, null, assetLoaderOptions);
</pre>

==Loading a Model from a Custom Source==
TriLib 1 allows loading models from byte arrays using a callback to retrieve the custom data, a callback to check if such data exists, and a callback to return custom external textures data from any external resource the model uses:

<pre>
// TriLib 1 Code
// --------------------
var modelData = File.ReadAllBytes("PATH_TO_MY_FILE.OBJ");
using (var assetLoader = new AssetLoader()) {
var assetLoaderOptions = AssetLoaderOptions.CreateInstance();
var myGameObject = assetLoader.LoadFromMemory(modelData, "MY_FILE.OBJ", assetLoaderOptions, null, "PATH_TO",
delegate(string path, int fileId, ref int fileSize) { //External data reading callback
var resourceData = File.ReadAllBytes(path); //Reads all external file data
fileSize = resourceData.Length; //Retrieves the external file size
return resourceData; //Returns the external file data
},
delegate(string path, int fileId) { //External data checking callback
return File.Exists(path); //Returns true when the external file exists
},
delegate (string path, string basePath) { //External texture data reading callback
var finalPath = Path.Combine(basePath, path); //Combines the model base path with the texture path
if (File.Exists(finalPath)) { //Checks if there is a file on the combined path
return File.ReadAllBytes(finalPath); //Returns the file data
}
return null; //Returns null when the given file could not be found
},
delegate (float progress) { //Progress handling callback
Debug.Log("Loaded:" + progress); //Writes the model loading progress to the console
});
}
</pre>

TriLib 2 uses different approaches to load models from custom data sources:

* First, it doesn't work with byte arrays, specifically anymore. TriLib 2 works with Stream data reading.
* Second, any external resource the model uses has to be loaded using a class inheriting the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_external_data_mapper.html ExternalDataMapper] class.
* Third, any external texture the model uses has to be loaded using a class inheriting the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_texture_mapper.html TextureMapper] class.

The example below loads a model from a custom Stream and handles its external resources with custom [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_external_data_mapper.html ExternalDataMapper] and [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_texture_mapper.html TextureMapper] classes.

<pre>
// TriLib 2 Code
// --------------------
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();
assetLoaderOptions.ExternalDataMapper = ScriptableObject.CreateInstance<ExternalDataMapperSample>();
assetLoaderOptions.TextureMapper = ScriptableObject.CreateInstance<TextureMapperSample>();
var modelPath = "PATH_TO_MY_MODEL.FBX";
AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
</source>

Here are the [https://ricardoreis.net/trilib/trilib2/docs/namespace_tri_lib_core_1_1_mappers.html Mappers] used on the code above. One creates Steams from external resource files and the other creates [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_texture_loading_context.html TextureLoadingContexts] from files:

<source lang="csharp">
// TriLib 2 Code
// --------------------
public class ExternalDataMapperSample : ExternalDataMapper
{
public override Stream Map(AssetLoaderContext assetLoaderContext, string originalFilename, out string finalPath)
{
finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(originalFilename)}";
if (File.Exists(finalPath))
{
Debug.Log($"Found external file at: {finalPath}");
return File.OpenRead(finalPath);
}
throw new Exception($"File {originalFilename} not found.");
}
}
</pre>

<pre>
// TriLib 2 Code
// --------------------
public class TextureMapperSample : TextureMapper
{
public override TextureLoadingContext Map(AssetLoaderContext assetLoaderContext, ITexture texture)
{
var finalPath = $"{assetLoaderContext.BasePath}/{FileUtils.GetFilename(texture.Filename)}";
if (File.Exists(finalPath))
{
var textureLoadingContext = new TextureLoadingContext
{
Context = assetLoaderContext,
Stream = File.OpenRead(finalPath),
Texture = texture
};
Debug.Log($"Found texture at: {finalPath}");
return textureLoadingContext;
}
throw new Exception($"Texture {texture.Filename} not found.");
}
}
</pre>

Basic Usage

2024-04-30T16:11:57Z

Trilib:

There are three main methods to load models and their dependencies in TriLib:

* Local File-System Loading
* URL Loading
* Custom Source Loading

The user can adapt other loading mechanisms as the core loading methods accept Streams as data input and Scriptable Objects called [https://ricardoreis.net/trilib/trilib2/docs/namespace_tri_lib_core_1_1_mappers.html Mappers], used to load Textures and external data from custom data Streams.

==Local File-System Loading==

=== Using File Picker ===
Loading models from the local file-system is simplified by using the StandaloneFileBrowser classes that come with TriLib.

Let's create an empty Unity project in this example and import the TriLib Unity package. Make sure you include the StandaloneFileBrowser folder when extracting.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Use the following code in your "TestLoader.cs" and hit the play button to test it:

<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from File"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Creates the AssetLoaderFilePicker instance.
// AssetLoaderFilePicker is a class that allows users to select models from the local file system.
var assetLoaderFilePicker = AssetLoaderFilePicker.Create();

// Shows the model selection file-picker.
assetLoaderFilePicker.LoadModelFromFilePickerAsync("Select a File", OnLoad, OnMaterialsLoad, OnProgress, OnBeginLoad, OnError, null, assetLoaderOptions);
}
}

// This event is called when the model is about to be loaded.
// You can use this event to do some loading preparation, like showing a loading screen in platforms without threading support.
// This event receives a Boolean indicating if any file has been selected on the file-picker dialog.
private void OnBeginLoad(bool anyModelSelected)
{

}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

=== Using the Model Filename ===
You can also load your Models, passing the Model Filename to the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_loader.html AssetLoader] methods.

Let's create an empty Unity project in this example and import the TriLib Unity package.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Use the following code in your "TestLoader.cs" and hit the play button to test it:
<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from File"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Loads the model from the "PATH_TO_MY_FILE.FBX" path
AssetLoader.LoadModelFromFile("PATH_TO_MY_FILE.FBX", OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
}
}

// This event is called when the model is about to be loaded.
// You can use this event to do some loading preparation, like showing a loading screen in platforms without threading support.
// This event receives a Boolean indicating if any file has been selected on the file-picker dialog.
private void OnBeginLoad(bool anyModelSelected)
{

}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

== URL Loading ==

You can use the [https://ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_asset_downloader.html AssetDownloader] class to load models from URLs (network). The usage is relatively simple and similar to the local file-system loading.

Let's create an empty Unity project in this example and import the TriLib Unity package. Make sure you include the StandaloneFileBrowser folder when extracting.

Create a new Script. You can call it "TestLoader.cs" then assign this script to the "Main Camera" on your scene.

Important: If you're downloading models from files that are not Zipped, you must pass the model extension as the last parameter from the "AssetDownloader.LoadModelFromUri" call (Eg: "fbx")

Use the following code in your "TestLoader.cs" and hit the play button to test it:

<pre>
using TriLibCore;
using TriLibCore.General;
using UnityEngine;

public class TestLoader : MonoBehaviour
{
// Lets the user load a new model by clicking a GUI button.
private void OnGUI()
{
// Displays a button to begin the model loading process.
if (GUILayout.Button("Load Model from URL"))
{
// Creates an AssetLoaderOptions instance.
// AssetLoaderOptions is a class used to configure many aspects of the loading process.
// We won't change the default settings this time, so we can use the instance as it is.
var assetLoaderOptions = AssetLoader.CreateDefaultLoaderOptions();

// Creates the web-request.
// The web-request contains information on how to download the model.
// Let's download a model from the TriLib website.
var webRequest = AssetDownloader.CreateWebRequest("https://ricardoreis.net/trilib/demos/avatars/003/003_visemes.zip");

// Important: If you're downloading models from files that are not Zipped, you must pass the model extension as the last parameter from this call (Eg: "fbx")
// Begins the model downloading.
AssetDownloader.LoadModelFromUri(webRequest, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions, null, null);
}
}

// This event is called when the model loading progress changes.
// You can use this event to update a loading progress-bar, for instance.
// The "progress" value comes as a normalized float (goes from 0 to 1).
// Platforms like UWP and WebGL don't call this method at this moment, since they don't use threads.
private void OnProgress(AssetLoaderContext assetLoaderContext, float progress)
{

}

// This event is called when there is any critical error loading your model.
// You can use this to show a message to the user.
private void OnError(IContextualizedError contextualizedError)
{

}

// This event is called when all model GameObjects and Meshes have been loaded.
// There may still Materials and Textures processing at this stage.
private void OnLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// If you want to make sure the GameObject will be visible only when all Materials and Textures have been loaded, you can disable it at this step.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(false);
}

// This event is called after OnLoad when all Materials and Textures have been loaded.
// This event is also called after a critical loading error, so you can clean up any resource you want to.
private void OnMaterialsLoad(AssetLoaderContext assetLoaderContext)
{
// The root loaded GameObject is assigned to the "assetLoaderContext.RootGameObject" field.
// You can make the GameObject visible again at this step if you prefer to.
var myLoadedGameObject = assetLoaderContext.RootGameObject;
myLoadedGameObject.SetActive(true);
}
}
</pre>

Known Issues/Limitations

2024-04-30T16:06:14Z

Trilib:

Main Page

2023-01-05T09:13:55Z

Trilib: /* Troubleshooting */

{{DISPLAYTITLE:Main page}}

==Getting started==
[[Basic Usage]]

[[Avatar Importing]]

[[Migrating from TriLib 1 to TriLib 2]]

[[Video Tutorials]]
==Troubleshooting==
[[Missing Materials (Pink color)]]

[[Missing Materials]]

[[Material Color Inconsistencies]]

[[Transparent Materials]]

[[Measurement Units]]

[[Scripted Importers Conflict]]

[[StandaloneFileBrowser can't be found]]

[[SharpZipLib conflicts]]

[[Loading models from URI]]
==Info==
[[Supported File Formats‎]]

[[Known Issues/Limitations]]

[[File Format specific Options]]

[[How to track loaded resources]]

[[Running TriLib in Headless Mode]]
==API Docs==
https://ricardoreis.net/trilib/trilib2/docs/

Loading models from URI

2023-01-05T09:13:36Z

Trilib: Criou página com 'A recurrent issue when loading models from URI is caused by a Cross-Origin Resource Sharing restrictions, resulting in the error message: "TriLib is unable to load the given f...'

A recurrent issue when loading models from URI is caused by a Cross-Origin Resource Sharing restrictions, resulting in the error message: "TriLib is unable to load the given file".

Web-servers can use these restrictions, for instance, to avoid unauthorized websites from making requests to the server.

This issue will generally not happen when loading models using TriLib from a desktop, or a mobile application.

To get more information on Cross-Origin Resource Sharing, please refer to:

https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS

Main Page

2022-11-23T20:51:09Z

Trilib: /* Troubleshooting */

{{DISPLAYTITLE:Main page}}

==Getting started==
[[Basic Usage]]

[[Avatar Importing]]

[[Migrating from TriLib 1 to TriLib 2]]

[[Video Tutorials]]
==Troubleshooting==
[[Missing Materials (Pink color)]]

[[Missing Materials]]

[[Material Color Inconsistencies]]

[[Transparent Materials]]

[[Measurement Units]]

[[Scripted Importers Conflict]]

[[StandaloneFileBrowser can't be found]]

[[SharpZipLib conflicts]]
==Info==
[[Supported File Formats‎]]

[[Known Issues/Limitations]]

[[File Format specific Options]]

[[How to track loaded resources]]

[[Running TriLib in Headless Mode]]
==API Docs==
https://ricardoreis.net/trilib/trilib2/docs/

Material Color Changes

2022-11-23T20:50:48Z

Trilib: Trilib moveu Material Color Changes para Material Color Inconsistencies

#REDIRECIONAMENTO [[Material Color Inconsistencies]]

Material Color Inconsistencies

2022-11-23T20:50:48Z

Trilib: Trilib moveu Material Color Changes para Material Color Inconsistencies

Sometimes when loading model materials, the color might differ from what other viewers are showing.

By default, TriLib will convert material color values and texture colors to the gamma (sRGB) representation.

If you don't want this to happen, you can disable these behaviors by disabling your '''AssetLoaderOptions'''<nowiki/>'s "'''ApplyGammaCurveToMaterialColors'''" and "'''LoadTexturesAsSRGB'''" fields.

Another reason for colors to differ happens when TriLib does not applies ambient color to FBX materials.

You can enable the "'''FBXReader.ApplyAmbientColo'''r" static field, so TriLib will apply ambient color to FBX materials.

Main Page

2022-11-23T20:27:38Z

Trilib: /* Troubleshooting */

{{DISPLAYTITLE:Main page}}

==Getting started==
[[Basic Usage]]

[[Avatar Importing]]

[[Migrating from TriLib 1 to TriLib 2]]

[[Video Tutorials]]
==Troubleshooting==
[[Missing Materials (Pink color)]]

[[Missing Materials]]

[[Material Color Changes]]

[[Transparent Materials]]

[[Measurement Units]]

[[Scripted Importers Conflict]]

[[StandaloneFileBrowser can't be found]]

[[SharpZipLib conflicts]]
==Info==
[[Supported File Formats‎]]

[[Known Issues/Limitations]]

[[File Format specific Options]]

[[How to track loaded resources]]

[[Running TriLib in Headless Mode]]
==API Docs==
https://ricardoreis.net/trilib/trilib2/docs/

Missing Materials

2022-11-23T20:27:22Z

Trilib: Criou página com 'Sometimes your model may not be loaded with the original colors or textures. There are a few reasons this might happen: -If your model uses textures, these textures must be...'

Sometimes your model may not be loaded with the original colors or textures.

There are a few reasons this might happen:

-If your model uses textures, these textures must be located at the same folder as the model, or inside the model Zip file in case you're loading your model from Zip files.

Model textures can be embedded in the model itself depending on your exporting options. glTF2 and FBX files accepts this feature.

-If your model doesn't use textures, make sure the resource files your model uses are located at the same folder as the model, or inside the model Zip file in case you're loading your model from Zip files.

glTF2 files sometimes comes with ".bin" resource files, and OBJ (Wavefront) files sometimes comes with ".mtl" (material library) files.

Main Page

2022-11-23T17:41:13Z

Trilib: /* Troubleshooting */

{{DISPLAYTITLE:Main page}}

==Getting started==
[[Basic Usage]]

[[Avatar Importing]]

[[Migrating from TriLib 1 to TriLib 2]]

[[Video Tutorials]]
==Troubleshooting==
[[Missing Materials (Pink color)]]

[[Material Color Changes]]

[[Transparent Materials]]

[[Measurement Units]]

[[Scripted Importers Conflict]]

[[StandaloneFileBrowser can't be found]]

[[SharpZipLib conflicts]]
==Info==
[[Supported File Formats‎]]

[[Known Issues/Limitations]]

[[File Format specific Options]]

[[How to track loaded resources]]

[[Running TriLib in Headless Mode]]
==API Docs==
https://ricardoreis.net/trilib/trilib2/docs/