private static Material CreateMaterial(this Link.Visual.Material urdfMaterial)
{
if (urdfMaterial.name == "")
{
urdfMaterial.name = GenerateMaterialName(urdfMaterial);
}
var material = AssetDatabase.LoadAssetAtPath <Material>(UrdfAssetPathHandler.GetMaterialAssetPath(urdfMaterial.name));
if (material != null) //material already exists
{
return(material);
}
material = InitializeMaterial();
if (urdfMaterial.color != null)
{
material.color = CreateColor(urdfMaterial.color);
}
else if (urdfMaterial.texture != null)
{
material.mainTexture = LoadTexture(urdfMaterial.texture.filename);
}
AssetDatabase.CreateAsset(material, UrdfAssetPathHandler.GetMaterialAssetPath(urdfMaterial.name));
return(material);
}
private static void CopyDaeTextureToExportDestination(string prefabPath, string newFolderLocation)
{
//Get material from Collada prefab
Material material = AssetDatabase.LoadAssetAtPath <Material>(prefabPath);
if (material.mainTexture == null)
{
return;
}
//Get relative subfolder where texture is, compared to the DAE file.
string commonFolder = Path.GetDirectoryName(prefabPath).SetSeparatorChar();
string texturePath = AssetDatabase.GetAssetPath(material.mainTexture).SetSeparatorChar();
string relativeLocation = "";
if (texturePath.Contains(commonFolder))
{
relativeLocation = texturePath.Substring(commonFolder.Length + 1);
}
string newTexturePath = Path.Combine(newFolderLocation, relativeLocation);
Directory.CreateDirectory(Path.GetDirectoryName(newTexturePath));
CopyFileToNewLocation(UrdfAssetPathHandler.GetFullAssetPath(texturePath), newTexturePath);
}
public static void Create(string filename)
{
Robot robot = new Robot();
robot.ConstructFromFile(filename);
if (!UrdfAssetPathHandler.IsValidAssetPath(robot.filename))
{
Debug.LogError("URDF file and ressources must be placed in Assets Folder:\n" + Application.dataPath);
return;
}
GameObject robotGameObject = new GameObject(robot.name);
robotGameObject.AddComponent <UrdfRobot>();
UrdfAssetPathHandler.SetPackageRoot(Path.GetDirectoryName(robot.filename));
UrdfMaterial.InitializeRobotMaterials(robot);
UrdfPlugins.Create(robotGameObject.transform, robot.plugins);
UrdfLinkExtensions.Create(robotGameObject.transform, robot.root);
GameObjectUtility.SetParentAndAlign(robotGameObject, Selection.activeObject as GameObject);
Undo.RegisterCreatedObjectUndo(robotGameObject, "Create " + robotGameObject.name);
Selection.activeObject = robotGameObject;
}
public static IEnumerator Create(string filename, ImportSettings settings, bool loadStatus = false)
{
CreateTag();
importsettings = settings;
Robot robot = new Robot(filename);
settings.totalLinks = robot.links.Count;
if (!UrdfAssetPathHandler.IsValidAssetPath(robot.filename))
{
Debug.LogError("URDF file and ressources must be placed in Assets Folder:\n" + Application.dataPath);
yield break;
}
GameObject robotGameObject = new GameObject(robot.name);
robotGameObject.tag = tagName;
robotGameObject.AddComponent <UrdfRobot>();
robotGameObject.AddComponent <RosSharp.Control.Controller>();
robotGameObject.GetComponent <UrdfRobot>().SetAxis(settings.choosenAxis);
UrdfAssetPathHandler.SetPackageRoot(Path.GetDirectoryName(robot.filename));
UrdfMaterial.InitializeRobotMaterials(robot);
UrdfPlugins.Create(robotGameObject.transform, robot.plugins);
Stack <Tuple <Link, Transform, Joint> > importStack = new Stack <Tuple <Link, Transform, Joint> >();
importStack.Push(new Tuple <Link, Transform, Joint>(robot.root, robotGameObject.transform, null));
while (importStack.Count != 0)
{
Tuple <Link, Transform, Joint> currentLink = importStack.Pop();
GameObject importedLink = UrdfLinkExtensions.Create(currentLink.Item2, currentLink.Item1, currentLink.Item3);
settings.linksLoaded++;
foreach (Joint childJoint in currentLink.Item1.joints)
{
Link child = childJoint.ChildLink;
importStack.Push(new Tuple <Link, Transform, Joint>(child, importedLink.transform, childJoint));
}
if (loadStatus)
{
yield return(null);
}
}
GameObjectUtility.SetParentAndAlign(robotGameObject, Selection.activeObject as GameObject);
Undo.RegisterCreatedObjectUndo(robotGameObject, "Create " + robotGameObject.name);
Selection.activeObject = robotGameObject;
CorrectAxis(robotGameObject);
CreateCollisionExceptions(robot, robotGameObject);
}
public static void CreateFromString(string urdfString)
{
Robot robot = new Robot();
robot.ConstructFromString(urdfString);
UrdfAssetPathHandler.SetPackageRoot(Application.dataPath + "/Urdf/FromString");
Create(robot);
}
private static string LocateAssetFile(string invalidPath)
{
string fileExtension = Path.GetExtension(invalidPath)?.Replace(".", "");
string newPath = EditorUtility.OpenFilePanel(
"Couldn't find asset at " + invalidPath + ". Select correct file.",
UrdfAssetPathHandler.GetPackageRoot(),
fileExtension);
return(UrdfAssetPathHandler.GetRelativeAssetPath(newPath));
}
private static void MoveMaterialsToNewLocation(string oldPackageRoot)
{
if (AssetDatabase.IsValidFolder(Path.Combine(oldPackageRoot, MaterialFolderName)))
{
AssetDatabase.MoveAsset(
Path.Combine(oldPackageRoot, MaterialFolderName),
Path.Combine(UrdfAssetPathHandler.GetPackageRoot(), MaterialFolderName));
}
else
{
AssetDatabase.CreateFolder(UrdfAssetPathHandler.GetPackageRoot(), MaterialFolderName);
}
}
private static void CreateDefaultMaterial()
{
var material = AssetDatabase.LoadAssetAtPath <Material>(UrdfAssetPathHandler.GetMaterialAssetPath(DefaultMaterialName));
if (material != null)
{
return;
}
material = InitializeMaterial();
material.color = new Color(0.33f, 0.33f, 0.33f, 0.0f);
AssetDatabase.CreateAsset(material, UrdfAssetPathHandler.GetMaterialAssetPath(DefaultMaterialName));
}
private static Link.Visual.Material.Texture ExportTextureData(Texture texture)
{
string oldTexturePath = UrdfAssetPathHandler.GetFullAssetPath(AssetDatabase.GetAssetPath(texture));
string newTexturePath = UrdfExportPathHandler.GetNewResourcePath(Path.GetFileName(oldTexturePath));
if (oldTexturePath != newTexturePath)
{
File.Copy(oldTexturePath, newTexturePath, true);
}
string packagePath = UrdfExportPathHandler.GetPackagePathForResource(newTexturePath);
return(new Link.Visual.Material.Texture(packagePath));
}
private static void CreateSimulatedUrdfObject()
{
string assetPath = AssetDatabase.GetAssetPath(Selection.activeObject);
if (Path.GetExtension(assetPath)?.ToLower() == ".urdf")
{
UrdfSimulatedRobotExtensions.CreateFromFile(UrdfAssetPathHandler.GetFullAssetPath(assetPath));
}
else
{
EditorUtility.DisplayDialog("Urdf Import As Simulation",
"The file you selected was not a URDF file. A robot can only be imported from a valid URDF file.", "Ok");
}
}
private static string CopyMeshToExportDestination(string prefabPath)
{
string newPrefabPath = UrdfExportPathHandler.GetNewMeshPath(Path.GetFileName(prefabPath));
if (Path.GetExtension(prefabPath)?.ToLower() == ".dae")
{
CopyDaeTextureToExportDestination(prefabPath, Path.GetDirectoryName(newPrefabPath));
}
prefabPath = UrdfAssetPathHandler.GetFullAssetPath(prefabPath);
CopyFileToNewLocation(prefabPath, newPrefabPath);
return(newPrefabPath);
}
private static void CreateUrdfObject()
{
//Get path to asset, check if it's a urdf file
string assetPath = AssetDatabase.GetAssetPath(Selection.activeObject);
if (Path.GetExtension(assetPath)?.ToLower() == ".urdf")
{
UrdfRobotExtensions.Create(UrdfAssetPathHandler.GetFullAssetPath(assetPath));
}
else
{
EditorUtility.DisplayDialog("URDF Import",
"The file you selected was not a URDF file. A robot can only be imported from a valid URDF file.", "Ok");
}
}
public static void CreateFromFile(string filename)
{
Robot robot = new Robot();
robot.ConstructFromFile(filename);
if (!UrdfAssetPathHandler.IsValidAssetPath(robot.filename))
{
Debug.LogError("URDF file and ressources must be placed in Assets Folder:\n" + Application.dataPath);
return;
}
UrdfAssetPathHandler.SetPackageRoot(Path.GetDirectoryName(robot.filename));
Create(robot);
}
private static string LocateRootAssetFolder <T>(string urdfFileName) where T : UnityEngine.Object
{
string newAssetPath = EditorUtility.OpenFolderPanel(
"Locate package root folder",
Path.Combine(Path.GetDirectoryName(Application.dataPath), "Assets"),
"");
if (UrdfAssetPathHandler.IsValidAssetPath(newAssetPath))
{
UrdfAssetPathHandler.SetPackageRoot(newAssetPath, true);
}
else
{
Debug.LogWarning("Selected package root " + newAssetPath + " is not within the Assets folder.");
}
return(UrdfAssetPathHandler.GetRelativeAssetPathFromUrdfPath(urdfFileName));
}
private static void CreateUrdfObject()
{
//Get path to asset, check if it's a urdf file
string assetPath = AssetDatabase.GetAssetPath(Selection.activeObject);
if (Path.GetExtension(assetPath)?.ToLower() == ".urdf")
{
// Get existing open window or if none, make a new one:
FileImportMenu window = (FileImportMenu)EditorWindow.GetWindow(typeof(FileImportMenu));
window.urdfFile = UrdfAssetPathHandler.GetFullAssetPath(assetPath);
window.minSize = new Vector2(500, 200);
window.Show();
}
else
{
EditorUtility.DisplayDialog("URDF Import",
"The file you selected was not a URDF file. Please select a valid URDF file.", "Ok");
}
}
public static void SetUrdfMaterial(GameObject gameObject, Link.Visual.Material urdfMaterial)
{
if (urdfMaterial != null)
{
var material = CreateMaterial(urdfMaterial);
SetMaterial(gameObject, material);
}
else
{
//If the URDF material is not defined, and the renderer is missing
//a material, assign the default material.
Renderer renderer = gameObject.GetComponentInChildren <Renderer>();
if (renderer != null && renderer.sharedMaterial == null)
{
var defaultMaterial = AssetDatabase.LoadAssetAtPath <Material>(UrdfAssetPathHandler.GetMaterialAssetPath(DefaultMaterialName));
SetMaterial(gameObject, defaultMaterial);
}
}
}
public static T FindUrdfAsset <T>(string urdfFileName) where T : UnityEngine.Object
{
string fileAssetPath = UrdfAssetPathHandler.GetRelativeAssetPathFromUrdfPath(urdfFileName);
T assetObject = AssetDatabase.LoadAssetAtPath <T>(fileAssetPath);
if (assetObject != null)
{
return(assetObject);
}
//If asset was not found, let user choose whether to search for
//or ignore the missing asset.
string invalidPath = fileAssetPath ?? urdfFileName;
int option = EditorUtility.DisplayDialogComplex("Urdf Importer: Asset Not Found",
"Current root folder: " + UrdfAssetPathHandler.GetPackageRoot() +
"\n\nExpected asset path: " + invalidPath,
"Locate Asset",
"Ignore Missing Asset",
"Locate Root Folder");
switch (option)
{
case 0:
fileAssetPath = LocateAssetFile(invalidPath);
break;
case 1: break;
case 2:
fileAssetPath = LocateRootAssetFolder <T>(urdfFileName);
break;
}
assetObject = (T)AssetDatabase.LoadAssetAtPath(fileAssetPath, typeof(T));
if (assetObject != null)
{
return(assetObject);
}
ChooseFailureOption(urdfFileName);
return(null);
}
public static void Create(string filename, ImportSettings settings)
{
CreateTag();
importsettings = settings;
Robot robot = new Robot(filename);
if (!UrdfAssetPathHandler.IsValidAssetPath(robot.filename))
{
Debug.LogError("URDF file and ressources must be placed in Assets Folder:\n" + Application.dataPath);
return;
}
GameObject robotGameObject = new GameObject(robot.name);
robotGameObject.tag = tagName;
robotGameObject.AddComponent <UrdfRobot>();
robotGameObject.AddComponent <RosSharp.Control.Controller>();
robotGameObject.GetComponent <UrdfRobot>().SetAxis(settings.choosenAxis);
UrdfAssetPathHandler.SetPackageRoot(Path.GetDirectoryName(robot.filename));
UrdfMaterial.InitializeRobotMaterials(robot);
UrdfPlugins.Create(robotGameObject.transform, robot.plugins);
UrdfLinkExtensions.Create(robotGameObject.transform, robot.root);
GameObjectUtility.SetParentAndAlign(robotGameObject, Selection.activeObject as GameObject);
Undo.RegisterCreatedObjectUndo(robotGameObject, "Create " + robotGameObject.name);
Selection.activeObject = robotGameObject;
CorrectAxis(robotGameObject);
CreateCollisionExceptions(robot, robotGameObject);
}
