Blender V5.3
strip_edit.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 * SPDX-FileCopyrightText: 2003-2009 Blender Authors
3 * SPDX-FileCopyrightText: 2005-2006 Peter Schlaile <peter [at] schlaile [dot] de>
4 *
5 * SPDX-License-Identifier: GPL-2.0-or-later */
6
10
11#include "DNA_scene_types.h"
12#include "DNA_sequence_types.h"
13
14#include "BLI_listbase.hh"
15#include "BLI_math_base_c.hh"
16#include "BLI_string.hh"
17#include "BLI_string_utf8.hh"
18
19#include "BLT_translation.hh"
20
21#include "BKE_animsys.hh"
22#include "BKE_sound.hh"
23
24#include "strip_time.hh"
25
26#include "SEQ_add.hh"
27#include "SEQ_animation.hh"
28#include "SEQ_channels.hh"
29#include "SEQ_connect.hh"
30
31#include "SEQ_edit.hh"
32#include "SEQ_effects.hh"
33#include "SEQ_iterator.hh"
34#include "SEQ_relations.hh"
35#include "SEQ_render.hh"
36#include "SEQ_sequencer.hh"
37#include "SEQ_time.hh"
38#include "SEQ_transform.hh"
39#include "SEQ_utils.hh"
40
41#include <cstring>
42
43namespace blender::seq {
44
45bool edit_strip_swap(Scene *scene, Strip *strip_a, Strip *strip_b, const char **r_error_str)
46{
47 char name[sizeof(strip_a->name)];
48
49 if (strip_a->length(scene) != strip_b->length(scene)) {
50 *r_error_str = N_("Strips must be the same length");
51 return false;
52 }
53
54 /* type checking, could be more advanced but disallow sound vs non-sound copy */
55 if (strip_a->type != strip_b->type) {
56 if (strip_a->type == STRIP_TYPE_SOUND || strip_b->type == STRIP_TYPE_SOUND) {
57 *r_error_str = N_("Strips were not compatible");
58 return false;
59 }
60
61 /* disallow effects to swap with non-effects strips */
62 if (strip_a->is_effect() != strip_b->is_effect()) {
63 *r_error_str = N_("Strips were not compatible");
64 return false;
65 }
66
67 if (strip_a->is_effect() && strip_b->is_effect()) {
68 if (strip_a->effect_num_inputs_get() != strip_b->effect_num_inputs_get()) {
69 *r_error_str = N_("Strips must have the same number of inputs");
70 return false;
71 }
72 }
73 }
74
75 dna::shallow_swap(*strip_a, *strip_b);
76
77 /* swap back names so animation fcurves don't get swapped */
78 STRNCPY(name, strip_a->name + 2);
79 BLI_strncpy(strip_a->name + 2, strip_b->name + 2, sizeof(strip_b->name) - 2);
80 BLI_strncpy(strip_b->name + 2, name, sizeof(strip_b->name) - 2);
81
82 /* swap back opacity, and overlay mode */
83 std::swap(strip_a->blend_mode, strip_b->blend_mode);
84 std::swap(strip_a->blend_opacity, strip_b->blend_opacity);
85
86 std::swap(strip_a->prev, strip_b->prev);
87 std::swap(strip_a->next, strip_b->next);
88 std::swap(strip_a->start, strip_b->start);
89 std::swap(strip_a->startofs, strip_b->startofs);
90 const float tmp_offset = strip_a->end_offset();
91 strip_a->end_offset_set(strip_b->end_offset());
92 strip_b->end_offset_set(tmp_offset);
93 std::swap(strip_a->channel, strip_b->channel);
94 strip_time_effect_range_set(scene, strip_a);
95 strip_time_effect_range_set(scene, strip_b);
96
98
99 return true;
100}
101
102static void strip_update_muting_recursive(ListBaseT<SeqTimelineChannel> *channels,
103 ListBaseT<Strip> *seqbasep,
104 Strip *strip_meta,
105 const bool mute)
106{
107 /* For sound we go over full meta tree to update muted state,
108 * since sound is played outside of evaluating the imbufs. */
109 for (Strip &strip : *seqbasep) {
110 bool strip_mute = (mute || render_is_muted(channels, &strip));
111
112 if (strip.type == STRIP_TYPE_META) {
113 /* if this is the current meta-strip, unmute because
114 * all strips above this were set to mute */
115 if (&strip == strip_meta) {
116 strip_mute = false;
117 }
118
119 strip_update_muting_recursive(&strip.channels, &strip.seqbase, strip_meta, strip_mute);
120 }
121 else if (ELEM(strip.type, STRIP_TYPE_SOUND, STRIP_TYPE_SCENE)) {
122 if (strip.runtime->scene_sound) {
123 BKE_sound_mute_scene_sound(strip.runtime->scene_sound, strip_mute);
124 }
125 }
126 }
127}
128
130{
131 if (ed) {
132 /* mute all sounds up to current metastack list */
133 MetaStack *ms = ed->metastack.last();
134
135 if (ms) {
136 strip_update_muting_recursive(&ed->channels, &ed->seqbase, ms->parent_strip, true);
137 }
138 else {
139 strip_update_muting_recursive(&ed->channels, &ed->seqbase, nullptr, false);
140 }
141 }
142}
143
145{
146 Editing *ed = editing_get(scene);
147 if (strip == nullptr || ed == nullptr ||
148 flag_is_set(strip->runtime->flag, StripRuntimeFlag::MarkForDelete))
149 {
150 return;
151 }
152
153 VectorSet<Strip *> strips_to_delete;
154 strips_to_delete.add_new(strip);
155
156 /* Delete effects that use `strip` as an input (either directly or through another effect), and
157 * the contents of any meta strip. Effect inputs are always in the same seqbase as the effect. */
159
160 for (Strip *strip_to_mark : strips_to_delete) {
161 strip_to_mark->runtime->flag |= StripRuntimeFlag::MarkForDelete;
162 }
163
164 /* Clear deleted strips from modifiers. The user strip can be in a different seqbase. */
165 foreach_strip(&ed->seqbase, [&](Strip *user_strip) {
166 for (StripModifierData &smd : user_strip->modifiers) {
167 if (strips_to_delete.contains(smd.mask_strip)) {
168 smd.mask_strip = nullptr;
169 }
170 }
171 return true;
172 });
173}
174
175void edit_remove_flagged_strips(Scene *scene, ListBaseT<Strip> *seqbase)
176{
177 for (Strip &strip : seqbase->items_mutable()) {
178 if (flag_is_set(strip.runtime->flag, StripRuntimeFlag::MarkForDelete)) {
179 if (strip.type == STRIP_TYPE_META) {
180 edit_remove_flagged_strips(scene, &strip.seqbase);
181 }
182 free_animdata(scene, &strip);
183 BLI_remlink(seqbase, &strip);
184 strip_free(scene, &strip);
186 }
187 }
188}
189
191 ListBaseT<Strip> *seqbase,
192 Strip *strip,
193 ListBaseT<Strip> *dst_seqbase)
194{
195 /* Move to meta. */
196 BLI_remlink(seqbase, strip);
197 BLI_addtail(dst_seqbase, strip);
198 relations_invalidate_cache(scene, strip);
199
200 /* Update meta. */
201 transform_shuffle_vertical(dst_seqbase, {strip}, scene);
202
203 return true;
204}
205
207 Strip *src_strip,
208 Strip *dst_stripm,
209 const char **r_error_str)
210{
211 /* Find the appropriate seqbase */
212 Editing *ed = editing_get(scene);
213 ListBaseT<Strip> *seqbase = get_seqbase_by_strip(scene, src_strip);
214
215 if (dst_stripm->type != STRIP_TYPE_META) {
216 *r_error_str = N_("Cannot move strip to non-meta strip");
217 return false;
218 }
219
220 if (src_strip == dst_stripm) {
221 *r_error_str = N_("Strip cannot be moved into itself");
222 return false;
223 }
224
225 if (seqbase == &dst_stripm->seqbase) {
226 *r_error_str = N_("Moved strip is already inside provided meta strip");
227 return false;
228 }
229
230 if (src_strip->type == STRIP_TYPE_META && exists_in_seqbase(dst_stripm, &src_strip->seqbase)) {
231 *r_error_str = N_("Moved strip is parent of provided meta strip");
232 return false;
233 }
234
235 if (!exists_in_seqbase(dst_stripm, &ed->seqbase)) {
236 *r_error_str = N_("Cannot move strip to different scene");
237 return false;
238 }
239
240 VectorSet<Strip *> strips;
241 strips.add(src_strip);
243
244 for (Strip *strip : strips) {
245 /* Move to meta. */
246 edit_move_strip_to_seqbase(scene, seqbase, strip, &dst_stripm->seqbase);
247 }
248
249 time_update_meta_strip_range(scene, dst_stripm);
250
251 return true;
252}
253
255 Scene *scene,
256 Strip *strip,
257 int timeline_frame)
258{
259 const float content_start = strip->content_start();
260 const float content_end = strip->content_end(scene);
261
262 /* Adjust within range of extended still-frames before strip. */
263 if (timeline_frame < content_start) {
264 const float offset = content_start + 1 - timeline_frame;
265 strip->start -= offset;
266 strip->startofs += offset;
267 }
268 /* Adjust within range of strip contents. */
269 else if ((timeline_frame >= content_start) && (timeline_frame <= content_end)) {
270 strip->end_offset_set(0);
271 const float scene_fps = float(scene->r.frs_sec) / float(scene->r.frs_sec_base);
272 const float speed_factor = strip->media_playback_rate_factor(scene_fps);
273 strip->anim_endofs += round_fl_to_int((content_end - timeline_frame) * speed_factor);
274 }
275
276 add_update_content_length(bmain, scene, strip);
277 strip->right_handle_set(scene, timeline_frame);
278}
279
281 Scene *scene,
282 Strip *strip,
283 int timeline_frame)
284{
285 const float content_start = strip->content_start();
286 const float content_end = strip->content_end(scene);
287
288 /* Adjust within range of strip contents. */
289 if ((timeline_frame >= content_start) && (timeline_frame <= content_end)) {
290 const float scene_fps = float(scene->r.frs_sec) / float(scene->r.frs_sec_base);
291 const float speed_factor = strip->media_playback_rate_factor(scene_fps);
292 strip->anim_startofs += round_fl_to_int((timeline_frame - content_start) * speed_factor);
293 strip->start = timeline_frame;
294 strip->startofs = 0;
295 }
296 /* Adjust within range of extended still-frames after strip. */
297 else if (timeline_frame > content_end) {
298 const float offset = timeline_frame - content_end + 1;
299 strip->start += offset;
300 strip->end_offset_set(strip->end_offset() + offset);
301 }
302
303 add_update_content_length(bmain, scene, strip);
304 strip->left_handle_set(scene, timeline_frame);
305}
306
307bool edit_frame_splits_strip(const Scene *scene, const Strip *strip, const int timeline_frame)
308{
309 return timeline_frame > strip->left_handle() && timeline_frame < strip->right_handle(scene);
310}
311
313 const int frame,
314 const std::optional<int> channel,
315 const bool only_selected)
316{
317 Editing *ed = editing_get(scene);
318 const ListBaseT<SeqTimelineChannel> *channels = channels_displayed_get(ed);
319
320 Vector<Strip *> strips;
321 for (Strip &strip : *ed->current_strips()) {
322 if (!edit_frame_splits_strip(scene, &strip, frame)) {
323 continue;
324 }
325 if (only_selected && (strip.flag & SEQ_SELECT) == 0) {
326 continue;
327 }
328 if (channel) {
329 if (strip.channel == *channel) {
330 return {&strip};
331 }
332 continue;
333 }
334 if (!only_selected && transform_is_locked(channels, &strip)) {
335 continue;
336 }
337 strips.append(&strip);
338 }
339 return strips;
340}
341
343 Scene *scene,
344 Strip *left_strip,
345 Strip *right_strip,
346 const int timeline_frame,
347 const eSplitMethod method)
348{
349 if (edit_frame_splits_strip(scene, right_strip, timeline_frame)) {
350 switch (method) {
351 case SPLIT_SOFT:
352 right_strip->left_handle_set(scene, timeline_frame);
353 break;
354 case SPLIT_HARD:
355 seq_split_set_left_hold_offset(bmain, scene, right_strip, timeline_frame);
356 break;
357 }
358 }
359
360 if (edit_frame_splits_strip(scene, left_strip, timeline_frame)) {
361 switch (method) {
362 case SPLIT_SOFT:
363 left_strip->right_handle_set(scene, timeline_frame);
364 break;
365 case SPLIT_HARD:
366 seq_split_set_right_hold_offset(bmain, scene, left_strip, timeline_frame);
367 break;
368 }
369 }
370}
371
373 const Strip *strip,
374 const int timeline_frame)
375{
376 bool input_does_intersect = false;
377 if (strip->input1) {
378 input_does_intersect |= edit_frame_splits_strip(scene, strip->input1, timeline_frame);
379 if (strip->input1->is_effect()) {
380 input_does_intersect |= seq_edit_split_effect_inputs_intersect(
381 scene, strip->input1, timeline_frame);
382 }
383 }
384 if (strip->input2) {
385 input_does_intersect |= edit_frame_splits_strip(scene, strip->input2, timeline_frame);
386 if (strip->input2->is_effect()) {
387 input_does_intersect |= seq_edit_split_effect_inputs_intersect(
388 scene, strip->input2, timeline_frame);
389 }
390 }
391 return input_does_intersect;
392}
393
395 Span<Strip *> strips,
396 const int timeline_frame,
397 const char **r_error)
398{
399 for (Strip *strip : strips) {
400 const ListBaseT<SeqTimelineChannel> *channels = channels_displayed_get(editing_get(scene));
401 if (transform_is_locked(channels, strip)) {
402 *r_error = "Strip is locked, cannot split";
403 return false;
404 }
405 if (!strip->is_effect()) {
406 continue;
407 }
408 if (!edit_frame_splits_strip(scene, strip, timeline_frame)) {
409 continue;
410 }
411 if (strip->effect_num_inputs_get() <= 1) {
412 continue;
413 }
414 if (effect_is_transition(strip->type)) {
415 *r_error = "Splitting transition effect is not permitted.";
416 return false;
417 }
418 if (!seq_edit_split_effect_inputs_intersect(scene, strip, timeline_frame)) {
419 *r_error = "Effect inputs don't overlap. Can not split such effect.";
420 return false;
421 }
422 }
423 return true;
424}
425
427 Scene *scene,
428 ListBaseT<Strip> *seqbase,
429 const Span<Strip *> strips_to_split,
430 const int timeline_frame,
431 const eSplitMethod method,
432 const StripRelation include,
433 const char **r_error)
434{
435 /* Whole strip effect chain must be duplicated in order to preserve relationships. */
436 VectorSet<Strip *> strips;
437 for (Strip *strip : strips_to_split) {
438 if (strips.contains(strip) || !edit_frame_splits_strip(scene, strip, timeline_frame)) {
439 continue;
440 }
441 VectorSet<Strip *> chain;
442 chain.add(strip);
443 expand_strips(editing_get(scene), chain, include);
444 if (seq_edit_split_operation_permitted_check(scene, chain, timeline_frame, r_error)) {
445 strips.add_multiple(chain.as_span());
446 }
447 }
448 if (strips.is_empty()) {
449 return {};
450 }
451
452 /* Store `F-Curves`, so original ones aren't renamed. */
453 AnimationBackup animation_backup{};
454 animation_backup_original(scene, &animation_backup);
455
456 /* This group of strips can keep its connections since they're all split at the same frame,
457 * producing copies that match one another. Any outside strips that reference in must be cut. */
459
460 ListBaseT<Strip> left_strips = {nullptr, nullptr};
461 for (Strip *strip_iter : strips) {
462 /* Move strips in collection from seqbase to new ListBase. */
463 BLI_remlink(seqbase, strip_iter);
464 BLI_addtail(&left_strips, strip_iter);
465
466 /* Duplicate curves from backup, so they can be renamed along with split strips. */
467 animation_duplicate_backup_to_scene(scene, strip_iter, &animation_backup);
468 }
469
470 /* Duplicate ListBase. */
471 ListBaseT<Strip> right_strips = {nullptr, nullptr};
473 bmain, scene, scene, &right_strips, &left_strips, StripDuplicate::All, 0);
474
475 Strip *left_strip = left_strips.first();
476 Strip *right_strip = right_strips.first();
477 Vector<Strip *> return_strips;
478
479 /* Move strips from detached `ListBase`, otherwise they can't be flagged for removal. */
480 BLI_movelisttolist(seqbase, &left_strips);
481 BLI_movelisttolist(seqbase, &right_strips);
482
483 /* Rename duplicated strips. This has to be done immediately after adding
484 * strips to seqbase, for lookup cache to work correctly. */
485 Strip *strip_rename = right_strip;
486 for (; strip_rename; strip_rename = strip_rename->next) {
487 ensure_unique_name(strip_rename, scene, {});
488 }
489
490 /* Split strips. */
491 while (left_strip && right_strip) {
492 if (left_strip->left_handle() >= timeline_frame) {
493 edit_flag_for_removal(scene, left_strip);
494 }
495 else if (right_strip->right_handle(scene) <= timeline_frame) {
496 edit_flag_for_removal(scene, right_strip);
497 }
498 else {
499 return_strips.append(right_strip);
500 }
501
503 bmain, scene, left_strip, right_strip, timeline_frame, method);
504 left_strip = left_strip->next;
505 right_strip = right_strip->next;
506 }
507
508 edit_remove_flagged_strips(scene, seqbase);
509 animation_restore_original(scene, &animation_backup);
510
511 return return_strips;
512}
513
515 Scene *scene,
516 ListBaseT<Strip> *seqbase,
517 Strip *strip,
518 const int timeline_frame,
519 const eSplitMethod method,
520 const bool ignore_connections,
521 const char **r_error)
522{
523 const StripRelation include = ignore_connections ? StripRelation::EffectChain :
525 const Vector<Strip *> right_strips = edit_strips_split(
526 bmain, scene, seqbase, {strip}, timeline_frame, method, include, r_error);
527 return right_strips.is_empty() ? nullptr : right_strips.first();
528}
529
531 ListBaseT<Strip> *seqbase,
532 const int initial_frame,
533 const bool remove_all_gaps)
534{
535 GapInfo gap_info = {0};
536 seq_time_gap_info_get(scene, seqbase, initial_frame, &gap_info);
537
538 if (!gap_info.gap_exists) {
539 return false;
540 }
541
542 if (remove_all_gaps) {
543 while (gap_info.gap_exists) {
544 transform_strips_after_frame(scene, seqbase, gap_info.gap_start_frame, -gap_info.gap_length);
545 seq_time_gap_info_get(scene, seqbase, initial_frame, &gap_info);
546 }
547 }
548 else {
549 transform_strips_after_frame(scene, seqbase, gap_info.gap_start_frame, -gap_info.gap_length);
550 }
551 return true;
552}
553
554void edit_strip_name_set(Scene *scene, Strip *strip, const char *new_name)
555{
556 BLI_strncpy_utf8(strip->name + 2, new_name, MAX_NAME - 2);
557 BLI_str_utf8_invalid_strip(strip->name + 2, strlen(strip->name + 2));
559}
560
561} // namespace blender::seq
#define MAX_NAME
Definition DNA_defs.h:63
#define ELEM(...)
bool add(const Key &key)
void add_multiple(Span< Key > keys)
bool contains(const Key &key) const
Span< Key > as_span() const
void add_new(const Key &key)
void append(const T &value)
bool is_empty() const
const T & first() const
void shallow_swap(T &a, T &b)
Definition DNA_defs.h:164
void relations_invalidate_cache(Scene *scene, Strip *strip)
void seqbase_duplicate_recursive(Main *bmain, const Scene *scene_src, Scene *scene_dst, ListBaseT< Strip > *seqbase_dst, const ListBaseT< Strip > *seqbase_src, const StripDuplicate dupe_flag, const int copy_flag)
Definition sequencer.cc:861
static void seq_split_set_left_hold_offset(Main *bmain, Scene *scene, Strip *strip, int timeline_frame)
void foreach_strip(ListBaseT< Strip > *seqbase, ForEachFunc callback, void *user_data)
Definition iterator.cc:60
void seq_time_gap_info_get(const Scene *scene, ListBaseT< Strip > *seqbase, const int initial_frame, GapInfo *r_gap_info)
bool render_is_muted(const ListBaseT< SeqTimelineChannel > *channels, const Strip *strip)
Definition render.cc:2241
ListBaseT< Strip > * get_seqbase_by_strip(const Scene *scene, Strip *strip)
Editing * editing_get(const Scene *scene)
Definition sequencer.cc:304
void edit_strip_name_set(Scene *scene, Strip *strip, const char *new_name)
void edit_remove_flagged_strips(Scene *scene, ListBaseT< Strip > *seqbase)
static void strip_update_muting_recursive(ListBaseT< SeqTimelineChannel > *channels, ListBaseT< Strip > *seqbasep, Strip *strip_meta, const bool mute)
void animation_duplicate_backup_to_scene(Scene *scene, Strip *strip, AnimationBackup *backup)
Definition animation.cc:187
bool effect_is_transition(StripType type)
Definition effects.cc:381
Vector< Strip * > edit_split_strips_get(Scene *scene, const int frame, const std::optional< int > channel, const bool only_selected)
void expand_strips(Editing *ed, VectorSet< Strip * > &strips, const StripRelation include)
Definition iterator.cc:70
void strip_free(Scene *scene, Strip *strip)
Definition sequencer.cc:265
Vector< Strip * > edit_strips_split(Main *bmain, Scene *scene, ListBaseT< Strip > *seqbase, const Span< Strip * > strips_to_split, const int timeline_frame, const eSplitMethod method, const StripRelation include, const char **r_error)
static void seq_split_set_right_hold_offset(Main *bmain, Scene *scene, Strip *strip, int timeline_frame)
void time_update_meta_strip_range(const Scene *scene, Strip *strip_meta)
void ensure_unique_name(Strip *strip, Scene *scene, const DriverMap &driver_map)
void free_animdata(Scene *scene, Strip *strip)
Definition animation.cc:74
bool edit_move_strip_to_meta(Scene *scene, Strip *src_strip, Strip *dst_stripm, const char **r_error_str)
void edit_update_muting(Editing *ed)
void edit_flag_for_removal(Scene *scene, Strip *strip)
bool exists_in_seqbase(const Strip *strip, const ListBaseT< Strip > *seqbase)
void animation_backup_original(Scene *scene, AnimationBackup *backup)
Definition animation.cc:91
Strip * edit_strip_split(Main *bmain, Scene *scene, ListBaseT< Strip > *seqbase, Strip *strip, const int timeline_frame, const eSplitMethod method, const bool ignore_connections, const char **r_error)
static void seq_edit_split_handle_strip_offsets(Main *bmain, Scene *scene, Strip *left_strip, Strip *right_strip, const int timeline_frame, const eSplitMethod method)
void cut_outside_connections(const VectorSet< Strip * > &strip_list)
bool edit_remove_gaps(Scene *scene, ListBaseT< Strip > *seqbase, const int initial_frame, const bool remove_all_gaps)
bool edit_strip_swap(Scene *scene, Strip *strip_a, Strip *strip_b, const char **r_error_str)
Definition strip_edit.cc:45
void animation_restore_original(Scene *scene, AnimationBackup *backup)
Definition animation.cc:110
static bool seq_edit_split_effect_inputs_intersect(const Scene *scene, const Strip *strip, const int timeline_frame)
void add_update_content_length(Main *bmain, Scene *scene, Strip *strip)
Definition strip_add.cc:649
void transform_strips_after_frame(Scene *scene, ListBaseT< Strip > *seqbase, const int timeline_frame, const int delta)
void transform_shuffle_vertical(ListBaseT< Strip > *seqbasep, Span< Strip * > strips, Scene *scene, const int channel_delta)
bool transform_is_locked(const ListBaseT< SeqTimelineChannel > *channels, const Strip *strip)
ListBaseT< SeqTimelineChannel > * channels_displayed_get(const Editing *ed)
Definition channels.cc:26
static bool seq_edit_split_operation_permitted_check(const Scene *scene, Span< Strip * > strips, const int timeline_frame, const char **r_error)
void strip_lookup_invalidate(const Editing *ed)
void strip_time_effect_range_set(const Scene *scene, Strip *strip)
bool edit_move_strip_to_seqbase(Scene *scene, ListBaseT< Strip > *seqbase, Strip *strip, ListBaseT< Strip > *dst_seqbase)
bool edit_frame_splits_strip(const Scene *scene, const Strip *strip, const int timeline_frame)
char * STRNCPY(char(&dst)[N], const char *src)
void BKE_sound_mute_scene_sound(AUD_SequenceEntry handle, bool mute)
MINLINE int round_fl_to_int(float a)
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void void void BLI_movelisttolist(ListBase *dst, ListBase *src) ATTR_NONNULL(1
Definition listbase.cc:32
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
int BLI_str_utf8_invalid_strip(char *str, size_t str_len) ATTR_NONNULL(1)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct Editing * ed
struct RenderData r
#define N_(msgid)