public override void OnImportAsset(AssetImportContext ctx)
{
var fileName = System.IO.Path.GetFileNameWithoutExtension(ctx.assetPath);
var go = new GameObject(fileName);
var usdStream = go.AddComponent <UsdStream>();
usdStream.importSettings = new usdi.ImportSettings()
{
interpolation = m_importSettings.interpolation,
normalCalculation = m_importSettings.normalCalculation,
tangentCalculation = m_importSettings.tangentCalculation,
maxBoneWeights = m_importSettings.maxBoneWeights,
scale = m_importSettings.scale,
loadAllPayloads = true,
triangulate = true,
swapHandedness = m_importSettings.swapHandedness,
swapFaces = m_importSettings.swapFaces,
splitMesh = true,
doubleBuffering = true,
};
usdStream.directVBUpdate = m_directVBUpdate;
usdStream.forceSingleThread = m_forceSingleThread;
usdStream.timeUnit = m_timeUnit;
usdStream.playTime = m_time;
usdStream.LoadImmediate(ctx.assetPath);
var material = new Material(Shader.Find("Standard"))
{
};
material.name = "Material_0";
ctx.AddSubAsset("Default Material", material);
_subObjects = new SortedDictionary <int, UnityEngine.Object>();
CollectSubAssets(go.transform, material);
int i = 0;
foreach (var m in _subObjects)
{
if (String.IsNullOrEmpty(m.Value.name) || m.Value.name.IndexOf("<dyn>") == 0)
{
m.Value.name = fileName + "_" + m.Value.GetType().Name + "_" + (++i);
}
ctx.AddSubAsset(m.Value.name, m.Value);
}
if (m_importMode == UsdImportMode.StripUSD)
{
usdStream.usdiDetachUsdComponents();
}
ctx.SetMainAsset(fileName, go);
}
public void AddTextures(AssetImportContext ctx, GLTFObject gltfObject)
{
for (int i = 0; i < gltfObject.images.Count; i++)
{
// Dont add asset textures
if (gltfObject.images[i].imageIsAsset)
{
continue;
}
Texture2D tex = gltfObject.images[i].GetTexture();
if (tex == null)
{
continue;
}
if (string.IsNullOrEmpty(tex.name))
{
tex.name = "texture" + i.ToString();
}
#if UNITY_2018_2_OR_NEWER
ctx.AddObjectToAsset(i.ToString(), tex);
#else
ctx.AddSubAsset(i.ToString(), glbObject.images[i].GetTexture());
#endif
}
}
private void CollectSubAssets(AssetImportContext ctx, AlembicTreeNode node, Material mat)
{
if (m_ImportSettings.m_importMeshes)
{
var meshFilter = node.linkedGameObj.GetComponent <MeshFilter>();
if (meshFilter != null)
{
var m = meshFilter.sharedMesh;
m.name = node.linkedGameObj.name;
ctx.AddSubAsset(m.name, m);
}
}
var renderer = node.linkedGameObj.GetComponent <MeshRenderer>();
if (renderer != null)
{
renderer.material = mat;
}
foreach (var child in node.children)
{
CollectSubAssets(ctx, child, mat);
}
}
public void Add(string identifier, Object asset)
{
#if UNITY_2017_3_OR_NEWER
m_ctx.AddObjectToAsset(identifier, asset);
#else
m_ctx.AddSubAsset(identifier, asset);
#endif
}
private static void AddObjectToAsset(AssetImportContext ctx, string identifier, Object asset)
{
#if UNITY_2017_3_OR_NEWER
ctx.AddObjectToAsset(identifier, asset);
#else
ctx.AddSubAsset(identifier, asset);
#endif
}
public static void AddAsset(this AssetImportContext ctx, string identifier, Object obj)
{
#if UNITY_2018_2_OR_NEWER
ctx.AddObjectToAsset(identifier, obj);
#else
ctx.AddSubAsset(identifier, obj);
#endif
}
private void GenerateSubAssets(AssetImportContext ctx, GameObject go, AlembicStream stream)
{
var material = new Material(Shader.Find("Standard"))
{
};
ctx.AddSubAsset("Default Material", material);
CollectSubAssets(ctx, stream.AlembicTreeRoot, material);
}
public GameObject GenerateUnityObject(CameraData playable, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
var playableObj = MakePlayableBaseObject(playable, parent);
var transformAnchor = new GameObject("TransformAnchor");
playable.CurrentShotOffset.ApplyTo(transformAnchor.transform);
transformAnchor.transform.SetParent(playableObj.transform, false);
var cam = transformAnchor.AddComponent <Camera>();
cam.backgroundColor = stage.backgroundColor;
cam.clearFlags = CameraClearFlags.SolidColor;
// TODO: Field of view
cam.stereoTargetEye = StereoTargetEyeMask.None;
var pathForName = AnimationUtility.CalculateTransformPath(transformAnchor.transform, stageTransform);
var groupTrack = parentTimeline.CreateTrack <GroupTrack>(parentTrack, playable.displayName);
ctx.AddSubAsset(pathForName + "_GroupTrack", groupTrack);
if (playable.Timeline.Frames.Count > 0)
{
var animTrack = parentTimeline.CreateTrack <AnimationTrack>(groupTrack, pathForName + "_TransformTrack");
director.SetGenericBinding(animTrack, animator);
ctx.AddSubAsset(pathForName + "_TransformTrack", animTrack);
var animationClip = MakeAnimationClip(playable.Timeline, AnimationUtility.CalculateTransformPath(transformAnchor.transform, rootTransform));
ctx.AddSubAsset(pathForName + "_animation", animationClip);
var timelineClip = animTrack.CreateClip(animationClip);
timelineClip.start = (playable.AbsoluteTimeOffset + frameOffset) / stage.fps;
timelineClip.displayName = playable.displayName;
ctx.AddSubAsset(pathForName + "_asset", timelineClip.asset);
}
return(playableObj);
}
public void AddAnimations(AssetImportContext ctx, GLTFObject gltfObject)
{
for (int i = 0; i < gltfObject.animations.Count; i++)
{
AnimationClip clip = gltfObject.animations[i].Clip;
#if UNITY_2018_2_OR_NEWER
ctx.AddObjectToAsset(clip.name, clip);
#else
ctx.AddSubAsset(clip.name, clip);
#endif
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
m_ImportSettings.m_pathToAbc = new DataPath(ctx.assetPath);
var mainObject = AlembicImportTasker.Import(m_importMode, m_ImportSettings, m_diagSettings, (stream, mainGO, streamDescr) =>
{
GenerateSubAssets(ctx, mainGO, stream);
if (streamDescr != null)
{
ctx.AddSubAsset(mainGO.name, streamDescr);
}
});
ctx.SetMainAsset(mainObject.name, mainObject);
}
public void AddMaterials(AssetImportContext ctx, GLTFObject gltfObject)
{
for (int i = 0; i < gltfObject.materials.Count; i++)
{
Material mat = gltfObject.materials[i].GetMaterial();
if (string.IsNullOrEmpty(mat.name))
{
mat.name = "material" + i.ToString();
}
#if UNITY_2018_2_OR_NEWER
ctx.AddObjectToAsset(mat.name, mat);
#else
ctx.AddSubAsset(mat.name, mat);
#endif
}
}
public override void OnImportAsset(AssetImportContext impContext)
{
Attributes attributes = JsonUtility.FromJson <Attributes>(File.ReadAllText(impContext.assetPath));
Texture2D texture = new Texture2D(attributes.width, attributes.height, attributes.tFormat, attributes.mips, true);
texture.SetPixels(attributes.colors);
texture.Apply();
texture.wrapMode = TextureWrapMode.Clamp;
texture.filterMode = FilterMode.Point;
#if !UNITY_2017_3_OR_NEWER
impContext.AddSubAsset("AttributesImage", texture);
impContext.SetMainAsset("AttributesImage", texture);
#else
impContext.AddObjectToAsset("AttributesImage", texture);
impContext.SetMainObject(texture);
#endif
}
public void AddMeshes(AssetImportContext ctx, GLTFObject gltfObject)
{
for (int i = 0; i < gltfObject.meshes.Count; i++)
{
Mesh mesh = gltfObject.meshes[i].GetMesh();
if (mesh == null)
{
Debug.LogWarning("Mesh at index " + i + " was null");
continue;
}
#if UNITY_2018_2_OR_NEWER
ctx.AddObjectToAsset(gltfObject.meshes[i].name, gltfObject.meshes[i].GetCachedMesh());
#else
ctx.AddSubAsset(glbObject.meshes[i].name, glbObject.meshes[i].GetCachedMesh());
#endif
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
stage = AnimData.LoadFromFile(ctx.assetPath);
if (stage == null)
{
return;
}
MeshUtils.SimplifyStage(stage);
savedClips = new Dictionary <AudioDataPool.AudioPoolKey, AudioClip>();
totalVertices = 0;
totalLines = 0;
PreviewTexture = new Texture2D(1, 1);
PreviewTexture.LoadImage(stage.previewFrames[0], false);
PreviewTexture.Apply();
if (Settings.Shader == null)
{
Settings.Shader = "AnimVR/Standard";
}
materialToUse = new Material(Shader.Find(Settings.Shader));
materialToUse.SetFloat("_Unlit", Settings.UnlitByDefault ? 1 : 0);
materialToUse.name = "BaseMaterial";
ctx.AddSubAsset("BaseMaterial", materialToUse);
needsAudioReimport = false;
var stageObj = GenerateUnityObject(stage, ctx);
ctx.SetMainAsset(stage.name, stageObj, PreviewTexture);
InfoString = "FPS: " + stage.fps + ", " + stage.timelineLength + " frames \n"
+ totalVertices + " verts, " + totalLines + " lines";
savedClips = null;
stage = null;
}
public GameObject GenerateUnityObject(StageData stage, AssetImportContext ctx)
{
var stageObj = new GameObject(stage.name);
stageTransform = rootTransform = stageObj.transform;
director = stageObj.AddComponent <PlayableDirector>();
director.extrapolationMode = Settings.DefaultWrapMode;
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
timelineAsset.name = stage.name + "_Timeline";
timelineAsset.editorSettings.fps = stage.fps;
timelineAsset.durationMode = TimelineAsset.DurationMode.FixedLength;
timelineAsset.fixedDuration = stage.timelineLength * 1.0 / stage.fps;
ctx.AddSubAsset(timelineAsset.name, timelineAsset);
director.playableAsset = timelineAsset;
animator = stageObj.AddComponent <Animator>();
foreach (var symbol in stage.Symbols)
{
var symbolObj = GenerateUnityObject(symbol, 0, ctx, timelineAsset, null, stageObj.transform);
symbolObj.transform.SetParent(stageObj.transform, false);
if (Settings.ApplyStageTransform)
{
symbolObj.transform.localPosition += stage.transform.pos;
symbolObj.transform.localRotation *= stage.transform.rot;
var scl = symbolObj.transform.localScale;
var s = stage.transform.scl;
symbolObj.transform.localScale = new Vector3(scl.x * s.x, scl.y * s.y, scl.z * s.z);
}
}
return(stageObj);
}
public GameObject GenerateUnityObject(StaticMeshData playable, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
var playableObj = MakePlayableBaseObject(playable, parent);
var transformAnchor = new GameObject("TransformAnchor");
transformAnchor.transform.SetParent(playableObj.transform, false);
var pathForName = AnimationUtility.CalculateTransformPath(transformAnchor.transform, stageTransform);
List <Material> materials = new List <Material>();
int matIndex = 0;
foreach (var matData in playable.Materials)
{
var mat = MeshUtils.MaterialFromData(matData, materialToUse);
mat.name = pathForName + "_material" + (matIndex++).ToString();
ctx.AddSubAsset(mat.name, mat);
if (mat.mainTexture)
{
ctx.AddSubAsset(mat.name + "_diffuse", mat.mainTexture);
}
materials.Add(mat);
}
int partIndex = 0;
foreach (var part in playable.Frames)
{
var partObj = new GameObject("MeshPart");
var mf = partObj.AddComponent <MeshFilter>();
var mr = partObj.AddComponent <MeshRenderer>();
partObj.transform.SetParent(transformAnchor.transform, false);
mr.sharedMaterial = materials[part.MaterialIndex];
mf.sharedMesh = MeshUtils.MeshFromData(part);
mf.sharedMesh.name = pathForName + "_mesh" + (partIndex).ToString();
ctx.AddSubAsset(mf.sharedMesh.name, mf.sharedMesh);
totalVertices += mf.sharedMesh.vertexCount;
}
var groupTrack = parentTimeline.CreateTrack <GroupTrack>(parentTrack, playable.displayName);
ctx.AddSubAsset(pathForName + "_GroupTrack", groupTrack);
double clipStart = (playable.AbsoluteTimeOffset + frameOffset) / stage.fps;
double clipDuration = 1.0 / stage.fps;
if (playable.InstanceMap.Count > 1)
{
var animTrack = parentTimeline.CreateTrack <AnimationTrack>(groupTrack, pathForName + "_TransformTrack");
director.SetGenericBinding(animTrack, animator);
ctx.AddSubAsset(pathForName + "_TransformTrack", animTrack);
var animationClip = MakeAnimationClip(playable.InstanceMap, null, AnimationUtility.CalculateTransformPath(transformAnchor.transform, rootTransform));
animationClip.name = pathForName + "_animation";
ctx.AddSubAsset(pathForName + "_animation", animationClip);
var timelineClip = animTrack.CreateClip(animationClip);
timelineClip.start = clipStart;
timelineClip.displayName = playable.displayName;
typeof(TimelineClip).GetProperty("preExtrapolationMode").SetValue(timelineClip, LOOP_MAPPING[playable.LoopIn], null);
typeof(TimelineClip).GetProperty("postExtrapolationMode").SetValue(timelineClip, LOOP_MAPPING[playable.LoopOut], null);
clipDuration = timelineClip.duration;
ctx.AddSubAsset(pathForName + "_asset", timelineClip.asset);
}
else
{
playable.InstanceMap[0].ApplyTo(transformAnchor.transform);
}
var activeTrack = parentTimeline.CreateTrack <ActivationTrack>(groupTrack, pathForName + "_Activation");
ctx.AddSubAsset(pathForName + "_Activation", activeTrack);
director.SetGenericBinding(activeTrack, playableObj);
var clip = activeTrack.CreateDefaultClip();
clip.start = playable.LoopIn != AnimVR.LoopType.OneShot ? 0 : clipStart;
clip.duration = playable.LoopOut != AnimVR.LoopType.OneShot ? parentTimeline.fixedDuration - clip.start : (clipStart - clip.start) + clipDuration;
ctx.AddSubAsset(pathForName + "_activeAsset", clip.asset);
return(playableObj);
}
public override void OnImportAsset(AssetImportContext ctx)
{
{
var ext = Path.GetExtension(ctx.assetPath).ToLower();
if (ext == ".vox")
{
fileType = VoxelBase.FileType.vox;
}
else if (ext == ".qb")
{
fileType = VoxelBase.FileType.qb;
}
else
{
return;
}
}
#region DefaultScale
if (dataVersion == 0 &&
importScale == Vector3.one &&
AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(ctx.assetPath) == null)
{
var x = EditorPrefs.GetFloat("VoxelImporter_DefaultScaleX", 1f);
var y = EditorPrefs.GetFloat("VoxelImporter_DefaultScaleY", 1f);
var z = EditorPrefs.GetFloat("VoxelImporter_DefaultScaleZ", 1f);
importScale = new Vector3(x, y, z);
}
#endregion
Action <string> LogImportError = (log) =>
{
#if UNITY_2018_1_OR_NEWER
ctx.LogImportError(log);
#else
Debug.LogError(log);
#endif
};
var gameObject = new GameObject(Path.GetFileNameWithoutExtension(ctx.assetPath));
var voxelObject = gameObject.AddComponent <VoxelObject>();
{
voxelObject.legacyVoxImport = legacyVoxImport;
voxelObject.importMode = importMode;
voxelObject.importScale = importScale;
voxelObject.importOffset = importOffset;
voxelObject.combineFaces = combineFaces;
voxelObject.ignoreCavity = ignoreCavity;
voxelObject.voxelStructure = outputStructure ? ScriptableObject.CreateInstance <VoxelStructure>() : null;
voxelObject.generateLightmapUVs = generateLightmapUVs;
voxelObject.generateLightmapUVsAngleError = generateLightmapUVsAngleError;
voxelObject.generateLightmapUVsAreaError = generateLightmapUVsAreaError;
voxelObject.generateLightmapUVsHardAngle = generateLightmapUVsHardAngle;
voxelObject.generateLightmapUVsPackMargin = generateLightmapUVsPackMargin;
voxelObject.generateTangents = generateTangents;
voxelObject.meshFaceVertexOffset = meshFaceVertexOffset;
voxelObject.loadFromVoxelFile = loadFromVoxelFile;
voxelObject.generateMipMaps = generateMipMaps;
}
var objectCore = new VoxelObjectCore(voxelObject);
try
{
if (!objectCore.Create(ctx.assetPath, null))
{
LogImportError(string.Format("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath));
DestroyImmediate(gameObject);
return;
}
}
catch
{
LogImportError(string.Format("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath));
DestroyImmediate(gameObject);
return;
}
#region Correspondence in Issue ID 947055 Correction in case before correction is applied
for (int i = 0; i < voxelObject.materials.Count; i++)
{
if (voxelObject.materials[i] != null)
{
voxelObject.materials[i].hideFlags |= HideFlags.NotEditable;
}
}
if (voxelObject.atlasTexture != null)
{
voxelObject.atlasTexture.hideFlags |= HideFlags.NotEditable;
}
if (voxelObject.mesh != null)
{
voxelObject.mesh.hideFlags |= HideFlags.NotEditable;
}
#endregion
#region Material
{
materials = new Material[voxelObject.materialIndexes.Count];
materialNames = new string[voxelObject.materialIndexes.Count];
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var index = voxelObject.materialIndexes[i];
var material = voxelObject.materials[index];
material.name = string.Format("mat{0}", index);
materials[i] = material;
materialNames[i] = material.name;
}
if (remappedMaterials != null)
{
remappedMaterials = remappedMaterials.Where(item => item.material != null).ToArray();
}
}
#endregion
#region Collider
switch (colliderType)
{
case ColliderType.Box:
gameObject.AddComponent <BoxCollider>();
break;
case ColliderType.Sphere:
gameObject.AddComponent <SphereCollider>();
break;
case ColliderType.Capsule:
gameObject.AddComponent <CapsuleCollider>();
break;
case ColliderType.Mesh:
gameObject.AddComponent <MeshCollider>();
break;
}
#endregion
#if UNITY_2017_3_OR_NEWER
ctx.AddObjectToAsset(gameObject.name, gameObject);
ctx.AddObjectToAsset(voxelObject.mesh.name = "mesh", voxelObject.mesh);
{
var materials = new List <Material>();
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var material = voxelObject.materials[voxelObject.materialIndexes[i]];
materials.Add(material);
if (remappedMaterials != null)
{
var index = ArrayUtility.FindIndex(remappedMaterials, (t) => { return(t.name == material.name); });
if (index >= 0)
{
materials[i] = remappedMaterials[index].material;
continue;
}
}
ctx.AddObjectToAsset(material.name, material);
}
gameObject.GetComponent <MeshRenderer>().sharedMaterials = materials.ToArray();
}
ctx.AddObjectToAsset(voxelObject.atlasTexture.name = "tex", voxelObject.atlasTexture);
if (voxelObject.voxelStructure != null)
{
ctx.AddObjectToAsset(voxelObject.voxelStructure.name = "structure", voxelObject.voxelStructure);
}
VoxelObject.DestroyImmediate(voxelObject);
ctx.SetMainObject(gameObject);
#else
ctx.SetMainAsset(gameObject.name, gameObject);
ctx.AddSubAsset(voxelObject.mesh.name = "mesh", voxelObject.mesh);
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var material = voxelObject.materials[voxelObject.materialIndexes[i]];
ctx.AddSubAsset(material.name, material);
}
ctx.AddSubAsset(voxelObject.atlasTexture.name = "tex", voxelObject.atlasTexture);
if (voxelObject.voxelStructure != null)
{
ctx.AddSubAsset(voxelObject.voxelStructure.name = "structure", voxelObject.voxelStructure);
}
VoxelObject.DestroyImmediate(voxelObject);
#endif
dataVersion = EditorDataVersion;
}
public override void OnImportAsset(AssetImportContext ctx)
{
{
var ext = Path.GetExtension(ctx.assetPath).ToLower();
if (ext == ".vox")
{
fileType = VoxelBase.FileType.vox;
}
else if (ext == ".qb")
{
fileType = VoxelBase.FileType.qb;
}
else
{
return;
}
}
#region DefaultScale
if (dataVersion == 0 &&
importScale == Vector3.one &&
AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(ctx.assetPath) == null)
{
var x = EditorPrefs.GetFloat("VoxelImporter_DefaultScaleX", 1f);
var y = EditorPrefs.GetFloat("VoxelImporter_DefaultScaleY", 1f);
var z = EditorPrefs.GetFloat("VoxelImporter_DefaultScaleZ", 1f);
importScale = new Vector3(x, y, z);
}
#endregion
#region LegacyAssetNaming
if (dataVersion > 0 && dataVersion < 6)
{
legacyAssetNaming = true;
}
#endregion
Action <string> LogImportError = (log) =>
{
#if UNITY_2018_1_OR_NEWER
ctx.LogImportError(log);
#else
Debug.LogError(log);
#endif
};
Action <VoxelBase> SetBasicOptions = (voxelObject) =>
{
voxelObject.importMode = importMode;
voxelObject.importScale = importScale;
voxelObject.importOffset = importOffset;
voxelObject.combineFaces = combineFaces;
voxelObject.ignoreCavity = ignoreCavity;
voxelObject.shareSameFace = shareSameFace;
voxelObject.removeUnusedPalettes = removeUnusedPalettes;
voxelObject.voxelStructure = outputStructure ? ScriptableObject.CreateInstance <VoxelStructure>() : null;
voxelObject.generateLightmapUVs = generateLightmapUVs;
voxelObject.generateLightmapUVsAngleError = generateLightmapUVsAngleError;
voxelObject.generateLightmapUVsAreaError = generateLightmapUVsAreaError;
voxelObject.generateLightmapUVsHardAngle = generateLightmapUVsHardAngle;
voxelObject.generateLightmapUVsPackMargin = generateLightmapUVsPackMargin;
voxelObject.generateTangents = generateTangents;
voxelObject.meshFaceVertexOffset = meshFaceVertexOffset;
voxelObject.loadFromVoxelFile = loadFromVoxelFile;
voxelObject.generateMipMaps = generateMipMaps;
voxelObject.legacyVoxImport = legacyVoxImport;
voxelObject.legacyAssetNaming = legacyAssetNaming;
};
Action <VoxelBaseCore> Export = (core) =>
{
if (export)
{
var fullPath = Application.dataPath + ctx.assetPath.Remove(0, "Assets".Length);
fullPath = fullPath.Remove(fullPath.LastIndexOf('.')) + ".dae";
core.ExportDaeFile(fullPath, false);
}
};
var gameObject = new GameObject(Path.GetFileNameWithoutExtension(ctx.assetPath));
if (string.IsNullOrEmpty(gameObjectName))
{
gameObjectName = gameObject.name;
}
if (meshMode == MeshMode.Combine)
{
#region Combine
var voxelObject = gameObject.AddComponent <VoxelObject>();
SetBasicOptions(voxelObject);
var objectCore = new VoxelObjectCore(voxelObject);
try
{
if (!objectCore.Create(ctx.assetPath, null))
{
LogImportError(string.Format("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath));
DestroyImmediate(gameObject);
return;
}
}
catch
{
LogImportError(string.Format("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath));
DestroyImmediate(gameObject);
return;
}
#region Correspondence in Issue ID 947055 Correction in case before correction is applied
foreach (var material in voxelObject.materials)
{
if (material != null)
{
material.hideFlags |= HideFlags.NotEditable;
}
}
if (voxelObject.atlasTexture != null)
{
voxelObject.atlasTexture.hideFlags |= HideFlags.NotEditable;
}
if (voxelObject.mesh != null)
{
voxelObject.mesh.hideFlags |= HideFlags.NotEditable;
}
#endregion
#region Material
{
materials = new Material[voxelObject.materialIndexes.Count];
materialNames = new string[voxelObject.materialIndexes.Count];
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var index = voxelObject.materialIndexes[i];
var material = voxelObject.materials[index];
materials[i] = material;
materialNames[i] = material.name;
}
if (remappedMaterials != null)
{
remappedMaterials = remappedMaterials.Where(item => item.material != null && materialNames.Contains(item.name)).ToArray();
}
}
#endregion
#region Structure
if (voxelObject.voxelStructure != null)
{
if (legacyAssetNaming)
{
voxelObject.voxelStructure.name = "structure";
}
else
{
voxelObject.voxelStructure.name = Path.GetFileNameWithoutExtension(ctx.assetPath);
}
}
#endregion
#region Collider
switch (colliderType)
{
case ColliderType.Box:
gameObject.AddComponent <BoxCollider>();
break;
case ColliderType.Sphere:
gameObject.AddComponent <SphereCollider>();
break;
case ColliderType.Capsule:
gameObject.AddComponent <CapsuleCollider>();
break;
case ColliderType.Mesh:
gameObject.AddComponent <MeshCollider>();
break;
}
#endregion
Export(objectCore);
#if UNITY_2017_3_OR_NEWER
ctx.AddObjectToAsset(gameObjectName, gameObject);
ctx.AddObjectToAsset("mesh", voxelObject.mesh);
{
var list = new List <Material>();
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var material = voxelObject.materials[voxelObject.materialIndexes[i]];
list.Add(material);
if (remappedMaterials != null)
{
var index = ArrayUtility.FindIndex(remappedMaterials, (t) => { return(t.name == material.name); });
if (index >= 0)
{
list[i] = remappedMaterials[index].material;
continue;
}
}
ctx.AddObjectToAsset(string.Format("mat{0}", i), material);
}
gameObject.GetComponent <MeshRenderer>().sharedMaterials = list.ToArray();
}
ctx.AddObjectToAsset("tex", voxelObject.atlasTexture);
if (voxelObject.voxelStructure != null)
{
ctx.AddObjectToAsset("structure", voxelObject.voxelStructure);
}
VoxelObject.DestroyImmediate(voxelObject);
ctx.SetMainObject(gameObject);
#else
ctx.SetMainAsset(gameObjectName, gameObject);
ctx.AddSubAsset("mesh", voxelObject.mesh);
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var material = voxelObject.materials[voxelObject.materialIndexes[i]];
ctx.AddSubAsset(string.Format("mat{0}", i), material);
}
ctx.AddSubAsset("tex", voxelObject.atlasTexture);
if (voxelObject.voxelStructure != null)
{
ctx.AddSubAsset("structure", voxelObject.voxelStructure);
}
VoxelObject.DestroyImmediate(voxelObject);
#endif
#endregion
}
else if (meshMode == MeshMode.Individual)
{
#region Individual
var voxelObject = gameObject.AddComponent <VoxelChunksObject>();
SetBasicOptions(voxelObject);
{
voxelObject.createContactChunkFaces = createContactChunkFaces;
voxelObject.materialMode = materialMode;
}
var objectCore = new VoxelChunksObjectCore(voxelObject);
try
{
if (!objectCore.Create(ctx.assetPath, null))
{
LogImportError(string.Format("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath));
DestroyImmediate(gameObject);
return;
}
}
catch
{
LogImportError(string.Format("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath));
DestroyImmediate(gameObject);
return;
}
#region Correspondence in Issue ID 947055 Correction in case before correction is applied
if (voxelObject.materials != null)
{
foreach (var material in voxelObject.materials)
{
if (material != null)
{
material.hideFlags |= HideFlags.NotEditable;
}
}
}
if (voxelObject.atlasTexture != null)
{
voxelObject.atlasTexture.hideFlags |= HideFlags.NotEditable;
}
foreach (var chunk in voxelObject.chunks)
{
if (chunk.materials != null)
{
foreach (var material in chunk.materials)
{
if (material != null)
{
material.hideFlags |= HideFlags.NotEditable;
}
}
}
if (chunk.atlasTexture != null)
{
chunk.atlasTexture.hideFlags |= HideFlags.NotEditable;
}
if (chunk.mesh != null)
{
chunk.mesh.hideFlags |= HideFlags.NotEditable;
}
}
#endregion
#region Legacy
if (legacyAssetNaming)
{
foreach (var chunk in voxelObject.chunks)
{
var oldName = chunk.chunkName;
chunk.chunkName = chunk.chunkName.Replace("Chunk(", "");
chunk.chunkName = chunk.chunkName.Remove(chunk.chunkName.Length - 1, 1);
chunk.gameObject.name = chunk.chunkName;
chunk.mesh.name = chunk.mesh.name.Replace(oldName, chunk.chunkName);
if (chunk.materials != null)
{
foreach (var mat in chunk.materials)
{
if (mat == null)
{
continue;
}
mat.name = mat.name.Replace(oldName, chunk.chunkName);
}
}
if (chunk.atlasTexture != null)
{
chunk.atlasTexture.name = chunk.atlasTexture.name.Replace(oldName, chunk.chunkName);
}
}
}
#endregion
#region Material
{
if (materialMode == VoxelChunksObject.MaterialMode.Combine)
{
materials = new Material[voxelObject.materialIndexes.Count];
materialNames = new string[voxelObject.materialIndexes.Count];
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var index = voxelObject.materialIndexes[i];
var material = voxelObject.materials[index];
materials[i] = material;
materialNames[i] = material.name;
}
}
else if (materialMode == VoxelChunksObject.MaterialMode.Individual)
{
List <Material> list = new List <Material>();
foreach (var chunk in voxelObject.chunks)
{
for (int i = 0; i < chunk.materialIndexes.Count; i++)
{
var index = chunk.materialIndexes[i];
var material = chunk.materials[index];
if (!list.Contains(material))
{
list.Add(material);
}
}
}
materials = list.ToArray();
materialNames = new string[list.Count];
for (int i = 0; i < list.Count; i++)
{
materialNames[i] = list[i].name;
}
}
if (remappedMaterials != null)
{
remappedMaterials = remappedMaterials.Where(item => item.material != null && materialNames.Contains(item.name)).ToArray();
}
}
#endregion
#region Structure
if (voxelObject.voxelStructure != null)
{
if (legacyAssetNaming)
{
voxelObject.voxelStructure.name = "structure";
}
else
{
voxelObject.voxelStructure.name = Path.GetFileNameWithoutExtension(ctx.assetPath);
}
}
#endregion
#region Collider
foreach (var chunk in voxelObject.chunks)
{
switch (colliderType)
{
case ColliderType.Box:
chunk.gameObject.AddComponent <BoxCollider>();
break;
case ColliderType.Sphere:
chunk.gameObject.AddComponent <SphereCollider>();
break;
case ColliderType.Capsule:
chunk.gameObject.AddComponent <CapsuleCollider>();
break;
case ColliderType.Mesh:
chunk.gameObject.AddComponent <MeshCollider>();
break;
}
}
#endregion
Export(objectCore);
#if UNITY_2017_3_OR_NEWER
ctx.AddObjectToAsset(gameObjectName, gameObject);
foreach (var chunk in voxelObject.chunks)
{
ctx.AddObjectToAsset(chunk.chunkName + "_mesh", chunk.mesh);
}
{
if (materialMode == VoxelChunksObject.MaterialMode.Combine)
{
var materials = new List <Material>();
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var material = voxelObject.materials[voxelObject.materialIndexes[i]];
materials.Add(material);
if (remappedMaterials != null)
{
var index = ArrayUtility.FindIndex(remappedMaterials, (t) => { return(t.name == material.name); });
if (index >= 0)
{
materials[i] = remappedMaterials[index].material;
continue;
}
}
ctx.AddObjectToAsset(string.Format("mat{0}", i), material);
}
foreach (var chunk in voxelObject.chunks)
{
chunk.gameObject.GetComponent <MeshRenderer>().sharedMaterials = materials.ToArray();
}
ctx.AddObjectToAsset("tex", voxelObject.atlasTexture);
}
else if (materialMode == VoxelChunksObject.MaterialMode.Individual)
{
foreach (var chunk in voxelObject.chunks)
{
var materials = new List <Material>();
for (int i = 0; i < chunk.materialIndexes.Count; i++)
{
var material = chunk.materials[chunk.materialIndexes[i]];
materials.Add(material);
if (remappedMaterials != null)
{
var index = ArrayUtility.FindIndex(remappedMaterials, (t) => { return(t.name == material.name); });
if (index >= 0)
{
materials[i] = remappedMaterials[index].material;
continue;
}
}
ctx.AddObjectToAsset(chunk.gameObject.name + string.Format("_mat{0}", i), material);
}
chunk.gameObject.GetComponent <MeshRenderer>().sharedMaterials = materials.ToArray();
ctx.AddObjectToAsset(chunk.gameObject.name + "_tex", chunk.atlasTexture);
}
}
}
if (voxelObject.voxelStructure != null)
{
ctx.AddObjectToAsset("structure", voxelObject.voxelStructure);
}
foreach (var chunk in voxelObject.chunks)
{
VoxelChunksObjectChunk.DestroyImmediate(chunk.GetComponent <VoxelChunksObjectChunk>());
}
VoxelObject.DestroyImmediate(voxelObject);
ctx.SetMainObject(gameObject);
#else
ctx.SetMainAsset(gameObjectName, gameObject);
foreach (var chunk in voxelObject.chunks)
{
ctx.AddSubAsset(chunk.gameObject.name + "_mesh", chunk.mesh);
}
{
if (materialMode == VoxelChunksObject.MaterialMode.Combine)
{
var materials = new List <Material>();
for (int i = 0; i < voxelObject.materialIndexes.Count; i++)
{
var material = voxelObject.materials[voxelObject.materialIndexes[i]];
materials.Add(material);
if (remappedMaterials != null)
{
var index = ArrayUtility.FindIndex(remappedMaterials, (t) => { return(t.name == material.name); });
if (index >= 0)
{
materials[i] = remappedMaterials[index].material;
continue;
}
}
ctx.AddSubAsset(string.Format("mat{0}", i), material, material);
}
foreach (var chunk in voxelObject.chunks)
{
chunk.gameObject.GetComponent <MeshRenderer>().sharedMaterials = materials.ToArray();
}
ctx.AddSubAsset("tex", voxelObject.atlasTexture);
}
else if (materialMode == VoxelChunksObject.MaterialMode.Individual)
{
foreach (var chunk in voxelObject.chunks)
{
var materials = new List <Material>();
for (int i = 0; i < chunk.materialIndexes.Count; i++)
{
var material = chunk.materials[chunk.materialIndexes[i]];
materials.Add(material);
if (remappedMaterials != null)
{
var index = ArrayUtility.FindIndex(remappedMaterials, (t) => { return(t.name == material.name); });
if (index >= 0)
{
materials[i] = remappedMaterials[index].material;
continue;
}
}
ctx.AddSubAsset(chunk.gameObject.name + string.Format("_mat{0}", i), material);
}
chunk.gameObject.GetComponent <MeshRenderer>().sharedMaterials = materials.ToArray();
ctx.AddSubAsset(chunk.gameObject.name + "_tex", chunk.atlasTexture);
}
}
}
if (voxelObject.voxelStructure != null)
{
ctx.AddSubAsset("structure", voxelObject.voxelStructure);
}
foreach (var chunk in voxelObject.chunks)
{
VoxelChunksObjectChunk.DestroyImmediate(chunk.GetComponent <VoxelChunksObjectChunk>());
}
VoxelObject.DestroyImmediate(voxelObject);
#endif
#endregion
}
dataVersion = EditorDataVersion;
}
public GameObject GenerateUnityObject(SymbolData symbol, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
var symbolObj = MakePlayableBaseObject(symbol, parent);
var path = AnimationUtility.CalculateTransformPath(symbolObj.transform, stageTransform);
var prevDirector = director;
var prevRootTransform = rootTransform;
var prevAnimator = animator;
// Top level symbol doesn't need to group stuff
if (parent != stageTransform)
{
int minPlayableStart = symbol.Playables.Min(p => p.AbsoluteTimeOffset);
int frameLength = symbol.Playables.Max(p => p.AbsoluteTimeOffset + p.GetFrameCount(stage.fps) - minPlayableStart);
int frameStart = symbol.AbsoluteTimeOffset + minPlayableStart;
director = symbolObj.AddComponent <PlayableDirector>();
var timelineAsset = TimelineAsset.CreateInstance <TimelineAsset>();
timelineAsset.name = path + "_Timeline";
timelineAsset.editorSettings.fps = stage.fps;
timelineAsset.durationMode = TimelineAsset.DurationMode.BasedOnClips;
timelineAsset.fixedDuration = frameLength / stage.fps;
ctx.AddSubAsset(timelineAsset.name, timelineAsset);
director.playableAsset = timelineAsset;
animator = symbolObj.AddComponent <Animator>();
var controlTrack = parentTimeline.CreateTrack <AnimVR.Timeline.AnimControlTrack>(null, symbolObj.name);
ctx.AddSubAsset(path + "_Control", controlTrack);
var controlClip = controlTrack.CreateDefaultClip();
controlClip.displayName = symbolObj.name;
controlClip.start = frameStart / stage.fps;
controlClip.duration = frameLength / stage.fps;
typeof(TimelineClip).GetProperty("preExtrapolationMode").SetValue(controlClip, LOOP_MAPPING[symbol.LoopIn], null);
typeof(TimelineClip).GetProperty("postExtrapolationMode").SetValue(controlClip, LOOP_MAPPING[symbol.LoopOut], null);
var controlAsset = controlClip.asset as AnimVR.Timeline.AnimControlPlayableAsset;
controlAsset.name = symbolObj.name;
prevDirector.SetGenericBinding(controlAsset, symbolObj);
ctx.AddSubAsset(path + "_ControlAsset", controlAsset);
parentTimeline = timelineAsset;
rootTransform = symbolObj.transform;
frameOffset = -minPlayableStart;
}
foreach (var playbale in symbol.Playables)
{
if (playbale.isVisible)
{
GenerateUnityObject(playbale, frameOffset, ctx, parentTimeline, null, symbolObj.transform);
}
}
director = prevDirector;
rootTransform = prevRootTransform;
animator = prevAnimator;
return(symbolObj);
}
public GameObject GenerateUnityObject(TimeLineData playable, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
var playableObj = MakePlayableBaseObject(playable, parent);
var pathForName = AnimationUtility.CalculateTransformPath(playableObj.transform, stageTransform);
// GROUP
var groupTrack = parentTimeline.CreateTrack <GroupTrack>(parentTrack, playable.displayName);
ctx.AddSubAsset(pathForName + "_GroupTrack", groupTrack);
// ANIMATION
var animationTrack = parentTimeline.CreateTrack <AnimVRTrack>(groupTrack, pathForName + "_animation");
ctx.AddSubAsset(pathForName + "_animation", animationTrack);
var animationClip = animationTrack.CreateDefaultClip();
animationClip.duration = playable.GetFrameCount(stage.fps) / stage.fps;
animationClip.start = (playable.AbsoluteTimeOffset + frameOffset) / stage.fps;
typeof(TimelineClip).GetProperty("preExtrapolationMode").SetValue(animationClip, LOOP_MAPPING[playable.LoopIn], null);
typeof(TimelineClip).GetProperty("postExtrapolationMode").SetValue(animationClip, LOOP_MAPPING[playable.LoopOut], null);
var animAsset = animationClip.asset as AnimVRFramesAsset;
animAsset.FPS = stage.fps;
director.SetGenericBinding(animAsset, playableObj);
ctx.AddSubAsset(pathForName + "_activeAsset", animAsset);
// ACTIVATION
var frameTrack = parentTimeline.CreateTrack <ActivationTrack>(groupTrack, pathForName + "_track");
ctx.AddSubAsset(pathForName + "_track", frameTrack);
director.SetGenericBinding(frameTrack, playableObj);
var frameClip = frameTrack.CreateDefaultClip();
frameClip.start = playable.LoopIn != AnimVR.LoopType.OneShot ? 0 : animationClip.start;
frameClip.duration = playable.LoopOut != AnimVR.LoopType.OneShot ?
parentTimeline.fixedDuration - frameClip.start :
(animationClip.start - frameClip.start) + animationClip.duration;
ctx.AddSubAsset(pathForName + "_activeAsset", frameClip.asset);
int frameIndex = -1;
foreach (var frame in playable.Frames)
{
if (!frame.isInstance)
{
var frameObj = GenerateUnityObject(frame, ctx, parentTimeline, playableObj.transform, ++frameIndex);
if (frameIndex != 0)
{
frameObj.SetActive(false);
}
frameObj.transform.SetAsLastSibling();
}
animAsset.FrameIndices.Add(frameIndex);
}
return(playableObj);
}
public GameObject GenerateUnityObject(FrameData frame, AssetImportContext ctx, TimelineAsset parentTimeline, Transform parent, int index)
{
var playableObj = new GameObject(index.ToString());
playableObj.transform.parent = parent;
playableObj.transform.localPosition = frame.transform.pos.V3;
playableObj.transform.localRotation = frame.transform.rot.Q;
playableObj.transform.localScale = frame.transform.scl.V3;
var pathForName = AnimationUtility.CalculateTransformPath(playableObj.transform, stageTransform);
List <List <CombineInstance> > instances = new List <List <CombineInstance> >();
List <CombineInstance> currentList = new List <CombineInstance>();
instances.Add(currentList);
int vCount = 0;
foreach (var line in frame.Lines)
{
try
{
List <Vector3> verts = new List <Vector3>();
List <int> indices = new List <int>();
List <Vector4> colors = new List <Vector4>();
MeshUtils.GeneratePositionData(line, verts, indices, colors);
CombineInstance instance = new CombineInstance();
if (verts.Count == 0)
{
continue;
}
Mesh mesh = new Mesh();
mesh.SetVertices(verts);
mesh.SetTriangles(indices, 0);
mesh.SetColors(colors.Select(c => new Color(c.x, c.y, c.z, c.w)).ToList());
instance.mesh = mesh;
vCount += verts.Count;
if (vCount > 60000)
{
currentList = new List <CombineInstance>();
instances.Add(currentList);
vCount -= 60000;
}
currentList.Add(instance);
totalLines++;
}
catch (Exception e)
{
Debug.LogWarning(e.Message);
}
}
totalVertices += vCount;
int meshId = 0;
foreach (var mesh in instances)
{
var subObj = new GameObject("Submesh" + index);
subObj.transform.SetParent(playableObj.transform, false);
var mf = subObj.AddComponent <MeshFilter>();
var mr = subObj.AddComponent <MeshRenderer>();
Mesh combinedMesh = new Mesh();
combinedMesh.CombineMeshes(mesh.ToArray(), true, false, false);
combinedMesh.name = pathForName + meshId;
mf.sharedMesh = combinedMesh;
mr.sharedMaterial = materialToUse;
ctx.AddSubAsset(pathForName + "_mesh" + index, mf.sharedMesh);
meshId++;
}
return(playableObj);
}
public static void AddObjectToAsset(this AssetImportContext ctx, string key, Object o)
{
ctx.AddSubAsset(key, o);
}
public GameObject GenerateUnityObject(AudioData playable, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
AudioClip clip = null;
var dir = Application.dataPath + Path.GetDirectoryName(ctx.assetPath).Substring(6);
var clipPath = dir + "/" + Path.GetFileNameWithoutExtension(ctx.assetPath) + "_audio/" + playable.displayName + "_audio.wav";
if (savedClips.ContainsKey(playable.audioDataKey))
{
clip = savedClips[playable.audioDataKey];
}
else
{
var assetPath = clipPath.Replace(Application.dataPath, "Assets");
if (!File.Exists(clipPath))
{
clip = stage.AudioDataPool.RetrieveClipFromPool(playable.audioDataKey);
if (clip)
{
clip.name = playable.displayName + "_audio";
SavWav.Save(clipPath, clip);
AssetDatabase.ImportAsset(assetPath);
if (Settings.AudioImport != AudioImportSetting.ClipsAndTracks)
{
needsAudioReimport = true;
}
}
}
clip = AssetDatabase.LoadAssetAtPath <AudioClip>(assetPath);
savedClips[playable.audioDataKey] = clip;
}
if (Settings.AudioImport != AudioImportSetting.ClipsAndTracks)
{
return(null);
}
var playableObj = MakePlayableBaseObject(playable, parent);
var audioSource = playableObj.AddComponent <AudioSource>();
audioSource.spatialBlend = playable.Spatialize ? 0 : 1;
var pathForName = AnimationUtility.CalculateTransformPath(playableObj.transform, stageTransform);
var groupTrack = parentTimeline.CreateTrack <GroupTrack>(parentTrack, playable.displayName);
ctx.AddSubAsset(pathForName + "_GroupTrack", groupTrack);
var track = parentTimeline.CreateTrack <AudioTrack>(groupTrack, playable.displayName);
ctx.AddSubAsset(pathForName + "_audioTrack", track);
bool loop = playable.LoopType == AnimVR.LoopType.Loop;
var audioTrackClip = track.CreateDefaultClip();
audioTrackClip.displayName = playable.displayName;
(audioTrackClip.asset as AudioPlayableAsset).clip = clip;
typeof(AudioPlayableAsset).GetField("m_Loop",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).
SetValue(audioTrackClip.asset, loop);
float start = (playable.AbsoluteTimeOffset + frameOffset) / stage.fps;
float duration = clip ? clip.length : 1;
if (loop)
{
audioTrackClip.start = 0;
audioTrackClip.duration = parentTimeline.fixedDuration;
audioTrackClip.clipIn = duration - start % duration;
}
else
{
audioTrackClip.start = start;
audioTrackClip.duration = duration;
}
ctx.AddSubAsset(pathForName + "_asset", audioTrackClip.asset);
director.SetGenericBinding(track, audioSource);
return(playableObj);
}
public override void OnImportAsset(AssetImportContext ctx)
{
string sceneName = null;
GameObject gltfScene = null;
UnityEngine.Mesh[] meshes = null;
try
{
sceneName = Path.GetFileNameWithoutExtension(ctx.assetPath);
gltfScene = CreateGLTFScene(ctx.assetPath);
// Remove empty roots
if (_removeEmptyRootObjects)
{
var t = gltfScene.transform;
while (
gltfScene.transform.childCount == 1 &&
gltfScene.GetComponents <Component>().Length == 1)
{
var parent = gltfScene;
gltfScene = gltfScene.transform.GetChild(0).gameObject;
t = gltfScene.transform;
t.parent = null; // To keep transform information in the new parent
Object.DestroyImmediate(parent); // Get rid of the parent
}
}
// Ensure there are no hide flags present (will cause problems when saving)
gltfScene.hideFlags &= ~(HideFlags.HideAndDontSave);
foreach (Transform child in gltfScene.transform)
{
child.gameObject.hideFlags &= ~(HideFlags.HideAndDontSave);
}
// Zero position
gltfScene.transform.position = Vector3.zero;
// Get meshes
var meshNames = new List <string>();
var meshHash = new HashSet <UnityEngine.Mesh>();
var meshFilters = gltfScene.GetComponentsInChildren <MeshFilter>();
var vertexBuffer = new List <Vector3>();
meshes = meshFilters.Select(mf =>
{
var mesh = mf.sharedMesh;
vertexBuffer.Clear();
mesh.GetVertices(vertexBuffer);
for (var i = 0; i < vertexBuffer.Count; ++i)
{
vertexBuffer[i] *= _scaleFactor;
}
mesh.SetVertices(vertexBuffer);
if (_swapUvs)
{
var uv = mesh.uv;
var uv2 = mesh.uv2;
mesh.uv = uv2;
mesh.uv2 = uv2;
}
if (_importNormals == GLTFImporterNormals.None)
{
mesh.normals = new Vector3[0];
}
if (_importNormals == GLTFImporterNormals.Calculate)
{
mesh.RecalculateNormals();
}
mesh.UploadMeshData(!_readWriteEnabled);
if (_generateColliders)
{
var collider = mf.gameObject.AddComponent <MeshCollider>();
collider.sharedMesh = mesh;
}
if (meshHash.Add(mesh))
{
var meshName = string.IsNullOrEmpty(mesh.name) ? mf.gameObject.name : mesh.name;
mesh.name = ObjectNames.GetUniqueName(meshNames.ToArray(), meshName);
meshNames.Add(mesh.name);
}
return(mesh);
}).ToArray();
var renderers = gltfScene.GetComponentsInChildren <Renderer>();
if (_importMaterials)
{
// Get materials
var materialNames = new List <string>();
var materialHash = new HashSet <UnityEngine.Material>();
var materials = renderers.SelectMany(r =>
{
return(r.sharedMaterials.Select(mat =>
{
if (materialHash.Add(mat))
{
var matName = string.IsNullOrEmpty(mat.name) ? mat.shader.name : mat.name;
if (matName == mat.shader.name)
{
matName = matName.Substring(Mathf.Min(matName.LastIndexOf("/") + 1, matName.Length - 1));
}
// Ensure name is unique
matName = string.Format("{0} {1}", sceneName, ObjectNames.NicifyVariableName(matName));
matName = ObjectNames.GetUniqueName(materialNames.ToArray(), matName);
mat.name = matName;
materialNames.Add(matName);
}
return mat;
}));
}).ToArray();
// Get textures
var textureNames = new List <string>();
var textureHash = new HashSet <Texture2D>();
var texMaterialMap = new Dictionary <Texture2D, List <TexMaterialMap> >();
var textures = materials.SelectMany(mat =>
{
var shader = mat.shader;
if (!shader)
{
return(Enumerable.Empty <Texture2D>());
}
var matTextures = new List <Texture2D>();
for (var i = 0; i < ShaderUtil.GetPropertyCount(shader); ++i)
{
if (ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv)
{
var propertyName = ShaderUtil.GetPropertyName(shader, i);
var tex = mat.GetTexture(propertyName) as Texture2D;
if (tex)
{
if (textureHash.Add(tex))
{
var texName = tex.name;
if (string.IsNullOrEmpty(texName))
{
if (propertyName.StartsWith("_"))
{
texName = propertyName.Substring(Mathf.Min(1, propertyName.Length - 1));
}
}
// Ensure name is unique
texName = string.Format("{0} {1}", sceneName, ObjectNames.NicifyVariableName(texName));
texName = ObjectNames.GetUniqueName(textureNames.ToArray(), texName);
tex.name = texName;
textureNames.Add(texName);
matTextures.Add(tex);
}
List <TexMaterialMap> materialMaps;
if (!texMaterialMap.TryGetValue(tex, out materialMaps))
{
materialMaps = new List <TexMaterialMap>();
texMaterialMap.Add(tex, materialMaps);
}
materialMaps.Add(new TexMaterialMap(mat, propertyName, propertyName == "_BumpMap"));
}
}
}
return(matTextures);
}).ToArray();
var folderName = Path.GetDirectoryName(ctx.assetPath);
// Save textures as separate assets and rewrite refs
// TODO: Support for other texture types
if (textures.Length > 0)
{
var texturesRoot = string.Concat(folderName, "/", "Textures/");
Directory.CreateDirectory(texturesRoot);
foreach (var tex in textures)
{
var ext = _useJpgTextures ? ".jpg" : ".png";
var texPath = string.Concat(texturesRoot, tex.name, ext);
File.WriteAllBytes(texPath, _useJpgTextures ? tex.EncodeToJPG() : tex.EncodeToPNG());
AssetDatabase.ImportAsset(texPath);
}
}
// Save materials as separate assets and rewrite refs
if (materials.Length > 0)
{
var materialRoot = string.Concat(folderName, "/", "Materials/");
Directory.CreateDirectory(materialRoot);
foreach (var mat in materials)
{
var materialPath = string.Concat(materialRoot, mat.name, ".mat");
var newMat = mat;
CopyOrNew(mat, materialPath, m =>
{
// Fix references
newMat = m;
foreach (var r in renderers)
{
var sharedMaterials = r.sharedMaterials;
for (var i = 0; i < sharedMaterials.Length; ++i)
{
var sharedMaterial = sharedMaterials[i];
if (sharedMaterial.name == mat.name)
{
sharedMaterials[i] = m;
}
}
sharedMaterials = sharedMaterials.Where(sm => sm).ToArray();
r.sharedMaterials = sharedMaterials;
}
});
// Fix textures
// HACK: This needs to be a delayed call.
// Unity needs a frame to kick off the texture import so we can rewrite the ref
if (textures.Length > 0)
{
EditorApplication.delayCall += () =>
{
for (var i = 0; i < textures.Length; ++i)
{
var tex = textures[i];
var texturesRoot = string.Concat(folderName, "/", "Textures/");
var ext = _useJpgTextures ? ".jpg" : ".png";
var texPath = string.Concat(texturesRoot, tex.name, ext);
// Grab new imported texture
var materialMaps = texMaterialMap[tex];
var importer = (TextureImporter)TextureImporter.GetAtPath(texPath);
var importedTex = AssetDatabase.LoadAssetAtPath <Texture2D>(texPath);
if (importer != null)
{
var isNormalMap = false;
foreach (var materialMap in materialMaps)
{
if (materialMap.Material == mat)
{
isNormalMap |= materialMap.IsNormalMap;
newMat.SetTexture(materialMap.Property, importedTex);
}
}
;
if (isNormalMap)
{
// Try to auto-detect normal maps
importer.textureType = TextureImporterType.NormalMap;
}
else if (importer.textureType == TextureImporterType.Sprite)
{
// Force disable sprite mode, even for 2D projects
importer.textureType = TextureImporterType.Default;
}
importer.SaveAndReimport();
}
else
{
Debug.LogWarning("GLTFImporter: Unable to import texture from path reference");
}
}
};
}
}
}
}
else
{
var temp = GameObject.CreatePrimitive(PrimitiveType.Plane);
temp.SetActive(false);
var defaultMat = new[] { temp.GetComponent <Renderer>().sharedMaterial };
DestroyImmediate(temp);
foreach (var rend in renderers)
{
rend.sharedMaterials = defaultMat;
}
}
}
catch
{
if (gltfScene)
{
DestroyImmediate(gltfScene);
}
throw;
}
#if UNITY_2017_3_OR_NEWER
// Set main asset
ctx.AddObjectToAsset("main asset", gltfScene);
// Add meshes
foreach (var mesh in meshes)
{
ctx.AddObjectToAsset("mesh " + mesh.name, mesh);
}
ctx.SetMainObject(gltfScene);
#else
// Set main asset
ctx.SetMainAsset("main asset", gltfScene);
// Add meshes
foreach (var mesh in meshes)
{
ctx.AddSubAsset("mesh " + mesh.name, mesh);
}
#endif
}
public override void OnImportAsset(AssetImportContext ctx)
{
{
var ext = Path.GetExtension(ctx.assetPath).ToLower();
if (ext == ".vox")
{
fileType = VoxelBase.FileType.vox;
}
else if (ext == ".qb")
{
fileType = VoxelBase.FileType.qb;
}
else
{
return;
}
}
var gameObject = new GameObject(Path.GetFileNameWithoutExtension(ctx.assetPath));
var voxelObject = gameObject.AddComponent <VoxelObject>();
{
voxelObject.legacyVoxImport = legacyVoxImport;
voxelObject.importMode = importMode;
voxelObject.importScale = importScale;
voxelObject.importOffset = importOffset;
voxelObject.combineFaces = combineFaces;
voxelObject.ignoreCavity = ignoreCavity;
voxelObject.voxelStructure = outputStructure ? ScriptableObject.CreateInstance <VoxelStructure>() : null;
voxelObject.generateLightmapUVs = generateLightmapUVs;
voxelObject.meshFaceVertexOffset = meshFaceVertexOffset;
voxelObject.loadFromVoxelFile = loadFromVoxelFile;
voxelObject.generateMipMaps = generateMipMaps;
}
var objectCore = new VoxelObjectCore(voxelObject);
try
{
if (!objectCore.Create(ctx.assetPath, null))
{
Debug.LogErrorFormat("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath);
DestroyImmediate(gameObject);
return;
}
}
catch
{
Debug.LogErrorFormat("<color=green>[Voxel Importer]</color> ScriptedImporter error. file:{0}", ctx.assetPath);
DestroyImmediate(gameObject);
return;
}
#region Material
if (retainExisting)
{
bool changed = false;
var assets = AssetDatabase.LoadAllAssetsAtPath(ctx.assetPath);
for (int i = 0; i < voxelObject.materials.Count; i++)
{
var material = assets.FirstOrDefault(c => c.name == string.Format("mat{0}", i)) as Material;
if (material != null)
{
material.mainTexture = voxelObject.atlasTexture;
voxelObject.materials[i] = material;
changed = true;
}
}
if (changed)
{
var renderer = gameObject.GetComponent <MeshRenderer>();
renderer.sharedMaterials = voxelObject.materials.ToArray();
}
}
#endregion
#region Collider
switch (colliderType)
{
case ColliderType.Box:
gameObject.AddComponent <BoxCollider>();
break;
case ColliderType.Sphere:
gameObject.AddComponent <SphereCollider>();
break;
case ColliderType.Capsule:
gameObject.AddComponent <CapsuleCollider>();
break;
case ColliderType.Mesh:
gameObject.AddComponent <MeshCollider>();
break;
}
#endregion
#if UNITY_2017_3_OR_NEWER
ctx.AddObjectToAsset(gameObject.name, gameObject);
ctx.AddObjectToAsset(voxelObject.mesh.name = "mesh", voxelObject.mesh);
for (int i = 0; i < voxelObject.materials.Count; i++)
{
ctx.AddObjectToAsset(voxelObject.materials[i].name = string.Format("mat{0}", i), voxelObject.materials[i]);
}
ctx.AddObjectToAsset(voxelObject.atlasTexture.name = "tex", voxelObject.atlasTexture);
if (voxelObject.voxelStructure != null)
{
ctx.AddObjectToAsset(voxelObject.voxelStructure.name = "structure", voxelObject.voxelStructure);
}
VoxelObject.DestroyImmediate(voxelObject);
ctx.SetMainObject(gameObject);
#else
ctx.SetMainAsset(gameObject.name, gameObject);
ctx.AddSubAsset(voxelObject.mesh.name = "mesh", voxelObject.mesh);
for (int i = 0; i < voxelObject.materials.Count; i++)
{
ctx.AddSubAsset(voxelObject.materials[i].name = string.Format("mat{0}", i), voxelObject.materials[i]);
}
ctx.AddSubAsset(voxelObject.atlasTexture.name = "tex", voxelObject.atlasTexture);
if (voxelObject.voxelStructure != null)
{
ctx.AddSubAsset(voxelObject.voxelStructure.name = "structure", voxelObject.voxelStructure);
}
VoxelObject.DestroyImmediate(voxelObject);
#endif
}
