void aiPoints::readSampleBody(Sample & sample, uint64_t idx)
{
auto ss = aiIndexToSampleSelector(idx);
auto ss2 = aiIndexToSampleSelector(idx + 1);
auto& summary = getSummary();
readVisibility(sample, ss);
// points
if (m_summary.has_points) {
auto prop = m_schema.getPositionsProperty();
prop.get(sample.m_points_sp, ss);
if (summary.interpolate_points) {
prop.get(sample.m_points_sp2, ss2);
}
}
// velocities
sample.m_velocities_sp.reset();
if (m_summary.has_velocities) {
m_schema.getVelocitiesProperty().get(sample.m_velocities_sp, ss);
}
// IDs
sample.m_ids_sp.reset();
if (m_summary.has_ids) {
m_schema.getIdsProperty().get(sample.m_ids_sp, ss);
}
}
void aiXform::readSampleBody(Sample& sample, uint64_t idx)
{
auto ss = aiIndexToSampleSelector(idx);
auto ss2 = aiIndexToSampleSelector(idx + 1);
readVisibility(sample, ss);
m_schema.get(sample.xf_sp, ss);
m_schema.get(sample.xf_sp2, ss2);
}
void tSimpleCopyPolyMesh(aiPolyMesh *iobj, aePolyMesh *eobj)
{
aiPolyMeshData idata;
aePolyMeshData edata;
int n = aiSchemaGetNumSamples(iobj);
for (int i = 0; i < n; ++i) {
auto ss = aiIndexToSampleSelector(i);
aiSchemaUpdateSample(iobj, &ss);
auto *sample = aiSchemaGetSample(iobj, &ss);
aiPolyMeshGetDataPointer(sample, &idata);
edata.positions = idata.positions;
edata.velocities = idata.velocities;
edata.normals = idata.normals;
edata.uvs = idata.uvs;
edata.indices = idata.indices;
edata.normalIndices = idata.normalIndices;
edata.uvIndices = idata.uvIndices;
edata.faces = idata.faces;
edata.positionCount = idata.positionCount;
edata.normalCount = idata.normalCount;
edata.uvCount = idata.uvCount;
edata.indexCount = idata.indexCount;
edata.normalIndexCount = idata.normalIndexCount;
edata.uvIndexCount = idata.uvIndexCount;
edata.faceCount = idata.faceCount;
aePolyMeshWriteSample(eobj, &edata);
}
}
void tSimpleCopyPoints(aiPoints *iobj, aePoints *eobj)
{
aiPointsData idata;
aePointsData edata;
int n = aiSchemaGetNumSamples(iobj);
for (int i = 0; i < n; ++i) {
auto ss = aiIndexToSampleSelector(i);
aiSchemaUpdateSample(iobj, &ss);
auto *sample = aiSchemaGetSample(iobj, &ss);
aiPointsGetDataPointer(sample, &idata);
edata.positions = idata.positions;
edata.velocities = idata.velocities;
edata.ids = idata.ids;
edata.count = idata.count;
aePointsWriteSample(eobj, &edata);
}
}
void tSimpleCopyXForm(aiXForm *iobj, aeXForm *eobj)
{
aiXFormData idata;
aeXFormData edata;
int n = aiSchemaGetNumSamples(iobj);
for (int i = 0; i < n; ++i) {
auto ss = aiIndexToSampleSelector(i);
aiSchemaUpdateSample(iobj, &ss);
auto *sample = aiSchemaGetSample(iobj, &ss);
aiXFormGetData(sample, &idata);
edata.translation = idata.translation;
edata.rotation = idata.rotation;
edata.scale = idata.scale;
edata.inherits = idata.inherits;
aeXFormWriteSample(eobj, &edata);
}
}
void tSimpleCopyCamera(aiCamera *iobj, aeCamera *eobj)
{
aiCameraData idata;
aeCameraData edata;
int n = aiSchemaGetNumSamples(iobj);
for (int i = 0; i < n; ++i) {
auto ss = aiIndexToSampleSelector(i);
aiSchemaUpdateSample(iobj, &ss);
auto *sample = aiSchemaGetSample(iobj, &ss);
aiCameraGetData(sample, &idata);
edata.nearClippingPlane = idata.nearClippingPlane;
edata.farClippingPlane = idata.farClippingPlane;
edata.fieldOfView = idata.fieldOfView;
edata.focusDistance = idata.focusDistance;
edata.focalLength = idata.focalLength;
aeCameraWriteSample(eobj, &edata);
}
}
tCLinkage tExport void tPointsExpanderConvert(tContext *tctx_, const PointsExpanderConfig *conf)
{
tContext& tctx = *tctx_;
tLogSetCallback(conf->logCB);
tctx.setPointsProcessor([&](aiPoints *iobj, aePoints *eobj) {
double time_proc_begin = tGetTime();
const char* target_name = aiGetNameS(aiGetParent(aiSchemaGetObject(iobj)));
tLog("processing \"%s\"\n", target_name);
tPointsBuffer buf;
std::vector<uint64_t> ids, ids_tmp1, ids_tmp2;
std::vector<char> point_info;
aiPointsSummary summary;
aiPointsGetSummary(iobj, &summary);
int num_samples = aiSchemaGetNumSamples(iobj);
// build list of all ids
for (int i = 0; i < num_samples; ++i) {
auto ss = aiIndexToSampleSelector(i);
aiSchemaUpdateSample(iobj, &ss);
auto *sample = aiSchemaGetSample(iobj, &ss);
aiPointsData idata;
aiPointsGetDataPointer(sample, &idata);
ids_tmp1.assign(idata.ids, idata.ids + idata.count);
ist::parallel_sort(ids_tmp1.begin(), ids_tmp1.end());
ids_tmp2.resize(ids_tmp1.size() + ids.size());
std::merge(ids_tmp1.begin(), ids_tmp1.end(), ids.begin(), ids.end(), ids_tmp2.begin());
ids_tmp2.erase(std::unique(ids_tmp2.begin(), ids_tmp2.end()), ids_tmp2.end());
ids.assign(ids_tmp2.begin(), ids_tmp2.end());
}
tLog(" listed all IDs. %d elements (%.2lfms)\n", (int)ids.size(), tGetTime() - time_proc_begin);
//
size_t info_size = size_t(sizeof(tPointInfoHeader) + sizeof(tPointInfo) * std::ceil(conf->count_rate));
uint64_t id_range = summary.maxID - summary.minID + 1;
point_info.resize(info_size * (size_t)id_range);
auto getPointInfoByID = [&](uint64_t id) -> tPointInfoHeader& {
return (tPointInfoHeader&)point_info[info_size * size_t(id - summary.minID)];
};
tRandSetSeed(conf->random_seed);
uint64_t id_size_scaled = uint64_t((double)ids.size() * conf->count_rate);
for (size_t pi = 0; pi < id_size_scaled; ++pi) {
size_t spi = size_t((double)pi / conf->count_rate);
uint64_t id = ids[spi];
tPointInfo &pf = getPointInfoByID(id).push();
pf.id = (uint32_t)pi;
pf.random_diffuse = conf->random_diffuse * tRand3();
}
mpKernelParams mpparams;
mpparams.damping = conf->repulse_damping;
mpparams.advection = conf->repulse_advection;
mpparams.max_particles = int(summary.peakCount * std::ceil(conf->count_rate));
mpparams.particle_size = conf->repulse_particle_size;
mpparams.pressure_stiffness = conf->repulse_stiffness;
auto mp = mpCreateContext();
// process all frames
for (int fi = 0; fi < num_samples; ++fi) {
double time_frame_begin = tGetTime();
auto ss = aiIndexToSampleSelector(fi);
// get points data from alembic
aiSchemaUpdateSample(iobj, &ss);
auto *sample = aiSchemaGetSample(iobj, &ss);
aiPointsData idata;
aiPointsGetDataPointer(sample, &idata);
// create inc/decreased points buffer
size_t num_scaled = 0;
for (int pi = 0; pi < idata.count; ++pi) {
tPointInfoHeader& pinfo = getPointInfoByID(idata.ids[pi]);
num_scaled += pinfo.num;
}
buf.allocate(num_scaled, idata.velocities != nullptr);
for (int pi = 0, spi = 0; pi < idata.count; ++pi) {
getPointInfoByID(idata.ids[pi]).each([&](const tPointInfo &pinfo) {
buf.positions[spi] = (float3&)idata.positions[pi] + pinfo.random_diffuse;
buf.ids[spi] = pinfo.id;
if (idata.velocities) {
buf.velocities[spi] = (float3&)idata.velocities[pi];
}
++spi;
});
}
// repulsion
if (conf->repulse_iteration > 0) {
mpparams.world_center = (mpV3&)idata.center;
mpparams.world_extent = (mpV3&)idata.size;
mpparams.world_div = mpV3i(
std::min<int>(int(mpparams.world_extent.x * 2.0f / conf->repulse_particle_size), 256),
std::min<int>(int(mpparams.world_extent.y * 2.0f / conf->repulse_particle_size), 256),
std::min<int>(int(mpparams.world_extent.z * 2.0f / conf->repulse_particle_size), 256) );
// apply repulsion
mpSetKernelParams(mp, &mpparams);
mpClearParticles(mp);
mpForceSetNumParticles(mp, (int)num_scaled);
mpParticle *particles = mpGetParticles(mp);
for (size_t pi = 0; pi < num_scaled; ++pi) {
particles[pi].position = (mpV3&)buf.positions[pi];
particles[pi].velocity = mpV3();
particles[pi].lifetime = std::numeric_limits<float>::max();
particles[pi].userdata = (int)pi;
}
for (int ri = 0; ri < conf->repulse_iteration; ++ri) {
mpUpdate(mp, conf->repulse_timestep);
}
ist::parallel_sort(particles, particles + num_scaled,
[](const mpParticle& a, const mpParticle& b) { return a.userdata < b.userdata; });
for (size_t pi = 0; pi < num_scaled; ++pi) {
buf.positions[pi] = (float3&)particles[pi].position;
}
if (idata.velocities) {
for (size_t pi = 0; pi < num_scaled; ++pi) {
buf.velocities[pi] = (float3&)particles[pi].velocity;
}
}
}
auto edata = buf.asExportData();
aePointsWriteSample(eobj, &edata);
tLog(" frame %d: %d -> %d points (%.2lfms)\n",
fi, idata.count, (int)num_scaled, tGetTime() - time_frame_begin);
}
mpDestroyContext(mp);
tLog("finished \"%s\" (%.2lfms)\n", target_name, tGetTime() - time_proc_begin);
});
tctx.doExport();
}
