Blender V5.3
scene/pointcloud.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "bvh/bvh.h"
6
7#include "scene/pointcloud.h"
8#include "scene/scene.h"
9
10#include "util/tbb.h"
11
13
14/* PointCloud Point */
15
17 const float *radius,
18 BoundBox &bounds) const
19{
20 bounds.grow(points[index], radius[index]);
21}
22
24 const float *radius,
25 const Transform &aligned_space,
26 BoundBox &bounds) const
27{
28 const float3 P = transform_point(&aligned_space, float3(points[index]));
29 bounds.grow(P, radius[index]);
30}
31
33{
34 bounds.grow(make_float3(point), point.w);
35}
36
38 const Attribute *attr_P,
39 const Attribute *attr_R,
40 const size_t num_steps,
41 const float time,
42 size_t p) const
43{
44 /* Figure out which steps we need to fetch and their
45 * interpolation factor. */
46 const size_t max_step = num_steps - 1;
47 const size_t step = min((size_t)(time * max_step), max_step - 1);
48 const float t = time * max_step - step;
49 /* Fetch vertex coordinates. */
50 const float4 curr_key = point_for_step(radius, attr_P, attr_R, step, p);
51 const float4 next_key = point_for_step(radius, attr_P, attr_R, step + 1, p);
52 /* Interpolate between steps. */
53 return (1.0f - t) * curr_key + t * next_key;
54}
55
57 const Attribute *attr_P,
58 const Attribute *attr_R,
59 const size_t step,
60 const size_t p) const
61{
62 const int num_steps = attr_P->num_motion_steps();
63 const float r = attr_R ? attr_R->data_at_time_step<float>(step, num_steps)[p] : radius[p];
64 return make_float4(float3(attr_P->data_at_time_step<packed_float3>(step, num_steps)[p]), r);
65}
66
67/* PointCloud */
68
70{
72 "pointcloud", create, NodeType::NONE, Geometry::get_node_base_type());
73
74 SOCKET_INT_ARRAY(shader, "Shader", array<int>());
75
76 static NodeEnum render_as_enum;
77 render_as_enum.insert("points", RENDER_AS_POINTS);
78 render_as_enum.insert("gaussian_splats", RENDER_AS_GSPLATS);
79
80 SOCKET_ENUM(render_as, "Render As", render_as_enum, RENDER_AS_POINTS);
81
82 return type;
83}
84
86{
87 add_builtin_attributes();
88}
89
90PointCloud::~PointCloud() = default;
91
92void PointCloud::add_builtin_attributes()
93{
96}
97
98void PointCloud::resize(const int numpoints)
99{
101 attr_P->resize(numpoints);
103 attr_R->resize(numpoints);
104 shader.resize(numpoints);
106
109 tag_shader_modified();
110}
111
116
117void PointCloud::clear(const bool preserve_shaders)
118{
119 Geometry::clear(preserve_shaders);
120
121 shader.clear();
123 add_builtin_attributes();
124
127 tag_shader_modified();
128}
129
131{
132 const int attr_step = motion_step + 1;
133 const size_t numpoints = num_points();
134
136 if (attr_P->has_motion()) {
137 std::copy_n(get_position(), numpoints, attr_P->data_for_write<packed_float3>(attr_step));
138 }
139
141 if (attr_R->has_motion()) {
142 std::copy_n(get_radius(), numpoints, attr_R->data_for_write<float>(attr_step));
143 }
144
145 /* Gaussian splat attributes. */
146 if (Attribute *attr_radiance_base = attributes.find(ATTR_STD_GSPLAT_RADIANCE_BASE);
147 attr_radiance_base && attr_radiance_base->has_motion())
148 {
149 std::copy_n(attr_radiance_base->data<float4>(),
150 numpoints,
151 attr_radiance_base->data_for_write<float4>(attr_step));
152 }
154 attr_scale && attr_scale->has_motion())
155 {
156 std::copy_n(attr_scale->data<packed_float3>(),
157 numpoints,
158 attr_scale->data_for_write<packed_float3>(attr_step));
159 }
161 attr_rotation && attr_rotation->has_motion())
162 {
163 std::copy_n(attr_rotation->data<Quaternion>(),
164 numpoints,
165 attr_rotation->data_for_write<Quaternion>(attr_step));
166 }
167}
168
169void PointCloud::get_uv_tiles(ustring map, unordered_set<int> &tiles)
170{
171 Attribute *attr;
172
173 if (map.empty()) {
175 }
176 else {
177 attr = attributes.find(map);
178 }
179
180 if (attr) {
182 }
183}
184
186{
188 const size_t numpoints = num_points();
189 const packed_float3 *points_data = get_position();
190 const float *radius_data = get_radius();
191
192 if (numpoints > 0) {
193 for (size_t i = 0; i < numpoints; i++) {
194 bnds.grow(points_data[i], radius_data[i]);
195 }
196
198 const Attribute *attr_R = attributes.find(ATTR_STD_RADIUS);
199 if (use_motion_blur && attr_P->has_motion()) {
200 for (int attr_step = 1; attr_step < attr_P->num_motion_steps(); attr_step++) {
201 const packed_float3 *motion_P = attr_P->data<packed_float3>(attr_step);
202 const float *motion_R = attr_R->data<float>(attr_step);
203 for (size_t i = 0; i < numpoints; i++) {
204 bnds.grow(motion_P[i], motion_R[i]);
205 }
206 }
207 }
208
209 if (!bnds.valid()) {
210 bnds = BoundBox::empty;
211
212 /* skip nan or inf coordinates */
213 for (size_t i = 0; i < numpoints; i++) {
214 bnds.grow_safe(points_data[i], radius_data[i]);
215 }
216
217 if (use_motion_blur && attr_P->has_motion()) {
218 for (int attr_step = 1; attr_step < attr_P->num_motion_steps(); attr_step++) {
219 const packed_float3 *motion_P = attr_P->data<packed_float3>(attr_step);
220 const float *motion_R = attr_R->data<float>(attr_step);
221 for (size_t i = 0; i < numpoints; i++) {
222 bnds.grow_safe(motion_P[i], motion_R[i]);
223 }
224 }
225 }
226 }
227 }
228
229 if (!bnds.valid()) {
230 /* empty mesh */
231 bnds.grow(make_float3(0.0f, 0.0f, 0.0f));
232 }
233
234 bounds = bnds;
235}
236
237void PointCloud::apply_transform(const Transform &tfm, const bool apply_to_motion)
238{
239 /* compute uniform scale */
240 const float3 c0 = transform_get_column(&tfm, 0);
241 const float3 c1 = transform_get_column(&tfm, 1);
242 const float3 c2 = transform_get_column(&tfm, 2);
243 const float scalar = powf(fabsf(dot(cross(c0, c1), c2)), 1.0f / 3.0f);
244
245 /* apply transform to points */
246 packed_float3 *points_data = get_position_for_write();
247 float *radius_data = get_radius_for_write();
248 const size_t numpoints = num_points();
249 for (size_t i = 0; i < numpoints; i++) {
250 const float3 co = transform_point(&tfm, points_data[i]);
251 const float r = radius_data[i] * scalar;
252
253 /* scale for radius is only correct for uniform scale */
254 points_data[i] = co;
255 radius_data[i] = r;
256 }
257
258 if (apply_to_motion) {
261
262 if (attr_P->has_motion()) {
263 const bool has_motion_radius = attr_R->has_motion();
264 for (int step = 1; step <= int(attr_P->motion.size()); step++) {
265 packed_float3 *motion_P = attr_P->data_for_write<packed_float3>(step);
266 float *motion_R = has_motion_radius ? attr_R->data_for_write<float>(step) : nullptr;
267 for (size_t i = 0; i < numpoints; i++) {
268 motion_P[i] = transform_point(&tfm, motion_P[i]);
269 if (motion_R) {
270 /* scale for curve radius is only correct for uniform scale */
271 motion_R[i] *= scalar;
272 }
273 }
274 }
275 }
276 }
277}
278
279void PointCloud::pack(Scene *scene, uint *packed_shader)
280{
281 const size_t numpoints = num_points();
282 int *shader_data = shader.data();
283
284 Shader *default_shader = (primitive_type() & PRIMITIVE_GSPLAT) ? scene->default_gsplat :
285 scene->default_surface;
286
287 uint shader_id = 0;
288 uint last_shader = -1;
289 for (size_t i = 0; i < numpoints; i++) {
290 if (last_shader != shader_data[i]) {
291 last_shader = shader_data[i];
292 Shader *shader = (last_shader < used_shaders.size()) ?
293 static_cast<Shader *>(used_shaders[last_shader]) :
294 default_shader;
295 shader_id = scene->shader_manager->get_shader_id(shader);
296 }
297 packed_shader[i] = shader_id;
298 }
299}
300
302{
303 /* Calculate radius attribute to bound the Gaussian splats based on the splat scale, allowing
304 * splats to be added to BVH as point primitives.
305 *
306 * Calculation is based on
307 *
308 * Nicolas Moenne-Loccoz et. al.
309 * "3D Gaussian Ray Tracing: Fast Tracing of Particle Scenes" (2024)
310 * ACM Transactions on Graphics and SIGGRAPH Asia
311 * https://gaussiantracer.github.io/
312 *
313 * Using Formula (7) from the paper with some tweaks to work with bounding spheres.
314 * Since spheres are rotation-agnostic we only consider scale. */
315
316 if ((primitive_type() & PRIMITIVE_GSPLAT) == 0) {
317 return;
318 }
319
322 if (!attr_radiance_base || !attr_scale) {
323 return;
324 }
325
326 const float4 *radiance_base_data = attr_radiance_base->data<float4>();
327 const packed_float3 *scale_data = attr_scale->data<packed_float3>();
328
329 float *radius_data = get_radius_for_write();
330
331 auto estimate_gsplat_radius = [](const float opacity, const float3 scale) -> float {
332 /* Minimum response of the Gaussian splat which must be captured.
333 * The value comes from the paper. */
334 constexpr float ALPHA_MIN = 0.01f;
335
336 if (opacity < ALPHA_MIN) {
337 return 0.0f;
338 }
339 const float factor = sqrtf(2.0f * logf(opacity / ALPHA_MIN));
340 return reduce_max(fabs(factor * scale));
341 };
342
343 /* Calculate bounding radius for the center step or Gaussian splats without motion blur. */
344 parallel_for(blocked_range<size_t>(0, num_points(), 32), [&](const blocked_range<size_t> &r) {
345 for (size_t i = r.begin(); i != r.end(); i++) {
346 radius_data[i] = estimate_gsplat_radius(radiance_base_data[i].w, scale_data[i]);
347 }
348 });
349
351 if (attr_R->has_motion()) {
352 for (int step = 1; step <= int(attr_R->motion.size()); step++) {
353 const float4 *motion_radiance_base = attr_radiance_base->has_motion() ?
354 attr_radiance_base->data<float4>(step) :
355 radiance_base_data;
356 const packed_float3 *motion_scale = attr_scale->has_motion() ?
357 attr_scale->data<packed_float3>(step) :
358 scale_data;
359 float *motion_R = attr_R->data_for_write<float>(step);
360 parallel_for(
361 blocked_range<size_t>(0, num_points(), 32), [&](const blocked_range<size_t> &r) {
362 for (size_t i = r.begin(); i != r.end(); i++) {
363 motion_R[i] = estimate_gsplat_radius(motion_radiance_base[i].w, motion_scale[i]);
364 }
365 });
366 }
367 }
368}
369
371{
372 const size_t numpoints = num_points();
373
374 if (Attribute *attr_radiance_base = attributes.find(ATTR_STD_GSPLAT_RADIANCE_BASE);
375 !attr_radiance_base)
376 {
377 attr_radiance_base = attributes.add(ATTR_STD_GSPLAT_RADIANCE_BASE);
378 float4 *radiance_base = attr_radiance_base->data_for_write<float4>();
379 std::fill_n(radiance_base, numpoints, DEFAULT_GSPLAT_RADIANCE_BASE);
380 }
381
382 if (Attribute *attr_scale = attributes.find(ATTR_STD_GSPLAT_SCALE); !attr_scale) {
384 packed_float3 *scale = attr_scale->data_for_write<packed_float3>();
385 std::fill_n(scale, numpoints, DEFAULT_GSPLAT_SCALE);
386 }
387
388 if (Attribute *attr_rotation = attributes.find(ATTR_STD_GSPLAT_ROTATION); !attr_rotation) {
389 attr_rotation = attributes.add(ATTR_STD_GSPLAT_ROTATION);
390 Quaternion *quaternion = attr_rotation->data_for_write<Quaternion>();
391 std::fill_n(quaternion, numpoints, identity_quaternion());
392 }
393}
394
396{
397 if (render_as == RENDER_AS_GSPLATS) {
398 const Attribute *attr_radiance_base = attributes.find(ATTR_STD_GSPLAT_RADIANCE_BASE);
399 const Attribute *attr_scale = attributes.find(ATTR_STD_GSPLAT_SCALE);
400 const Attribute *attr_rotation = attributes.find(ATTR_STD_GSPLAT_ROTATION);
401 if (attr_radiance_base && attr_scale && attr_rotation) {
403 }
404 }
406}
407
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
Attribute * find(ustring name) const
Attribute * add(ustring name, const TypeDesc type, AttributeElement element)
void clear(bool preserve_voxel_data=false)
vector< Buffer > motion
const T * data(const int step=0) const
void resize(Geometry *geom, AttributePrimitive prim)
T * data_for_write(const int step=0)
bool has_motion() const
void get_uv_tiles(Geometry *geom, AttributePrimitive prim, unordered_set< int > &tiles) const
int num_motion_steps() const
const T * data_at_time_step(const int step, const int num_time_steps) const
__forceinline bool valid() const
Definition boundbox.h:127
__forceinline void grow_safe(const float3 &pt)
Definition boundbox.h:56
__forceinline void grow(const float3 &pt)
Definition boundbox.h:35
int motion_step(const float time) const
BoundBox bounds
void tag_position_modified()
const packed_float3 * get_position() const
virtual bool has_motion_blur() const
float * get_radius_for_write()
const float * get_radius() const
AttributeSet attributes
Geometry(const NodeType *node_type, const Type type)
void tag_radius_modified()
virtual void clear(bool preserve_shaders=false)
packed_float3 * get_position_for_write()
void update_gsplat_radii()
void clear(const bool preserve_shaders=false) override
void resize(const int numpoints)
void create_missing_gsplat_attributes()
void apply_transform(const Transform &tfm, const bool apply_to_motion) override
void get_uv_tiles(ustring map, unordered_set< int > &tiles) override
size_t num_points() const
static const float4 DEFAULT_GSPLAT_RADIANCE_BASE
~PointCloud() override
void copy_center_to_motion_step(const int motion_step)
void pack(Scene *scene, uint *packed_shader)
void compute_bounds() override
PrimitiveType primitive_type() const override
static const float3 DEFAULT_GSPLAT_SCALE
Definition scene.h:133
Shader * default_surface
Definition scene.h:178
Shader * default_gsplat
Definition scene.h:183
unique_ptr< ShaderManager > shader_manager
Definition scene.h:169
#define logf(x)
#define powf(x, y)
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
float3x3 scale(float3x3 mat, float2 scale)
float3 transform_point(float3x3 mat, float3 point)
float reduce_max(float2 a)
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
PrimitiveType
@ PRIMITIVE_GSPLAT
@ PRIMITIVE_MOTION_GSPLAT
@ PRIMITIVE_MOTION_POINT
@ PRIMITIVE_POINT
@ ATTR_PRIM_GEOMETRY
@ ATTR_STD_UV
@ ATTR_STD_GSPLAT_SCALE
@ ATTR_STD_GSPLAT_RADIANCE_BASE
@ ATTR_STD_GSPLAT_ROTATION
@ ATTR_STD_POSITION
@ ATTR_STD_RADIUS
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
Definition math_dual.h:241
#define SOCKET_INT_ARRAY(name, ui_name, default_value,...)
Definition node_type.h:265
#define NODE_DEFINE(structname)
Definition node_type.h:157
#define SOCKET_ENUM(name, ui_name, values, default_value,...)
Definition node_type.h:235
#define fabsf
#define sqrtf
#define make_float4
#define min(a, b)
Definition sort.cc:38
void insert(const char *x, const int y)
Definition node_enum.h:21
static NodeType * add(const char *name, CreateFunc create, Type type=NONE, const NodeType *base=nullptr)
const NodeType * type
Definition graph/node.h:179
float4 point_for_step(const float *radius, const Attribute *attr_P, const Attribute *attr_R, const size_t step, size_t p) const
void bounds_grow(const packed_float3 *points, const float *radius, BoundBox &bounds) const
float4 motion_key(const float *radius, const Attribute *attr_P, const Attribute *attr_R, const size_t num_steps, const float time, size_t p) const
float w
Definition sky_math.h:225
ccl_device_inline float3 transform_get_column(const Transform *t, const int column)
Definition transform.h:387
ccl_device_inline Quaternion identity_quaternion()