Blender V5.3
motion_gsplat.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2021-2026 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
7#include "kernel/globals.h"
8
9#include "kernel/bvh/util.h"
11
13
15{
16 kernel_assert(kernel_data_fetch(objects, object).gsplat.radiance_base_offset_and_flag !=
18 return kernel_data_fetch(objects, object).gsplat.radiance_base_offset_and_flag >> 1;
19}
20
22{
23 kernel_assert(kernel_data_fetch(objects, object).gsplat.radiance_base_offset_and_flag !=
25 return kernel_data_fetch(objects, object).gsplat.radiance_base_offset_and_flag & 1;
26}
27
29{
30 kernel_assert(kernel_data_fetch(objects, object).gsplat.rotation_offset_and_flag !=
32 return kernel_data_fetch(objects, object).gsplat.rotation_offset_and_flag >> 1;
33}
34
36{
37 kernel_assert(kernel_data_fetch(objects, object).gsplat.rotation_offset_and_flag !=
39 return kernel_data_fetch(objects, object).gsplat.rotation_offset_and_flag & 1;
40}
41
43{
44 kernel_assert(kernel_data_fetch(objects, object).gsplat.scale_offset_and_flag !=
46 return kernel_data_fetch(objects, object).gsplat.scale_offset_and_flag >> 1;
47}
48
50{
51 kernel_assert(kernel_data_fetch(objects, object).gsplat.scale_offset_and_flag !=
53 return kernel_data_fetch(objects, object).gsplat.scale_offset_and_flag & 1;
54}
55
56/* Motion Gaussian Splat Primitive
57 *
58 * These are stored as regular Gaussian splats, plus extra positions, radii (packed into
59 * positions), radiances, and opacities (packed into radiance) at times other than the frame
60 * center. Computing the point at a given ray time is a matter of interpolation of the two steps
61 * between which the ray time lies.
62 *
63 * The extra points are stored as additional motion steps in ATTR_STD_POSITION. */
64
65#if defined(__GSPLATS__)
66
67ccl_device_inline float4 motion_gsplat_point(KernelGlobals kg,
68 const int object,
69 const int prim,
70 const float time)
71{
72 return motion_point(kg, object, prim, time);
73}
74
75ccl_device_forceinline void motion_gsplat_compute_info(KernelGlobals kg,
76 const int object,
77 const float time,
78 ccl_private int *num_steps,
79 ccl_private int *step,
80 ccl_private float *t)
81{
82 *num_steps = kernel_data_fetch(objects, object).num_geom_steps;
83
84 const int max_step = *num_steps - 1;
85 *step = min((int)(time * max_step), max_step - 1);
86 *t = time * max_step - *step;
87}
88
89ccl_device_inline Quaternion motion_gsplat_rotation_for_step(KernelGlobals kg,
90 int offset,
91 const int num_verts,
92 const int num_steps,
93 const int step,
94 const int prim)
95{
96 offset += motion_point_offset_for_step(num_verts, num_steps, step);
97 return kernel_data_fetch(attributes_quaternion, offset + prim);
98}
99
100ccl_device_forceinline Quaternion motion_gsplat_rotation_interpolate(const Quaternion r1,
101 const Quaternion r2,
102 const float t)
103{
104 /* Use linear interpolation which is cheap and works good enough. This is also what
105 * quat_interpolate() does for HW-RT.
106 * Note that interpolation is supposed to happen on normalized quaternions, and currently no
107 * normalization is enforced on the gsplat attributes. */
108 /* TODO(sergey): Investigate whether normalizing ahead of time brings performance improvement.
109 * The tricky part with doing it ahead of time is that it could would mean data could no longer
110 * be implicitly shared with the host application. */
111 return lerp(normalized(r1), normalized(r2), t);
112}
113
114ccl_device_inline Quaternion motion_gsplat_rotation(KernelGlobals kg,
115 const int object,
116 const int prim,
117 const float time)
118{
119 const int offset = gsplat_attr_rotation_offset(kg, object);
120 if (!gsplat_attr_rotation_has_motion(kg, object)) {
121 return kernel_data_fetch(attributes_quaternion, offset + prim);
122 }
123
124 /* Get motion info. */
125 const int num_verts = kernel_data_fetch(objects, object).numverts;
126 int step, num_steps;
127 float t;
128 motion_gsplat_compute_info(kg, object, time, &num_steps, &step, &t);
129
130 /* Fetch key rotations. */
131 const Quaternion rotation = motion_gsplat_rotation_for_step(
132 kg, offset, num_verts, num_steps, step, prim);
133 const Quaternion next_rotation = motion_gsplat_rotation_for_step(
134 kg, offset, num_verts, num_steps, step + 1, prim);
135
136 /* Interpolate between steps. */
137 return motion_gsplat_rotation_interpolate(rotation, next_rotation, t);
138}
139
140ccl_device_inline float4 motion_gsplat_radiance_base_for_step(KernelGlobals kg,
141 int offset,
142 const int num_verts,
143 const int num_steps,
144 const int step,
145 const int prim)
146{
147 offset += motion_point_offset_for_step(num_verts, num_steps, step);
148 return kernel_data_fetch(attributes_float4, offset + prim);
149}
150
151ccl_device_inline float4 motion_gsplat_radiance_base(KernelGlobals kg,
152 const int object,
153 const int prim,
154 const float time)
155{
156 const int offset = gsplat_attr_radiance_base_offset(kg, object);
157 if (!gsplat_attr_radiance_base_has_motion(kg, object)) {
158 return kernel_data_fetch(attributes_float4, offset + prim);
159 }
160
161 /* Get motion info. */
162 const int num_verts = kernel_data_fetch(objects, object).numverts;
163 int step, num_steps;
164 float t;
165 motion_gsplat_compute_info(kg, object, time, &num_steps, &step, &t);
166
167 /* Fetch key radiance bases. */
168 const float4 radiance_base = motion_gsplat_radiance_base_for_step(
169 kg, offset, num_verts, num_steps, step, prim);
170 const float4 next_radiance_base = motion_gsplat_radiance_base_for_step(
171 kg, offset, num_verts, num_steps, step + 1, prim);
172
173 /* Interpolate between steps. */
174 return mix(radiance_base, next_radiance_base, t);
175}
176
177ccl_device_inline float3 motion_gsplat_scale_for_step(KernelGlobals kg,
178 int offset,
179 const int num_verts,
180 const int num_steps,
181 const int step,
182 const int prim)
183{
184 offset += motion_point_offset_for_step(num_verts, num_steps, step);
185 return kernel_data_fetch(attributes_float3, offset + prim);
186}
187
188ccl_device_inline float3 motion_gsplat_scale(KernelGlobals kg,
189 const int object,
190 const int prim,
191 const float time)
192{
193 const int offset = gsplat_attr_scale_offset(kg, object);
194 if (!gsplat_attr_scale_has_motion(kg, object)) {
195 return kernel_data_fetch(attributes_float3, offset + prim);
196 }
197
198 /* Get motion info. */
199 const int num_verts = kernel_data_fetch(objects, object).numverts;
200 int step, num_steps;
201 float t;
202 motion_gsplat_compute_info(kg, object, time, &num_steps, &step, &t);
203
204 /* Fetch key scales. */
205 const float3 scale = motion_gsplat_scale_for_step(kg, offset, num_verts, num_steps, step, prim);
206 const float3 next_scale = motion_gsplat_scale_for_step(
207 kg, offset, num_verts, num_steps, step + 1, prim);
208
209 /* Interpolate between steps. */
210 return mix(scale, next_scale, t);
211}
212
213/* Pre-calculated parameters for faster access to the Gaussian splat attributes for scale,
214 * rotation, and base radiance.
215 *
216 * Naive implementation:
217 * const float3 scale = motion_gsplat_scale(kg, ...);
218 * const Quaternion rotation = motion_gsplat_rotation(kg, ...)
219 * const float opacity = motion_gsplat_radiance_base(kg, ...).w;
220 *
221 * More efficient implementation using pre-calculated information:
222 * const GSplatMotionInfo motion_info = motion_gsplat_compute_motion_info(kg, object, time);
223 * const float3 scale = motion_gsplat_scale(kg, motion_info, ...);
224 * const Quaternion rotation = motion_gsplat_rotation(kg, motion_info, ...);
225 * const float opacity = motion_gsplat_opacity(kg, motion_info, ...); */
226struct GSplatMotionInfo {
227 int offset_for_step;
228 int offset_for_next_step;
229 float t;
230};
231
232ccl_device_forceinline GSplatMotionInfo motion_gsplat_compute_motion_info(KernelGlobals kg,
233 const int object,
234 const float time)
235{
236 GSplatMotionInfo prim_motion_info;
237
238 const int num_verts = kernel_data_fetch(objects, object).numverts;
239 int step, num_steps;
240 motion_gsplat_compute_info(kg, object, time, &num_steps, &step, &prim_motion_info.t);
241
242 prim_motion_info.offset_for_step = motion_point_offset_for_step(num_verts, num_steps, step);
243 prim_motion_info.offset_for_next_step = motion_point_offset_for_step(
244 num_verts, num_steps, step + 1);
245
246 return prim_motion_info;
247}
248
249ccl_device_forceinline float3 motion_gsplat_scale(KernelGlobals kg,
250 ccl_private const GSplatMotionInfo &motion_info,
251 const int object,
252 const int prim)
253{
254 const int offset = gsplat_attr_scale_offset(kg, object) + prim;
255 if (gsplat_attr_scale_has_motion(kg, object)) {
256 const float3 scale = kernel_data_fetch(attributes_float3,
257 motion_info.offset_for_step + offset);
258 const float3 next_scale = kernel_data_fetch(attributes_float3,
259 motion_info.offset_for_next_step + offset);
260 return mix(scale, next_scale, motion_info.t);
261 }
262 return kernel_data_fetch(attributes_float3, offset);
263}
264
266motion_gsplat_rotation(KernelGlobals kg,
267 ccl_private const GSplatMotionInfo &motion_info,
268 const int object,
269 const int prim)
270{
271 const int offset = gsplat_attr_rotation_offset(kg, object) + prim;
272 if (gsplat_attr_rotation_has_motion(kg, object)) {
273 const Quaternion rotation = kernel_data_fetch(attributes_quaternion,
274 motion_info.offset_for_step + offset);
275 const Quaternion next_rotation = kernel_data_fetch(attributes_quaternion,
276 motion_info.offset_for_next_step + offset);
277 return motion_gsplat_rotation_interpolate(rotation, next_rotation, motion_info.t);
278 }
279 return kernel_data_fetch(attributes_quaternion, offset);
280}
281
282ccl_device_forceinline float motion_gsplat_opacity(KernelGlobals kg,
283 ccl_private const GSplatMotionInfo &motion_info,
284 const int object,
285 const int prim)
286{
287 const int offset = gsplat_attr_radiance_base_offset(kg, object) + prim;
288 if (gsplat_attr_radiance_base_has_motion(kg, object)) {
289 const float opacity =
290 kernel_data_fetch(attributes_float4, motion_info.offset_for_step + offset).w;
291 const float next_opacity =
292 kernel_data_fetch(attributes_float4, motion_info.offset_for_next_step + offset).w;
293 return mix(opacity, next_opacity, motion_info.t);
294 }
295 return kernel_data_fetch(attributes_float4, offset).w;
296}
297
298#endif /* __GSPLATS__ */
299
#define kernel_assert(cond)
#define ccl_device_forceinline
#define kernel_data_fetch(name, index)
#define ccl_private
#define ccl_device_inline
#define CCL_NAMESPACE_END
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
float3x3 scale(float3x3 mat, float2 scale)
@ ATTR_STD_NOT_FOUND
ccl_device_inline Quaternion normalized(const Quaternion q)
CCL_NAMESPACE_BEGIN ccl_device_forceinline int gsplat_attr_radiance_base_offset(KernelGlobals kg, const int object)
ccl_device_forceinline int gsplat_attr_scale_offset(KernelGlobals kg, const int object)
ccl_device_forceinline int gsplat_attr_rotation_has_motion(KernelGlobals kg, const int object)
ccl_device_forceinline int gsplat_attr_scale_has_motion(KernelGlobals kg, const int object)
ccl_device_forceinline int gsplat_attr_rotation_offset(KernelGlobals kg, const int object)
ccl_device_forceinline int gsplat_attr_radiance_base_has_motion(KernelGlobals kg, const int object)
std::string time(const std::tm &date_time, TimeFormat format=TimeFormat::H24)
#define mix
#define lerp(a, b, t)
Definition smaa.cc:318
#define min(a, b)
Definition sort.cc:38