Blender V5.3
eevee_motion_blur.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
11#include "eevee_velocity.bsl.hh"
14
16
17/* -------------------------------------------------------------------- */
20
21#define MotionTilePayload uint
22
27
28/* Tile indirection buffer. */
29struct TileBuf {
30 [[storage(0, read_write)]] uint (&tile_indirection_buf)[];
31
32 void store(MotionStep motion_step, uint2 tile, MotionTilePayload payload)
33 {
34 uint index = indirection_index(uint(motion_step), tile);
36 }
37
38 int2 load(MotionStep motion_step, uint2 tile) const
39 {
40 uint index = indirection_index(uint(motion_step), tile);
42 }
43
44 static uint indirection_index(uint motion_step, uint2 tile)
45 {
46 uint index = tile.x;
49 return index;
50 }
51
52 /* Store velocity magnitude in the MSB to be able to use it with atomicMax operations. */
54 {
55 /* NOTE: Clamp to 16383 pixel velocity. After that, it is tile position that determine the tile
56 * to dilate over. */
57 uint velocity = min(uint(ceil(length(motion))), 0x3FFFu);
58 /* Designed for 512x512 tiles max. */
59 return (velocity << 18u) | ((payload.x & 0x1FFu) << 9u) | (payload.y & 0x1FFu);
60 }
61
62 /* Return thread index. */
63 static int2 unpack_payload(uint data)
64 {
65 return int2((data >> 9u) & 0x1FFu, data & 0x1FFu);
66 }
67};
68
70
72float clamp_motion_and_get_length(float max_offset, float2 &motion)
73{
74 float len_sqr = length_squared(motion);
75 if (len_sqr > square(max_offset)) {
76 motion *= max_offset * inversesqrt(len_sqr);
77 return max_offset;
78 }
79 return sqrt(len_sqr);
80}
81
82namespace flatten {
83
84template<enum TextureWriteFormat velocity_format> struct Resources {
86
87 [[uniform(0)]] const MotionBlurData &motion_blur_buf;
89 [[image(0, read_write, velocity_format)]] image2D velocity_img;
91
96};
97
98template struct Resources<SFLOAT_16_16>;
99template struct Resources<SFLOAT_16_16_16_16>;
100
101/* Store velocity magnitude in the MSB and thread id in the LSB. */
102uint pack_payload(float2 motion, uint2 thread_id)
103{
104 /* NOTE: We clamp max velocity to 16k pixels. */
105 return (min(uint(ceil(length(motion))), 0xFFFFu) << 16u) | (thread_id.y << 8) | thread_id.x;
106}
107
108/* Return thread index from the payload. */
110{
111 return uint2(payload & 0xFFu, (payload >> 8) & 0xFFu);
112}
113
125template<enum TextureWriteFormat velocity_format>
128 [[resource_table]] const draw::View &views,
129 [[work_group_id]] const uint3 group_id,
130 [[global_invocation_id]] const uint3 global_id,
131 [[local_invocation_id]] const uint3 local_id,
132 [[local_invocation_index]] const uint local_index)
133{
134 const ViewMatrices view = views.get(0);
135
136 if (local_index == 0u) {
137 srt.payload_prev = 0u;
138 srt.payload_next = 0u;
139 }
140 barrier();
141
142 uint local_payload_prev = 0u;
143 uint local_payload_next = 0u;
144 float2 local_max_motion_prev;
145 float2 local_max_motion_next;
146
147 int2 texel = min(int2(global_id.xy), imageSize(srt.velocity_img) - 1);
148
149 float2 render_size = float2(imageSize(srt.velocity_img).xy);
150 float2 uv = (float2(texel) + 0.5f) / render_size;
151 float depth = reverse_z::read(texelFetch(srt.depth_tx, texel, 0).r);
152 float4 motion = srt.camera.resolve_local(view, imageLoad(srt.velocity_img, texel), uv, depth);
153 if constexpr (velocity_format == SFLOAT_16_16) {
154 /* imageLoad does not perform the swizzling like sampler does. Do it manually. */
155 motion = motion.xyxy;
156 }
157
158 /* Store resolved velocity to speedup the gather pass. Out of bounds writes are ignored.
159 * Unfortunately, we cannot convert to pixel space here since it is also used by TAA and the
160 * motion blur needs to remain optional. */
161 imageStore(srt.velocity_img, int2(global_id.xy), velocity::pack(motion));
162 /* Clip velocity to viewport bounds (in NDC space). */
163 float2 line_clip;
164 line_clip.x = line_unit_square_intersect_dist_safe(uv * 2.0f - 1.0f, motion.xy * 2.0f);
165 line_clip.y = line_unit_square_intersect_dist_safe(uv * 2.0f - 1.0f, -motion.zw * 2.0f);
166 motion *= min(line_clip, float2(1.0f)).xxyy;
167 /* Convert to pixel space. Note this is only for velocity tiles. */
168 motion *= render_size.xyxy;
169 /* Rescale to shutter relative motion for viewport. */
170 motion *= srt.motion_blur_buf.motion_scale.xxyy;
171
172 /* Clamp to the same radius as gather_blur()'s clamp because pack_payload()'s uint conversion
173 * runs first and need this bounded. */
174 float max_offset = srt.motion_blur_buf.motion_max_offset_px;
175 float2 motion_prev = motion.xy;
176 float2 motion_next = motion.zw;
177 clamp_motion_and_get_length(max_offset, motion_prev);
178 clamp_motion_and_get_length(max_offset, motion_next);
179 motion = float4(motion_prev, motion_next);
180
181 uint sample_payload_prev = pack_payload(motion.xy, local_id.xy);
182 if (local_payload_prev < sample_payload_prev) {
183 local_payload_prev = sample_payload_prev;
184 local_max_motion_prev = motion.xy;
185 }
186
187 uint sample_payload_next = pack_payload(motion.zw, local_id.xy);
188 if (local_payload_next < sample_payload_next) {
189 local_payload_next = sample_payload_next;
190 local_max_motion_next = motion.zw;
191 }
192
193 /* Compare the local payload with the other threads. */
194 atomicMax(srt.payload_prev, local_payload_prev);
195 atomicMax(srt.payload_next, local_payload_next);
196 barrier();
197
198 /* Need to broadcast the result to another thread in order to issue a unique write. */
199 if (all(equal(unpack_payload(srt.payload_prev), local_id.xy))) {
200 srt.max_motion_prev = local_max_motion_prev;
201 }
202 if (all(equal(unpack_payload(srt.payload_next), local_id.xy))) {
203 srt.max_motion_next = local_max_motion_next;
204 }
205 barrier();
206
207 if (local_index == 0u) {
208 int2 tile_co = int2(group_id.xy);
209 imageStore(srt.out_tiles_img, tile_co, float4(srt.max_motion_prev, srt.max_motion_next));
210 }
211}
212
214 const draw::View &,
215 const uint3,
216 const uint3,
217 const uint3,
218 const uint);
220 const draw::View &,
221 const uint3,
222 const uint3,
223 const uint3,
224 const uint);
225
226} // namespace flatten
227
228namespace dilate {
229
230#define DEBUG_BYPASS_DILATION 0
231
236
242
244 {
245#if DEBUG_BYPASS_DILATION
246 return true;
247#endif
248 /* NOTE: Everything in is tile unit. */
250 /* In order to be conservative and for simplicity, we use the tiles bounding circles.
251 * Consider that both the tile and the line have bounding radius of M_SQRT1_2. */
252 return abs(dist) < M_SQRT2;
253 }
254};
255
256struct Resources {
258
260 {
261 float2 dir = safe_normalize(motion);
262 return {.origin = float2(tile),
263 /* Rotate 90 degrees counter-clockwise. */
264 .normal = float2(-dir.y, dir.x)};
265 }
266
268 {
269#if DEBUG_BYPASS_DILATION
270 return {tile, int2(1)};
271#endif
272 /* `ceil()` to number of tile touched. */
273 int2 point1 = tile + int2(sign(motion) * ceil(abs(motion) / float(MOTION_BLUR_TILE_SIZE)));
274 int2 point2 = tile;
275
276 int2 max_point = max(point1, point2);
277 int2 min_point = min(point1, point2);
278 /* Clamp to bounds. */
279 max_point = min(max_point, imageSize(in_tiles_img) - 1);
280 min_point = max(min_point, int2(0));
281
282 return {.bottom_left = min_point, .extent = 1 + max_point - min_point};
283 }
284};
285
293 [[global_invocation_id]] const uint3 global_id)
294{
295 int2 src_tile = int2(global_id.xy);
296 if (any(greaterThanEqual(src_tile, imageSize(srt.in_tiles_img)))) {
297 return;
298 }
299
300 float4 max_motion = imageLoad(srt.in_tiles_img, src_tile);
301
302 MotionTilePayload payload_prev = TileBuf::pack_payload(max_motion.xy, uint2(src_tile));
303 MotionTilePayload payload_next = TileBuf::pack_payload(max_motion.zw, uint2(src_tile));
304 if (true) {
305 /* Rectangular area (in tiles) where the motion vector spreads. */
306 MotionRect motion_rect = srt.compute_motion_rect(src_tile, max_motion.xy);
307 MotionLine motion_line = srt.compute_motion_line(src_tile, max_motion.xy);
308 /* Do a conservative rasterization of the line of the motion vector line. */
309 for (int x = 0; x < motion_rect.extent.x; x++) {
310 for (int y = 0; y < motion_rect.extent.y; y++) {
311 int2 tile = motion_rect.bottom_left + int2(x, y);
312 if (motion_line.is_inside_motion_line(tile)) {
313 tiles.store(MOTION_PREV, uint2(tile), payload_prev);
314 /* FIXME: This is a bit weird, but for some reason, we need the store the same vector in
315 * the motion next so that weighting in gather pass is better. */
316 tiles.store(MOTION_NEXT, uint2(tile), payload_next);
317 }
318 }
319 }
320 }
321
322 if (true) {
323 /* Rectangular area (in tiles) where the motion vector spreads. */
324 MotionRect motion_rect = srt.compute_motion_rect(src_tile, max_motion.zw);
325 MotionLine motion_line = srt.compute_motion_line(src_tile, max_motion.zw);
326 /* Do a conservative rasterization of the line of the motion vector line. */
327 for (int x = 0; x < motion_rect.extent.x; x++) {
328 for (int y = 0; y < motion_rect.extent.y; y++) {
329 int2 tile = motion_rect.bottom_left + int2(x, y);
330 if (motion_line.is_inside_motion_line(tile)) {
331 tiles.store(MOTION_NEXT, uint2(tile), payload_next);
332 /* FIXME: This is a bit weird, but for some reason, we need the store the same vector in
333 * the motion next so that weighting in gather pass is better. */
334 tiles.store(MOTION_PREV, uint2(tile), payload_prev);
335 }
336 }
337 }
338 }
339}
340
341} // namespace dilate
342
343namespace gather {
344
345#define gather_sample_count 8
346
353
354struct Resources {
355 [[uniform(0)]] const MotionBlurData &motion_blur_buf;
361
362 /* Converts uv velocity into pixel space. Assumes velocity_tx is the same resolution as the
363 * target post-FX frame-buffer. */
365 {
366 /* We can load velocity without velocity_resolve() since we resolved during the flatten pass.
367 */
369 return velocity * float2(textureSize(velocity_tx, 0)).xyxy * motion_blur_buf.motion_scale.xxyy;
370 }
371
372 float2 spread_compare(float center_motion_length,
373 float sample_motion_length,
374 float offset_length)
375 {
376 return saturate(float2(center_motion_length, sample_motion_length) - offset_length + 1.0f);
377 }
378
379 float2 depth_compare(float center_depth, float sample_depth)
380 {
381 float2 depth_scale = float2(-motion_blur_buf.depth_scale, motion_blur_buf.depth_scale);
382 return saturate(0.5f + depth_scale * (sample_depth - center_depth));
383 }
384
385 /* Kill contribution if not going the same direction. */
386 float dir_compare(float2 offset, float2 sample_motion, float sample_motion_length)
387 {
388 if (sample_motion_length < 0.5f) {
389 return 1.0f;
390 }
391 return (dot(offset, sample_motion) > 0.0f) ? 1.0f : 0.0f;
392 }
393
394 /* Return background (x) and foreground (y) weights. */
395 float2 sample_weights(float center_depth,
396 float sample_depth,
397 float center_motion_length,
398 float sample_motion_length,
399 float offset_length)
400 {
401 /* Classify foreground/background. */
402 float2 depth_weight = depth_compare(center_depth, sample_depth);
403 /* Weight if sample is overlapping or under the center pixel. */
404 float2 spread_weight = spread_compare(
405 center_motion_length, sample_motion_length, offset_length);
406 return depth_weight * spread_weight;
407 }
408
410 float2 screen_uv,
411 float center_depth,
412 float center_motion_len,
413 float2 offset,
414 float offset_len,
415 const bool next,
416 Accumulator &accum)
417 {
418 float2 sample_uv = screen_uv - offset * motion_blur_buf.target_size_inv;
419 float4 sample_vectors = motion_blur_sample_velocity(sample_uv);
420 float2 sample_motion = (next) ? sample_vectors.zw : sample_vectors.xy;
421 /* Clamp to the same radius as the sampling offset (see gather_blur()). */
422 float max_offset = motion_blur_buf.motion_max_offset_px;
423 float sample_motion_len = clamp_motion_and_get_length(max_offset, sample_motion);
424 float sample_depth = reverse_z::read(textureLod(depth_tx, sample_uv, 0.0f).r);
425 float4 sample_color = textureLod(in_color_tx, sample_uv, 0.0f);
426
427 sample_depth = view.depth_screen_to_view(sample_depth);
428
429 float3 weights;
430 weights.xy = sample_weights(
431 center_depth, sample_depth, center_motion_len, sample_motion_len, offset_len);
432 weights.z = dir_compare(offset, sample_motion, sample_motion_len);
433 weights.xy *= weights.z;
434
435 accum.fg += sample_color * weights.y;
436 accum.bg += sample_color * weights.x;
437 accum.weight += weights;
438 }
439
441 float2 screen_uv,
442 float2 center_motion,
443 float center_depth,
444 float2 max_motion,
445 float ofs,
446 const bool next,
447 Accumulator &accum)
448 {
449 /* Cap `center_motion`/`max_motion` so `gather_sample()`'s `sample_uv` offset doesn't reach
450 * past this cubeface's overscan margin into the neighboring face. */
451 float max_offset = motion_blur_buf.motion_max_offset_px;
452 float center_motion_len = clamp_motion_and_get_length(max_offset, center_motion);
453 float max_motion_len = clamp_motion_and_get_length(max_offset, max_motion);
454
455 /* Tile boundaries randomization can fetch a tile where there is less motion than this pixel.
456 * Fix this by overriding the max_motion. */
457 if (max_motion_len < center_motion_len) {
458 max_motion_len = center_motion_len;
459 max_motion = center_motion;
460 }
461
462 if (max_motion_len < 0.5f) {
463 return;
464 }
465
466 int i;
467 float t, inc = 1.0f / float(gather_sample_count);
468 for (i = 0, t = ofs * inc; i < gather_sample_count; i++, t += inc) {
469 gather_sample(view,
470 screen_uv,
471 center_depth,
472 center_motion_len,
473 max_motion * t,
474 max_motion_len * t,
475 next,
476 accum);
477 }
478
479 if (center_motion_len < 0.5f) {
480 return;
481 }
482
483 for (i = 0, t = ofs * inc; i < gather_sample_count; i++, t += inc) {
484 /* Also sample in center motion direction.
485 * Allow recovering motion where there is conflicting
486 * motion between foreground and background. */
487 gather_sample(view,
488 screen_uv,
489 center_depth,
490 center_motion_len,
491 center_motion * t,
492 center_motion_len * t,
493 next,
494 accum);
495 }
496 }
497};
498
511 [[resource_table]] const Sampling &sampling,
512 [[resource_table]] const draw::View &views,
513 [[resource_table]] const TileBuf &tiles,
514 [[global_invocation_id]] const uint3 global_id)
515{
516 int2 texel = int2(global_id.xy);
517 float2 uv = (float2(texel) + 0.5f) / float2(textureSize(srt.depth_tx, 0).xy);
518
519 if (!in_texture_range(texel, srt.depth_tx)) {
520 return;
521 }
522
523 const ViewMatrices view = views.get(0);
524
525 /* Data of the center pixel of the gather (target). */
526 float center_depth = reverse_z::read(texelFetch(srt.depth_tx, texel, 0).r);
527 center_depth = view.depth_screen_to_view(center_depth);
528 float4 center_motion = srt.motion_blur_sample_velocity(uv);
529
530 float4 center_color = textureLod(srt.in_color_tx, uv, 0.0f);
531
532 float noise_offset = sampling.rng_1D_get(SAMPLING_TIME);
534 float2 rand = float2(random::interleaved_gradient(float2(global_id.xy), 0, noise_offset),
535 random::interleaved_gradient(float2(global_id.xy), 1, noise_offset));
536
537 /* Randomize tile boundary to avoid ugly discontinuities. Randomize 1/4th of the tile.
538 * Note this randomize only in one direction but in practice it's enough. */
539 rand.x = rand.x * 2.0f - 1.0f;
540 int2 tile = (texel + int2(int(rand.x * float(MOTION_BLUR_TILE_SIZE) * 0.25f))) /
542 tile = clamp(tile, int2(0), imageSize(srt.in_tiles_img) - 1);
543 /* NOTE: Tile velocity is already in pixel space and with correct zw sign. */
544 float4 max_motion;
545 /* Load dilation result from the indirection table. */
546 int2 tile_prev = tiles.load(MOTION_PREV, uint2(tile));
547 max_motion.xy = imageLoad(srt.in_tiles_img, tile_prev).xy;
548 int2 tile_next = tiles.load(MOTION_NEXT, uint2(tile));
549 max_motion.zw = imageLoad(srt.in_tiles_img, tile_next).zw;
550
551 Accumulator accum;
552 accum.weight = float3(0.0f, 0.0f, 1.0f);
553 accum.bg = float4(0.0f);
554 accum.fg = float4(0.0f);
555 /* First linear gather. time = [T - delta, T] */
556 srt.gather_blur(view, uv, center_motion.xy, center_depth, max_motion.xy, rand.y, false, accum);
557 /* Second linear gather. time = [T, T + delta] */
558 srt.gather_blur(view, uv, center_motion.zw, center_depth, max_motion.zw, rand.y, true, accum);
559
560#if 1 /* Own addition. Not present in reference implementation. */
561 /* Avoid division by 0.0. */
562 float w = 1.0f / (50.0f * float(gather_sample_count) * 4.0f);
563 /* Restore background crispiness if there are large motions around. */
564 bool no_motion = length(center_motion.xy) + length(center_motion.zw) < 0.5;
565 if (accum.weight.x < 1.0 && no_motion) {
566 w = 1.0f;
567 }
568 accum.bg += center_color * w;
569 accum.weight.x += w;
570 /* NOTE: In Jimenez's presentation, they used center sample.
571 * We use background color as it contains more information for foreground
572 * elements that have not enough weights.
573 * Yield better blur in complex motion. */
574 center_color = accum.bg / accum.weight.x;
575#endif
576 /* Merge background. */
577 accum.fg += accum.bg;
578 accum.weight.y += accum.weight.x;
579 /* Balance accumulation for failed samples.
580 * We replace the missing foreground by the background. */
581 float blend_fac = saturate(1.0f - accum.weight.y / accum.weight.z);
582 float4 out_color = (accum.fg / accum.weight.z) + center_color * blend_fac;
583
584#if 0 /* For debugging. */
585 out_color.rgb = out_color.ggg;
586 out_color.rg += max_motion.xy;
587#endif
588
589 imageStoreFast(srt.out_color_img, texel, out_color);
590}
591
592} // namespace gather
593
594} // namespace eevee::motion_blur
595
#define M_SQRT2
btScalar max
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
float line_unit_square_intersect_dist_safe(float2 line_origin, float2 line_direction)
float point_line_projection_dist(float2 point, float2 line_origin, float2 line_normal)
#define MOTION_BLUR_GROUP_SIZE
#define MotionTilePayload
PipelineCompute eevee_motion_blur_gather(eevee::motion_blur::gather::gather_comp)
PipelineCompute eevee_motion_blur_tiles_flatten_rg(eevee::motion_blur::flatten::flatten_comp< SFLOAT_16_16 >)
PipelineCompute eevee_motion_blur_tiles_dilate(eevee::motion_blur::dilate::dilate_comp)
PipelineCompute eevee_motion_blur_tiles_flatten_rgba(eevee::motion_blur::flatten::flatten_comp< SFLOAT_16_16_16_16 >)
#define gather_sample_count
#define MOTION_BLUR_TILE_SIZE
#define MOTION_BLUR_MAX_TILE
@ SFLOAT_16_16_16_16
#define shared
#define uniform(slot)
#define local_invocation_index
#define storage(slot, qualifiers)
#define image(slot, qualifiers, format)
#define work_group_id
#define index(i)
#define resource_table
#define sampler(slot)
#define global_invocation_id
#define local_invocation_id
#define compute
#define local_size(...)
VecBase< bool, D > greaterThanEqual(VecOp< T, D >, VecOp< T, D >) RET
bool any(VecOp< bool, D >) RET
int atomicMax(int &, int) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
constexpr T sign(T) RET
constexpr T inversesqrt(T) RET
#define abs
#define ceil
bool all(VecOp< bool, D >) RET
#define sqrt
VecBase< bool, D > equal(VecOp< T, D >, VecOp< T, D >) RET
void barrier()
constexpr T clamp(T, U, U) RET
float length(VecOp< float, D >) RET
IMG_TEMPLATE DataVec imageLoad(const T &, IntCoord) RET
ImageBase< float, 2 > image2D
IMG_TEMPLATE SizeVec imageSize(const T &) RET
#define imageStoreFast
IMG_TEMPLATE void imageStore(T &, IntCoord, DataVec)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
TEX_TEMPLATE DataVec texelFetch(T, IntCoord, int) RET
TEX_TEMPLATE DataVec textureLod(T, FltCoord, float) RET
SamplerBase< float, 2, false, false, false, true > sampler2DDepth
SamplerBase< float, 2 > sampler2D
TEX_TEMPLATE SizeVec textureSize(T, int) RET
unsigned int uchar
float square(float v)
float length_squared(VecT a)
VecT safe_normalize(VecT vector)
#define in_texture_range(texel, tex)
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
const ccl_global KernelWorkTile * tile
void dilate_comp(Resources &srt, TileBuf &tiles, const uint3 global_id)
uint pack_payload(float2 motion, uint2 thread_id)
void flatten_comp(Resources< velocity_format > &srt, const draw::View &views, const uint3 group_id, const uint3 global_id, const uint3 local_id, const uint local_index)
void gather_comp(Resources &srt, const Sampling &sampling, const draw::View &views, const TileBuf &tiles, const uint3 global_id)
float clamp_motion_and_get_length(float max_offset, float2 &motion)
float4 unpack(float4 data)
float4 pack(float4 data)
float interleaved_gradient(float2 pixel, float seed, float offset)
T read(T depth_buffer_value)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define saturate(a)
Definition smaa.cc:319
#define min(a, b)
Definition sort.cc:38
float depth_screen_to_view(float ss_depth) const
int2 load(MotionStep motion_step, uint2 tile) const
static MotionTilePayload pack_payload(float2 motion, uint2 payload)
static uint indirection_index(uint motion_step, uint2 tile)
void store(MotionStep motion_step, uint2 tile, MotionTilePayload payload)
static int2 unpack_payload(uint data)
MotionRect compute_motion_rect(int2 tile, float2 motion)
MotionLine compute_motion_line(int2 tile, float2 motion)
float2 spread_compare(float center_motion_length, float sample_motion_length, float offset_length)
float2 sample_weights(float center_depth, float sample_depth, float center_motion_length, float sample_motion_length, float offset_length)
void gather_blur(ViewMatrices view, float2 screen_uv, float2 center_motion, float center_depth, float2 max_motion, float ofs, const bool next, Accumulator &accum)
float2 depth_compare(float center_depth, float sample_depth)
void gather_sample(ViewMatrices view, float2 screen_uv, float center_depth, float center_motion_len, float2 offset, float offset_len, const bool next, Accumulator &accum)
float dir_compare(float2 offset, float2 sample_motion, float sample_motion_length)
float x
float y
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136
uint x
Definition types_uint2.h:13
uint y
Definition types_uint2.h:13