Migrating from TriLib 1 to TriLib 2 - Histórico de revisão

Trilib em 12h04min de 18 de maio de 2024

2024-05-18T12:04:03Z

← Edição anterior		Edição das 09h04min de 18 de maio de 2024
Linha 26:		Linha 26:
	</pre>		</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.		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 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~~.		* 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 ~~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 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 ~~[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.		* 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:		Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:<pre>

	<pre>
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 76:		Linha 74:
	TriLib 2 uses different approaches to load models from custom data sources:		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.		* 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 ~~[https://ricardoreis.net/trilib/trilib2/docs~~/~~class_tri_lib_core_1_1_mappers_1_1_external_data_mapper.html ExternalDataMapper]~~ class.		* 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 ~~[https:/~~/~~ricardoreis.net/trilib/trilib2/docs/class_tri_lib_core_1_1_mappers_1_1_texture_mapper.html TextureMapper]~~ 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>
	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		// TriLib 2 Code
	// --------------------		// --------------------
Linha 93:		Linha 88:
	</pre>		</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:		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>		<pre>

Trilib em 16h16min de 30 de abril de 2024

2024-04-30T16:16:30Z

← Edição anterior		Edição das 13h16min de 30 de abril de 2024
Linha 7:		Linha 7:
	// --------------------		// --------------------
	using (var assetLoader = new AssetLoader()) {		using (var assetLoader = new AssetLoader()) {
	var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.		var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.
	~~//AssetLoaderOptions let you specify options to load your model.~~		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.~~

	~~//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.		var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
	}		}
Linha 26:		Linha 18:
	using (var assetLoaderAsync = new AssetLoaderAsync()) {		using (var assetLoaderAsync = new AssetLoaderAsync()) {
	var assetLoaderOptions = AssetLoaderOptions.CreateInstance(); //Creates the AssetLoaderOptions instance.		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.		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) {		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.		//Here you can get the reference to the loaded model using myGameObject.

Trilib em 16h14min de 30 de abril de 2024

2024-04-30T16:14:58Z

← Edição anterior		Edição das 13h14min de 30 de abril de 2024
Linha 106:		Linha 106:
	var modelPath = "PATH_TO_MY_MODEL.FBX";		var modelPath = "PATH_TO_MY_MODEL.FBX";
	AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);		AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
	</~~source~~>		</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:		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"~~>		<pre>
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------

Trilib em 16h14min de 30 de abril de 2024

2024-04-30T16:14:30Z

← Edição anterior		Edição das 13h14min de 30 de abril de 2024
Linha 3:		Linha 3:
	When loading a model from a file in TriLib 1, the following snippets are used:		When loading a model from a file in TriLib 1, the following snippets are used:

	<~~source lang="csharp"~~>		<pre>
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 19:		Linha 19:
	var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.		var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
	}		}
	</~~source~~>		</pre>

	<~~source lang="csharp"~~>		<pre>
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 39:		Linha 39:
	}); //Loads the model asynchronously and returns the reference to the created Task/Thread.		}); //Loads the model asynchronously and returns the reference to the created Task/Thread.
	}		}
	</~~source~~>		</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.		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.
Linha 49:		Linha 49:
	Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:		Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:

	<~~source lang="csharp"~~>		<pre>
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 56:		Linha 56:
	var myGameObject = assetLoaderContext.RootGameObject;		var myGameObject = assetLoaderContext.RootGameObject;
	}, null, null, null, null, assetLoaderOptions);		}, null, null, null, null, assetLoaderOptions);
	</~~source~~>		</pre>

	==Loading a Model from a Custom Source==		==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:		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:

	<~~source lang="csharp"~~>		<pre>
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 87:		Linha 87:
	});		});
	}		}
	</~~source~~>		</pre>

	TriLib 2 uses different approaches to load models from custom data sources:		TriLib 2 uses different approaches to load models from custom data sources:
Linha 98:		Linha 98:
	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.		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.

	<~~source lang="csharp"~~>		<pre>
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 126:		Linha 126:
	}		}
	}		}
	</~~source~~>		</pre>

	<~~source lang="csharp"~~>		<pre>
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 150:		Linha 150:
	}		}
	}		}
	</~~source~~>		</pre>

Trilib em 19h56min de 13 de julho de 2021

2021-07-13T19:56:08Z

← Edição anterior		Edição das 16h56min de 13 de julho de 2021
Linha 49:		Linha 49:
	Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:		Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:

	<source lang="c#">		<source lang="csharp">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 98:		Linha 98:
	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.		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.

	<source lang="c#">		<source lang="csharp">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 110:		Linha 110:
	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:		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="c#">		<source lang="csharp">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 128:		Linha 128:
	</source>		</source>

	<source lang="c#">		<source lang="csharp">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------

Trilib em 17h45min de 28 de fevereiro de 2021

2021-02-28T17:45:56Z

← Edição anterior		Edição das 14h45min de 28 de fevereiro de 2021
Linha 43:		Linha 43:
	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.		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 AssetLoader static class now.		* 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 no longer returns a GameObject or a Thread when loading a model. Instead, it will produce an AssetLoaderContext object containing the loaded GameObject as the 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.

	TriLib 2 also uses AssetLoaderOptions, but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the AssetLoaderOptions remains the same.

	Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:		Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:
Linha 91:		Linha 89:
	</source>		</source>

	TriLib 2 uses different approaches to load models from custom data sources.		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.

	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 ExternalDataMapper class. Third, any external texture the model uses has to be loaded using a class inheriting the TextureMapper class.

	The example below loads a model from a custom Stream and handles its external resources with custom ExternalDataMapper and TextureMapper classes.		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.

	<source lang="c#">		<source lang="c#">
Linha 107:		Linha 108:
	</source>		</source>

	Here are the Mappers used on the code above. One creates Steams from external resource files and the other creates TextureLoadingContexts from files:		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="c#">		<source lang="c#">

Trilib em 15h42min de 28 de fevereiro de 2021

2021-02-28T15:42:51Z

← Edição anterior		Edição das 12h42min de 28 de fevereiro de 2021
Linha 1:		Linha 1:
	The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.		The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
	==Loading a Model from a File==		==Loading a Model from a File==
	When loading a model from a file in TriLib 1, the following snippets are used:<source lang="csharp~~" line="1~~">		When loading a model from a file in TriLib 1, the following snippets are used:

			<source lang="csharp">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 17:		Linha 19:
	var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.		var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
	}		}
	</source ><source lang="csharp">		</source>

			<source lang="csharp">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 35:		Linha 39:
	}); //Loads the model asynchronously and returns the reference to the created Task/Thread.		}); //Loads the model asynchronously and returns the reference to the created Task/Thread.
	}		}
	</source >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.		</source>

			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 AssetLoader static class now.		On TriLib 2, we don't have to instantiate an AssetLoader or AssetLoaderAsync class. All loading is done using the AssetLoader static class now.
Linha 43:		Linha 49:
	TriLib 2 also uses AssetLoaderOptions, but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the AssetLoaderOptions remains the same.		TriLib 2 also uses AssetLoaderOptions, but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the AssetLoaderOptions remains the same.

	Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:<source lang="c#">		Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:

			<source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 50:		Linha 58:
	var myGameObject = assetLoaderContext.RootGameObject;		var myGameObject = assetLoaderContext.RootGameObject;
	}, null, null, null, null, assetLoaderOptions);		}, null, null, null, null, assetLoaderOptions);
	</source >		</source>

	==Loading a Model from a Custom Source==		==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:<source lang="csharp">		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:

			<source lang="csharp">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 79:		Linha 89:
	});		});
	}		}
	</source >TriLib 2 uses different approaches to load models from custom data sources.		</source>

			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 ExternalDataMapper class. Third, any external texture the model uses has to be loaded using a class inheriting the TextureMapper class.		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 ExternalDataMapper class. Third, any external texture the model uses has to be loaded using a class inheriting the TextureMapper class.

	The example below loads a model from a custom Stream and handles its external resources with custom ExternalDataMapper and TextureMapper classes.<source lang="c#">		The example below loads a model from a custom Stream and handles its external resources with custom ExternalDataMapper and TextureMapper classes.

			<source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 91:		Linha 105:
	var modelPath = "PATH_TO_MY_MODEL.FBX";		var modelPath = "PATH_TO_MY_MODEL.FBX";
	AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);		AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
	</source >Here are the Mappers used on the code above. One creates Steams from external resource files and the other creates TextureLoadingContexts from files:<source lang="c#">		</source>

			Here are the Mappers used on the code above. One creates Steams from external resource files and the other creates TextureLoadingContexts from files:

			<source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 107:		Linha 125:
	}		}
	}		}
	</source ><source lang="c#">		</source>

			<source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 129:		Linha 149:
	}		}
	}		}
	</source >		</source>

Trilib em 15h39min de 28 de fevereiro de 2021

2021-02-28T15:39:48Z

← Edição anterior		Edição das 12h39min de 28 de fevereiro de 2021
Linha 1:		Linha 1:
	The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.		The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
	==Loading a Model from a File==		==Loading a Model from a File==
	When loading a model from a file in TriLib 1, the following snippets are used:<~~syntaxhighlight~~ lang="csharp" line="1">		When loading a model from a file in TriLib 1, the following snippets are used:<source lang="csharp" line="1">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 17:		Linha 17:
	var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.		var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
	}		}
	</~~syntaxhighlight~~><~~syntaxhighlight~~ lang="csharp">		</source ><source lang="csharp">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 35:		Linha 35:
	}); //Loads the model asynchronously and returns the reference to the created Task/Thread.		}); //Loads the model asynchronously and returns the reference to the created Task/Thread.
	}		}
	</~~syntaxhighlight~~>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.		</source >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 AssetLoader static class now.		On TriLib 2, we don't have to instantiate an AssetLoader or AssetLoaderAsync class. All loading is done using the AssetLoader static class now.
Linha 43:		Linha 43:
	TriLib 2 also uses AssetLoaderOptions, but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the AssetLoaderOptions remains the same.		TriLib 2 also uses AssetLoaderOptions, but these have changed to adopt a cleaner and file-format agnostic approach. The way we create the AssetLoaderOptions remains the same.

	Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:<~~syntaxhighlight~~ lang="c#">		Given these changes, a simple TriLib 2 model loading that matches the TriLib 1 samples above could be reproduced as:<source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 50:		Linha 50:
	var myGameObject = assetLoaderContext.RootGameObject;		var myGameObject = assetLoaderContext.RootGameObject;
	}, null, null, null, null, assetLoaderOptions);		}, null, null, null, null, assetLoaderOptions);
	</~~syntaxhighlight~~>		</source >

	==Loading a Model from a Custom Source==		==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:<~~syntaxhighlight~~ lang="csharp">		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:<source lang="csharp">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 79:		Linha 79:
	});		});
	}		}
	</~~syntaxhighlight~~>TriLib 2 uses different approaches to load models from custom data sources.		</source >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 ExternalDataMapper class. Third, any external texture the model uses has to be loaded using a class inheriting the TextureMapper class.		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 ExternalDataMapper class. Third, any external texture the model uses has to be loaded using a class inheriting the TextureMapper class.

	The example below loads a model from a custom Stream and handles its external resources with custom ExternalDataMapper and TextureMapper classes.<~~syntaxhighlight~~ lang="c#">		The example below loads a model from a custom Stream and handles its external resources with custom ExternalDataMapper and TextureMapper classes.<source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 91:		Linha 91:
	var modelPath = "PATH_TO_MY_MODEL.FBX";		var modelPath = "PATH_TO_MY_MODEL.FBX";
	AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);		AssetLoader.LoadModelFromStream(File.OpenRead(modelPath), modelPath, null, OnLoad, OnMaterialsLoad, OnProgress, OnError, null, assetLoaderOptions);
	</~~syntaxhighlight~~>Here are the Mappers used on the code above. One creates Steams from external resource files and the other creates TextureLoadingContexts from files:<~~syntaxhighlight~~ lang="c#">		</source >Here are the Mappers used on the code above. One creates Steams from external resource files and the other creates TextureLoadingContexts from files:<source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 107:		Linha 107:
	}		}
	}		}
	</~~syntaxhighlight~~><~~syntaxhighlight~~ lang="c#">		</source ><source lang="c#">
	// TriLib 2 Code		// TriLib 2 Code
	// --------------------		// --------------------
Linha 129:		Linha 129:
	}		}
	}		}
	</~~syntaxhighlight~~>		</source >

Trilib: /* Loading a Model from a File */

2021-02-28T15:38:48Z

Loading a Model from a File

← Edição anterior		Edição das 12h38min de 28 de fevereiro de 2021
Linha 1:		Linha 1:
	The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.		The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
	==Loading a Model from a File==		==Loading a Model from a File==
	When loading a model from a file in TriLib 1, the following snippets are used:<syntaxhighlight lang="c#" line="1">		When loading a model from a file in TriLib 1, the following snippets are used:<syntaxhighlight lang="csharp" line="1">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 17:		Linha 17:
	var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.		var myGameObject = assetLoader.LoadFromFile("PATH TO MY FILE.FBX", assetLoaderOptions, wrapperGameObject); //Loads the model synchronously and stores the reference in myGameObject.
	}		}
	</syntaxhighlight><syntaxhighlight lang="c#">		</syntaxhighlight><syntaxhighlight lang="csharp">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------
Linha 53:		Linha 53:

	==Loading a Model from a Custom Source==		==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:<syntaxhighlight lang="c#">		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:<syntaxhighlight lang="csharp">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------

Trilib em 02h41min de 28 de fevereiro de 2021

2021-02-28T02:41:27Z

← Edição anterior		Edição das 23h41min de 27 de fevereiro de 2021
Linha 1:		Linha 1:
	The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.		The usage of TriLib 2 is very similar to TriLib 1, but some fundamental changes have been made.
	==Loading a Model from a File==		==Loading a Model from a File==
	When loading a model from a file in TriLib 1, the following snippets are used:<syntaxhighlight lang="c#">		When loading a model from a file in TriLib 1, the following snippets are used:<syntaxhighlight lang="c#" line="1">
	// TriLib 1 Code		// TriLib 1 Code
	// --------------------		// --------------------