/// <summary>
/// Returns HEU_UploadMeshData with mesh data found on meshGameObject.
/// </summary>
/// <param name="meshGameObject">The GameObject to query mesh data from</param>
/// <returns>A valid HEU_UploadMeshData if mesh data found or null</returns>
public static HEU_UploadMeshData CreateSingleMeshData(GameObject meshGameObject)
{
HEU_UploadMeshData meshData = new HEU_UploadMeshData();
MeshFilter meshfilter = meshGameObject.GetComponent<MeshFilter>();
if (meshfilter == null)
{
return null;
}
if (meshfilter.sharedMesh == null)
{
return null;
}
meshData._mesh = meshfilter.sharedMesh;
meshData._numVertices = meshData._mesh.vertexCount;
meshData._numSubMeshes = meshData._mesh.subMeshCount;
meshData._meshName = meshGameObject.name;
meshData._meshPath = HEU_AssetDatabase.GetAssetOrScenePath(meshGameObject);
if (string.IsNullOrEmpty(meshData._meshPath))
{
meshData._meshPath = meshGameObject.name;
}
MeshRenderer meshRenderer = meshGameObject.GetComponent<MeshRenderer>();
if (meshRenderer != null)
{
meshData._materials = meshRenderer.sharedMaterials;
}
return meshData;
}
/// <summary>
/// Returns HEU_UploadMeshData with mesh data found on meshGameObject.
/// </summary>
/// <param name="meshGameObject">The GameObject to query mesh data from</param>
/// <returns>A valid HEU_UploadMeshData if mesh data found or null</returns>
public static HEU_InputDataMesh CreateSingleMeshData(GameObject meshGameObject)
{
HEU_InputDataMesh meshData = new HEU_InputDataMesh();
if (meshGameObject == null)
{
return null;
}
Mesh sharedMesh = GetMeshFromObject(meshGameObject);
if (sharedMesh == null)
{
return null;
}
meshData._mesh = sharedMesh;
meshData._numVertices = meshData._mesh.vertexCount;
meshData._numSubMeshes = meshData._mesh.subMeshCount;
meshData._meshName = meshGameObject.name;
// Use project path is not saved in scene, otherwise just use name
if (HEU_GeneralUtility.IsGameObjectInProject(meshGameObject))
{
meshData._meshPath = HEU_AssetDatabase.GetAssetOrScenePath(meshGameObject);
if (string.IsNullOrEmpty(meshData._meshPath))
{
meshData._meshPath = meshGameObject.name;
}
}
else
{
meshData._meshPath = meshGameObject.name;
}
//Debug.Log("Mesh Path: " + meshData._meshPath);
MeshRenderer meshRenderer = meshGameObject.GetComponent<MeshRenderer>();
if (meshRenderer != null)
{
meshData._materials = meshRenderer.sharedMaterials;
}
meshData._transform = meshGameObject.transform;
return meshData;
}
public void PopulateInputPreset(HEU_InputPreset inputPreset)
{
inputPreset._inputObjectType = _inputObjectType;
inputPreset._inputAssetName = _inputAsset != null ? _inputAsset.name : "";
inputPreset._inputIndex = _inputIndex;
inputPreset._inputName = _inputName;
inputPreset._keepWorldTransform = _keepWorldTransform;
inputPreset._packGeometryBeforeMerging = _packGeometryBeforeMerging;
foreach (HEU_InputObjectInfo inputObject in _inputObjects)
{
HEU_InputObjectPreset inputObjectPreset = new HEU_InputObjectPreset();
if (inputObject._gameObject != null)
{
inputObjectPreset._gameObjectName = inputObject._gameObject.name;
// Tag whether scene or project input object
inputObjectPreset._isSceneObject = !HEU_GeneralUtility.IsGameObjectInProject(inputObject._gameObject);
if (!inputObjectPreset._isSceneObject)
{
// For inputs in project, use the project path as name
inputObjectPreset._gameObjectName = HEU_AssetDatabase.GetAssetOrScenePath(inputObject._gameObject);
}
}
else
{
inputObjectPreset._gameObjectName = "";
}
inputObjectPreset._useTransformOffset = inputObject._useTransformOffset;
inputObjectPreset._translateOffset = inputObject._translateOffset;
inputObjectPreset._rotateOffset = inputObject._rotateOffset;
inputObjectPreset._scaleOffset = inputObject._scaleOffset;
inputPreset._inputObjectPresets.Add(inputObjectPreset);
}
}
public void PopulateInputPreset(HEU_InputPreset inputPreset)
{
inputPreset._inputObjectType = _inputObjectType;
// Deprecated and replaced with _inputAssetPresets. Leaving it in for backwards compatibility.
//inputPreset._inputAssetName = _inputAsset != null ? _inputAsset.name : "";
inputPreset._inputIndex = _inputIndex;
inputPreset._inputName = _inputName;
inputPreset._keepWorldTransform = _keepWorldTransform;
inputPreset._packGeometryBeforeMerging = _packGeometryBeforeMerging;
foreach (HEU_InputObjectInfo inputObject in _inputObjects)
{
HEU_InputObjectPreset inputObjectPreset = new HEU_InputObjectPreset();
if (inputObject._gameObject != null)
{
inputObjectPreset._gameObjectName = inputObject._gameObject.name;
// Tag whether scene or project input object
inputObjectPreset._isSceneObject = !HEU_GeneralUtility.IsGameObjectInProject(inputObject._gameObject);
if (!inputObjectPreset._isSceneObject)
{
// For inputs in project, use the project path as name
inputObjectPreset._gameObjectName = HEU_AssetDatabase.GetAssetOrScenePath(inputObject._gameObject);
}
}
else
{
inputObjectPreset._gameObjectName = "";
}
inputObjectPreset._useTransformOffset = inputObject._useTransformOffset;
inputObjectPreset._translateOffset = inputObject._translateOffset;
inputObjectPreset._rotateOffset = inputObject._rotateOffset;
inputObjectPreset._scaleOffset = inputObject._scaleOffset;
inputPreset._inputObjectPresets.Add(inputObjectPreset);
}
foreach (HEU_InputHDAInfo hdaInfo in _inputAssetInfos)
{
HEU_InputAssetPreset inputAssetPreset = new HEU_InputAssetPreset();
if (hdaInfo._connectedGO != null)
{
if (!HEU_GeneralUtility.IsGameObjectInProject(hdaInfo._connectedGO))
{
inputAssetPreset._gameObjectName = hdaInfo._connectedGO.name;
}
else
{
inputAssetPreset._gameObjectName = "";
}
inputPreset._inputAssetPresets.Add(inputAssetPreset);
}
}
}
/// <summary>
/// Returns HEU_UploadMeshData with mesh data found on meshGameObject.
/// </summary>
/// <param name="meshGameObject">The GameObject to query mesh data from</param>
/// <returns>A valid HEU_UploadMeshData if mesh data found or null</returns>
public static HEU_InputDataMesh CreateSingleMeshData(GameObject meshGameObject, bool bExportColliders)
{
HEU_InputDataMesh meshData = new HEU_InputDataMesh();
if (meshGameObject == null)
{
return null;
}
Mesh sharedMesh = GetMeshFromObject(meshGameObject);
if (sharedMesh == null)
{
return null;
}
meshData._mesh = sharedMesh;
meshData._numVertices = meshData._mesh.vertexCount;
meshData._numSubMeshes = meshData._mesh.subMeshCount;
meshData._meshName = meshGameObject.name;
// Use project path is not saved in scene, otherwise just use name
if (HEU_GeneralUtility.IsGameObjectInProject(meshGameObject))
{
meshData._meshPath = HEU_AssetDatabase.GetAssetOrScenePath(meshGameObject);
if (string.IsNullOrEmpty(meshData._meshPath))
{
meshData._meshPath = meshGameObject.name;
}
}
else
{
meshData._meshPath = meshGameObject.name;
}
//HEU_Logger.Log("Mesh Path: " + meshData._meshPath);
MeshRenderer meshRenderer = meshGameObject.GetComponent<MeshRenderer>();
if (meshRenderer != null)
{
meshData._materials = meshRenderer.sharedMaterials;
}
meshData._transform = meshGameObject.transform;
if (bExportColliders && meshGameObject != null)
{
meshData._colliders = new List<HEU_InputDataCollider>();
Collider[] colliders = meshGameObject.GetComponents<Collider>();
if (colliders != null)
{
for (int i = 0; i < colliders.Length; i++)
{
Collider collider = colliders[i];
if (collider == null) continue;
HEU_InputDataCollider newCollider = new HEU_InputDataCollider();
newCollider._collider = collider;
if (collider.GetType() == typeof(BoxCollider))
{
newCollider._colliderType = HEU_InputColliderType.BOX;
}
else if (collider.GetType() == typeof(SphereCollider))
{
newCollider._colliderType = HEU_InputColliderType.SPHERE;
}
else if (collider.GetType() == typeof(CapsuleCollider))
{
newCollider._colliderType = HEU_InputColliderType.CAPSULE;
}
else if (collider.GetType() == typeof(MeshCollider))
{
newCollider._colliderType = HEU_InputColliderType.MESH;
}
else
{
HEU_Logger.LogWarningFormat("Collider type not supported: {0}", meshGameObject.name);
newCollider._collider = null;
newCollider._colliderType = HEU_InputColliderType.NONE;
}
if (newCollider._colliderType != HEU_InputColliderType.NONE)
{
meshData._colliders.Add(newCollider);
}
}
}
}
return meshData;
}
