public override void OnImportAsset(AssetImportContext ctx)
{
Import(this, ctx, m_reverseAxis.ToAxes(), m_renderPipeline);
}
public override void OnImportAsset(AssetImportContext ctx)
{
ImportContext = ctx;
Import();
}
public override void OnImportAsset(AssetImportContext ctx)
{
var lines = File.ReadAllLines(ctx.assetPath);
bool vibFreqMode = false;
int currentModeIndex = 0;
var molecule = ScriptableObject.CreateInstance <MoleculeDefinition> ();
var elementData = AssetDatabase.FindAssets("t:Element");
foreach (var line in lines)
{
if (line == "VIBFREQ")
{
vibFreqMode = true;
}
if (vibFreqMode)
{
var matchFreq = Regex.Match(line, "^ +(\\d+.\\d+) +[\\w\\?\\+\\-\\'\\\"]+ *$");
if (matchFreq.Success)
{
var mode = new VibrationalModeDefinition();
mode.Wavenumber = float.Parse(matchFreq.Groups [1].Value.Trim());
molecule.VibrationalModes.Add(mode);
Debug.Log("Found Vibrational Frequency");
}
else if (molecule.VibrationalModes.Count > 0)
{
var matchNumbers = Regex.Matches(line, "(?: +-?\\d+.\\d+)");
if (matchNumbers.Count > 0)
{
for (int i = 0; i < matchNumbers.Count / 3; i++)
{
molecule.VibrationalModes [currentModeIndex].Displacements.Add(new Vector3(
float.Parse(matchNumbers[3 * i].Groups[0].Value.Trim()),
float.Parse(matchNumbers[3 * i + 1].Groups[0].Value.Trim()),
float.Parse(matchNumbers[3 * i + 2].Groups[0].Value.Trim())
));
if (molecule.VibrationalModes [currentModeIndex].Displacements.Count == molecule.Atoms.Count)
{
currentModeIndex++;
}
}
}
else
{
vibFreqMode = false;
}
}
}
else
{
var match = Regex.Match(line, "^ (\\d) ([- ]\\d+.\\d+) ([- ]\\d+.\\d+) ([- ]\\d+.\\d+)$");
if (!match.Success)
{
continue;
}
// Found an atom
var atomicNumber = int.Parse(match.Groups [1].Value.Trim());
var x = float.Parse(match.Groups [2].Value.Trim());
var y = float.Parse(match.Groups [3].Value.Trim());
var z = float.Parse(match.Groups [4].Value.Trim());
molecule.Atoms.Add(new AtomDefinition()
{
Position = new Vector3(x, y, z),
Element = elementData.Select(e => AssetDatabase.LoadAssetAtPath <Element>(AssetDatabase.GUIDToAssetPath(e))).Where(e => e != null && e.AtomicNumber == atomicNumber).FirstOrDefault()
});
}
}
ctx.AddObjectToAsset("Data", molecule);
ctx.SetMainObject(molecule);
}
public override void OnImportAsset(AssetImportContext ctx)
{
}
public UXMLImporterImpl(AssetImportContext context) : base(context)
{
}
public override void OnImportAsset(AssetImportContext ctx)
{
Debug.Log("Attempting to import AMF:" + ctx.assetPath);
progressString += ctx.assetPath;
EditorUtility.DisplayProgressBar(progressString, "Parsing...", 0);
AMF amf = ParseAMF(ctx.assetPath);
string workingDir = ctx.assetPath.Substring(0, ctx.assetPath.LastIndexOf("/") + 1);
/*
* Setup materials first
*/
Dictionary <string, Material> mats = new Dictionary <string, Material>();
Dictionary <string, AMFShaderInfo> matsHelpers = new Dictionary <string, AMFShaderInfo>();
System.IO.Directory.CreateDirectory(workingDir + "Materials/");
//System.IO.Directory.CreateDirectory(workingDir+"MaterialHelpers/");
AMFShaderInfo asi;
float totalMats = amf.shaderInfos.Count;
float matsComplete = 0;
foreach (AdjutantSharp.ShaderInfo si in amf.shaderInfos)
{
EditorUtility.DisplayProgressBar("Setting up Materials...", si.sName, (matsComplete / totalMats));
asi = (AMFShaderInfo)AMFShaderInfo.CreateInstance(typeof(AMFShaderInfo));
asi.name = si.sName;
asi.SaveData(si);
if (!mats.ContainsKey(si.sName))
{
string path = workingDir + "Materials/" + si.sName + ".mat";
Material material = (Material)AssetDatabase.LoadAssetAtPath(workingDir + "Materials/" + si.sName + ".mat", typeof(Material));
if (material == null)
{
asi.workingDir = workingDir;
material = asi.CreateMaterial();
/* if(si.GetType()==typeof(RegularShader)){
* material=SetupRegularMaterial((RegularShader)si,workingDir);
* }else{
* material=SetupTerrainMaterial((TerrainShader)si,workingDir);
* } */
AssetDatabase.CreateAsset(material, workingDir + "Materials/" + si.sName + ".mat");
}
mats.Add(si.sName, material);
matsHelpers.Add(si.sName, asi);
ctx.AddObjectToAsset("MaterialHelper-" + asi.sName, asi);
ctx.DependsOnSourceAsset(workingDir + "Materials/" + si.sName + ".mat");
/* if(material!=null)
* ctx.AddObjectToAsset(material.name,material); */
}
matsComplete++;
}
//EditorUtility.DisplayProgressBar(progressString,"[4/5] Creating Meshes...",(4f/5f));
/*
* Create Meshes
*/
GameObject root = new GameObject(amf.modelName);
ctx.AddObjectToAsset(amf.modelName, root);
ctx.SetMainObject(root);
Dictionary <long, Mesh> meshList = ConvertMeshes(amf, mats, matsHelpers, root);
//root.transform.rotation=Quaternion.Euler(-90f,0f,0f);
/* LoadRegions(amf,root);
* List<Mesh> meshList=CreateMeshes(amf,root.transform,mats);
*/
UnwrapParam.SetDefaults(out uvSettings);
EditorUtility.DisplayProgressBar(progressString, "[5/5] Finishing up...", (5f / 5f));
float lightCount = 0;
float totalLight = meshList.Count;
foreach (Mesh m in meshList.Values)
{
/* if(GenerateLightmapUVs){
* EditorUtility.DisplayProgressBar("Generating Lightmaps","["+lightCount+"/"+totalLight+"] Generating UVs...",(lightCount/totalLight));
* Unwrapping.GenerateSecondaryUVSet(m,uvSettings);
* lightCount++;
* } */
ctx.AddObjectToAsset(m.name, m);
}
Debug.Log("AMF import complete");
EditorUtility.ClearProgressBar();
}
public override void OnImportAsset(AssetImportContext context)
{
GltfEditorImporter.OnImportGltfAsset(context);
}
public override void OnImportAsset(AssetImportContext ctx)
{
string fileJson = File.ReadAllText(ctx.assetPath);
var suvObj = fileJson.FromJson <SuvObj>();
var suvObjMeshList = suvObj.mesh;
var rootObj = new GameObject(Path.GetFileNameWithoutExtension(ctx.assetPath));
var rootObjTransform = rootObj.transform;
Material mat = null;
switch (m_objImportSettings.m_materialSettings)
{
case MaterialSettings.Import:
var suvMat = suvObj.mat;
mat = BuildMaterial(ctx, suvMat);
ctx.AddObjectToAsset(suvMat.id, mat);
break;
case MaterialSettings.External:
mat = m_objImportSettings.m_materialExternal;
break;
}
var meshRendererRef = m_objImportSettings.m_meshRendererRef;
for (int i = 0, l = suvObjMeshList.Length; i < l; i++)
{
var suvMesh = suvObjMeshList[i];
Mesh mesh = BuildMesh(suvMesh);
ctx.AddObjectToAsset(suvMesh.id + "_msh", mesh);
if (m_ImportMeshWithTexture)
{
SuvMeshWithTexture meshWithTexture = ScriptableObject.CreateInstance <SuvMeshWithTexture>();
meshWithTexture.name = suvMesh.name;
meshWithTexture.mesh = mesh;
meshWithTexture.texture = m_MainTexture;
ctx.AddObjectToAsset(suvMesh.id + "_mwt", meshWithTexture);
}
if (m_objImportSettings.m_ImportObject)
{
var go = new GameObject(suvMesh.name);
go.hideFlags = HideFlags.NotEditable;
go.AddComponent <MeshFilter>().sharedMesh = mesh;
var goRenderer = go.AddComponent <MeshRenderer>();
if (meshRendererRef)
{
goRenderer.lightProbeUsage = meshRendererRef.lightProbeUsage;
goRenderer.probeAnchor = meshRendererRef.probeAnchor;
goRenderer.lightProbeProxyVolumeOverride = meshRendererRef.lightProbeProxyVolumeOverride;
goRenderer.motionVectorGenerationMode = meshRendererRef.motionVectorGenerationMode;
goRenderer.allowOcclusionWhenDynamic = meshRendererRef.allowOcclusionWhenDynamic;
goRenderer.additionalVertexStreams = meshRendererRef.additionalVertexStreams;
goRenderer.receiveShadows = meshRendererRef.receiveShadows;
goRenderer.reflectionProbeUsage = meshRendererRef.reflectionProbeUsage;
goRenderer.shadowCastingMode = meshRendererRef.shadowCastingMode;
goRenderer.tag = meshRendererRef.tag;
goRenderer.renderingLayerMask = meshRendererRef.renderingLayerMask;
if (m_objImportSettings.m_materialSettings == MaterialSettings.FromRenderer)
{
goRenderer.sharedMaterials = meshRendererRef.sharedMaterials;
}
}
if (m_objImportSettings.m_materialSettings != MaterialSettings.FromRenderer)
{
goRenderer.sharedMaterial = mat;
}
var goTransform = go.transform;
goTransform.SetParent(rootObjTransform);
goTransform.SetPositionAndRotation(suvMesh.pos, Quaternion.AngleAxis(suvMesh.rot, new Vector3(0, 0, 1)));
}
}
ctx.AddObjectToAsset(ROOT_ID, rootObj);
ctx.SetMainObject(rootObj);
}
private void ImportYarn(AssetImportContext ctx)
{
var sourceText = File.ReadAllText(ctx.assetPath);
string fileName = System.IO.Path.GetFileNameWithoutExtension(ctx.assetPath);
try
{
// Compile the source code into a compiled Yarn program (or
// generate a parse error)
compilationStatus = Compiler.CompileString(sourceText, fileName, out var compiledProgram, out var stringTable);
// Create a container for storing the bytes
var programContainer = ScriptableObject.CreateInstance <YarnProgram>();
using (var memoryStream = new MemoryStream())
using (var outputStream = new Google.Protobuf.CodedOutputStream(memoryStream))
{
// Serialize the compiled program to memory
compiledProgram.WriteTo(outputStream);
outputStream.Flush();
byte[] compiledBytes = memoryStream.ToArray();
programContainer.compiledProgram = compiledBytes;
// Add this container to the imported asset; it will be
// what the user interacts with in Unity
ctx.AddObjectToAsset("Program", programContainer, YarnEditorUtility.GetYarnDocumentIconTexture());
ctx.SetMainObject(programContainer);
isSuccesfullyCompiled = true;
// var outPath = Path.ChangeExtension(ctx.assetPath, ".yarnc");
// File.WriteAllBytes(outPath, compiledBytes);
}
if (stringTable.Count > 0)
{
using (var memoryStream = new MemoryStream())
using (var textWriter = new StreamWriter(memoryStream)) {
// Generate the localised .csv file
// Use the invariant culture when writing the CSV
var configuration = new CsvHelper.Configuration.Configuration(
System.Globalization.CultureInfo.InvariantCulture
);
var csv = new CsvHelper.CsvWriter(
textWriter, // write into this stream
configuration // use this configuration
);
var lines = stringTable.Select(x => new {
id = x.Key,
text = x.Value.text,
file = x.Value.fileName,
node = x.Value.nodeName,
lineNumber = x.Value.lineNumber
});
csv.WriteRecords(lines);
textWriter.Flush();
memoryStream.Position = 0;
using (var reader = new StreamReader(memoryStream)) {
var textAsset = new TextAsset(reader.ReadToEnd());
textAsset.name = $"{fileName} ({baseLanguageID})";
ctx.AddObjectToAsset("Strings", textAsset);
programContainer.baseLocalisationStringTable = textAsset;
baseLanguage = textAsset;
programContainer.localizations = localizations;
}
stringIDs = lines.Select(l => l.id).ToArray();
}
}
}
catch (Yarn.Compiler.ParseException e)
{
isSuccesfullyCompiled = false;
compilationErrorMessage = e.Message;
ctx.LogImportError(e.Message);
return;
}
}
PointCloudData ImportLas(AssetImportContext context)
{
long size = new FileInfo(context.assetPath).Length;
using (var file = MemoryMappedFile.CreateFromFile(context.assetPath, FileMode.Open))
{
using (var view = file.CreateViewAccessor(0, size, MemoryMappedFileAccess.Read))
{
view.Read <LasHeader>(0, out var header);
if (Encoding.ASCII.GetString(header.Signature) != "LASF")
{
throw new Exception("Incorrect LAS file signature");
}
if (header.PointDataFormat > 10)
{
throw new Exception($"Unsupported LAS file format: {header.PointDataFormat}");
}
long offset = header.PointDataOffset;
int stride = header.PointDataSize;
long count = header.PointDataCount;
if (header.VersionMajor > 1 || header.VersionMajor == 1 && header.VersionMinor >= 4)
{
if (count == 0)
{
count = (long)header.PointDataCountLong;
}
}
if (count > MaxPointCount)
{
Debug.LogWarning($"Too many points ({count:n0}), truncating to {MaxPointCount:n0}");
count = MaxPointCount;
}
var bounds = new PointCloudBounds()
{
MinX = header.MinX,
MinY = header.MinY,
MinZ = header.MinZ,
MaxX = header.MaxX,
MaxY = header.MaxY,
MaxZ = header.MaxZ,
};
unsafe
{
byte *ptr = null;
view.SafeMemoryMappedViewHandle.AcquirePointer(ref ptr);
try
{
var points = new PointCloudPoint[(int)count];
fixed(PointCloudPoint *output = points)
{
bool hasColor = LasConvert(context, ptr + offset, stride, (int)count, ref header, bounds, output);
var transform = GetTransform();
var b = GetBounds(bounds);
b.center = transform.MultiplyPoint3x4(b.center);
b.extents = transform.MultiplyVector(b.extents);
return(PointCloudData.Create(points, GetBounds(bounds), hasColor, transform.MultiplyPoint3x4(bounds.Center), transform.MultiplyVector(bounds.Extents)));
}
}
finally
{
view.SafeMemoryMappedViewHandle.ReleasePointer();
}
}
}
}
}
unsafe bool LasConvert(AssetImportContext context, byte *ptr, int stride, int count, ref LasHeader header, PointCloudBounds bounds, PointCloudPoint *points)
{
var name = Path.GetFileName(context.assetPath);
var counts = new NativeArray <int>(JobsUtility.MaxJobThreadCount, Allocator.TempJob);
try
{
double scaleX, scaleY, scaleZ;
double centerX, centerY, centerZ;
if (Normalize)
{
centerX = -0.5 * (bounds.MaxX + bounds.MinX);
centerY = -0.5 * (bounds.MaxY + bounds.MinY);
centerZ = -0.5 * (bounds.MaxZ + bounds.MinZ);
scaleX = 2.0 / (bounds.MaxX - bounds.MinX);
scaleY = 2.0 / (bounds.MaxY - bounds.MinY);
scaleZ = 2.0 / (bounds.MaxZ - bounds.MinZ);
}
else if (Center)
{
centerX = -0.5 * (bounds.MaxX + bounds.MinX);
centerY = -0.5 * (bounds.MaxY + bounds.MinY);
centerZ = -0.5 * (bounds.MaxZ + bounds.MinZ);
scaleX = scaleY = scaleZ = 1.0;
}
else
{
centerX = centerY = centerZ = 0.0;
scaleX = scaleY = scaleZ = 1.0;
}
var job = new LasConvertJob()
{
LasRGB8BitWorkaround = LasRGB8BitWorkaround,
Input = ptr,
Stride = stride,
Output = points,
Transform = GetTransform(),
InputScaleX = header.ScaleX,
InputScaleY = header.ScaleY,
InputScaleZ = header.ScaleZ,
InputOffsetX = header.OffsetX,
InputOffsetY = header.OffsetY,
InputOffsetZ = header.OffsetZ,
OutputCenterX = centerX,
OutputCenterY = centerY,
OutputCenterZ = centerZ,
OutputScaleX = scaleX,
OutputScaleY = scaleY,
OutputScaleZ = scaleZ,
Counts = (int *)counts.GetUnsafePtr(),
ThreadIndex = 0,
};
bool hasColor = false;
if (header.PointDataFormat == 2)
{
job.ColorInput = ptr + 20;
hasColor = true;
}
else if (header.PointDataFormat == 3 || header.PointDataFormat == 5)
{
job.ColorInput = ptr + 28;
hasColor = true;
}
else if (header.PointDataFormat == 7 || header.PointDataFormat == 8 || header.PointDataFormat == 10)
{
job.ColorInput = ptr + 30;
hasColor = true;
}
var h = job.Schedule((int)count, 65536);
while (!h.IsCompleted)
{
System.Threading.Thread.Sleep(100);
int processed = counts.Sum();
float progress = (float)((double)processed / count);
EditorUtility.DisplayProgressBar($"Importing {name}", $"{processed:N0} points", progress);
}
return(hasColor);
}
finally
{
EditorUtility.ClearProgressBar();
counts.Dispose();
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
ReadWithAssetImportContext(ctx, ctx.assetPath);
} //OnImportAsset
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 SuperImportContext(AssetImportContext context, ST2USettings settings)
{
m_Context = context;
Settings = settings;
}
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 override void OnImportAsset(AssetImportContext ctx)
{
if (ctx == null)
{
return;
}
var path = ctx.assetPath;
AlembicStream.DisconnectStreamsWithPath(path);
var fileName = Path.GetFileNameWithoutExtension(path);
var previousGoName = fileName;
if (!string.IsNullOrEmpty(rootGameObjectName))
{
previousGoName = rootGameObjectName;
}
var go = new GameObject(previousGoName);
var streamDescriptor = ScriptableObject.CreateInstance <AlembicStreamDescriptor>();
streamDescriptor.name = go.name + "_ABCDesc";
streamDescriptor.PathToAbc = path;
streamDescriptor.Settings = StreamSettings;
using (var abcStream = new AlembicStream(go, streamDescriptor))
{
abcStream.AbcLoad(true, true);
abcStream.GetTimeRange(out abcStartTime, out abcEndTime);
if (firstImport)
{
startTime = abcStartTime;
endTime = abcEndTime;
}
streamDescriptor.mediaStartTime = (float)abcStartTime;
streamDescriptor.mediaEndTime = (float)abcEndTime;
var streamPlayer = go.AddComponent <AlembicStreamPlayer>();
streamPlayer.StreamDescriptor = streamDescriptor;
streamPlayer.StartTime = (float)StartTime;
streamPlayer.EndTime = (float)EndTime;
var subassets = new Subassets(ctx);
subassets.Add(streamDescriptor.name, streamDescriptor);
GenerateSubAssets(subassets, abcStream.abcTreeRoot, streamDescriptor);
AlembicStream.ReconnectStreamsWithPath(path);
var prevIdName = fileName;
if (!string.IsNullOrEmpty(rootGameObjectId))
{
prevIdName = rootGameObjectId;
}
ctx.AddObjectToAsset(prevIdName, go);
ctx.SetMainObject(go);
isHDF5 = abcStream.IsHDF5();
if (IsHDF5)
{
Debug.LogWarning(path + ": Deprecated HDF5 file format. Consider converting to Ogawa.");
}
}
firstImport = false;
}
bool ParseCubeData(AssetImportContext ctx, out int lutSize, out Color[] pixels)
{
// Quick & dirty error utility
bool Error(string msg)
{
ctx.LogImportError(msg);
return(false);
}
var lines = File.ReadAllLines(ctx.assetPath);
pixels = null;
lutSize = -1;
// Start parsing
int sizeCube = -1;
var table = new List <Color>();
for (int i = 0; true; i++)
{
// EOF
if (i >= lines.Length)
{
if (table.Count != sizeCube)
{
return(Error("Premature end of file"));
}
break;
}
// Cleanup & comment removal
var line = FilterLine(lines[i]);
if (string.IsNullOrEmpty(line))
{
continue;
}
// Header data
if (line.StartsWith("TITLE"))
{
continue; // Skip the title tag, we don't need it
}
if (line.StartsWith("LUT_3D_SIZE"))
{
var sizeStr = line.Substring(11).TrimStart();
if (!int.TryParse(sizeStr, out var size))
{
return(Error($"Invalid data on line {i}"));
}
if (size < GlobalPostProcessSettings.k_MinLutSize || size > GlobalPostProcessSettings.k_MaxLutSize)
{
return(Error("LUT size out of range"));
}
lutSize = size;
sizeCube = size * size * size;
continue;
}
if (line.StartsWith("DOMAIN_"))
{
continue; // Skip domain boundaries, haven't run into a single cube file that used them
}
// Table
var row = line.Split();
if (row.Length != 3)
{
return(Error($"Invalid data on line {i}"));
}
var color = Color.black;
for (int j = 0; j < 3; j++)
{
if (!float.TryParse(row[j], NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out var d))
{
return(Error($"Invalid data on line {i}"));
}
color[j] = d;
}
table.Add(color);
}
if (sizeCube != table.Count)
{
return(Error($"Wrong table size - Expected {sizeCube} elements, got {table.Count}"));
}
pixels = table.ToArray();
return(true);
}
public Subassets(AssetImportContext ctx)
{
m_ctx = ctx;
}
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;
Animation animation = gltfScene.GetComponentInChildren <Animation>();
HashSet <AnimationClip> animationClips = new HashSet <AnimationClip>();
if (animation != null)
{
foreach (AnimationState animationState in animation)
{
if (!animationClips.Contains(animationState.clip))
{
animationClips.Add(animationState.clip);
}
}
}
// 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 (animationClips.Count > 0)
{
var folderName = Path.GetDirectoryName(ctx.assetPath);
var animationsRoot = string.Concat(folderName, "/", "Animations/");
Directory.CreateDirectory(animationsRoot);
foreach (AnimationClip clip in animationClips)
{
string fileName = clip.name;
foreach (char c in System.IO.Path.GetInvalidFileNameChars())
{
fileName = fileName.Replace(c, '_');
}
AssetDatabase.CreateAsset(clip, animationsRoot + fileName + ".anim");
var importer = AssetImporter.GetAtPath(animationsRoot + fileName + ".anim");
}
}
if (_importMaterials)
{
var materials = SimplifyMaterials(renderers);
// Get materials
List <string> materialNames = new List <string>();
foreach (var mat in materials)
{
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 = ObjectNames.NicifyVariableName(matName);
matName = ObjectNames.GetUniqueName(materialNames.ToArray(), matName);
mat.name = matName;
materialNames.Add(matName);
}
Texture2D[] textures = null;
var texMaterialMap = new Dictionary <Texture2D, List <TexMaterialMap> >();
if (_importTextures)
{
// Get textures
var textureNames = new List <string>();
var textureHash = new HashSet <Texture2D>();
Texture2D[] cachedTextures = PersistentAssetCache.ImageCacheByUri.Values.Select((x) => { return(x.Texture); }).ToArray();
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 (cachedTextures.Contains(tex))
{
continue;
}
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 = 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/");
if (!Directory.Exists(texturesRoot))
{
Directory.CreateDirectory(texturesRoot);
}
foreach (var tex in textures)
{
var ext = _useJpgTextures ? ".jpg" : ".png";
var texPath = string.Concat(texturesRoot, tex.name, ext);
if (!File.Exists(texPath))
{
File.WriteAllBytes(texPath, _useJpgTextures ? tex.EncodeToJPG() : tex.EncodeToPNG());
AssetDatabase.ImportAsset(texPath, ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate);
}
}
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.ImportRecursive);
}
}
// Save materials as separate assets and rewrite refs
if (materials.Count > 0)
{
var folderName = Path.GetDirectoryName(ctx.assetPath);
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;
EditorUtility.SetDirty(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 != null && textures.Length > 0)
{
delayCallsCount++;
EditorApplication.delayCall += () =>
{
delayCallsCount--;
for (var i = 0; i < textures.Length; ++i)
{
var tex = textures[i];
var materialMaps = texMaterialMap[tex];
var texturesRoot = string.Concat(folderName, "/", "Textures/");
var ext = _useJpgTextures ? ".jpg" : ".png";
var texPath = string.Concat(texturesRoot, tex.name, ext);
var importedTex = AssetDatabase.LoadAssetAtPath <Texture2D>(texPath);
var importer = (TextureImporter)TextureImporter.GetAtPath(texPath);
if (importer != null)
{
importer.isReadable = true;
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;
}
}
else
{
Debug.LogWarning(string.Format("GLTFImporter: Unable to import texture at path: {0}", texPath));
}
if (delayCallsCount == 0)
{
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.ImportRecursive);
AssetDatabase.SaveAssets();
}
}
};
}
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ForceUpdate | ImportAssetOptions.ImportRecursive);
AssetDatabase.SaveAssets();
}
}
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;
}
}
var rootObject = gltfScene.GetComponentInChildren <InstantiatedGLTFObject>();
if (rootObject != null)
{
DestroyImmediate(rootObject);
}
}
}
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)
{
try
{
ctx.AddObjectToAsset("mesh " + mesh.name, mesh);
}
catch (System.InvalidOperationException e)
{
Debug.LogWarning(e.ToString(), 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 GameObject GenerateUnityObject(PlayableData playable, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
if (playable is SymbolData)
{
return(GenerateUnityObject(playable as SymbolData, frameOffset, ctx, parentTimeline, parentTrack, parent));
}
else if (playable is TimeLineData)
{
return(GenerateUnityObject(playable as TimeLineData, frameOffset, ctx, parentTimeline, parentTrack, parent));
}
// No audio support on Mac
#if UNITY_EDITOR_WIN
else if (playable is AudioData && Settings.AudioImport != AudioImportSetting.None)
{
return(GenerateUnityObject(playable as AudioData, frameOffset, ctx, parentTimeline, parentTrack, parent));
}
#endif
else if (playable is CameraData && Settings.ImportCameras)
{
return(GenerateUnityObject(playable as CameraData, frameOffset, ctx, parentTimeline, parentTrack, parent));
}
else if (playable is StaticMeshData)
{
return(GenerateUnityObject(playable as StaticMeshData, frameOffset, ctx, parentTimeline, parentTrack, parent));
}
else
{
return(null);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
var graphAsset = ScriptableObject.CreateInstance <SubGraphAsset>();
var subGraphPath = ctx.assetPath;
var subGraphGuid = AssetDatabase.AssetPathToGUID(subGraphPath);
graphAsset.assetGuid = subGraphGuid;
var textGraph = File.ReadAllText(subGraphPath, Encoding.UTF8);
var messageManager = new MessageManager();
var graphData = new GraphData
{
isSubGraph = true, assetGuid = subGraphGuid, messageManager = messageManager
};
MultiJson.Deserialize(graphData, textGraph);
try
{
ProcessSubGraph(graphAsset, graphData);
}
catch (Exception e)
{
graphAsset.isValid = false;
Debug.LogException(e, graphAsset);
}
finally
{
if (messageManager.AnyError())
{
graphAsset.isValid = false;
foreach (var pair in messageManager.GetNodeMessages())
{
var node = graphData.GetNodeFromId(pair.Key);
foreach (var message in pair.Value)
{
MessageManager.Log(node, subGraphPath, message, graphAsset);
}
}
}
messageManager.ClearAll();
}
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_subgraph_icon");
ctx.AddObjectToAsset("MainAsset", graphAsset, texture);
ctx.SetMainObject(graphAsset);
var metadata = ScriptableObject.CreateInstance <ShaderSubGraphMetadata>();
metadata.hideFlags = HideFlags.HideInHierarchy;
metadata.assetDependencies = new List <UnityEngine.Object>();
AssetCollection assetCollection = new AssetCollection();
MinimalGraphData.GatherMinimalDependenciesFromFile(assetPath, assetCollection);
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.IncludeInExportPackage))
{
// this sucks that we have to fully load these assets just to set the reference,
// which then gets serialized as the GUID that we already have here. :P
var dependencyPath = AssetDatabase.GUIDToAssetPath(asset.Key);
if (!string.IsNullOrEmpty(dependencyPath))
{
metadata.assetDependencies.Add(
AssetDatabase.LoadAssetAtPath(dependencyPath, typeof(UnityEngine.Object)));
}
}
}
ctx.AddObjectToAsset("Metadata", metadata);
// declare dependencies
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.SourceDependency))
{
ctx.DependsOnSourceAsset(asset.Key);
// I'm not sure if this warning below is actually used or not, keeping it to be safe
var assetPath = AssetDatabase.GUIDToAssetPath(asset.Key);
// Ensure that dependency path is relative to project
if (!string.IsNullOrEmpty(assetPath) && !assetPath.StartsWith("Packages/") && !assetPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {assetPath}", graphAsset);
}
}
// NOTE: dependencies declared by GatherDependenciesFromSourceFile are automatically registered as artifact dependencies
// HOWEVER: that path ONLY grabs dependencies via MinimalGraphData, and will fail to register dependencies
// on GUIDs that don't exist in the project. For both of those reasons, we re-declare the dependencies here.
if (asset.Value.HasFlag(AssetCollection.Flags.ArtifactDependency))
{
ctx.DependsOnArtifact(asset.Key);
}
}
}
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 override void OnImportAsset(AssetImportContext ctx)
{
var text = new TextAsset(File.ReadAllText(ctx.assetPath));
ctx.AddObjectToAsset(Path.GetFileNameWithoutExtension(ctx.assetPath), text);
}
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);
}
/// <summary>Imports an SVG asset</summary>
/// <param name="ctx">The asset import context of the scripted importer</param>
public override void OnImportAsset(AssetImportContext ctx)
{
UpdateProperties();
// We're using a hardcoded window size of 100x100. This way, using a pixels per point value of 100
// results in a sprite of size 1 when the SVG file has a viewbox specified.
SVGParser.SceneInfo sceneInfo;
using (var stream = new StreamReader(ctx.assetPath))
sceneInfo = SVGParser.ImportSVG(stream, ViewportOptions, 0, 1, 100, 100);
if (sceneInfo.Scene == null || sceneInfo.Scene.Root == null)
{
throw new Exception("Wowzers!");
}
float stepDist = StepDistance;
float samplingStepDist = SamplingStepDistance;
float maxCord = MaxCordDeviationEnabled ? MaxCordDeviation : float.MaxValue;
float maxTangent = MaxTangentAngleEnabled ? MaxTangentAngle : Mathf.PI * 0.5f;
if (!AdvancedMode)
{
// Automatically compute sensible tessellation options from the
// vector scene's bouding box and target resolution
ComputeTessellationOptions(sceneInfo, TargetResolution, ResolutionMultiplier, out stepDist, out maxCord, out maxTangent);
}
var tessOptions = new VectorUtils.TessellationOptions();
tessOptions.MaxCordDeviation = maxCord;
tessOptions.MaxTanAngleDeviation = maxTangent;
tessOptions.SamplingStepSize = 1.0f / (float)samplingStepDist;
tessOptions.StepDistance = stepDist;
var rect = Rect.zero;
if (ViewportOptions == ViewportOptions.PreserveViewport)
{
rect = sceneInfo.SceneViewport;
}
var geometry = VectorUtils.TessellateScene(sceneInfo.Scene, tessOptions, sceneInfo.NodeOpacity);
var name = System.IO.Path.GetFileNameWithoutExtension(ctx.assetPath);
Sprite sprite = null;
switch (SvgType)
{
case SVGType.VectorSprite:
sprite = BuildSpriteFromGeometry(geometry, rect);
GenerateSpriteAsset(ctx, sprite, name);
break;
case SVGType.UISVGImage:
sprite = BuildSpriteFromGeometry(geometry, rect);
GenerateUGUISpriteAsset(ctx, sprite, name);
break;
case SVGType.TexturedSprite:
sprite = BuildSpriteFromGeometry(geometry, rect);
GenerateTexturedSpriteAsset(ctx, sprite, name);
break;
case SVGType.Texture2D:
sprite = BuildSpriteFromGeometry(geometry, rect);
GenerateTexture2DAsset(ctx, sprite, name);
break;
#if UNITY_2019_3_OR_NEWER
case SVGType.UIToolkit:
GenerateVectorImageAsset(ctx, geometry, name);
break;
#endif
default:
break;
}
}
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);
}
void ImportSpriteSet(AssetImportContext assetContext,
ImportContext ctx,
List <FrameImage> images)
{
// Stage 0: Create the texture atlas and define the sprites
var packResult = SpritePacker.Pack(ctx.Settings.Border, ctx.Settings.DenselyPacked, images);
var texture = AtlasGenerator.CreateTexture(packResult);
var metaList = AtlasGenerator.GenerateAtlasMetaData(ctx, packResult);
var preview = images.Count > 0 ? AtlasGenerator.CreateTexture(images[0]) : texture;
assetContext.AddObjectToAsset(ctx.BaseName, texture, preview);
assetContext.SetMainObject(texture);
var subImages = ctx.AseFile.SubImages.ToList();
foreach (var subImage in subImages)
{
var metaLayers = subImage.AllLayers.Where(layer => layer.Type == LayerType.Meta).ToList();
// State 1 - Post process the sprite definitions
var sprteContext = new SpriteProcessingContext(ctx, metaList);
foreach (var processor in SpritePostProcessors)
{
foreach (var layer in metaLayers.Where(l => l.ActionName == processor.ActionName))
{
processor.Process(sprteContext, layer);
}
}
}
// Stage 2: Actually generate the sprite instances. Generate generic animation templates ..
var sprites = GenerateSprites(metaList, ctx, texture);
var animImporter = new AnimationImporter(ChildPath);
var animations = animImporter.GenerateAnimClips(ctx, subImages, sprites);
// Stage 3: Post process the animations and add events etc.
foreach (var subImage in subImages)
{
var metaLayers = subImage.AllLayers.Where(layer => layer.Type == LayerType.Meta).ToList();
var metaContext = new MetaProcessingContext(ctx, animations, sprites);
foreach (var processor in MetaPostProcessors)
{
foreach (var layer in metaLayers.Where(l => l.ActionName == processor.ActionName))
{
processor.Process(metaContext, layer);
}
}
}
// Step 4: Add all generated sprites and animations to the import context.
foreach (var def in sprites)
{
var sprite = def.Sprite;
assetContext.AddObjectToAsset(sprite.name, sprite, AtlasGenerator.CreateTexture(def.Definition.Frame));
}
foreach (var anim in animations)
{
var clip = anim.Value;
var tag = anim.Key;
assetContext.AddObjectToAsset(tag.Name, clip);
}
}
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 oldShader = AssetDatabase.LoadAssetAtPath <Shader>(ctx.assetPath);
if (oldShader != null)
{
ShaderUtil.ClearShaderMessages(oldShader);
}
List <PropertyCollector.TextureInfo> configuredTextures;
string path = ctx.assetPath;
AssetCollection assetCollection = new AssetCollection();
MinimalGraphData.GatherMinimalDependenciesFromFile(assetPath, assetCollection);
var textGraph = File.ReadAllText(path, Encoding.UTF8);
var graph = new GraphData
{
messageManager = new MessageManager(), assetGuid = AssetDatabase.AssetPathToGUID(path)
};
MultiJson.Deserialize(graph, textGraph);
graph.OnEnable();
graph.ValidateGraph();
Shader shader = null;
#if VFX_GRAPH_10_0_0_OR_NEWER
if (!graph.isOnlyVFXTarget)
#endif
{
// build the shader text
// this will also add Target dependencies into the asset collection
var text = GetShaderText(path, out configuredTextures, assetCollection, graph);
#if UNITY_2021_1_OR_NEWER
// 2021.1 or later is guaranteed to have the new version of this function
shader = ShaderUtil.CreateShaderAsset(ctx, text, false);
#else
// earlier builds of Unity may or may not have it
// here we try to invoke the new version via reflection
var createShaderAssetMethod = typeof(ShaderUtil).GetMethod(
"CreateShaderAsset",
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.ExactBinding,
null,
new Type[] { typeof(AssetImportContext), typeof(string), typeof(bool) },
null);
if (createShaderAssetMethod != null)
{
shader = createShaderAssetMethod.Invoke(null, new Object[] { ctx, text, false }) as Shader;
}
else
{
// method doesn't exist in this version of Unity, call old version
// this doesn't create dependencies properly, but is the best that we can do
shader = ShaderUtil.CreateShaderAsset(text, false);
}
#endif
ReportErrors(graph, shader, path);
EditorMaterialUtility.SetShaderDefaults(
shader,
configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
EditorMaterialUtility.SetShaderNonModifiableDefaults(
shader,
configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
}
UnityEngine.Object mainObject = shader;
#if VFX_GRAPH_10_0_0_OR_NEWER
ShaderGraphVfxAsset vfxAsset = null;
if (graph.hasVFXTarget)
{
vfxAsset = GenerateVfxShaderGraphAsset(graph);
if (mainObject == null)
{
mainObject = vfxAsset;
}
else
{
//Correct main object if we have a shader and ShaderGraphVfxAsset : save as sub asset
vfxAsset.name = Path.GetFileNameWithoutExtension(path);
ctx.AddObjectToAsset("VFXShaderGraph", vfxAsset);
}
}
#endif
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon");
ctx.AddObjectToAsset("MainAsset", mainObject, texture);
ctx.SetMainObject(mainObject);
foreach (var target in graph.activeTargets)
{
if (target is IHasMetadata iHasMetadata)
{
var metadata = iHasMetadata.GetMetadataObject();
if (metadata == null)
{
continue;
}
metadata.hideFlags = HideFlags.HideInHierarchy;
ctx.AddObjectToAsset($"{iHasMetadata.identifier}:Metadata", metadata);
}
}
var sgMetadata = ScriptableObject.CreateInstance <ShaderGraphMetadata>();
sgMetadata.hideFlags = HideFlags.HideInHierarchy;
sgMetadata.assetDependencies = new List <UnityEngine.Object>();
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.IncludeInExportPackage))
{
// this sucks that we have to fully load these assets just to set the reference,
// which then gets serialized as the GUID that we already have here. :P
var dependencyPath = AssetDatabase.GUIDToAssetPath(asset.Key);
if (!string.IsNullOrEmpty(dependencyPath))
{
sgMetadata.assetDependencies.Add(
AssetDatabase.LoadAssetAtPath(dependencyPath, typeof(UnityEngine.Object)));
}
}
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
// declare dependencies
foreach (var asset in assetCollection.assets)
{
if (asset.Value.HasFlag(AssetCollection.Flags.SourceDependency))
{
ctx.DependsOnSourceAsset(asset.Key);
// I'm not sure if this warning below is actually used or not, keeping it to be safe
var assetPath = AssetDatabase.GUIDToAssetPath(asset.Key);
// Ensure that dependency path is relative to project
if (!string.IsNullOrEmpty(assetPath) && !assetPath.StartsWith("Packages/") && !assetPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {assetPath}", mainObject);
}
}
// NOTE: dependencies declared by GatherDependenciesFromSourceFile are automatically registered as artifact dependencies
// HOWEVER: that path ONLY grabs dependencies via MinimalGraphData, and will fail to register dependencies
// on GUIDs that don't exist in the project. For both of those reasons, we re-declare the dependencies here.
if (asset.Value.HasFlag(AssetCollection.Flags.ArtifactDependency))
{
ctx.DependsOnArtifact(asset.Key);
}
}
}
/// <summary>
/// Common method performing the import of the asset
/// </summary>
/// <param name="ctx">Asset importer context.</param>
/// <param name="setupRenderPipelinePrefabLight">Delegate needed to perform operation which are "Render Pipeline specific" here setuping the prefab of light</param>
public void CommonOnImportAsset(AssetImportContext ctx, SetupRenderPipelinePrefabLight setupRenderPipelinePrefabLight)
{
Texture cookieTextureCube = null;
Texture cookieTexture2D = null;
string iesFilePath = Path.Combine(Path.GetDirectoryName(Application.dataPath), ctx.assetPath);
string errorMessage = engine.ReadFile(iesFilePath);
if (string.IsNullOrEmpty(errorMessage))
{
iesMetaData.FileFormatVersion = engine.FileFormatVersion;
iesMetaData.IESPhotometricType = engine.GetPhotometricType();
iesMetaData.Manufacturer = engine.GetKeywordValue("MANUFAC");
iesMetaData.LuminaireCatalogNumber = engine.GetKeywordValue("LUMCAT");
iesMetaData.LuminaireDescription = engine.GetKeywordValue("LUMINAIRE");
iesMetaData.LampCatalogNumber = engine.GetKeywordValue("LAMPCAT");
iesMetaData.LampDescription = engine.GetKeywordValue("LAMP");
(iesMetaData.IESMaximumIntensity, iesMetaData.IESMaximumIntensityUnit) = engine.GetMaximumIntensity();
string warningMessage;
(warningMessage, cookieTextureCube) = engine.GenerateCubeCookie(iesMetaData.CookieCompression, (int)iesMetaData.iesSize);
if (!string.IsNullOrEmpty(warningMessage))
{
ctx.LogImportWarning($"Cannot properly generate IES Cube texture: {warningMessage}");
}
cookieTextureCube.IncrementUpdateCount();
(warningMessage, cookieTexture2D) = engine.Generate2DCookie(iesMetaData.CookieCompression, iesMetaData.SpotAngle, (int)iesMetaData.iesSize, iesMetaData.ApplyLightAttenuation);
if (!string.IsNullOrEmpty(warningMessage))
{
ctx.LogImportWarning($"Cannot properly generate IES 2D texture: {warningMessage}");
}
cookieTexture2D.IncrementUpdateCount();
}
else
{
ctx.LogImportError($"Cannot read IES file '{iesFilePath}': {errorMessage}");
}
string iesFileName = Path.GetFileNameWithoutExtension(ctx.assetPath);
var iesObject = ScriptableObject.CreateInstance <IESObject>();
iesObject.iesMetaData = iesMetaData;
var lightObject = new GameObject(iesFileName);
lightObject.transform.localEulerAngles = new Vector3(90f, 0f, iesMetaData.LightAimAxisRotation);
Light light = lightObject.AddComponent <Light>();
light.type = (iesMetaData.PrefabLightType == IESLightType.Point) ? LightType.Point : LightType.Spot;
light.intensity = 1f; // would need a better intensity value formula
light.range = 10f; // would need a better range value formula
light.spotAngle = iesMetaData.SpotAngle;
setupRenderPipelinePrefabLight(engine, light, (iesMetaData.PrefabLightType == IESLightType.Point) ? cookieTextureCube : cookieTexture2D);
ctx.AddObjectToAsset("IES", iesObject);
ctx.SetMainObject(iesObject);
// The light object will be automatically converted into a prefab.
ctx.AddObjectToAsset(iesFileName, lightObject);
if (cookieTextureCube != null)
{
cookieTextureCube.name = iesFileName + "-Cube-IES";
ctx.AddObjectToAsset(cookieTextureCube.name, cookieTextureCube);
}
if (cookieTexture2D != null)
{
cookieTexture2D.name = iesFileName + "-2D-IES";
ctx.AddObjectToAsset(cookieTexture2D.name, cookieTexture2D);
}
}
