public override void AbcSetup(
AlembicStream abcstream,
AbcAPI.aiObject abcobj,
AbcAPI.aiSchema abcschema)
{
base.AbcSetup(abcstream, abcobj, abcschema);
}
public override void OnImportAsset(AssetImportContext ctx)
{
if (ctx == null)
{
return;
}
var path = ctx.assetPath;
AlembicStream.DisconnectStreamsWithPath(path);
var fileName = Path.GetFileNameWithoutExtension(path);
var go = new GameObject(fileName);
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(ref abcStartTime, ref abcEndTime);
if (firstImport)
{
startTime = abcStartTime;
endTime = abcEndTime;
}
streamDescriptor.abcStartTime = abcStartTime;
streamDescriptor.abcEndTime = abcEndTime;
var streamPlayer = go.AddComponent <AlembicStreamPlayer>();
streamPlayer.StreamDescriptor = streamDescriptor;
streamPlayer.StartTime = StartTime;
streamPlayer.EndTime = EndTime;
var subassets = new Subassets(ctx);
subassets.Add(streamDescriptor.name, streamDescriptor);
GenerateSubAssets(subassets, abcStream.abcTreeRoot, streamDescriptor);
AlembicStream.ReconnectStreamsWithPath(path);
if (string.IsNullOrEmpty(rootGameObjectId))
{
rootGameObjectId = fileName;
EditorUtility.SetDirty(this);
}
#if UNITY_2017_3_OR_NEWER
ctx.AddObjectToAsset(rootGameObjectId, go);
ctx.SetMainObject(go);
#else
ctx.SetMainAsset(rootGameObjectId, go);
#endif
}
firstImport = false;
}
public override void AbcSetup(AlembicStream abcStream,
AbcAPI.aiObject abcObj,
AbcAPI.aiSchema abcSchema)
{
base.AbcSetup(abcStream, abcObj, abcSchema);
m_camera = GetOrAddComponent <Camera>();
}
public override void AbcSetup(AlembicStream abcStream,
AbcAPI.aiObject abcObj,
AbcAPI.aiSchema abcSchema)
{
base.AbcSetup(abcStream, abcObj, abcSchema);
m_camera = GetOrAddComponent<Camera>();
}
public override void AbcSetup(
AlembicStream abcstream,
AbcAPI.aiObject abcobj,
AbcAPI.aiSchema abcschema)
{
base.AbcSetup(abcstream, abcobj, abcschema);
m_trans = GetComponent<Transform>();
}
public override void AbcSetup(AlembicStream abcStream,
AbcAPI.aiObject abcObj,
AbcAPI.aiSchema abcSchema)
{
base.AbcSetup(abcStream, abcObj, abcSchema);
AbcAPI.aiPolyMeshGetSummary(abcSchema, ref m_summary);
m_freshSetup = true;
}
public override void AbcSetup(AlembicStream abcStream,
AbcAPI.aiObject abcObj,
AbcAPI.aiSchema abcSchema)
{
base.AbcSetup(abcStream, abcObj, abcSchema);
Light light = GetOrAddComponent <Light>();
// Disable component for now
light.enabled = false;
}
public override void AbcSetup(AlembicStream abcStream,
AbcAPI.aiObject abcObj,
AbcAPI.aiSchema abcSchema)
{
base.AbcSetup(abcStream, abcObj, abcSchema);
Light light = GetOrAddComponent<Light>();
// Disable component for now
light.enabled = false;
}
public virtual void AbcSetup(AlembicStream abcStream,
AbcAPI.aiObject abcObj,
AbcAPI.aiSchema abcSchema)
{
m_abcStream = abcStream;
m_abcObj = abcObj;
m_abcSchema = abcSchema;
m_thisHandle = GCHandle.Alloc(this);
m_trans = GetComponent <Transform>();
IntPtr ptr = GCHandle.ToIntPtr(m_thisHandle);
AbcAPI.aiSchemaSetConfigCallback(abcSchema, ConfigCallback, ptr);
AbcAPI.aiSchemaSetSampleCallback(abcSchema, SampleCallback, ptr);
}
public static AssetDeleteResult OnWillDeleteAsset(string assetPath, RemoveAssetOptions rao)
{
if (string.IsNullOrEmpty(assetPath))
{
return(AssetDeleteResult.DidNotDelete);
}
if (Path.GetExtension(assetPath.ToLower()) != ".abc")
{
return(AssetDeleteResult.DidNotDelete);
}
AlembicStream.DisconnectStreamsWithPath(assetPath);
return(AssetDeleteResult.DidNotDelete);
}
public static AssetMoveResult OnWillMoveAsset(string from, string to)
{
if (string.IsNullOrEmpty(from))
{
return(AssetMoveResult.DidNotMove);
}
if (Path.GetExtension(from.ToLower()) != ".abc")
{
return(AssetMoveResult.DidNotMove);
}
AlembicStream.DisconnectStreamsWithPath(from);
AlembicStream.RemapStreamsWithPath(from, to);
AssetDatabase.Refresh(ImportAssetOptions.Default);
AlembicStream.ReconnectStreamsWithPath(to);
return(AssetMoveResult.DidNotMove);
}
public static AssetMoveResult OnWillMoveAsset(string from, string to)
{
if (string.IsNullOrEmpty(from))
{
return(AssetMoveResult.DidNotMove);
}
if (Path.GetExtension(from.ToLower()) != ".abc")
{
return(AssetMoveResult.DidNotMove);
}
var importer = AssetImporter.GetAtPath(from) as AlembicImporter;
if (importer != null)
{
var so = new SerializedObject(importer);
var prop = so.FindProperty("rootGameObjectName");
if (prop != null && string.IsNullOrEmpty(prop.stringValue))
{
prop.stringValue = Path.GetFileNameWithoutExtension(from);
so.ApplyModifiedPropertiesWithoutUndo();
}
prop = so.FindProperty("rootGameObjectId");
if (prop != null && string.IsNullOrEmpty(prop.stringValue))
{
prop.stringValue = Path.GetFileNameWithoutExtension(from);
so.ApplyModifiedPropertiesWithoutUndo();
}
AssetDatabase.WriteImportSettingsIfDirty(from);
}
AlembicStream.DisconnectStreamsWithPath(from);
AlembicStream.RemapStreamsWithPath(from, to);
AssetDatabase.Refresh(ImportAssetOptions.Default);
AlembicStream.ReconnectStreamsWithPath(to);
return(AssetMoveResult.DidNotMove);
}
public override void AbcSetup(AlembicStream abcStream,
AbcAPI.aiObject abcObj,
AbcAPI.aiSchema abcSchema)
{
base.AbcSetup(abcStream, abcObj, abcSchema);
AbcAPI.aiPolyMeshGetSummary(abcSchema, ref m_summary);
m_freshSetup = true;
}
public static void Import(string xmlPath, GameObject root, string materialFolder)
{
XmlDocument doc = new XmlDocument();
doc.Load(xmlPath);
XmlNode xmlRoot = doc.DocumentElement;
XmlNodeList nodes = xmlRoot.SelectNodes("/assignments/node");
Dictionary <GameObject, List <AlembicMaterial.Assignment> > allAssignments = new Dictionary <GameObject, List <AlembicMaterial.Assignment> >();
foreach (XmlNode node in nodes)
{
string path = node.Attributes["path"].Value;
XmlNodeList shaders = node.SelectNodes("shader");
foreach (XmlNode shader in shaders)
{
XmlAttribute name = shader.Attributes["name"];
XmlAttribute inst = shader.Attributes["instance"];
if (name == null)
{
continue;
}
int instNum = (inst == null ? 0 : Convert.ToInt32(inst.Value));
GameObject target = FindNode(root, path, instNum);
if (target == null)
{
// Debug.Log("Could not find node: " + path);
continue;
}
List <AlembicMaterial.Assignment> assignments;
if (!allAssignments.ContainsKey(target))
{
assignments = new List <AlembicMaterial.Assignment>();
allAssignments.Add(target, assignments);
}
else
{
assignments = allAssignments[target];
}
Material material = GetMaterial(name.Value, materialFolder);
if (material == null)
{
material = new Material(Shader.Find("Standard"));
material.color = new Color(UnityEngine.Random.value,
UnityEngine.Random.value,
UnityEngine.Random.value);
AssetDatabase.CreateAsset(material, materialFolder + "/" + name.Value + ".mat");
}
// Get or create material assignment
bool newlyAssigned = false;
AlembicMaterial.Assignment a = null;
if (a == null)
{
a = new AlembicMaterial.Assignment();
a.material = material;
a.faces = new List <int>();
assignments.Add(a);
newlyAssigned = true;
}
string faceset = shader.InnerText;
faceset.Trim();
if (faceset.Length > 0 && (newlyAssigned || a.faces.Count > 0))
{
string[] items = faceset.Split(FaceSep, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < items.Length; ++i)
{
string[] rng = items[i].Split(RangeSep, StringSplitOptions.RemoveEmptyEntries);
if (rng.Length == 1)
{
a.faces.Add(Convert.ToInt32(rng[0]));
}
else if (rng.Length == 2)
{
int j0 = Convert.ToInt32(rng[0]);
int j1 = Convert.ToInt32(rng[1]);
for (int j = j0; j <= j1; ++j)
{
a.faces.Add(j);
}
}
}
if (!newlyAssigned)
{
a.faces = new List <int>(new HashSet <int>(a.faces));
}
}
else if (faceset.Length == 0 && a.faces.Count > 0)
{
// Shader assgined to whole object, remove any face level assignments
a.faces.Clear();
}
}
}
// Update AlembicMaterial components
foreach (KeyValuePair <GameObject, List <AlembicMaterial.Assignment> > pair in allAssignments)
{
AlembicMaterial abcmaterial = pair.Key.GetComponent <AlembicMaterial>();
if (abcmaterial == null)
{
abcmaterial = pair.Key.AddComponent <AlembicMaterial>();
}
abcmaterial.UpdateAssignments(pair.Value);
}
// Force refresh
AlembicStream abcstream = root.GetComponent <AlembicStream>();
if (abcstream != null)
{
abcstream.m_forceRefresh = true;
abcstream.SendMessage("AbcUpdate", abcstream.m_time, SendMessageOptions.DontRequireReceiver);
}
}
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;
}
static Mesh AddMeshComponents(AbcAPI.aiObject abc, Transform trans, AlembicStream.MeshDataType mdt)
{
Mesh mesh = null;
var mesh_filter = trans.GetComponent<MeshFilter>();
var mesh_renderer = trans.GetComponent<MeshRenderer>();
if (mesh_filter == null)
{
mesh_filter = trans.gameObject.AddComponent<MeshFilter>();
}
if (mesh_renderer == null)
{
trans.gameObject.AddComponent<MeshRenderer>();
}
if (mdt == AlembicStream.MeshDataType.Texture)
{
#if UNITY_EDITOR
mesh = AssetDatabase.LoadAssetAtPath<Mesh>("Assets/AlembicImporter/Meshes/IndexOnlyMesh.asset");
#endif
}
else
{
mesh = new Mesh();
mesh.name = AbcAPI.aiGetName(abc);
mesh.MarkDynamic();
}
mesh_filter.sharedMesh = mesh;
return mesh;
}
public override void AbcSetup(
AlembicStream abcstream,
AbcAPI.aiObject abcobj,
AbcAPI.aiSchema abcschema)
{
base.AbcSetup(abcstream, abcobj, abcschema);
m_trans = GetComponent<Transform>();
AbcAPI.aiPolyMeshGetSchemaSummary(abcschema, ref m_schema_summary);
int peak_index_count = (int)m_schema_summary.peak_index_count;
int peak_vertex_count = (int)m_schema_summary.peak_vertex_count;
if(GetComponent<MeshRenderer>()==null)
{
int num_mesh_objects = AlembicUtils.ceildiv(peak_index_count, max_indices);
AddMeshComponents(abcobj, m_trans, abcstream.m_data_type);
var entry = new AlembicMesh.Entry
{
host = m_trans.gameObject,
mesh = GetComponent<MeshFilter>().sharedMesh,
renderer = GetComponent<MeshRenderer>(),
};
m_meshes.Add(entry);
#if UNITY_EDITOR
if (abcstream.m_data_type == AlembicStream.MeshDataType.Mesh)
{
GetComponent<MeshRenderer>().sharedMaterial = GetDefaultMaterial();
}
else if(abcstream.m_data_type == AlembicStream.MeshDataType.Texture)
{
GetComponent<MeshRenderer>().sharedMaterial = AssetDatabase.LoadAssetAtPath<Material>("Assets/AlembicImporter/Materials/AlembicStandard.mat");
}
#endif
for (int i = 1; i < num_mesh_objects; ++i)
{
string name = "Submesh_" + i;
GameObject go = new GameObject();
Transform child = go.GetComponent<Transform>();
go.name = name;
child.parent = m_trans;
child.localPosition = Vector3.zero;
child.localEulerAngles = Vector3.zero;
child.localScale = Vector3.one;
Mesh mesh = AddMeshComponents(abcobj, child, m_abcstream.m_data_type);
mesh.name = name;
child.GetComponent<MeshRenderer>().sharedMaterial = GetComponent<MeshRenderer>().sharedMaterial;
entry = new Entry
{
host = go,
mesh = mesh,
renderer = child.GetComponent<MeshRenderer>(),
};
m_meshes.Add(entry);
}
}
if (abcstream.m_data_type == AlembicStream.MeshDataType.Mesh)
{
for (int i = 0; i < m_meshes.Count; ++i)
{
m_meshes[i].buf_indices = new int[0];
m_meshes[i].buf_vertices = new Vector3[0];
m_meshes[i].buf_normals = new Vector3[0];
m_meshes[i].buf_uvs = new Vector2[0];
}
}
else if (abcstream.m_data_type == AlembicStream.MeshDataType.Texture)
{
m_mtex = new TextureMeshData();
m_abc_mtex = new AbcAPI.aiTextureMeshData();
m_abc_mtex.tex_width = MeshTextureWidth;
m_mtex.indices = CreateDataTexture(peak_index_count, 1, RenderTextureFormat.RInt);
m_abc_mtex.tex_indices = m_mtex.indices.GetNativeTexturePtr();
m_mtex.vertices = CreateDataTexture(peak_vertex_count, 3, RenderTextureFormat.RFloat);
m_abc_mtex.tex_vertices = m_mtex.vertices.GetNativeTexturePtr();
if (m_schema_summary.has_normals != 0)
{
int normal_count = m_schema_summary.is_normals_indexed != 0 ? peak_vertex_count : peak_index_count;
m_mtex.normals = CreateDataTexture(normal_count, 3, RenderTextureFormat.RFloat);
m_abc_mtex.tex_normals = m_mtex.normals.GetNativeTexturePtr();
}
if (m_schema_summary.has_uvs != 0)
{
int uv_count = m_schema_summary.is_uvs_indexed != 0 ? peak_vertex_count : peak_index_count;
m_mtex.uvs = CreateDataTexture(uv_count, 2, RenderTextureFormat.RFloat);
m_abc_mtex.tex_uvs = m_mtex.uvs.GetNativeTexturePtr();
}
if (m_schema_summary.has_velocities != 0)
{
m_mtex.velocities = CreateDataTexture(peak_vertex_count, 3, RenderTextureFormat.RFloat);
m_abc_mtex.tex_velocities = m_mtex.velocities.GetNativeTexturePtr();
}
for (int i = 0; i < m_meshes.Count; ++i)
{
m_meshes[i].mpb = new MaterialPropertyBlock();
m_meshes[i].mpb.SetVector("_DrawData", Vector4.zero);
m_meshes[i].mpb.SetTexture("_Indices", m_mtex.indices);
m_meshes[i].mpb.SetTexture("_Vertices", m_mtex.vertices);
if (m_mtex.normals != null) { m_meshes[i].mpb.SetTexture("_Normals", m_mtex.normals); }
if (m_mtex.uvs != null) { m_meshes[i].mpb.SetTexture("_UVs", m_mtex.uvs); }
if (m_mtex.velocities != null) { m_meshes[i].mpb.SetTexture("_Velocities", m_mtex.velocities); }
m_meshes[i].renderer.SetPropertyBlock(m_meshes[i].mpb);
}
}
}
