private void CreatePrefab(XElement xmlPrefab, string objPath)
{
var customImporters = GetCustomImporterInstances();
// Part 1: Create the prefab
string prefabName = xmlPrefab.Attribute("name").Value;
float prefabScale = ImportUtils.GetAttributeAsFloat(xmlPrefab, "scale", 1.0f);
GameObject tempPrefab = new GameObject(prefabName);
HandleTiledAttributes(tempPrefab, xmlPrefab);
HandleCustomProperties(tempPrefab, xmlPrefab, customImporters);
// Part 2: Build out the prefab
// We may have an 'isTrigger' attribute that we want our children to obey
bool isTrigger = ImportUtils.GetAttributeAsBoolean(xmlPrefab, "isTrigger", false);
AddGameObjectsTo(tempPrefab, xmlPrefab, isTrigger, objPath, customImporters);
// Part 3: Allow for customization from other editor scripts to be made on the prefab
// (These are generally for game-specific needs)
CustomizePrefab(tempPrefab, customImporters);
// Part 3.5: Apply the scale only after all children have been added
tempPrefab.transform.localScale = new Vector3(prefabScale, prefabScale, prefabScale);
// Part 4: Save the prefab, keeping references intact.
string resourcePath = ImportUtils.GetAttributeAsString(xmlPrefab, "resourcePath", "");
bool isResource = !String.IsNullOrEmpty(resourcePath) || ImportUtils.GetAttributeAsBoolean(xmlPrefab, "resource", false);
string prefabPath = GetPrefabAssetPath(prefabName, isResource, resourcePath);
UnityEngine.Object finalPrefab = AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject));
if (finalPrefab == null)
{
// The prefab needs to be created
ImportUtils.ReadyToWrite(prefabPath);
finalPrefab = PrefabUtility.CreateEmptyPrefab(prefabPath);
}
// Replace the prefab, keeping connections based on name.
PrefabUtility.ReplacePrefab(tempPrefab, finalPrefab, ReplacePrefabOptions.ReplaceNameBased);
// Destroy the instance from the current scene hiearchy.
UnityEngine.Object.DestroyImmediate(tempPrefab);
}
private void ImportTexturesFromXml(XDocument xml)
{
var texData = xml.Root.Elements("ImportTexture");
foreach (var tex in texData)
{
string name = tex.Attribute("filename").Value;
string data = tex.Value;
// The data is gzip compressed base64 string. We need the raw bytes.
//byte[] bytes = ImportUtils.GzipBase64ToBytes(data);
byte[] bytes = ImportUtils.Base64ToBytes(data);
// Save and import the texture asset
{
string pathToSave = GetTextureAssetPath(name);
ImportUtils.ReadyToWrite(pathToSave);
File.WriteAllBytes(pathToSave, bytes);
AssetDatabase.ImportAsset(pathToSave, ImportAssetOptions.ForceSynchronousImport);
}
// Create a material if needed in prepartion for the texture being successfully imported (NOTICE: Only if this is not a normal map)
if (!name.Contains(ImportTiled2Unity.TiledNormalMapFileIdentification))
{
string materialPath = GetMaterialAssetPath(name);
Material material = AssetDatabase.LoadAssetAtPath(materialPath, typeof(Material)) as Material;
if (material == null)
{
// We need to create the material afterall
// Use our custom shader
if (ImportTiled2Unity.ProcessingNormalMaps)
{
material = new Material(Shader.Find("Tiled/TextureTintSnapNormal"));
}
else
{
material = new Material(Shader.Find("Tiled/TextureTintSnap"));
}
ImportUtils.ReadyToWrite(materialPath);
AssetDatabase.CreateAsset(material, materialPath);
}
}
}
}
private void CreateMaterialsFromInternalTextures(XDocument xml)
{
var texData = xml.Root.Elements("InternalTexture");
foreach (var tex in texData)
{
string texAssetPath = tex.Attribute("assetPath").Value;
string materialPath = GetMaterialAssetPath(texAssetPath);
// Create our material
Material material = CreateMaterialFromXml(tex);
// Assign to it the texture that is already internal to our Unity project
Texture2D texture2d = AssetDatabase.LoadAssetAtPath(texAssetPath, typeof(Texture2D)) as Texture2D;
material.SetTexture("_MainTex", texture2d);
// Write the material to our asset database
ImportUtils.ReadyToWrite(materialPath);
ImportUtils.CreateOrReplaceAsset(material, materialPath);
}
}
private void ImportMeshesFromXml(XDocument xml)
{
var meshData = xml.Root.Elements("ImportMesh");
foreach (var mesh in meshData)
{
// We're going to create/write a file that contains our mesh data as a Wavefront Obj file
// The actual mesh will be imported from this Obj file
string fname = mesh.Attribute("filename").Value;
string data = mesh.Value;
// The data is in base64 format. We need it as a raw string.
string raw = ImportUtils.Base64ToString(data);
// Save and import the asset
string pathToMesh = GetMeshAssetPath(fname);
ImportUtils.ReadyToWrite(pathToMesh);
File.WriteAllText(pathToMesh, raw, Encoding.UTF8);
AssetDatabase.ImportAsset(pathToMesh, ImportAssetOptions.ForceSynchronousImport);
}
}
private void ImportTexturesFromXml(XDocument xml)
{
var texData = xml.Root.Elements("ImportTexture");
foreach (var tex in texData)
{
string name = tex.Attribute("filename").Value;
string data = tex.Value;
// The data is gzip compressed base64 string. We need the raw bytes.
//byte[] bytes = ImportUtils.GzipBase64ToBytes(data);
byte[] bytes = ImportUtils.Base64ToBytes(data);
// Save and import the texture asset
{
string pathToSave = GetTextureAssetPath(name);
ImportUtils.ReadyToWrite(pathToSave);
File.WriteAllBytes(pathToSave, bytes);
AssetDatabase.ImportAsset(pathToSave, ImportAssetOptions.ForceSynchronousImport);
}
// Create a material if needed in prepartion for the texture being successfully imported
{
string materialPath = GetMaterialAssetPath(name);
Material material = AssetDatabase.LoadAssetAtPath(materialPath, typeof(Material)) as Material;
if (material == null)
{
// We need to create the material afterall
// Use our custom shader
material = CreateMaterialFromXml(tex);
ImportUtils.ReadyToWrite(materialPath);
AssetDatabase.CreateAsset(material, materialPath);
}
}
}
}
private void ImportAllMaterials(Tiled2Unity.ImportBehaviour importComponent)
{
// Create a material for each texture that has been imported
foreach (var xmlTexture in importComponent.XmlDocument.Root.Elements("ImportTexture"))
{
bool isResource = ImportUtils.GetAttributeAsBoolean(xmlTexture, "isResource", false);
string textureFile = ImportUtils.GetAttributeAsString(xmlTexture, "filename");
string materialPath = MakeMaterialAssetPath(textureFile, isResource);
string materialFile = Path.GetFileName(materialPath);
// Keep track that we importing this material
importComponent.ImportWait_Materials.Add(materialFile);
// Create the material
UnityEngine.Material material = CreateMaterialFromXml(xmlTexture);
// Assign the texture to the material
{
string textureAsset = GetTextureAssetPath(textureFile);
Texture2D texture2d = AssetDatabase.LoadAssetAtPath(textureAsset, typeof(Texture2D)) as Texture2D;
material.SetTexture("_MainTex", texture2d);
}
ImportUtils.ReadyToWrite(materialPath);
ImportUtils.CreateOrReplaceAsset(material, materialPath);
importComponent.ImportTiled2UnityAsset(materialPath);
}
// Create a material for each internal texture
foreach (var xmlInternal in importComponent.XmlDocument.Root.Elements("InternalTexture"))
{
bool isResource = ImportUtils.GetAttributeAsBoolean(xmlInternal, "isResource", false);
string textureAsset = ImportUtils.GetAttributeAsString(xmlInternal, "assetPath");
string textureFile = Path.GetFileName(textureAsset);
string materialPath = MakeMaterialAssetPath(textureFile, isResource);
string materialFile = Path.GetFileName(materialPath);
// Keep track that we importing this material
importComponent.ImportWait_Materials.Add(materialFile);
// Create the material
UnityEngine.Material material = CreateMaterialFromXml(xmlInternal);
// Assign the texture to the material
{
Texture2D texture2d = AssetDatabase.LoadAssetAtPath(textureAsset, typeof(Texture2D)) as Texture2D;
material.SetTexture("_MainTex", texture2d);
}
ImportUtils.ReadyToWrite(materialPath);
ImportUtils.CreateOrReplaceAsset(material, materialPath);
importComponent.ImportTiled2UnityAsset(materialPath);
}
// If we have no materials to import then go to next stage (meshes)
if (importComponent.ImportWait_Materials.Count() == 0)
{
ImportAllMeshes(importComponent);
}
}
private void ImportAllMaterials(Tiled2Unity.ImportBehaviour importComponent)
{
// Create a material for each texture that has been imported
foreach (var xmlTexture in importComponent.XmlDocument.Root.Elements("ImportTexture"))
{
bool isResource = ImportUtils.GetAttributeAsBoolean(xmlTexture, "isResource", false);
string textureFile = ImportUtils.GetAttributeAsString(xmlTexture, "filename");
string materialPath = MakeMaterialAssetPath(textureFile, isResource);
string materialFile = System.IO.Path.GetFileName(materialPath);
// Keep track that we importing this material
if (!importComponent.ImportWait_Materials.Contains(materialFile, StringComparer.OrdinalIgnoreCase))
{
importComponent.ImportWait_Materials.Add(materialFile);
}
// Create the material
UnityEngine.Material material = CreateMaterialFromXml(xmlTexture, importComponent);
// Assign the texture to the material
{
string textureAsset = GetTextureAssetPath(textureFile);
AssignTextureAssetToMaterial(material, materialFile, textureAsset, importComponent);
}
ImportUtils.ReadyToWrite(materialPath);
ImportUtils.CreateOrReplaceAsset(material, materialPath);
importComponent.ImportTiled2UnityAsset(materialPath);
}
// Create a material for each internal texture
foreach (var xmlInternal in importComponent.XmlDocument.Root.Elements("InternalTexture"))
{
bool isResource = ImportUtils.GetAttributeAsBoolean(xmlInternal, "isResource", false);
string textureAsset = ImportUtils.GetAttributeAsString(xmlInternal, "assetPath");
string textureFile = System.IO.Path.GetFileName(textureAsset);
string materialPath = MakeMaterialAssetPath(textureFile, isResource);
// "Internal textures" may have a unique material name that goes with it
string uniqueMaterialName = ImportUtils.GetAttributeAsString(xmlInternal, "materialName", "");
if (!String.IsNullOrEmpty(uniqueMaterialName))
{
materialPath = String.Format("{0}/{1}{2}", Path.GetDirectoryName(materialPath), uniqueMaterialName, Path.GetExtension(materialPath));
materialPath = materialPath.Replace(System.IO.Path.DirectorySeparatorChar, '/');
}
string materialFile = System.IO.Path.GetFileName(materialPath);
// Keep track that we are importing this material
if (!importComponent.ImportWait_Materials.Contains(materialFile, StringComparer.OrdinalIgnoreCase))
{
importComponent.ImportWait_Materials.Add(materialFile);
}
// Create the material and assign the texture
UnityEngine.Material material = CreateMaterialFromXml(xmlInternal, importComponent);
AssignTextureAssetToMaterial(material, materialFile, textureAsset, importComponent);
ImportUtils.ReadyToWrite(materialPath);
ImportUtils.CreateOrReplaceAsset(material, materialPath);
importComponent.ImportTiled2UnityAsset(materialPath);
}
// If we have no materials to import then go to next stage (meshes)
if (importComponent.ImportWait_Materials.Count() == 0)
{
ImportAllMeshes(importComponent);
}
}
private void ImportAllMaterials(Tiled2Unity.ImportBehaviour importComponent)
{
// Create a material for each texture that has been imported
foreach (var xmlTexture in importComponent.XmlDocument.Root.Elements("ImportTexture"))
{
bool isResource = ImportUtils.GetAttributeAsBoolean(xmlTexture, "isResource", false);
string textureFile = ImportUtils.GetAttributeAsString(xmlTexture, "filename");
string materialPath = MakeMaterialAssetPath(textureFile, isResource);
string materialFile = System.IO.Path.GetFileName(materialPath);
// Keep track that we importing this material
if (!importComponent.ImportWait_Materials.Contains(materialFile, StringComparer.OrdinalIgnoreCase))
{
importComponent.ImportWait_Materials.Add(materialFile);
}
// Create the material
UnityEngine.Material material = CreateMaterialFromXml(xmlTexture, importComponent);
// Assign the texture to the material
{
string textureAsset = GetTextureAssetPath(textureFile);
AssignTextureAssetToMaterial(material, materialFile, textureAsset, importComponent);
}
ImportUtils.ReadyToWrite(materialPath);
ImportUtils.CreateOrReplaceAsset(material, materialPath);
importComponent.ImportTiled2UnityAsset(materialPath);
}
// Create a material for each internal texture
foreach (var xmlInternal in importComponent.XmlDocument.Root.Elements("InternalTexture"))
{
bool isResource = ImportUtils.GetAttributeAsBoolean(xmlInternal, "isResource", false);
string textureAsset = ImportUtils.GetAttributeAsString(xmlInternal, "assetPath");
string textureFile = System.IO.Path.GetFileName(textureAsset);
string materialPath = MakeMaterialAssetPath(textureFile, isResource);
string materialFile = System.IO.Path.GetFileName(materialPath);
// Keep track that we importing this material
if (!importComponent.ImportWait_Materials.Contains(materialFile, StringComparer.OrdinalIgnoreCase))
{
importComponent.ImportWait_Materials.Add(materialFile);
}
// Create the material and assign the texture
UnityEngine.Material material = CreateMaterialFromXml(xmlInternal, importComponent);
AssignTextureAssetToMaterial(material, materialFile, textureAsset, importComponent);
ImportUtils.ReadyToWrite(materialPath);
ImportUtils.CreateOrReplaceAsset(material, materialPath);
importComponent.ImportTiled2UnityAsset(materialPath);
}
// If we have no materials to import then go to next stage (meshes)
if (importComponent.ImportWait_Materials.Count() == 0)
{
ImportAllMeshes(importComponent);
}
}