public override void OnImportAsset(AssetImportContext ctx)
{
string fileContent = File.ReadAllText(ctx.assetPath);
var package = ObjectFactory.CreateInstance <ShaderPackage>();
if (!string.IsNullOrEmpty(fileContent))
{
EditorJsonUtility.FromJsonOverwrite(fileContent, package);
}
if (package.entries == null)
{
package.entries = new List <ShaderPackage.Entry>();
}
#if __BETTERSHADERS__
if (package.betterShader != null)
{
package.betterShaderPath = AssetDatabase.GetAssetPath(package.betterShader);
}
#endif
package.Pack(false);
#if __BETTERSHADERS__
if (package.betterShader != null)
{
ctx.DependsOnSourceAsset(package.betterShaderPath);
}
#endif
foreach (var e in package.entries)
{
if (e.shader != null)
{
ctx.DependsOnSourceAsset(AssetDatabase.GetAssetPath(e.shader));
}
}
string shaderSrc = package.GetShaderSrc();
if (shaderSrc == null)
{
Debug.LogError("No Shader for this platform and SRP provided");
// maybe make an error shader here?
return;
}
Shader shader = ShaderUtil.CreateShaderAsset(ctx, shaderSrc, false);
ctx.AddObjectToAsset("MainAsset", shader);
ctx.SetMainObject(shader);
}
public override void OnImportAsset(AssetImportContext ctx)
{
var settings = new SearchDatabase.Settings {
type = "asset", options = GetOptions()
};
var indexer = SearchDatabase.CreateIndexer(settings);
try
{
indexer.IndexDocument(ctx.assetPath, false);
indexer.Finish(removedDocuments: null);
var indexArtifactPath = ctx.GetOutputArtifactFilePath($"{(int)options:X}.index".ToLowerInvariant());
using (var fileStream = new FileStream(indexArtifactPath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
indexer.Write(fileStream);
ctx.DependsOnSourceAsset(ctx.assetPath);
ctx.DependsOnCustomDependency(GetType().GUID.ToString("N"));
ctx.DependsOnCustomDependency(nameof(CustomObjectIndexerAttribute));
}
catch (Exception ex)
{
ctx.LogImportError($"Failed to build search index for {ctx.assetPath}\n{ex}");
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
var textGraph = File.ReadAllText(ctx.assetPath, Encoding.UTF8);
var graph = JsonUtility.FromJson <SubGraph>(textGraph);
if (graph == null)
{
return;
}
var sourceAssetDependencyPaths = new List <string>();
foreach (var node in graph.GetNodes <AbstractMaterialNode>())
{
node.GetSourceAssetDependencies(sourceAssetDependencyPaths);
}
var graphAsset = ScriptableObject.CreateInstance <MaterialSubGraphAsset>();
graphAsset.subGraph = graph;
ctx.AddObjectToAsset("MainAsset", graphAsset);
ctx.SetMainObject(graphAsset);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
int width = m_TexturePlatformSettings.maxTextureSize;
int height = m_TexturePlatformSettings.maxTextureSize;
Texture2D[] textures = m_InputTextures;
TexturePackingSettings[] settings = m_InputTextureSettings;
var canGenerateTexture = GetOuputTextureSize(textures, out var inputW, out var inputH);
//Mimic default importer. We use max size unless assets are smaller
width = width < inputW ? width : inputW;
height = height < inputH ? height : inputH;
bool hasAlpha = textures[3] != null;
Texture2D texture = new Texture2D(width, height, hasAlpha ? TextureFormat.ARGB32 : TextureFormat.RGB24, m_EnableMipMap, m_sRGBTexture)
{
filterMode = m_FilterMode,
wrapMode = m_WrapMode,
anisoLevel = m_AnisotricLevel,
};
if (canGenerateTexture)
{
//Only attempt to apply any settings if the inputs exist
texture.PackChannels(textures, settings);
// Mark all input textures as dependency to the texture array.
// This causes the texture array to get re-generated when any input texture changes or when the build target changed.
foreach (Texture2D t in textures)
{
if (t != null)
{
var path = AssetDatabase.GetAssetPath(t);
ctx.DependsOnSourceAsset(path);
}
}
// TODO: Seems like we need to call TextureImporter.SetPlatformTextureSettings to register/apply platform
// settings. However we can't subclass from TextureImporter... Is there other way?
//Currently just supporting one compression format in liew of TextureImporter.SetPlatformTextureSettings
if (m_UseExplicitTextureFormat)
{
EditorUtility.CompressTexture(texture, m_TextureFormat, 100);
}
else if (m_TexturePlatformSettings.textureCompression != TextureImporterCompression.Uncompressed)
{
texture.Compress(m_TexturePlatformSettings.textureCompression == TextureImporterCompression.CompressedHQ);
}
ApplyPropertiesViaSerializedObj(texture);
}
//If we pass the tex to the 3rd arg we can have it show in an Icon as normal, maybe configurable?
//ctx.AddObjectToAsset("mask", texture, texture);
ctx.AddObjectToAsset("mask", texture);
ctx.SetMainObject(texture);
}
public override void OnImportAsset(AssetImportContext ctx)
{
var oldShader = AssetDatabase.LoadAssetAtPath <Shader>(ctx.assetPath);
if (oldShader != null)
{
ShaderUtil.ClearShaderErrors(oldShader);
}
List <PropertyCollector.TextureInfo> configuredTextures;
string path = ctx.assetPath;
var sourceAssetDependencyPaths = new List <string>();
var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths);
var shader = ShaderUtil.CreateShaderAsset(text);
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());
ctx.AddObjectToAsset("MainAsset", shader);
ctx.SetMainObject(shader);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
SimulatorWindow.MarkAllDeviceListsDirty();
var asset = ScriptableObject.CreateInstance <DeviceInfoAsset>();
var deviceJson = File.ReadAllText(ctx.assetPath);
asset.deviceInfo = ParseDeviceInfo(deviceJson, out var errors, out var systemInfoElement, out var graphicsDataElement);
if (errors.Length > 0)
{
asset.parseErrors = errors;
}
else
{
FindOptionalFieldAvailability(asset, systemInfoElement, graphicsDataElement);
AddOptionalFields(asset.deviceInfo);
// Saving asset path in order to find overlay relatively to it
asset.directory = Path.GetDirectoryName(ctx.assetPath);
ctx.DependsOnSourceAsset(ctx.assetPath);
}
ctx.AddObjectToAsset("main obj", asset);
ctx.SetMainObject(asset);
}
///<summary>Load first prefab with `name`.</summary>
public static GameObject Load(string name, AssetImportContext context)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
if (cache.TryGetValue(name, out var cachedPrefab))
{
return(cachedPrefab);
}
var filename = name + ".prefab";
var asset = (
from guid in AssetDatabase.FindAssets($"{name} t:gameobject")
let path = AssetDatabase.GUIDToAssetPath(guid)
where Path.GetFileName(path) == filename
let prefab = AssetDatabase.LoadAssetAtPath <GameObject>(path)
where prefab != null
select new { prefab, path }
).FirstOrDefault();
cache.Add(name, asset?.prefab);
if (!string.IsNullOrEmpty(asset?.path))
{
context?.DependsOnSourceAsset(asset.path);
}
else
{
Debug.LogWarning($"No prefab named \"{name}\" could be found, skipping.");
}
return(asset?.prefab);
}
public override void OnImportAsset(AssetImportContext ctx)
{
int counter = 0;
// Main import object
VoxelObject importObject = ScriptableObject.CreateInstance <VoxelObject>();
importObject.m_Scale = m_Scale;
importObject.name = Path.GetFileNameWithoutExtension(ctx.assetPath);
ctx.AddObjectToAsset(importObject.name, importObject);
ctx.SetMainObject(importObject);
// Main game import object
GameObject rootObject = new GameObject();
rootObject.name = importObject.name;
ctx.AddObjectToAsset(rootObject.name, rootObject);
importObject.m_ModelObject = rootObject;
List <VoxelData> allData = new List <VoxelData>();
foreach (string voxFile in Directory.EnumerateFiles(Path.GetDirectoryName(ctx.assetPath), importObject.name + "*.vox"))
{
ctx.DependsOnSourceAsset(voxFile);
// Add all separate data with model and voxel data
Color32[] palette;
foreach (VoxelData data in VoxelData.ParseFrom(voxFile, out palette))
{
allData.Add(data);
data.name = "VOX_" + importObject.name + "_" + counter;
ctx.AddObjectToAsset(data.name, data);
Mesh mesh = data.GenerateMesh(m_PivotOffset, m_Scale);
mesh.name = "MDL_" + importObject.name + "_" + counter;
ctx.AddObjectToAsset(mesh.name, mesh);
// Setup a game object to hold this
GameObject modelObject = new GameObject();
modelObject.name = "OBJ_" + importObject.name + "_" + counter;
MeshFilter meshFilter = modelObject.AddComponent <MeshFilter>();
MeshRenderer renderer = modelObject.AddComponent <MeshRenderer>();
meshFilter.mesh = mesh;
renderer.material = m_SourceMaterial;
modelObject.transform.SetParent(rootObject.transform);
ctx.AddObjectToAsset(modelObject.name, modelObject);
++counter;
}
}
importObject.m_VoxelData = allData.ToArray();
}
public void AddDependency(AssetImportContext context, string assetPath)
{
if (!m_AssetDependencies.Contains(assetPath))
{
context.DependsOnSourceAsset(assetPath);
m_AssetDependencies.Add(assetPath);
}
}
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;
var sourceAssetDependencyPaths = new List <string>();
var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths, out var graph);
var shader = ShaderUtil.CreateShaderAsset(text, false);
if (graph != null && graph.messageManager.nodeMessagesChanged)
{
foreach (var pair in graph.messageManager.GetNodeMessages())
{
var node = graph.GetNodeFromTempId(pair.Key);
MessageManager.Log(node, path, pair.Value.First(), shader);
}
}
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());
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon@64");
ctx.AddObjectToAsset("MainAsset", shader, texture);
ctx.SetMainObject(shader);
var metadata = ScriptableObject.CreateInstance <ShaderGraphMetadata>();
metadata.hideFlags = HideFlags.HideInHierarchy;
if (graph != null)
{
metadata.outputNodeTypeName = graph.outputNode.GetType().FullName;
}
ctx.AddObjectToAsset("Metadata", metadata);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
// Ensure that dependency path is relative to project
if (!sourceAssetDependencyPath.StartsWith("Packages/") && !sourceAssetDependencyPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {sourceAssetDependencyPath}", shader);
continue;
}
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
var oldShader = AssetDatabase.LoadAssetAtPath <Shader>(ctx.assetPath);
if (oldShader != null)
{
ShaderUtil.ClearShaderErrors(oldShader);
}
List <PropertyCollector.TextureInfo> configuredTextures;
string path = ctx.assetPath;
string shaderString = null;
var sourceAssetDependencyPaths = new List <string>();
var shaderName = Path.GetFileNameWithoutExtension(path);
try
{
var textGraph = File.ReadAllText(path, Encoding.UTF8);
var graph = JsonUtility.FromJson <MaterialGraph>(textGraph);
graph.LoadedFromDisk();
if (!string.IsNullOrEmpty(graph.path))
{
shaderName = graph.path + "/" + shaderName;
}
shaderString = graph.GetShader(shaderName, GenerationMode.ForReals, out configuredTextures, sourceAssetDependencyPaths);
foreach (var node in graph.GetNodes <AbstractMaterialNode>())
{
node.GetSourceAssetDependencies(sourceAssetDependencyPaths);
}
}
catch (Exception)
{
configuredTextures = new List <PropertyCollector.TextureInfo>();
// ignored
}
var text = shaderString ?? k_ErrorShader.Replace("Hidden/GraphErrorShader2", shaderName);
var shader = ShaderUtil.CreateShaderAsset(text);
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());
ctx.AddObjectToAsset("MainAsset", shader);
ctx.SetMainObject(shader);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
public void AddDependency(AssetImportContext context, string assetPath)
{
if (!m_AssetDependencies.Contains(assetPath))
{
#if UNITY_2018_3_OR_NEWER
context.DependsOnSourceAsset(assetPath);
#endif
m_AssetDependencies.Add(assetPath);
}
}
Material GetMaterial(string shaderFile)
{
var path = Path.Combine("Packages/com.unity.formats.alembic/Runtime/Shaders", shaderFile);
m_ctx.DependsOnSourceAsset(path);
var shader =
AssetDatabase.LoadAssetAtPath <Shader>(path);
return(new Material(shader));
}
public override void OnImportAsset(AssetImportContext ctx)
{
// Attempt to generate models for each frame
string expectedImage = Path.Combine(Path.GetDirectoryName(ctx.assetPath), Path.GetFileNameWithoutExtension(ctx.assetPath));
Texture2D sourceTexture = AssetDatabase.LoadAssetAtPath <Texture2D>(expectedImage);
if (sourceTexture == null)
{
ctx.LogImportError($"Failed to load associated texture at '{expectedImage}'");
return;
}
ctx.DependsOnSourceAsset(expectedImage);
IVoxelVolume textureVolume = new Texture2DVoxelVolume(sourceTexture);
// Layers will be stacked next to each other progressing
int layerCount = m_ImportSettings.GetTotalChannelCountRounded(4) / 4;
Vector3Int cellSize, frameStep, channelStep;
if (m_ImportFrameOrientation == LayoutOrientation.Vertical)
{
cellSize = new Vector3Int();
cellSize.x = sourceTexture.width / layerCount;
cellSize.y = sourceTexture.height / m_ImportSettings.FrameCount;
frameStep = new Vector3Int(0, cellSize.y, 0);
channelStep = new Vector3Int(cellSize.x, 0, 0);
}
else
{
cellSize = new Vector3Int();
cellSize.x = sourceTexture.width / m_ImportSettings.FrameCount;
cellSize.y = sourceTexture.height / layerCount;
frameStep = new Vector3Int(cellSize.x, 0, 0);
channelStep = new Vector3Int(0, cellSize.y, 0);
}
CommonVoxelImporter importer = new CommonVoxelImporter(textureVolume, m_ImportSettings, cellSize, frameStep, channelStep);
MeshSheet meshSheet = importer.GenerateMeshSheet();
ctx.AddObjectToAsset("Meshes", meshSheet);
for (int i = 0; i < meshSheet.FrameCount; ++i)
{
Mesh mesh = meshSheet.GetMeshAtFrame(i);
mesh.name = Path.GetFileNameWithoutExtension(ctx.assetPath) + "_MeshFrame_" + i;
ctx.AddObjectToAsset("MeshFrame_" + i, mesh);
}
ctx.SetMainObject(meshSheet);
}
public override void OnImportAsset(AssetImportContext ctx)
{
if (m_AnimatorController == null)
{
var controller = new AnimatorController();
ctx.AddObjectToAsset("DefaultController", controller);
ctx.SetMainObject(controller);
return;
}
var path = AssetDatabase.GetAssetPath(m_AnimatorController);
if (string.IsNullOrEmpty(path))
{
Debug.LogError($"{m_AnimatorController.name} is not an asset.", m_AnimatorController);
return;
}
var newAnimatorController = Instantiate(m_AnimatorController);
newAnimatorController.name = m_AnimatorController.name;
ctx.AddObjectToAsset($"{newAnimatorController.name}", newAnimatorController);
var animatorAssets = AssetDatabase.LoadAllAssetsAtPath(path);
var index = 0;
foreach (var asset in animatorAssets)
{
if (asset == null || asset == m_AnimatorController)
{
continue;
}
ctx.AddObjectToAsset($"{asset.name}{index}", asset);
++index;
}
ctx.SetMainObject(newAnimatorController);
ctx.DependsOnSourceAsset(path);
var overrideMotions = new Dictionary <Motion, Motion>();
foreach (var overrideMotion in m_OverrideMotions)
{
if (overrideMotion.originalMotion != null && overrideMotion.overrideMotion != null)
{
overrideMotions.Add(overrideMotion.originalMotion, overrideMotion.overrideMotion);
}
}
var motions = new HashSet <Motion>();
foreach (var layer in newAnimatorController.layers)
{
ReplaceMotion(overrideMotions, layer.stateMachine);
}
}
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;
var sourceAssetDependencyPaths = new List <string>();
var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths, out var graph);
var shader = ShaderUtil.CreateShaderAsset(text);
if (graph.messageManager.nodeMessagesChanged)
{
foreach (var pair in graph.messageManager.GetNodeMessages())
{
var node = graph.GetNodeFromTempId(pair.Key);
var errorString = $"Error in Shader Graph at {path} in node {node.name}: {pair.Value.First().message}";
Debug.LogError(errorString, shader);
}
}
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());
ctx.AddObjectToAsset("MainAsset", shader);
ctx.SetMainObject(shader);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
// Ensure that dependency path is relative to project
if (!sourceAssetDependencyPath.StartsWith("Packages/") && !sourceAssetDependencyPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {sourceAssetDependencyPath}", shader);
continue;
}
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
var settings = new SearchDatabase.Settings
{
guid = null,
root = null,
roots = null,
source = null,
name = null,
baseScore = 0,
excludes = null,
includes = null,
type = type,
options = GetOptions(),
};
EditorApplication.LockReloadAssemblies();
try
{
var indexer = SearchDatabase.CreateIndexer(settings);
indexer.IndexDocument(ctx.assetPath, false);
indexer.ApplyUnsorted();
var indexArtifactPath = ctx.GetResultPath($"{type}.{(int)options:X}.index".ToLowerInvariant());
using (var fileStream = new FileStream(indexArtifactPath, FileMode.CreateNew, FileAccess.Write, FileShare.Read))
indexer.Write(fileStream);
Debug.LogFormat(LogType.Log, LogOption.NoStacktrace, null, $"\nGenerated {type} ({GetType().Name}) {indexArtifactPath} for {ctx.assetPath} with {options}");
ctx.DependsOnSourceAsset(Path.GetDirectoryName(ctx.assetPath).Replace("\\", "/"));
ctx.DependsOnCustomDependency(GetType().GUID.ToString("N"));
#if UNITY_2020_1_OR_NEWER
ctx.DependsOnCustomDependency(nameof(CustomObjectIndexerAttribute));
#endif
}
catch (Exception ex)
{
Debug.LogException(ex);
ctx.LogImportError(ex.Message);
}
finally
{
EditorApplication.UnlockReloadAssemblies();
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
// Create our main object
var name = Path.GetFileNameWithoutExtension(ctx.assetPath);
var main = new GameObject(name);
ctx.AddObjectToAsset(name, main);
ctx.SetMainObject(main);
// Instantiate a prefab to add to our main object
// Bug: The object heirarchy of children in our prefab is not preserved. Instead, the children are ordered alphabetically.
var path = "Assets/TestPrefab.prefab";
var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(path);
var instance = PrefabUtility.InstantiatePrefab(prefab, main.transform) as GameObject;
ctx.DependsOnSourceAsset(path);
}
///<summary>
///Load embedded or external tileset.
///</summary>
static Tileset ParseTileset(AssetImportContext context, TSX tsx)
{
// Load embedded tileset.
if (tsx.source == null)
{
return(TSXImporter.Load(context, tsx));
}
// Load external tileset, respecting relative paths.
var source = PathHelper.AssetPath(
Path.GetDirectoryName(context.assetPath) +
Path.DirectorySeparatorChar +
tsx.source
);
context.DependsOnSourceAsset(source);
return(AssetDatabase.LoadAssetAtPath <Tileset>(source));
}
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;
var sourceAssetDependencyPaths = new List <string>();
var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths);
var shader = ShaderUtil.CreateShaderAsset(text);
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());
ctx.AddObjectToAsset("MainAsset", shader);
ctx.SetMainObject(shader);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
// Ensure that dependency path is relative to project
if (!sourceAssetDependencyPath.StartsWith("Packages/") && !sourceAssetDependencyPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {sourceAssetDependencyPath}");
continue;
}
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
if (!schema)
{
ctx.LogImportError("need a schema");
return;
}
var fileName = Path.GetFileName(ctx.assetPath);
var text = File.ReadAllText(ctx.assetPath);
var document = Parser.Parse(schema, text);
if (!Generator.Generate(document, ctx.assetPath))
{
// TODO: trigger reimport to load the generated class and add as component
}
var root = Spawner.Spawn(document);
ctx.AddObjectToAsset("UAML", root);
ctx.SetMainObject(root);
ctx.DependsOnSourceAsset(AssetDatabase.GetAssetPath(schema));
}
public override void OnImportAsset(AssetImportContext ctx)
{
var scene = EditorSceneManager.OpenScene(ctx.assetPath, OpenSceneMode.Additive);
try
{
var dependencies = AssetDatabase.GetDependencies(scene.path).Where(x => x.ToLower().EndsWith(".prefab"));
foreach (var dependency in dependencies)
{
ctx.DependsOnSourceAsset(dependency);
}
var metaPath = ctx.GetResultPath("scenemeta");
var subScenes = SubScene.AllSubScenes;
var sceneGuids = subScenes.Where(x => x.SceneGUID != default(Hash128)).Select(x => x.SceneGUID).Distinct().ToArray();
var builder = new BlobBuilder(Allocator.Temp);
ref var metaData = ref builder.ConstructRoot <SceneMetaData>();
builder.Construct(ref metaData.SubScenes, sceneGuids);
BlobAssetReference <SceneMetaData> .Write(builder, metaPath, SceneMetaDataImporter.CurrentFileFormatVersion);
builder.Dispose();
}
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@64");
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);
}
}
}
///<summary>Construct a tilemap from Tiled, adding named prefab instances based on Type.</summary>
public override void OnImportAsset(AssetImportContext context)
{
var assetPathPrefix = Path.GetDirectoryName(assetPath) + Path.DirectorySeparatorChar;
// TODO: Support ../source.tsx
var tmx = new TMX(XDocument.Load(assetPath).Element("map"), assetPathPrefix);
// if (tmx.infinite) {
//throw new NotImplementedException("Infinite: " + tmx.infinite);
// }
var layout = tmx.orientation == "orthogonal"
? GridLayout.CellLayout.Rectangle
: tmx.orientation == "isometric"
? GridLayout.CellLayout.Isometric
: GridLayout.CellLayout.Hexagon;
var gids = new uint[tmx.layers.Length][][];
var gidSet = new HashSet <uint>();
// TODO: & 0x1fffffff the gidSet values from tile gids[]
for (var i = 0; i < tmx.layers.Length; ++i)
{
var layer = tmx.layers[i];
if (layer.data.chunks != null) // Tile layer
{
gids[i] = new uint[layer.data.chunks.Length][];
for (var j = 0; j < gids[i].Length; ++j)
{
gids[i][j] = ParseGIDs(
layer.data.encoding,
layer.data.compression,
layer.data.chunks[j].value,
layer.width,
layout
);
gidSet.UnionWith(gids[i][j]);
}
}
else // Object layer
{
foreach (var @object in layer.objects)
{
gidSet.Add(@object.gid & 0x1fffffff);
}
}
}
// Tilesets
var tiles = new Tile[1]; // Global Tile IDs start from 1
foreach (var tsx in tmx.tilesets)
{
Tileset tileset = null;
if (tsx.source == null) // Embedded tileset
{
tileset = TSXImporter.Load(context, tsx);
}
else // External tileset
{
var tilesetSource = "Assets" + Path.GetFullPath(assetPathPrefix + tsx.source).Substring(Application.dataPath.Length);
tileset = AssetDatabase.LoadAssetAtPath <Tileset>(tilesetSource);
context.DependsOnSourceAsset(tilesetSource);
}
var tilesetTiles = new Tile[tileset.tiles.Length];
for (var i = 0; i < tilesetTiles.Length; ++i)
{
if (!gidSet.Contains((uint)(i + tsx.firstgid)))
{
continue;
}
tilesetTiles[i] = tileset.tiles[i].Instantiate(tmx.tilewidth);
context.AddObjectToAsset($"tile{i + tsx.firstgid:0000}", tilesetTiles[i]);
context.AddObjectToAsset($"sprite{i + tsx.firstgid:0000}", tilesetTiles[i].sprite);
for (var j = 0; j < tilesetTiles[i].sprites.Length; ++j)
{
context.AddObjectToAsset($"frame{i + tsx.firstgid:0000}:{j}", tilesetTiles[i].sprites[j]);
}
}
ArrayUtility.AddRange(ref tiles, tilesetTiles);
}
// Grid
var grid = new GameObject(Path.GetFileNameWithoutExtension(assetPath), typeof(Grid));
grid.AddComponent <Rigidbody2D>().bodyType = RigidbodyType2D.Static;
grid.isStatic = true;
grid.GetComponent <Grid>().cellLayout = layout;
grid.GetComponent <Grid>().cellSize = new Vector3(1f, (float)tmx.tileheight / tmx.tilewidth, 1f);
context.AddObjectToAsset("grid", grid);
context.SetMainObject(grid);
var collider = grid.AddComponent <CompositeCollider2D>();
collider.generationType = CompositeCollider2D.GenerationType.Manual;
// Layers
PrefabHelper.cache.Clear();
for (var i = 0; i < tmx.layers.Length; ++i)
{
var layer = tmx.layers[i];
var layerObject = new GameObject(layer.name);
layerObject.transform.parent = grid.transform;
layerObject.isStatic = true;
// Tile layer
if (layer.data.chunks != null)
{
// Tilemap
var tilemap = layerObject.AddComponent <Tilemap>();
var renderer = layerObject.AddComponent <TilemapRenderer>();
layerObject.AddComponent <TilemapCollider2D>().usedByComposite = true;
tilemap.color = new Color(1f, 1f, 1f, layer.opacity);
tilemap.orientation = layout == GridLayout.CellLayout.Hexagon ? Tilemap.Orientation.Custom : Tilemap.Orientation.XY;
tilemap.orientationMatrix = Matrix4x4.TRS(
Vector3.zero,
Quaternion.Euler(0f, 180f, 180f),
Vector3.one
);
tilemap.transform.localScale = layout == GridLayout.CellLayout.Hexagon ? new Vector3(1f, -1f, 1f) : Vector3.one;
// Chunks
for (var j = 0; j < layer.data.chunks.Length; ++j)
{
var layerTiles = new Tile[gids[i][j].Length];
for (var k = 0; k < layerTiles.Length; ++k)
{
layerTiles[k] = tiles[gids[i][j][k] & 0x1ffffff]; // 3 MSB are for flipping
}
var size = new Vector3Int(layer.data.chunks[j].width, layer.data.chunks[j].height, 1);
var bounds = new BoundsInt(
new Vector3Int(
layer.width - layer.data.chunks[j].width + layer.data.chunks[j].x,
layer.height - layer.data.chunks[j].height - layer.data.chunks[j].y,
0
),
size);
tilemap.SetTilesBlock(bounds, layerTiles);
// Flipped tiles
for (var k = 0; k < gids[i][j].Length; ++k)
{
var diagonal = (gids[i][j][k] >> 29) & 1;
var vertical = (gids[i][j][k] >> 30) & 1;
var horizontal = (gids[i][j][k] >> 31) & 1;
var flips = new Vector4(diagonal, vertical, horizontal, 0);
if (flips.sqrMagnitude > 0f)
{
var position = new Vector3Int(
layer.width - layer.data.chunks[j].width + k % layer.data.chunks[j].width,
layer.height - layer.data.chunks[j].height + k / layer.data.chunks[j].width,
0
);
var transform = Matrix4x4.TRS(
Vector3.zero,
Quaternion.AngleAxis(diagonal * 180, new Vector3(1, 1, 0)),
Vector3.one - (diagonal == 1 ? new Vector3(flips.y, flips.z, flips.w) : new Vector3(flips.z, flips.y, flips.w)) * 2
);
tilemap.SetTransformMatrix(position, transform);
}
}
}
renderer.sortOrder = layout == GridLayout.CellLayout.Hexagon ? TilemapRenderer.SortOrder.BottomLeft : TilemapRenderer.SortOrder.TopLeft;
renderer.sortingOrder = i;
// Object layer
}
else
{
var objects = layer.objects; //layer.Elements("object").ToArray();
foreach (var @object in objects)
{
var tile = tiles[@object.gid & 0x1fffffff];
string icon = null;
GameObject gameObject; // Doubles as prefab when object has type
// Default instantiation when object has no set type
if (string.IsNullOrEmpty(@object.type))
{
gameObject = new GameObject($"{@object.name} {@object.id}".Trim());
icon = "sv_label_0";
// Warn instantiation when object has type but no prefab was found
}
else if (null == (gameObject = PrefabHelper.Load(@object.type, context)))
{
var gameObjectName = string.IsNullOrEmpty(@object.name) ? @object.type : @object.name;
gameObject = new GameObject($"{gameObjectName} {@object.id}".Trim());
icon = "sv_label_6";
// Prefab instantiation based on object type
}
else
{
gameObject = PrefabUtility.InstantiatePrefab(gameObject) as GameObject;
gameObject.name = $"{@object.name} {@object.id}".Trim();
foreach (var component in gameObject.GetComponentsInChildren <MonoBehaviour>())
{
ApplyProperties(@object.properties, component);
}
}
gameObject.transform.parent = layerObject.transform;
// Object sprite
var sprite = tile?.sprite;
if (sprite)
{
var diagonal = ((@object.gid >> 29) & 1) == 1 ? true : false;
var vertical = ((@object.gid >> 30) & 1) == 1 ? true : false;
var horizontal = ((@object.gid >> 31) & 1) == 1 ? true : false;
gameObject.transform.localRotation *= Quaternion.Euler(0f, 0f, [email protected]);
gameObject.transform.localRotation *= Quaternion.Euler(vertical ? 180f : 0f, horizontal ? 180f : 0f, 0f);
gameObject.transform.localPosition = new Vector3(@object.x / tmx.tilewidth, [email protected] / tmx.tileheight + tmx.height, 0);
gameObject.transform.localPosition += horizontal ? -gameObject.transform.right * @object.width / tmx.tilewidth : Vector3.zero;
gameObject.transform.localPosition += vertical ? -gameObject.transform.up * @object.height / tmx.tileheight : Vector3.zero;
var renderer = new GameObject("Renderer").AddComponent <SpriteRenderer>();
renderer.transform.SetParent(gameObject.transform, worldPositionStays: false);
renderer.sprite = sprite;
renderer.sortingOrder = i;
renderer.spriteSortPoint = SpriteSortPoint.Pivot;
renderer.drawMode = SpriteDrawMode.Sliced; // HACK: Makes renderer.size work
renderer.size = new Vector2(@object.width, @object.height) / tmx.tilewidth;
renderer.color = new Color(1f, 1f, 1f, layer.opacity);
renderer.transform.localPosition = new Vector3(@object.width / tmx.tilewidth / 2f, @object.height / tmx.tileheight / 2f);
}
else
{
gameObject.transform.localPosition =
new Vector3(@object.x / tmx.tileheight, [email protected] / tmx.tileheight + tmx.height - @object.height / tmx.tileheight, 0);
}
// Icon
if (icon != null)
{
InternalEditorGUIHelper.SetIconForObject(
gameObject,
EditorGUIUtility.IconContent(icon).image
);
}
}
}
}
collider.generationType = CompositeCollider2D.GenerationType.Synchronous;
}
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
if (graph.messageManager.nodeMessagesChanged)
{
foreach (var pair in graph.messageManager.GetNodeMessages())
{
var node = graph.GetNodeFromId(pair.Key);
MessageManager.Log(node, path, pair.Value.First(), shader);
}
}
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);
}
}
}
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;
var sourceAssetDependencyPaths = new List <string>();
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
{
var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths, 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
if (graph.messageManager.nodeMessagesChanged)
{
foreach (var pair in graph.messageManager.GetNodeMessages())
{
var node = graph.GetNodeFromId(pair.Key);
MessageManager.Log(node, path, pair.Value.First(), shader);
}
}
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@64");
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>();
var deps = GatherDependenciesFromSourceFile(ctx.assetPath);
foreach (string dependency in deps)
{
sgMetadata.assetDependencies.Add(AssetDatabase.LoadAssetAtPath(dependency, typeof(UnityEngine.Object)));
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
// Ensure that dependency path is relative to project
if (!sourceAssetDependencyPath.StartsWith("Packages/") && !sourceAssetDependencyPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {sourceAssetDependencyPath}", mainObject);
continue;
}
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
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;
var sourceAssetDependencyPaths = new List <string>();
UnityEngine.Object mainObject;
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();
// TODO: How to handle this?
if (graph.isVFXTarget)
{
var vfxAsset = GenerateVfxShaderGraphAsset(graph);
mainObject = vfxAsset;
}
else
{
var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths, graph);
var shader = ShaderUtil.CreateShaderAsset(text, false);
if (graph != null && graph.messageManager.nodeMessagesChanged)
{
foreach (var pair in graph.messageManager.GetNodeMessages())
{
var node = graph.GetNodeFromId(pair.Key);
MessageManager.Log(node, path, pair.Value.First(), shader);
}
}
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());
mainObject = shader;
}
Texture2D texture = Resources.Load <Texture2D>("Icons/sg_graph_icon@64");
ctx.AddObjectToAsset("MainAsset", mainObject, texture);
ctx.SetMainObject(mainObject);
if (graph != null)
{
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>();
var deps = GatherDependenciesFromSourceFile(ctx.assetPath);
foreach (string dependency in deps)
{
sgMetadata.assetDependencies.Add(AssetDatabase.LoadAssetAtPath(dependency, typeof(UnityEngine.Object)));
}
ctx.AddObjectToAsset("SGInternal:Metadata", sgMetadata);
foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
{
// Ensure that dependency path is relative to project
if (!sourceAssetDependencyPath.StartsWith("Packages/") && !sourceAssetDependencyPath.StartsWith("Assets/"))
{
Debug.LogWarning($"Invalid dependency path: {sourceAssetDependencyPath}", mainObject);
continue;
}
ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
/* if(amf!=null&&!shouldReimport)
* return; */
Debug.Log("Attempting to import AMF:" + ctx.assetPath);
EditorUtility.DisplayProgressBar("Parsing" + ctx.assetPath, "Parsing...", 0);
this.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++;
}
/*
* Create Meshes
*/
GameObject root = new GameObject(amf.modelName);
//amf.name=amf.modelName+"-RawAMF";
ctx.AddObjectToAsset(amf.modelName, root);
/* ctx.AddObjectToAsset(amf.name,amf);
* EditorUtility.SetDirty(amf); */
ctx.SetMainObject(root);
Dictionary <long, Mesh> meshList = ConvertMeshes(amf, mats, matsHelpers, root);
EditorUtility.DisplayProgressBar("Parsing " + ctx.assetPath, "[5/5] Finishing up...", (5f / 5f));
foreach (Mesh m in meshList.Values)
{
ctx.AddObjectToAsset(m.name, m);
}
if (CreateSkinnedMeshes)
{
Avatar a = root.GetComponent <Animator>().avatar;
ctx.AddObjectToAsset(a.name, a);
}
Debug.Log("AMF import complete");
EditorUtility.ClearProgressBar();
shouldReimport = false;
}
// Allow overriding this in tests
public virtual UnityEngine.Object DeclareDependencyAndLoad(string path)
{
m_Context.DependsOnSourceAsset(path);
return(AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(path));
}
public override void OnImportAsset(AssetImportContext ctx)
{
try
{
ctx.DependsOnCustomDependency("EntityBinaryFileFormatVersion");
ctx.DependsOnCustomDependency("SceneMetaDataFileFormatVersion");
ctx.DependsOnSourceAsset(EntitiesCacheUtility.globalEntitySceneDependencyPath);
var sceneWithBuildConfiguration = SceneWithBuildConfigurationGUIDs.ReadFromFile(ctx.assetPath);
// Ensure we have as many dependencies as possible registered early in case an exception is thrown
var scenePath = AssetDatabase.GUIDToAssetPath(sceneWithBuildConfiguration.SceneGUID.ToString());
ctx.DependsOnSourceAsset(scenePath);
if (sceneWithBuildConfiguration.BuildConfiguration.IsValid)
{
var buildConfigurationPath = AssetDatabase.GUIDToAssetPath(sceneWithBuildConfiguration.BuildConfiguration.ToString());
ctx.DependsOnSourceAsset(buildConfigurationPath);
var buildConfigurationDependencies = AssetDatabase.GetDependencies(buildConfigurationPath);
foreach (var dependency in buildConfigurationDependencies)
{
ctx.DependsOnSourceAsset(dependency);
}
}
var dependencies = AssetDatabase.GetDependencies(scenePath);
foreach (var dependency in dependencies)
{
if (dependency.ToLower().EndsWith(".prefab"))
{
ctx.DependsOnSourceAsset(dependency);
}
}
var config = BuildConfiguration.LoadAsset(sceneWithBuildConfiguration.BuildConfiguration);
var scene = EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Additive);
try
{
var settings = new GameObjectConversionSettings();
settings.SceneGUID = sceneWithBuildConfiguration.SceneGUID;
settings.BuildConfiguration = config;
settings.AssetImportContext = ctx;
settings.FilterFlags = WorldSystemFilterFlags.HybridGameObjectConversion;
WriteEntitySceneSettings writeEntitySettings = new WriteEntitySceneSettings();
if (config != null && config.TryGetComponent <DotsRuntimeBuildProfile>(out var profile))
{
if (config.TryGetComponent <DotsRuntimeRootAssembly>(out var rootAssembly))
{
ctx.DependsOnSourceAsset(AssetDatabase.GetAssetPath(rootAssembly.RootAssembly.asset));
EditorSceneManager.SetActiveScene(scene);
writeEntitySettings.Codec = Codec.LZ4;
writeEntitySettings.IsDotsRuntime = true;
writeEntitySettings.BuildAssemblyCache = new BuildAssemblyCache()
{
BaseAssemblies = rootAssembly.RootAssembly.asset,
PlatformName = profile.Target.UnityPlatformName
};
settings.FilterFlags = WorldSystemFilterFlags.DotsRuntimeGameObjectConversion;
}
}
var sectionRefObjs = new List <ReferencedUnityObjects>();
var sectionData = EditorEntityScenes.ConvertAndWriteEntitySceneInternal(scene, settings, sectionRefObjs, writeEntitySettings);
WriteAssetDependencyGUIDs(sectionRefObjs, sectionData, ctx);
}
finally
{
EditorSceneManager.CloseScene(scene, true);
}
}
// Currently it's not acceptable to let the asset database catch the exception since it will create a default asset without any dependencies
// This means a reimport will not be triggered if the scene is subsequently modified
catch (Exception e)
{
Debug.Log($"Exception thrown during SubScene import: {e}");
}
}
