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); } }