A Multi-Threaded Mesh Combiner that runs in another thread. (Yes! It is just that cool!) More...

Inheritance diagram for Hydrogen.Threading.Jobs.MeshCombiner:

Classes
class	BufferedMesh
	A thread safe representation of a Mesh. More...

class	MeshInput
	Mesh Input Format More...

class	MeshObject
	Mesh Object Format More...

class	MeshOutput
	Mesh Output Format More...

class	TransitionMesh
	Transition Stage Mesh More...

class	TransitionMeshSorter
	A class defining how to sort TransitionMeshes. More...

Public Member Functions
int	AddMaterial (UnityEngine.Material material)
	Add a Material to the Material reference Dictionary. More...

int	AddMaterial (int code, UnityEngine.Material material)
	Add a Material to the Material reference Dictionary with a specific code. More...

int[]	AddMaterials (UnityEngine.Material[] materials)
	Add an array of Material(s) to the reference Dictionary. More...

bool	AddMesh (MeshFilter meshFilter, Renderer renderer, Matrix4x4 worldMatrix)
	Add a Unity based Mesh into the MeshCombiner. More...

bool	AddMesh (MeshInput meshInput)
	Adds an existing MeshInput into the MeshCombiner. More...

void	ClearMaterials ()
	Clear the Material reference Dictionary. More...

void	ClearMeshes ()
	Clear the all Mesh data inside of the MeshCombiner. More...

int	Combine (Action< int, MeshOutput[]> onFinished)
	Start the actual threaded process to combine MeshInput data currently added to the MeshCombiner. More...

MeshInput	CreateMeshInput (MeshFilter meshFilter, Renderer renderer, Matrix4x4 worldMatrix)
	Creates a MeshInput from the passed arguements. More...

MeshInput[]	CreateMeshInputs (MeshFilter[] meshFilters, Renderer[] renderers, Matrix4x4[] worldMatrices)
	Creates MeshInput(s) from the passed arguement arrays. More...

MeshObject	CreateMeshObject (MeshOutput meshOutput)
	Creates a MeshObject from the MeshOutput (Instanced Materials). More...

MeshObject	CreateMeshObject (MeshOutput meshOutput, bool instanceMaterials)
	Creates a MeshObject from the passed MeshOutput. More...

MeshObject[]	CreateMeshObjects (MeshOutput[] meshOutputs)
	Creates MeshObject(s) from the passed MeshOutput(s) (Instanced Materials). More...

MeshObject[]	CreateMeshObjects (MeshOutput[] meshOutputs, bool instanceMaterials)
	Creates MeshObject(s) from the passed MeshOutput(s). More...

UnityEngine.Material[]	GetMaterials (int[] codes)
	Gets an array of Materials. More...

UnityEngine.Material[]	GetMaterialInstances (int[] codes)
	Gets an array of Materials (Instanced). More...

bool	RemoveMaterial (UnityEngine.Material material)
	Remove a UnityEngine.Material from the Material reference Dictionary. More...

bool	RemoveMesh (MeshFilter meshFilter, Renderer renderer, Matrix4x4 worldMatrix)
	Removes a Unity based Mesh from the MeshInput list to be processed. More...

bool	RemoveMesh (MeshInput meshInput)
	Removes a MeshInput from the MeshInput list to be processed. More...

Public Member Functions inherited from Hydrogen.Threading.ThreadPoolJob
override void	Start (bool backgroundThread, System.Threading.ThreadPriority priority)
	Sends the work process to the ThreadPool for starting when resources are available, This needs to initialize the WaitCallback with the Run function. More...

Public Member Functions inherited from Hydrogen.Threading.JobBase
virtual bool	Check ()
	Checks if the Job is done, and facilitates calling OnFinished when completed. More...

Protected Member Functions
sealed override void	ThreadedFunction ()
	This is the main workhorse method which runs in another thread. More...

sealed override void	OnFinished ()
	Executed when the ThreadedFunction is finished (sort of), sending our MeshOutput(s) back to Unity for our coroutine to use. More...

Protected Member Functions inherited from Hydrogen.Threading.JobBase
virtual void	Abort ()
	Abort the Job (as best we can). More...

virtual void	Run (object state)
	The launcher of the ThreadedFunction, used to handle the state as well. More...

Properties
Dictionary< int, UnityEngine.Material >	MaterialsLookup `[get]`
	Gets the current Material reference Dictionary. More...

List< MeshInput >	MeshInputs `[get]`
	Gets the MeshInput(s) list to be used to create TransitionMeshes during the processing. More...

int	MeshInputCount `[get]`
	The total number of MeshInput(s) currently in the system. More...

List< MeshOutput >	MeshOutputs `[get]`
	Gets the MeshOutput(s) list, often used during post processing to create meshes. More...

int	MeshOutputCount `[get]`
	The total number of MeshOutput(s) currently generated in the system. More...

Properties inherited from Hydrogen.Threading.JobBase
bool	IsBusy `[get, set]`
	Is the Job busy working? More...

bool	IsDone `[get, set]`
	Is the Job done? More...

bool	FiredOnFinished `[get, set]`
	Has the OnFinished been called yet? More...

Detailed Description

A Multi-Threaded Mesh Combiner that runs in another thread. (Yes! It is just that cool!)

Definition at line 38 of file MeshCombiner.cs.

Member Function Documentation

int Hydrogen.Threading.Jobs.MeshCombiner.AddMaterial ( UnityEngine.Material material )

Add a Material to the Material reference Dictionary.

This can only be used from within Unity's main thread.

Returns: The DataHashCode

Parameters

material The UnityEngine.Material to be added.

Definition at line 114 of file MeshCombiner.cs.

                 {
                         return AddMaterial (material.GetDataHashCode (), material);
 
                 }

int Hydrogen.Threading.Jobs.MeshCombiner.AddMaterial	(	int	code,
		UnityEngine.Material	material
	)

Add a Material to the Material reference Dictionary with a specific code.

This can only be used from within Unity's main thread.

Returns: The DataHashCode

Parameters

code	The code to store as the reference for the Material.
material	The UnityEngine.Material to be added.

Definition at line 127 of file MeshCombiner.cs.

                 {
                         if (!_materialLookup.ContainsKey (code)) {
                                 _materialLookup.Add (code, material);
                         }
                         return code;
                 }

int [] Hydrogen.Threading.Jobs.MeshCombiner.AddMaterials ( UnityEngine.Material[] materials )

Add an array of Material(s) to the reference Dictionary.

Returns: The DataHashCode(s).

Parameters

materials The UnityEngine.Material(s) to be added..

Definition at line 140 of file MeshCombiner.cs.

                 {
                         var hashcodes = new int[materials.Length];
                         for (var x = 0; x < materials.Length; x++) {
                                 // Add if we need it
                                 hashcodes [x] = AddMaterial (materials [x].GetDataHashCode (), materials [x]);
                         }
                         return hashcodes;
                 }

bool Hydrogen.Threading.Jobs.MeshCombiner.AddMesh	(	MeshFilter	meshFilter,
		Renderer	renderer,
		Matrix4x4	worldMatrix
	)

Add a Unity based Mesh into the MeshCombiner.

This can only be used from within Unity's main thread.

Returns: true, if mesh was added, false otherwise.

Definition at line 155 of file MeshCombiner.cs.

                 {                   
                         return AddMesh (CreateMeshInput (meshFilter, renderer, worldMatrix));
                 }

bool Hydrogen.Threading.Jobs.MeshCombiner.AddMesh ( MeshInput meshInput )

Adds an existing MeshInput into the MeshCombiner.

This can be done without Unity's main thread, if you have access to the data already. Just need to make sure that the material codes are set correctly.

Returns: true, if MeshInput was added, false otherwise.

Parameters

meshInput The MeshInput to add.

Definition at line 169 of file MeshCombiner.cs.

                 {
                         if (!_meshInputs.Contains (meshInput)) {
                                 _meshInputs.Add (meshInput);
                                 return true;
                         }
                         return false;
                 }

void Hydrogen.Threading.Jobs.MeshCombiner.ClearMaterials ( )

Clear the Material reference Dictionary.

Definition at line 181 of file MeshCombiner.cs.

                 {
                         _materialLookup.Clear ();
                 }

void Hydrogen.Threading.Jobs.MeshCombiner.ClearMeshes ( )

Clear the all Mesh data inside of the MeshCombiner.

Definition at line 189 of file MeshCombiner.cs.

                 {
                         _meshInputs.Clear ();
                         _meshOutputs.Clear ();
                         _transitionMeshes.Clear ();
                 }

int Hydrogen.Threading.Jobs.MeshCombiner.Combine ( Action< int, MeshOutput[]> onFinished )

Start the actual threaded process to combine MeshInput data currently added to the MeshCombiner.

Parameters

onFinished The method to call when completed inside of Unity's main thread.

Definition at line 200 of file MeshCombiner.cs.

                 {
                         // Generate Hash Code
                         _hash = (Time.time + UnityEngine.Random.Range (0, 100)).GetHashCode ();
 
                         // Start the threaded prcess
                         if (onFinished != null) {
                                 _callback = onFinished;
                         }
 
                         // These values mean nothing in this case as we don't assign any of it to the ThreadPool tasks.
                         Start (true, System.Threading.ThreadPriority.Normal);
 
                         return _hash;
                 }

MeshInput Hydrogen.Threading.Jobs.MeshCombiner.CreateMeshInput	(	MeshFilter	meshFilter,
		Renderer	renderer,
		Matrix4x4	worldMatrix
	)

Creates a MeshInput from the passed arguements.

This can only be used from within Unity's main thread.

Returns: The created MeshInput

Parameters

meshFilter	The source Mesh's MeshFilter.
renderer	The source Mesh's Renderer.
worldMatrix	The source Mesh's World Matrix

Definition at line 224 of file MeshCombiner.cs.

                 {
                         var newMeshInput = new MeshInput ();
 
                         newMeshInput.Mesh = new BufferedMesh ();
                         newMeshInput.Mesh.Name = meshFilter.name;
                         newMeshInput.Mesh.Vertices = meshFilter.sharedMesh.vertices;
                         newMeshInput.Mesh.Normals = meshFilter.sharedMesh.normals;
                         newMeshInput.Mesh.Colors = meshFilter.sharedMesh.colors;
                         newMeshInput.Mesh.Tangents = meshFilter.sharedMesh.tangents;
                         newMeshInput.Mesh.UV = meshFilter.sharedMesh.uv;
                         newMeshInput.Mesh.UV1 = meshFilter.sharedMesh.uv1;
                         newMeshInput.Mesh.UV2 = meshFilter.sharedMesh.uv2;
 
                         newMeshInput.Mesh.Topology = new MeshTopology[meshFilter.sharedMesh.subMeshCount];
 
                         for (var i = 0; i < meshFilter.sharedMesh.subMeshCount; i++) {
                                 newMeshInput.Mesh.Topology [i] = meshFilter.sharedMesh.GetTopology (i);
 
                                 // Check for Unsupported Mesh Topology
                                 switch (newMeshInput.Mesh.Topology [i]) {
                                 case MeshTopology.Lines:
                                 case MeshTopology.LineStrip:
                                 case MeshTopology.Points:
                                         Debug.LogWarning ("The MeshCombiner does not support this meshes (" +
                                         newMeshInput.Mesh.Name + "topology (" + newMeshInput.Mesh.Topology [i] + ")");
                                         break;
                                 }
                                 newMeshInput.Mesh.Indexes.Add (meshFilter.sharedMesh.GetIndices (i));
                         }
 
                         // Create Materials
                         newMeshInput.Materials = AddMaterials (renderer.sharedMaterials);
 
 
                         // Determine Inversion of Scale
                         // Don't Scale (NNP, PPP, PNN, NPN)
                         Vector3 scaleTest = meshFilter.gameObject.transform.localScale;
                          
                         bool invertedX = (scaleTest.x < 0f); 
                         bool invertedY = (scaleTest.y < 0f);
                         bool invertedZ = (scaleTest.z < 0f);
 
                         if ((invertedX && invertedY && invertedZ) ||
                             (invertedX && !invertedY && !invertedZ) ||
                             (!invertedX && invertedY && !invertedZ) ||
                             (!invertedX && !invertedY && invertedZ)) {
                                 newMeshInput.ScaleInverted = true;
                         } 
                         newMeshInput.WorldMatrix = worldMatrix;
 
                         return newMeshInput;
                 }

MeshInput [] Hydrogen.Threading.Jobs.MeshCombiner.CreateMeshInputs	(	MeshFilter[]	meshFilters,
		Renderer[]	renderers,
		Matrix4x4[]	worldMatrices
	)

Creates MeshInput(s) from the passed arguement arrays.

This can only be used from within Unity's main thread.

Returns: The created MeshInput(s)

Parameters

meshFilters	The source Meshes MeshFilters.
renderers	The source Meshes Renderers.
worldMatrices	The source Meshes World Matrices

Definition at line 286 of file MeshCombiner.cs.

                 {
                         // Create our holder
                         var meshInputs = new MeshInput[meshFilters.Length];
 
                         // Lazy way of making a whole bunch.
                         for (int i = 0; i < meshFilters.Length; i++) {
                                 meshInputs [i] = CreateMeshInput (meshFilters [i], renderers [i], worldMatrices [i]);
                         }
 
                         // Send it back!
                         return meshInputs;
                 }

MeshObject Hydrogen.Threading.Jobs.MeshCombiner.CreateMeshObject ( MeshOutput meshOutput )

Creates a MeshObject from the MeshOutput (Instanced Materials).

Returns: The created MeshObject.

Parameters

meshOutput The source MeshOutput to use in creating the MeshObject.

Definition at line 305 of file MeshCombiner.cs.

                 {
                         return CreateMeshObject (meshOutput, true);
                 }

MeshObject Hydrogen.Threading.Jobs.MeshCombiner.CreateMeshObject	(	MeshOutput	meshOutput,
		bool	instanceMaterials
	)

Creates a MeshObject from the passed MeshOutput.

Returns: The created MeshObject.

Parameters

meshOutput	The source MeshOutput to use in creating the MeshObject.
instanceMaterials	If set to `true` materials will be instanced.

Definition at line 316 of file MeshCombiner.cs.

                 {
                         var meshObject = new MeshObject ();
 
                         meshObject.Materials = instanceMaterials ? 
                                 GetMaterialInstances (meshOutput.Materials.ToArray ()) : 
                                 GetMaterials (meshOutput.Materials.ToArray ());
 
                         meshObject.Mesh = new UnityEngine.Mesh ();
                         meshObject.Mesh.vertices = meshOutput.Vertices.ToArray ();
                         meshObject.Mesh.name = "Combined Mesh (" + meshObject.Mesh.vertices.GetHashCode () + ")";
 
                         // If there are normals we need to assign them to the mesh.
                         if (meshOutput.Normals != null) {
                                 meshObject.Mesh.normals = meshOutput.Normals.ToArray ();
                         }
 
                         // Much like normals, if we've got tangents lets throw them on there too.
                         if (meshOutput.Tangents != null) {
                                 meshObject.Mesh.tangents = meshOutput.Tangents.ToArray ();
                         }
 
                         // How about some vertex color data? Sounds like a good idea to add that too.
                         if (meshOutput.Colors != null) {
                                 meshObject.Mesh.colors = meshOutput.Colors.ToArray ();
                         }
 
                         // Better make those textures work too while were at it.
                         if (meshOutput.UV != null) {
                                 meshObject.Mesh.uv = meshOutput.UV.ToArray ();
                         }
 
                         // How about some more UV's?
                         if (meshOutput.UV1 != null) {
                                 meshObject.Mesh.uv1 = meshOutput.UV1.ToArray ();
                         }
 
                         // Lightmapping UV's anyone?
                         if (meshOutput.UV2 != null) {
                                 meshObject.Mesh.uv2 = meshOutput.UV2.ToArray ();
                         }
 
 
                         meshObject.Mesh.subMeshCount = meshOutput.Indexes.Count;
                         for (int i = 0; i < meshOutput.Indexes.Count; i++) {
                                 meshObject.Mesh.SetIndices (meshOutput.Indexes [i].ToArray (), MeshTopology.Triangles, i);
                         }
 
                         // Recalculate mesh's bounds for fun.
                         meshObject.Mesh.RecalculateBounds ();
 
                     
                         // Return our processed object.
                         return meshObject;
                 }

MeshObject [] Hydrogen.Threading.Jobs.MeshCombiner.CreateMeshObjects ( MeshOutput[] meshOutputs )

Creates MeshObject(s) from the passed MeshOutput(s) (Instanced Materials).

Returns: The created MeshObject(s).

Parameters

meshOutputs The source MeshOutput(s) to use in creating the MeshObject(s).

Definition at line 377 of file MeshCombiner.cs.

                 {
                         return CreateMeshObjects (meshOutputs, true);
                 }

MeshObject [] Hydrogen.Threading.Jobs.MeshCombiner.CreateMeshObjects	(	MeshOutput[]	meshOutputs,
		bool	instanceMaterials
	)

Creates MeshObject(s) from the passed MeshOutput(s).

Returns: The created MeshObject(s).

Parameters

meshOutputs	The source MeshOutput(s) to use in creating the MeshObject(s).
instanceMaterials	If set to `true` materials will be instanced.

Definition at line 388 of file MeshCombiner.cs.

                 {
                         MeshObject[] meshObjects = new MeshObject[meshOutputs.Length];
                         for (int i = 0; i < meshOutputs.Length; i++) {
                                 meshObjects [i] = CreateMeshObject (meshOutputs [i], instanceMaterials);
                         }
                         return meshObjects;
                 }

UnityEngine.Material [] Hydrogen.Threading.Jobs.MeshCombiner.GetMaterialInstances ( int[] codes )

Gets an array of Materials (Instanced).

Returns: The referenced Materials instanced.

Parameters

codes An array of Material DataHashCodes.

Definition at line 416 of file MeshCombiner.cs.

                 {
                         var materials = new UnityEngine.Material[codes.Length];
                         for (int x = 0; x < codes.Length; x++) {
                                 materials [x] = new UnityEngine.Material (_materialLookup [codes [x]]);
                                 materials [x].name += " Instance";
                         }
                         return materials;
                 }

UnityEngine.Material [] Hydrogen.Threading.Jobs.MeshCombiner.GetMaterials ( int[] codes )

Gets an array of Materials.

Returns: The referenced Materials.

Parameters

codes An array of Material DataHashCodes.

Definition at line 402 of file MeshCombiner.cs.

                 {
                         var materials = new UnityEngine.Material[codes.Length];
                         for (int x = 0; x < codes.Length; x++) {
                                 materials [x] = _materialLookup [codes [x]];
                         }
                         return materials;
                 }

sealed override void Hydrogen.Threading.Jobs.MeshCombiner.OnFinished ( )

protectedvirtual

Executed when the ThreadedFunction is finished (sort of), sending our MeshOutput(s) back to Unity for our coroutine to use.

Can use Unity API.

Reimplemented from Hydrogen.Threading.JobBase.

Definition at line 560 of file MeshCombiner.cs.

                 {
                         // Callback
                         if (_callback != null)
                                 _callback (_hash, _meshOutputs.ToArray ());
                 }

bool Hydrogen.Threading.Jobs.MeshCombiner.RemoveMaterial ( UnityEngine.Material material )

Remove a UnityEngine.Material from the Material reference Dictionary.

Returns: true, if UnityEngine.Material was removed, false otherwise.

Parameters

material The target UnityEngine.Material to be removed.

Definition at line 431 of file MeshCombiner.cs.

                 {
                         int check = material.GetDataHashCode ();
                         if (_materialLookup.ContainsKey (check)) {
                                 _materialLookup.Remove (check);
                                 return true;
                         }
                         return false;
                 }

bool Hydrogen.Threading.Jobs.MeshCombiner.RemoveMesh	(	MeshFilter	meshFilter,
		Renderer	renderer,
		Matrix4x4	worldMatrix
	)

Removes a Unity based Mesh from the MeshInput list to be processed.

This is useful if you are caching MeshInputs for future use, and just want to remove a mesh as its no longer being combined. Open worlds may find this very useful. This can only be used from within Unity's main thread.

Returns: true, if the Unity based Mesh was removed, false otherwise.

Parameters

meshFilter	The Mesh's MeshFilter.
renderer	The Mesh's Renderer.
worldMatrix	The Mesh's World Matrix

Definition at line 453 of file MeshCombiner.cs.

                 {
                         return RemoveMesh (CreateMeshInput (meshFilter, renderer, worldMatrix));
                 }

bool Hydrogen.Threading.Jobs.MeshCombiner.RemoveMesh ( MeshInput meshInput )

Removes a MeshInput from the MeshInput list to be processed.

This is useful if you are caching MeshInputs for future use, and just want to remove a mesh as its no longer being combined. Open worlds may find this very useful.

Returns: true, if the MeshInput was removed, false otherwise.

Parameters

meshInput The MeshInput to be removed.

Definition at line 467 of file MeshCombiner.cs.

                 {
                         if (_meshInputs.Contains (meshInput)) {
                                 _meshInputs.Remove (meshInput);
                                 return true;
                         }
                         return false;
 
                 }

sealed override void Hydrogen.Threading.Jobs.MeshCombiner.ThreadedFunction ( )

protectedvirtual

This is the main workhorse method which runs in another thread.

Takes the MeshInput(s) and converts them to TransitionMeshes in parallel. It then creates optimized MeshOutput(s) for use later or through the callback.

Reimplemented from Hydrogen.Threading.JobBase.

Definition at line 484 of file MeshCombiner.cs.

                 {
                         // Empty out preexisting parsed data
                         _transitionMeshes.Clear ();
                         _meshOutputs.Clear ();
 
                         // Clever forker solution since we don't have Parallel.ForEach support available.
                         var parallelTasks = new Forker ();
                         foreach (var meshInput in _meshInputs) {
                                 var tempInput = meshInput;
                                 parallelTasks.Fork (delegate {
                                         CreateTransitionMesh (tempInput);
                                 });
                         }
                         parallelTasks.Join ();
 
                         // Sort the meshes in order
                         _transitionMeshes.Sort (new TransitionMeshSorter ());
 
                         var meshOutput = new MeshOutput ();
                         int bitmask = _transitionMeshes [0].GetBitMask ();
                     
 
                         foreach (var transitionMesh in _transitionMeshes) {
                                 if (transitionMesh.GetBitMask () != bitmask ||
                                     (transitionMesh.VertexCount + meshOutput.VertexCount) > Mesh.VerticesArrayLimit) {
                                         _meshOutputs.Add (meshOutput);
                                         meshOutput = new MeshOutput ();
                                 }
                                                 
                                 var baseIndex = meshOutput.VertexCount;
                                 meshOutput.VertexCount += transitionMesh.VertexCount;
                                 meshOutput.SortedSources.Add (transitionMesh);
 
                                 meshOutput.Vertices.AddRange (transitionMesh.Vertices);
 
                                 if (transitionMesh.Normals != null) {
                                         meshOutput.Normals.AddRange (transitionMesh.Normals);
                                 }
 
                                 if (transitionMesh.Colors != null) {
                                         meshOutput.Colors.AddRange (transitionMesh.Colors);
                                 }
 
                                 if (transitionMesh.Tangents != null) {
                                         meshOutput.Tangents.AddRange (transitionMesh.Tangents);
                                 }
 
                                 if (transitionMesh.UV != null) {
                                         meshOutput.UV.AddRange (transitionMesh.UV);
                                 }
 
                                 if (transitionMesh.UV1 != null) {
                                         meshOutput.UV1.AddRange (transitionMesh.UV1);
                                 }
 
                                 if (transitionMesh.UV2 != null) {
                                         meshOutput.UV2.AddRange (transitionMesh.UV2);
                                 }
 
                                 var indexes = meshOutput.GetSubMesh (transitionMesh.Material);
                                 indexes.Capacity = indexes.Count + transitionMesh.IndexCount;
                                 for (var i = 0; i < transitionMesh.IndexCount; i++) {
                                         indexes.Add (baseIndex + transitionMesh.Indexes [i]);
                                 }
 
                                 bitmask = transitionMesh.GetBitMask ();
                         }
                         _meshOutputs.Add (meshOutput);
                 }

Property Documentation

Dictionary<int, UnityEngine.Material> Hydrogen.Threading.Jobs.MeshCombiner.MaterialsLookup

get

Gets the current Material reference Dictionary.

The Material Reference Dictionary.

Definition at line 72 of file MeshCombiner.cs.

int Hydrogen.Threading.Jobs.MeshCombiner.MeshInputCount

get

The total number of MeshInput(s) currently in the system.

The MeshInput(s) Count.

Definition at line 88 of file MeshCombiner.cs.

List<MeshInput> Hydrogen.Threading.Jobs.MeshCombiner.MeshInputs

get

Gets the MeshInput(s) list to be used to create TransitionMeshes during the processing.

The MeshInput(s)

Definition at line 80 of file MeshCombiner.cs.

int Hydrogen.Threading.Jobs.MeshCombiner.MeshOutputCount

get

The total number of MeshOutput(s) currently generated in the system.

The MeshOutput(s) Count.

Definition at line 104 of file MeshCombiner.cs.

List<MeshOutput> Hydrogen.Threading.Jobs.MeshCombiner.MeshOutputs

get

Gets the MeshOutput(s) list, often used during post processing to create meshes.

The MeshOutput(s)

Definition at line 96 of file MeshCombiner.cs.

Classes

Public Member Functions

Protected Member Functions

Properties

Detailed Description

Member Function Documentation

Property Documentation