public void usdiUnload()
{
if (!m_ctx)
{
return;
}
usdiWaitAsyncUpdateTask();
m_asyncUpdate = null;
int c = m_schemas.Count;
for (int i = 0; i < c; ++i)
{
m_schemas[i].usdiOnUnload();
}
m_schemas.Clear();
m_schemaLUT.Clear();
usdi.usdiDestroyContext(m_ctx);
m_ctx = default(usdi.Context);
usdiLog("usdiStream: unloaded " + m_path.GetFullPath());
}
void usdiKickAsyncUpdateTask()
{
// kick async update tasks
#if UNITY_EDITOR
if (m_forceSingleThread)
{
usdiAsyncUpdate(m_time);
}
else
#endif
{
if (m_asyncUpdate == null)
{
m_asyncUpdate = new usdi.DelegateTask(
(arg) =>
{
try
{
usdiAsyncUpdate(m_time);
}
finally { }
}, "usdiStream: " + gameObject.name);
}
m_asyncUpdate.Run();
}
}
public override void usdiOnUnload()
{
base.usdiOnUnload();
if (m_asyncRead != null)
{
m_asyncRead.Wait();
m_asyncRead = null;
}
m_mesh = default(usdi.Mesh);
m_buf.Clear();
}
public override void usdiOnUnload()
{
base.usdiOnUnload();
m_asyncRead = null;
m_points = default(usdi.Points);
m_summary = default(usdi.PointsSummary);
m_pointsData = default(usdi.PointsData);
m_attrRot = default(usdi.Attribute);
m_rotData = default(usdi.AttributeData);
m_positions = null;
m_velocities = null;
m_rotations = null;
}
public void usdiUnload()
{
if (m_ctx)
{
usdiWaitAsyncUpdateTask();
m_asyncUpdate = null;
int c = m_elements.Count;
for (int i = 0; i < c; ++i)
{
m_elements[i].usdiOnUnload();
}
m_updater.OnUnload();
m_updater = null;
usdi.usdiDestroyContext(m_ctx);
m_ctx = default(usdi.Context);
usdiLog("usdiStream: unloaded " + m_path);
}
}
public override void usdiOnUnload()
{
base.usdiOnUnload();
int c = m_submeshes.Count;
for (int i = 0; i < c; ++i)
{
m_submeshes[i].usdiOnUnload();
}
m_meshData = usdi.MeshData.default_value;
m_submeshData = null;
m_meshSummary = usdi.MeshSummary.default_value;
m_allocateMeshDataRequired = false;
m_updateIndicesRequired = false;
m_updateVerticesRequired = false;
m_timeRead = 0.0;
m_asyncRead = null;
}
// async
void usdiReadMeshData(double t)
{
if (m_directVBUpdate)
{
usdi.usdiMeshReadSample(m_mesh, ref m_meshData, t, false);
}
else
{
#if UNITY_EDITOR
if (m_stream.forceSingleThread)
{
usdi.usdiMeshReadSample(m_mesh, ref m_meshData, t, true);
}
else
#endif
{
if (m_asyncRead == null)
{
m_asyncRead = new usdi.Task(usdi.usdiTaskCreateMeshReadSample(m_mesh, ref m_meshData, ref m_timeRead));
}
m_asyncRead.Run();
}
}
}
// async
public override void usdiAsyncUpdate(double time)
{
base.usdiAsyncUpdate(time);
if (m_updateFlags.bits == 0 && !m_allocateMeshDataRequired && !m_updateIndicesRequired && !m_updateVerticesRequired)
{
return;
}
if (m_updateFlags.importConfigChanged || m_updateFlags.variantSetChanged)
{
usdi.usdiMeshGetSummary(m_mesh, ref m_meshSummary);
}
m_timeRead = time;
if (isInstance)
{
m_allocateMeshDataRequired = false;
m_updateIndicesRequired = false;
m_updateVerticesRequired = false;
}
else
{
if (!m_allocateMeshDataRequired)
{
m_allocateMeshDataRequired =
m_meshSummary.topology_variance == usdi.TopologyVariance.Heterogenous ||
m_updateFlags.variantSetChanged;
}
if (!m_updateIndicesRequired)
{
m_updateIndicesRequired =
m_allocateMeshDataRequired ||
m_meshSummary.topology_variance == usdi.TopologyVariance.Heterogenous ||
m_updateFlags.importConfigChanged;
}
if (!m_updateVerticesRequired)
{
m_updateVerticesRequired =
m_updateIndicesRequired ||
m_meshSummary.topology_variance != usdi.TopologyVariance.Constant;
}
}
// todo: update heterogenous mesh when possible
m_directVBUpdate =
#if UNITY_5_5_OR_NEWER
m_stream.directVBUpdate&& !m_allocateMeshDataRequired &&
m_meshSummary.topology_variance == usdi.TopologyVariance.Homogenous;
#else
false;
#endif
if (m_allocateMeshDataRequired)
{
usdiAllocateMeshData(m_timeRead);
}
if (m_updateVerticesRequired)
{
if (m_directVBUpdate)
{
usdi.usdiMeshReadSample(m_mesh, ref m_meshData, m_timeRead, false);
// kick VB update task in usdiUpdate()
}
else
{
#if UNITY_EDITOR
if (m_stream.forceSingleThread)
{
usdi.usdiMeshReadSample(m_mesh, ref m_meshData, m_timeRead, true);
}
else
#endif
{
if (m_asyncRead == null)
{
m_asyncRead = new usdi.Task(usdi.usdiTaskCreateMeshReadSample(m_mesh, ref m_meshData, ref m_timeRead));
}
m_asyncRead.Run();
}
}
}
}
void ProcessCapture()
{
if (!m_recording)
{
return;
}
// for some reason, come here twice on first frame. skip second run.
int frame = Time.frameCount;
if (frame == m_prevFrame)
{
return;
}
m_prevFrame = frame;
// wait for complete previous flush
WaitFlush();
float begin_time = Time.realtimeSinceStartup;
// capture components
foreach (var c in m_capturers)
{
c.Capture(m_time);
}
// kick flush task
#if UNITY_EDITOR
if (m_forceSingleThread)
{
foreach (var c in m_capturers)
{
c.Flush(time);
}
}
else
#endif
{
if (m_asyncFlush == null)
{
m_asyncFlush = new usdi.DelegateTask((var) =>
{
try
{
foreach (var c in m_capturers)
{
c.Flush(m_timeFlush);
}
}
finally
{
}
}, "usdiExporter: " + gameObject.name);
}
m_timeFlush = m_time;
m_asyncFlush.Run();
}
m_time += Time.deltaTime;
++m_frameCount;
// flush to file when needed
if (m_flushEveryNthFrames > 0 && m_frameCount % m_flushEveryNthFrames == 0)
{
FlushUSD();
}
m_elapsed = Time.realtimeSinceStartup - begin_time;
usdiLog("usdiExporter.ProcessCapture(): " + (m_elapsed * 1000.0f) + "ms");
if (m_maxCaptureFrame > 0 && m_frameCount >= m_maxCaptureFrame)
{
EndCapture();
}
}
public override void usdiAsyncUpdate(double time)
{
base.usdiAsyncUpdate(time);
if (!m_needsUpdate)
{
return;
}
usdi.PointsData tmp = usdi.PointsData.default_value;
usdi.usdiPointsReadSample(m_points, ref tmp, time, true);
// allocate points data
if (m_pointsData.num_points == tmp.num_points)
{
// no need to allocate
}
else
{
m_pointsData.num_points = tmp.num_points;
m_positions = new Vector3[m_pointsData.num_points];
m_pointsData.points = usdi.GetArrayPtr(m_positions);
if (m_summary.has_velocities)
{
m_velocities = new Vector3[m_pointsData.num_points];
m_pointsData.velocities = usdi.GetArrayPtr(m_velocities);
}
if (m_attrRot)
{
m_rotations = new Vector4[m_pointsData.num_points];
m_rotData.data = usdi.GetArrayPtr(m_rotations);
m_rotData.num_elements = tmp.num_points;
}
}
// read points data
if (m_pointsData.num_points > 0)
{
#if UNITY_EDITOR
if (m_stream.forceSingleThread)
{
usdi.usdiPointsReadSample(m_points, ref m_pointsData, m_timeRead, true);
if (m_attrRot)
{
usdi.usdiAttrReadSample(m_attrRot, ref m_rotData, m_timeRead, true);
}
}
else
#endif
{
if (m_asyncRead == null)
{
if (m_attrRot)
{
m_asyncRead = new usdi.CompositeTask(new IntPtr[] {
usdi.usdiTaskCreatePointsReadSample(m_points, ref m_pointsData, ref m_timeRead),
usdi.usdiTaskCreateAttrReadSample(m_attrRot, ref m_rotData, ref m_timeRead)
});
}
else
{
m_asyncRead = new usdi.Task(usdi.usdiTaskCreatePointsReadSample(m_points, ref m_pointsData, ref m_timeRead));
}
}
m_timeRead = time;
m_asyncRead.Run();
}
}
}
void ProcessCapture()
{
if (!m_recording)
{
return;
}
// for some reason, come here twice on first frame. skip second run.
int frame = Time.frameCount;
if (frame == m_prevFrame)
{
return;
}
m_prevFrame = frame;
// wait for complete previous flush
WaitFlush();
float begin_time = Time.realtimeSinceStartup;
// capture components
foreach (var c in m_capturers)
{
c.Capture(m_time);
}
// kick flush task
#if UNITY_EDITOR
if (m_forceSingleThread)
{
foreach (var c in m_capturers)
{
c.Flush(time);
}
}
else
#endif
{
if (m_asyncFlush == null)
{
m_asyncFlush = new usdi.DelegateTask((var) =>
{
try
{
foreach (var c in m_capturers)
{
c.Flush(m_timeFlush);
}
}
finally
{
}
}, "usdiExporter: " + gameObject.name);
}
m_timeFlush = m_time;
m_asyncFlush.Run();
}
++m_frameCount;
switch (m_timeUnit.type)
{
case TimeUnit.Types.Frame_30FPS:
case TimeUnit.Types.Frame_60FPS:
m_time = m_frameCount;
break;
default:
m_time += Time.deltaTime * m_timeUnit.scale;
break;
}
m_elapsed = Time.realtimeSinceStartup - begin_time;
usdiLog("usdiExporter.ProcessCapture(): " + (m_elapsed * 1000.0f) + "ms");
if (m_maxCaptureFrame > 0 && m_frameCount >= m_maxCaptureFrame)
{
EndCapture();
}
}
