Blender V5.3
abc_writer_points.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2016 Kévin Dietrich. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "abc_writer_points.h"
10
11#include <numeric>
12
13#include "DNA_object_types.h"
14#include "DNA_particle_types.h"
16
17#include "BLI_math_matrix_c.hh"
18#include "BLI_math_vector_c.hh"
19
21#include "BKE_lib_id.hh"
22#include "BKE_particle.h"
23#include "BKE_pointcloud.hh"
24
26
27#include "CLG_log.h"
28
29namespace blender {
30
31static CLG_LogRef LOG = {"io.alembic"};
32
33namespace io::alembic {
34
35using Alembic::AbcGeom::kConstantScope;
36using Alembic::AbcGeom::kVertexScope;
37using Alembic::AbcGeom::OPoints;
38using Alembic::AbcGeom::OPointsSchema;
39
41
43{
44 CLOG_DEBUG(&LOG, "exporting OPoints %s", args_.abc_path.c_str());
45 abc_points_ = OPoints(args_.abc_parent, args_.abc_name, timesample_index_);
46 abc_points_schema_ = abc_points_.getSchema();
47}
48
49Alembic::Abc::OObject ABCPointsWriter::get_alembic_object() const
50{
51 return abc_points_;
52}
53
54Alembic::Abc::OCompoundProperty ABCPointsWriter::abc_prop_for_custom_props()
55{
56 return abc_schema_prop_for_custom_props(abc_points_schema_);
57}
58
73
75{
76 /* We assume that particles are always animated. */
77 return true;
78}
79
81{
82 BLI_assert(context.particle_system != nullptr);
83
84 std::vector<Imath::V3f> points;
85 std::vector<Imath::V3f> velocities;
86 std::vector<float> widths;
87 std::vector<uint64_t> ids;
88
89 ParticleSystem *psys = context.particle_system;
94 sim.ob = context.object;
95 sim.psys = psys;
96
98
99 uint64_t index = 0;
100 for (int p = 0; p < psys->totpart; p++) {
101 float pos[3], vel[3];
102
103 if (psys->particles[p].flag & (PARS_NO_DISP | PARS_UNEXIST)) {
104 continue;
105 }
106
108 if (psys_get_particle_state(&sim, p, &state, false) == 0) {
109 continue;
110 }
111
112 /* location */
113 mul_v3_m4v3(pos, context.object->world_to_object().ptr(), state.co);
114
115 /* velocity */
116 sub_v3_v3v3(vel, state.co, psys->particles[p].prev_state.co);
117
118 /* Convert Z-up to Y-up. */
119 points.emplace_back(pos[0], pos[2], -pos[1]);
120 velocities.emplace_back(vel[0], vel[2], -vel[1]);
121 widths.push_back(psys->particles[p].size);
122 ids.push_back(index++);
123 }
124
125 psys_sim_data_free(&sim);
126
127 Alembic::Abc::P3fArraySample psample(points);
128 Alembic::Abc::UInt64ArraySample idsample(ids);
129 Alembic::Abc::V3fArraySample vsample(velocities);
130 Alembic::Abc::FloatArraySample wsample_array(widths);
131 Alembic::AbcGeom::OFloatGeomParam::Sample wsample(wsample_array, kVertexScope);
132
133 OPointsSchema::Sample sample(psample, idsample, vsample, wsample);
134 update_bounding_box(context.object);
135 sample.setSelfBounds(bounding_box_);
136 abc_points_schema_.set(sample);
137}
138
143
145{
146 CLOG_DEBUG(&LOG, "exporting OPoints %s", args_.abc_path.c_str());
147 abc_points_ = OPoints(args_.abc_parent, args_.abc_name, timesample_index_);
148 abc_points_schema_ = abc_points_.getSchema();
149}
150
151Alembic::Abc::OObject ABCPointCloudWriter::get_alembic_object() const
152{
153 return abc_points_;
154}
155
156Alembic::Abc::OCompoundProperty ABCPointCloudWriter::abc_prop_for_custom_props()
157{
158 return abc_schema_prop_for_custom_props(abc_points_schema_);
159}
160
162{
163 const PointCloud *pointcloud = id_cast<const PointCloud *>(context.object->data);
164
165 OPointsSchema::Sample sample;
166
167 std::vector<Imath::V3f> points;
168 get_positions(pointcloud->positions(), points);
169 sample.setPositions(points);
170
171 std::vector<uint64_t> ids;
172 ids.resize(pointcloud->totpoint);
173 const VArraySpan point_ids = *pointcloud->attributes().lookup<int>("id", bke::AttrDomain::Point);
174 if (point_ids.is_empty()) {
175 /* Fill ids from 0 to size - 1 if we do not have any as Alembic requires a sample to have ids.
176 */
177 std::iota(ids.begin(), ids.end(), 0);
178 }
179 else {
180 for (const int i : point_ids.index_range()) {
181 ids[i] = uint64_t(point_ids[i]);
182 }
183 }
184 sample.setIds(ids);
185
186 VArray<float> radii = pointcloud->radius();
187 std::vector<float> widths;
188 if (!radii.is_empty()) {
189 Alembic::AbcGeom::GeometryScope scope = kVertexScope;
190 if (radii.is_single()) {
191 scope = kConstantScope;
192 widths.push_back(radii[0] * 2.0f);
193 }
194 else {
195 widths.resize(radii.size());
196 for (const int i : radii.index_range()) {
197 widths[i] = radii[i] * 2.0f;
198 }
199 }
200
201 Alembic::Abc::FloatArraySample wsample_array(widths);
202 Alembic::AbcGeom::OFloatGeomParam::Sample wsample(wsample_array, scope);
203 sample.setWidths(wsample);
204 }
205
206 std::vector<Imath::V3f> velocities;
207 if (get_velocities(pointcloud->attributes(), velocities)) {
208 sample.setVelocities(velocities);
209 }
210
211 update_bounding_box(context.object);
212 sample.setSelfBounds(bounding_box_);
213 abc_points_schema_.set(sample);
214
215 write_arb_geo_params(pointcloud, *context.object, abc_points_schema_.getNumSamples());
216}
217
218void ABCPointCloudWriter::write_arb_geo_params(const PointCloud *pointcloud,
219 const Object &object,
220 const size_t num_geom_samples)
221{
222 Alembic::Abc::OCompoundProperty arb_geom_params = abc_points_schema_.getArbGeomParams();
223
224 const bke::AttributeAccessor attributes = pointcloud->attributes();
225
226 attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
227 /* Skip "internal" Blender properties and attributes dealt with elsewhere. */
228 if (iter.name[0] == '.' || bke::attribute_name_is_anonymous(iter.name) ||
229 ELEM(iter.name, "position", "velocity", "id", "radius"))
230 {
231 return;
232 }
233
234 AttributeParamMaps &param_maps = get_attribute_param_maps();
235 /* Pass num_geom_samples - 1 so we write empty samples up until this frame. */
236 BLI_assert(num_geom_samples >= 1);
237 create_geom_param_for_attribute(arb_geom_params,
238 param_maps,
239 iter,
241 {},
242 BKE_id_name(object.id),
243 num_geom_samples - 1);
244 });
245
246 if (attribute_maps_) {
247 /* If an attribute was missing this frame, write empty samples for it.
248 * This is mostly to ensure that attributes have the same number of samples as the geometry
249 * data if some disappear midway in the animation and never come back. */
250 attribute_maps_->write_empty_samples(num_geom_samples);
251 }
252}
253
254AttributeParamMaps &ABCPointCloudWriter::get_attribute_param_maps()
255{
256 if (!attribute_maps_) {
257 attribute_maps_ = std::make_unique<AttributeParamMaps>();
258 }
259 return *attribute_maps_.get();
260}
261
262} // namespace io::alembic
263} // namespace blender
General operations for point clouds.
#define CLOG_DEBUG(clg_ref,...)
Definition CLG_log.h:191
Object is a sort of wrapper for general info.
#define ELEM(...)
IndexRange index_range() const
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
constexpr bool is_empty() const
constexpr IndexRange index_range() const
ABCAbstractWriter(const ABCWriterConstructorArgs &args)
Alembic::Abc::OCompoundProperty abc_schema_prop_for_custom_props(T abc_schema)
const ABCWriterConstructorArgs args_
virtual void update_bounding_box(Object *object)
ABCPointCloudWriter(const ABCWriterConstructorArgs &args)
virtual void do_write(HierarchyContext &context) override
virtual Alembic::Abc::OObject get_alembic_object() const override
virtual void create_alembic_objects(const HierarchyContext *context) override
Alembic::Abc::OCompoundProperty abc_prop_for_custom_props() override
void create_alembic_objects(const HierarchyContext *context) override
bool is_supported(const HierarchyContext *context) const override
Alembic::Abc::OCompoundProperty abc_prop_for_custom_props() override
Alembic::Abc::OObject get_alembic_object() const override
void do_write(HierarchyContext &context) override
ABCPointsWriter(const ABCWriterConstructorArgs &args)
bool check_is_animated(const HierarchyContext &context) const override
const int state
bool attribute_name_is_anonymous(const StringRef name)
void create_geom_param_for_attribute(const Alembic::Abc::OCompoundProperty &prop, AttributeParamMaps &param_maps, const bke::AttributeIter &attr, const int timesample_index, const OffsetIndices< int > faces, const StringRefNull object_name, const size_t num_geom_samples)
bool get_velocities(const bke::AttributeAccessor &attributes, std::vector< Imath::V3f > &velocities)
void get_positions(const Span< float3 > positions, std::vector< Imath::V3f > &points)
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
Definition BKE_text.h:91
void psys_sim_data_init(struct ParticleSimulationData *sim)
Definition particle.cc:621
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
@ PART_FLUID_SPRAYFOAMBUBBLE
const char * BKE_id_name(const ID &id)
bool psys_get_particle_state(struct ParticleSimulationData *sim, int p, struct ParticleKey *state, bool always)
Definition particle.cc:4930
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
static CLG_LogRef LOG
Definition logging.cpp:12
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
float DEG_get_ctime(const Depsgraph *graph)
void psys_sim_data_free(struct ParticleSimulationData *sim)
Definition particle.cc:662
struct ParticleSystem * psys