Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
This commit is contained in:
parent
2f9df08aa8
commit
b79b8478ee
|
@ -325,14 +325,14 @@ static bool ObtainCacheParticleVcol(Mesh *mesh,
|
|||
return true;
|
||||
}
|
||||
|
||||
static void set_resolution(BL::Object *b_ob, BL::Scene *scene, BL::ViewLayer *sl, bool render)
|
||||
static void set_resolution(BL::Object *b_ob, BL::Scene *scene, BL::ViewLayer *view_layer, bool render)
|
||||
{
|
||||
BL::Object::modifiers_iterator b_mod;
|
||||
for(b_ob->modifiers.begin(b_mod); b_mod != b_ob->modifiers.end(); ++b_mod) {
|
||||
if((b_mod->type() == b_mod->type_PARTICLE_SYSTEM) && ((b_mod->show_viewport()) || (b_mod->show_render()))) {
|
||||
BL::ParticleSystemModifier psmd((const PointerRNA)b_mod->ptr);
|
||||
BL::ParticleSystem b_psys((const PointerRNA)psmd.particle_system().ptr);
|
||||
b_psys.set_resolution(*scene, *sl, *b_ob, (render)? 2: 1);
|
||||
b_psys.set_resolution(*scene, *view_layer, *b_ob, (render)? 2: 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -387,14 +387,14 @@ void BlenderSync::sync_view_layers(BL::SpaceView3D& b_v3d, const char *layer)
|
|||
}
|
||||
|
||||
/* render layer */
|
||||
BL::Scene::view_layers_iterator b_rlay;
|
||||
BL::Scene::view_layers_iterator b_view_layer;
|
||||
bool first_layer = true;
|
||||
uint layer_override = get_layer(b_engine.layer_override());
|
||||
uint view_layers = layer_override ? layer_override : get_layer(b_scene.layers());
|
||||
|
||||
for(b_scene.view_layers.begin(b_rlay); b_rlay != b_scene.view_layers.end(); ++b_rlay) {
|
||||
if((!layer && first_layer) || (layer && b_rlay->name() == layer)) {
|
||||
view_layer.name = b_rlay->name();
|
||||
for(b_scene.view_layers.begin(b_view_layer); b_view_layer != b_scene.view_layers.end(); ++b_view_layer) {
|
||||
if((!layer && first_layer) || (layer && b_view_layer->name() == layer)) {
|
||||
view_layer.name = b_view_layer->name();
|
||||
|
||||
view_layer.holdout_layer = 0;
|
||||
view_layer.exclude_layer = 0;
|
||||
|
@ -406,10 +406,10 @@ void BlenderSync::sync_view_layers(BL::SpaceView3D& b_v3d, const char *layer)
|
|||
view_layer.layer |= view_layer.holdout_layer;
|
||||
|
||||
view_layer.material_override = PointerRNA_NULL;
|
||||
view_layer.use_background_shader = b_rlay->use_sky();
|
||||
view_layer.use_background_ao = b_rlay->use_ao();
|
||||
view_layer.use_surfaces = b_rlay->use_solid();
|
||||
view_layer.use_hair = b_rlay->use_strand();
|
||||
view_layer.use_background_shader = b_view_layer->use_sky();
|
||||
view_layer.use_background_ao = b_view_layer->use_ao();
|
||||
view_layer.use_surfaces = b_view_layer->use_solid();
|
||||
view_layer.use_hair = b_view_layer->use_strand();
|
||||
|
||||
view_layer.bound_samples = false;
|
||||
view_layer.samples = 0;
|
||||
|
@ -526,7 +526,7 @@ int BlenderSync::get_denoising_pass(BL::RenderPass& b_pass)
|
|||
}
|
||||
|
||||
array<Pass> BlenderSync::sync_render_passes(BL::RenderLayer& b_rlay,
|
||||
BL::ViewLayer& b_slay,
|
||||
BL::ViewLayer& b_view_layer,
|
||||
const SessionParams &session_params)
|
||||
{
|
||||
array<Pass> passes;
|
||||
|
@ -549,49 +549,49 @@ array<Pass> BlenderSync::sync_render_passes(BL::RenderLayer& b_rlay,
|
|||
Pass::add(pass_type, passes);
|
||||
}
|
||||
|
||||
PointerRNA crp = RNA_pointer_get(&b_slay.ptr, "cycles");
|
||||
PointerRNA crp = RNA_pointer_get(&b_view_layer.ptr, "cycles");
|
||||
if(get_boolean(crp, "denoising_store_passes") &&
|
||||
get_boolean(crp, "use_denoising"))
|
||||
{
|
||||
b_engine.add_pass("Denoising Normal", 3, "XYZ", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Normal Variance", 3, "XYZ", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Albedo", 3, "RGB", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Albedo Variance", 3, "RGB", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Depth", 1, "Z", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Depth Variance", 1, "Z", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Shadow A", 3, "XYV", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Shadow B", 3, "XYV", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Image", 3, "RGB", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Image Variance", 3, "RGB", b_slay.name().c_str());
|
||||
b_engine.add_pass("Denoising Normal", 3, "XYZ", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Normal Variance", 3, "XYZ", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Albedo", 3, "RGB", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Albedo Variance", 3, "RGB", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Depth", 1, "Z", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Depth Variance", 1, "Z", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Shadow A", 3, "XYV", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Shadow B", 3, "XYV", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Image", 3, "RGB", b_view_layer.name().c_str());
|
||||
b_engine.add_pass("Denoising Image Variance", 3, "RGB", b_view_layer.name().c_str());
|
||||
}
|
||||
#ifdef __KERNEL_DEBUG__
|
||||
if(get_boolean(crp, "pass_debug_bvh_traversed_nodes")) {
|
||||
b_engine.add_pass("Debug BVH Traversed Nodes", 1, "X", b_slay.name().c_str());
|
||||
b_engine.add_pass("Debug BVH Traversed Nodes", 1, "X", b_view_layer.name().c_str());
|
||||
Pass::add(PASS_BVH_TRAVERSED_NODES, passes);
|
||||
}
|
||||
if(get_boolean(crp, "pass_debug_bvh_traversed_instances")) {
|
||||
b_engine.add_pass("Debug BVH Traversed Instances", 1, "X", b_slay.name().c_str());
|
||||
b_engine.add_pass("Debug BVH Traversed Instances", 1, "X", b_view_layer.name().c_str());
|
||||
Pass::add(PASS_BVH_TRAVERSED_INSTANCES, passes);
|
||||
}
|
||||
if(get_boolean(crp, "pass_debug_bvh_intersections")) {
|
||||
b_engine.add_pass("Debug BVH Intersections", 1, "X", b_slay.name().c_str());
|
||||
b_engine.add_pass("Debug BVH Intersections", 1, "X", b_view_layer.name().c_str());
|
||||
Pass::add(PASS_BVH_INTERSECTIONS, passes);
|
||||
}
|
||||
if(get_boolean(crp, "pass_debug_ray_bounces")) {
|
||||
b_engine.add_pass("Debug Ray Bounces", 1, "X", b_slay.name().c_str());
|
||||
b_engine.add_pass("Debug Ray Bounces", 1, "X", b_view_layer.name().c_str());
|
||||
Pass::add(PASS_RAY_BOUNCES, passes);
|
||||
}
|
||||
#endif
|
||||
if(get_boolean(crp, "pass_debug_render_time")) {
|
||||
b_engine.add_pass("Debug Render Time", 1, "X", b_slay.name().c_str());
|
||||
b_engine.add_pass("Debug Render Time", 1, "X", b_view_layer.name().c_str());
|
||||
Pass::add(PASS_RENDER_TIME, passes);
|
||||
}
|
||||
if(get_boolean(crp, "use_pass_volume_direct")) {
|
||||
b_engine.add_pass("VolumeDir", 3, "RGB", b_slay.name().c_str());
|
||||
b_engine.add_pass("VolumeDir", 3, "RGB", b_view_layer.name().c_str());
|
||||
Pass::add(PASS_VOLUME_DIRECT, passes);
|
||||
}
|
||||
if(get_boolean(crp, "use_pass_volume_indirect")) {
|
||||
b_engine.add_pass("VolumeInd", 3, "RGB", b_slay.name().c_str());
|
||||
b_engine.add_pass("VolumeInd", 3, "RGB", b_view_layer.name().c_str());
|
||||
Pass::add(PASS_VOLUME_INDIRECT, passes);
|
||||
}
|
||||
|
||||
|
@ -820,9 +820,9 @@ SessionParams BlenderSync::get_session_params(BL::RenderEngine& b_engine,
|
|||
!b_r.use_save_buffers();
|
||||
|
||||
if(params.progressive_refine) {
|
||||
BL::Scene::view_layers_iterator b_rlay;
|
||||
for(b_scene.view_layers.begin(b_rlay); b_rlay != b_scene.view_layers.end(); ++b_rlay) {
|
||||
PointerRNA crl = RNA_pointer_get(&b_rlay->ptr, "cycles");
|
||||
BL::Scene::view_layers_iterator b_view_layer;
|
||||
for(b_scene.view_layers.begin(b_view_layer); b_view_layer != b_scene.view_layers.end(); ++b_view_layer) {
|
||||
PointerRNA crl = RNA_pointer_get(&b_view_layer->ptr, "cycles");
|
||||
if(get_boolean(crl, "use_denoising")) {
|
||||
params.progressive_refine = false;
|
||||
}
|
||||
|
|
|
@ -68,8 +68,8 @@ public:
|
|||
void **python_thread_state,
|
||||
const char *layer = 0);
|
||||
void sync_view_layers(BL::SpaceView3D& b_v3d, const char *layer);
|
||||
array<Pass> sync_render_passes(BL::RenderLayer& b_rlay,
|
||||
BL::ViewLayer& b_slay,
|
||||
array<Pass> sync_render_passes(BL::RenderLayer& b_render_layer,
|
||||
BL::ViewLayer& b_view_layer,
|
||||
const SessionParams &session_params);
|
||||
void sync_integrator();
|
||||
void sync_camera(BL::RenderSettings& b_render,
|
||||
|
|
|
@ -129,7 +129,7 @@ void BKE_camera_view_frame(
|
|||
float r_vec[4][3]);
|
||||
|
||||
bool BKE_camera_view_frame_fit_to_scene(
|
||||
struct Scene *scene, struct ViewLayer *sl, struct Object *camera_ob,
|
||||
struct Scene *scene, struct ViewLayer *view_layer, struct Object *camera_ob,
|
||||
float r_co[3], float *r_scale);
|
||||
bool BKE_camera_view_frame_fit_to_coords(
|
||||
const struct Scene *scene,
|
||||
|
|
|
@ -63,26 +63,26 @@ struct ViewLayer *BKE_view_layer_add(struct Scene *scene, const char *name);
|
|||
/* DEPRECATED */
|
||||
struct ViewLayer *BKE_view_layer_context_active_PLACEHOLDER(const struct Scene *scene);
|
||||
|
||||
void BKE_view_layer_free(struct ViewLayer *sl);
|
||||
void BKE_view_layer_free(struct ViewLayer *view_layer);
|
||||
|
||||
void BKE_view_layer_selected_objects_tag(struct ViewLayer *sl, const int tag);
|
||||
void BKE_view_layer_selected_objects_tag(struct ViewLayer *view_layer, const int tag);
|
||||
|
||||
struct Object *BKE_view_layer_camera_find(struct ViewLayer *sl);
|
||||
struct Object *BKE_view_layer_camera_find(struct ViewLayer *view_layer);
|
||||
struct ViewLayer *BKE_view_layer_find_from_collection(const struct Scene *scene, struct LayerCollection *lc);
|
||||
struct Base *BKE_view_layer_base_find(struct ViewLayer *sl, struct Object *ob);
|
||||
struct Base *BKE_view_layer_base_find_by_name(struct ViewLayer *sl, struct Object *ob);
|
||||
void BKE_view_layer_base_deselect_all(struct ViewLayer *sl);
|
||||
void BKE_view_layer_base_select(struct ViewLayer *sl, struct Base *selbase);
|
||||
struct Base *BKE_view_layer_base_find(struct ViewLayer *view_layer, struct Object *ob);
|
||||
struct Base *BKE_view_layer_base_find_by_name(struct ViewLayer *view_layer, struct Object *ob);
|
||||
void BKE_view_layer_base_deselect_all(struct ViewLayer *view_layer);
|
||||
void BKE_view_layer_base_select(struct ViewLayer *view_layer, struct Base *selbase);
|
||||
|
||||
void BKE_layer_collection_free(struct ViewLayer *sl, struct LayerCollection *lc);
|
||||
void BKE_layer_collection_free(struct ViewLayer *view_layer, struct LayerCollection *lc);
|
||||
|
||||
struct LayerCollection *BKE_layer_collection_get_active(struct ViewLayer *sl);
|
||||
struct LayerCollection *BKE_layer_collection_get_active_ensure(struct Scene *scene, struct ViewLayer *sl);
|
||||
struct LayerCollection *BKE_layer_collection_get_active(struct ViewLayer *view_layer);
|
||||
struct LayerCollection *BKE_layer_collection_get_active_ensure(struct Scene *scene, struct ViewLayer *view_layer);
|
||||
|
||||
int BKE_layer_collection_count(struct ViewLayer *sl);
|
||||
int BKE_layer_collection_count(struct ViewLayer *view_layer);
|
||||
|
||||
struct LayerCollection *BKE_layer_collection_from_index(struct ViewLayer *sl, const int index);
|
||||
int BKE_layer_collection_findindex(struct ViewLayer *sl, const struct LayerCollection *lc);
|
||||
struct LayerCollection *BKE_layer_collection_from_index(struct ViewLayer *view_layer, const int index);
|
||||
int BKE_layer_collection_findindex(struct ViewLayer *view_layer, const struct LayerCollection *lc);
|
||||
|
||||
bool BKE_layer_collection_move_above(const struct Scene *scene, struct LayerCollection *lc_dst, struct LayerCollection *lc_src);
|
||||
bool BKE_layer_collection_move_below(const struct Scene *scene, struct LayerCollection *lc_dst, struct LayerCollection *lc_src);
|
||||
|
@ -90,14 +90,14 @@ bool BKE_layer_collection_move_into(const struct Scene *scene, struct LayerColle
|
|||
|
||||
void BKE_layer_collection_resync(const struct Scene *scene, const struct SceneCollection *sc);
|
||||
|
||||
struct LayerCollection *BKE_collection_link(struct ViewLayer *sl, struct SceneCollection *sc);
|
||||
struct LayerCollection *BKE_collection_link(struct ViewLayer *view_layer, struct SceneCollection *sc);
|
||||
|
||||
void BKE_collection_unlink(struct ViewLayer *sl, struct LayerCollection *lc);
|
||||
void BKE_collection_unlink(struct ViewLayer *view_layer, struct LayerCollection *lc);
|
||||
|
||||
void BKE_collection_enable(struct ViewLayer *sl, struct LayerCollection *lc);
|
||||
void BKE_collection_disable(struct ViewLayer *sl, struct LayerCollection *lc);
|
||||
void BKE_collection_enable(struct ViewLayer *view_layer, struct LayerCollection *lc);
|
||||
void BKE_collection_disable(struct ViewLayer *view_layer, struct LayerCollection *lc);
|
||||
|
||||
bool BKE_view_layer_has_collection(struct ViewLayer *sl, const struct SceneCollection *sc);
|
||||
bool BKE_view_layer_has_collection(struct ViewLayer *view_layer, const struct SceneCollection *sc);
|
||||
bool BKE_scene_has_object(struct Scene *scene, struct Object *ob);
|
||||
|
||||
/* syncing */
|
||||
|
@ -125,8 +125,8 @@ void BKE_layer_collection_engine_settings_create(struct IDProperty *root);
|
|||
void BKE_layer_collection_engine_settings_validate_scene(struct Scene *scene);
|
||||
void BKE_layer_collection_engine_settings_validate_collection(struct LayerCollection *lc);
|
||||
|
||||
struct IDProperty *BKE_view_layer_engine_evaluated_get(struct ViewLayer *sl, const int type, const char *engine_name);
|
||||
struct IDProperty *BKE_view_layer_engine_layer_get(struct ViewLayer *sl, const int type, const char *engine_name);
|
||||
struct IDProperty *BKE_view_layer_engine_evaluated_get(struct ViewLayer *view_layer, const int type, const char *engine_name);
|
||||
struct IDProperty *BKE_view_layer_engine_layer_get(struct ViewLayer *view_layer, const int type, const char *engine_name);
|
||||
struct IDProperty *BKE_view_layer_engine_scene_get(struct Scene *scene, const int type, const char *engine_name);
|
||||
void BKE_view_layer_engine_settings_callback_register(struct Main *bmain, const char *engine_name, EngineSettingsCB func);
|
||||
void BKE_view_layer_engine_settings_callback_free(void);
|
||||
|
@ -182,55 +182,55 @@ void BKE_visible_bases_iterator_begin(BLI_Iterator *iter, void *data_in);
|
|||
void BKE_visible_bases_iterator_next(BLI_Iterator *iter);
|
||||
void BKE_visible_bases_iterator_end(BLI_Iterator *iter);
|
||||
|
||||
#define FOREACH_SELECTED_OBJECT(sl, _instance) \
|
||||
#define FOREACH_SELECTED_OBJECT(view_layer, _instance) \
|
||||
ITER_BEGIN(BKE_selected_objects_iterator_begin, \
|
||||
BKE_selected_objects_iterator_next, \
|
||||
BKE_selected_objects_iterator_end, \
|
||||
sl, Object *, _instance)
|
||||
view_layer, Object *, _instance)
|
||||
|
||||
#define FOREACH_SELECTED_OBJECT_END \
|
||||
ITER_END
|
||||
|
||||
#define FOREACH_VISIBLE_OBJECT(sl, _instance) \
|
||||
#define FOREACH_VISIBLE_OBJECT(view_layer, _instance) \
|
||||
ITER_BEGIN(BKE_visible_objects_iterator_begin, \
|
||||
BKE_visible_objects_iterator_next, \
|
||||
BKE_visible_objects_iterator_end, \
|
||||
sl, Object *, _instance)
|
||||
view_layer, Object *, _instance)
|
||||
|
||||
#define FOREACH_VISIBLE_OBJECT_END \
|
||||
ITER_END
|
||||
|
||||
#define FOREACH_SELECTED_BASE(sl, _instance) \
|
||||
#define FOREACH_SELECTED_BASE(view_layer, _instance) \
|
||||
ITER_BEGIN(BKE_selected_bases_iterator_begin, \
|
||||
BKE_selected_bases_iterator_next, \
|
||||
BKE_selected_bases_iterator_end, \
|
||||
sl, Base *, _instance)
|
||||
view_layer, Base *, _instance)
|
||||
|
||||
#define FOREACH_SELECTED_BASE_END \
|
||||
ITER_END
|
||||
|
||||
#define FOREACH_VISIBLE_BASE(sl, _instance) \
|
||||
#define FOREACH_VISIBLE_BASE(view_layer, _instance) \
|
||||
ITER_BEGIN(BKE_visible_bases_iterator_begin, \
|
||||
BKE_visible_bases_iterator_next, \
|
||||
BKE_visible_bases_iterator_end, \
|
||||
sl, Base *, _instance)
|
||||
view_layer, Base *, _instance)
|
||||
|
||||
#define FOREACH_VISIBLE_BASE_END \
|
||||
ITER_END
|
||||
|
||||
|
||||
#define FOREACH_OBJECT(sl, _instance) \
|
||||
#define FOREACH_OBJECT(view_layer, _instance) \
|
||||
{ \
|
||||
Object *_instance; \
|
||||
Base *base; \
|
||||
for (base = (sl)->object_bases.first; base; base = base->next) { \
|
||||
for (base = (view_layer)->object_bases.first; base; base = base->next) { \
|
||||
_instance = base->object;
|
||||
|
||||
#define FOREACH_OBJECT_END \
|
||||
} \
|
||||
}
|
||||
|
||||
#define FOREACH_OBJECT_FLAG(scene, sl, flag, _instance) \
|
||||
#define FOREACH_OBJECT_FLAG(scene, view_layer, flag, _instance) \
|
||||
{ \
|
||||
IteratorBeginCb func_begin; \
|
||||
IteratorCb func_next, func_end; \
|
||||
|
@ -240,7 +240,7 @@ void BKE_visible_bases_iterator_end(BLI_Iterator *iter);
|
|||
func_begin = &BKE_selected_objects_iterator_begin; \
|
||||
func_next = &BKE_selected_objects_iterator_next; \
|
||||
func_end = &BKE_selected_objects_iterator_end; \
|
||||
data_in = (sl); \
|
||||
data_in = (view_layer); \
|
||||
} \
|
||||
else { \
|
||||
func_begin = BKE_scene_objects_iterator_begin; \
|
||||
|
|
|
@ -105,9 +105,9 @@ void BKE_object_lod_add(struct Object *ob);
|
|||
void BKE_object_lod_sort(struct Object *ob);
|
||||
bool BKE_object_lod_remove(struct Object *ob, int level);
|
||||
void BKE_object_lod_update(struct Object *ob, const float camera_position[3]);
|
||||
bool BKE_object_lod_is_usable(struct Object *ob, struct ViewLayer *sl);
|
||||
struct Object *BKE_object_lod_meshob_get(struct Object *ob, struct ViewLayer *sl);
|
||||
struct Object *BKE_object_lod_matob_get(struct Object *ob, struct ViewLayer *sl);
|
||||
bool BKE_object_lod_is_usable(struct Object *ob, struct ViewLayer *view_layer);
|
||||
struct Object *BKE_object_lod_meshob_get(struct Object *ob, struct ViewLayer *view_layer);
|
||||
struct Object *BKE_object_lod_matob_get(struct Object *ob, struct ViewLayer *view_layer);
|
||||
|
||||
void BKE_object_copy_data(struct Main *bmain, struct Object *ob_dst, const struct Object *ob_src, const int flag);
|
||||
struct Object *BKE_object_copy(struct Main *bmain, const struct Object *ob);
|
||||
|
@ -157,7 +157,7 @@ bool BKE_object_minmax_dupli(struct Scene *scene, struct Object *ob, float r_min
|
|||
void BKE_object_foreach_display_point(struct Object *ob, float obmat[4][4],
|
||||
void (*func_cb)(const float[3], void *), void *user_data);
|
||||
void BKE_scene_foreach_display_point(struct Scene *scene,
|
||||
struct ViewLayer *sl,
|
||||
struct ViewLayer *view_layer,
|
||||
void (*func_cb)(const float[3], void *), void *user_data);
|
||||
|
||||
bool BKE_object_parent_loop_check(const struct Object *parent, const struct Object *ob);
|
||||
|
|
|
@ -91,8 +91,8 @@ typedef enum eOverlayControlFlags {
|
|||
PAINT_OVERLAY_OVERRIDE_PRIMARY | \
|
||||
PAINT_OVERLAY_OVERRIDE_CURSOR)
|
||||
|
||||
void BKE_paint_invalidate_overlay_tex(struct Scene *scene, struct ViewLayer *sl, const struct Tex *tex);
|
||||
void BKE_paint_invalidate_cursor_overlay(struct Scene *scene, struct ViewLayer *sl, struct CurveMapping *curve);
|
||||
void BKE_paint_invalidate_overlay_tex(struct Scene *scene, struct ViewLayer *view_layer, const struct Tex *tex);
|
||||
void BKE_paint_invalidate_cursor_overlay(struct Scene *scene, struct ViewLayer *view_layer, struct CurveMapping *curve);
|
||||
void BKE_paint_invalidate_overlay_all(void);
|
||||
eOverlayControlFlags BKE_paint_get_overlay_flags(void);
|
||||
void BKE_paint_reset_overlay_invalid(eOverlayControlFlags flag);
|
||||
|
@ -126,7 +126,7 @@ void BKE_paint_cavity_curve_preset(struct Paint *p, int preset);
|
|||
|
||||
short BKE_paint_object_mode_from_paint_mode(ePaintMode mode);
|
||||
struct Paint *BKE_paint_get_active_from_paintmode(struct Scene *sce, ePaintMode mode);
|
||||
struct Paint *BKE_paint_get_active(struct Scene *sce, struct ViewLayer *sl);
|
||||
struct Paint *BKE_paint_get_active(struct Scene *sce, struct ViewLayer *view_layer);
|
||||
struct Paint *BKE_paint_get_active_from_context(const struct bContext *C);
|
||||
ePaintMode BKE_paintmode_get_active_from_context(const struct bContext *C);
|
||||
struct Brush *BKE_paint_brush(struct Paint *paint);
|
||||
|
|
|
@ -423,7 +423,7 @@ struct Sequence *BKE_sequencer_add_movie_strip(struct bContext *C, ListBase *seq
|
|||
/* view3d draw callback, run when not in background view */
|
||||
typedef struct ImBuf *(*SequencerDrawView)(
|
||||
const struct EvaluationContext *eval_ctx, struct Scene *,
|
||||
struct ViewLayer *sl, struct Object *, int, int,
|
||||
struct ViewLayer *view_layer, struct Object *, int, int,
|
||||
unsigned int, int, bool, bool, bool,
|
||||
int, int, bool, const char *,
|
||||
struct GPUFX *, struct GPUOffScreen *, char[256]);
|
||||
|
|
|
@ -2707,8 +2707,8 @@ static void editbmesh_build_data(
|
|||
static CustomDataMask object_get_datamask(const Scene *scene, Object *ob, bool *r_need_mapping)
|
||||
{
|
||||
/* TODO(sergey): Avoid this linear list lookup. */
|
||||
ViewLayer *sl = BKE_view_layer_context_active_PLACEHOLDER(scene);
|
||||
Object *actob = sl->basact ? sl->basact->object : NULL;
|
||||
ViewLayer *view_layer = BKE_view_layer_context_active_PLACEHOLDER(scene);
|
||||
Object *actob = view_layer->basact ? view_layer->basact->object : NULL;
|
||||
CustomDataMask mask = ob->customdata_mask;
|
||||
|
||||
if (r_need_mapping) {
|
||||
|
|
|
@ -666,7 +666,7 @@ static bool camera_frame_fit_calc_from_data(
|
|||
/* don't move the camera, just yield the fit location */
|
||||
/* r_scale only valid/useful for ortho cameras */
|
||||
bool BKE_camera_view_frame_fit_to_scene(
|
||||
Scene *scene, ViewLayer *sl, Object *camera_ob, float r_co[3], float *r_scale)
|
||||
Scene *scene, ViewLayer *view_layer, Object *camera_ob, float r_co[3], float *r_scale)
|
||||
{
|
||||
CameraParams params;
|
||||
CameraViewFrameData data_cb;
|
||||
|
@ -677,7 +677,7 @@ bool BKE_camera_view_frame_fit_to_scene(
|
|||
camera_frame_fit_data_init(scene, camera_ob, ¶ms, &data_cb);
|
||||
|
||||
/* run callback on all visible points */
|
||||
BKE_scene_foreach_display_point(scene, sl, camera_to_frame_view_cb, &data_cb);
|
||||
BKE_scene_foreach_display_point(scene, view_layer, camera_to_frame_view_cb, &data_cb);
|
||||
|
||||
return camera_frame_fit_calc_from_data(¶ms, &data_cb, r_co, r_scale);
|
||||
}
|
||||
|
|
|
@ -923,10 +923,10 @@ Scene *CTX_data_scene(const bContext *C)
|
|||
|
||||
ViewLayer *CTX_data_view_layer(const bContext *C)
|
||||
{
|
||||
ViewLayer *sl;
|
||||
ViewLayer *view_layer;
|
||||
|
||||
if (ctx_data_pointer_verify(C, "view_layer", (void *)&sl)) {
|
||||
return sl;
|
||||
if (ctx_data_pointer_verify(C, "view_layer", (void *)&view_layer)) {
|
||||
return view_layer;
|
||||
}
|
||||
else {
|
||||
return BKE_view_layer_from_workspace_get(CTX_data_scene(C), CTX_wm_workspace(C));
|
||||
|
@ -962,17 +962,17 @@ RenderEngineType *CTX_data_engine(const bContext *C)
|
|||
*/
|
||||
LayerCollection *CTX_data_layer_collection(const bContext *C)
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
LayerCollection *lc;
|
||||
|
||||
if (ctx_data_pointer_verify(C, "layer_collection", (void *)&lc)) {
|
||||
if (BKE_view_layer_has_collection(sl, lc->scene_collection)) {
|
||||
if (BKE_view_layer_has_collection(view_layer, lc->scene_collection)) {
|
||||
return lc;
|
||||
}
|
||||
}
|
||||
|
||||
/* fallback */
|
||||
return BKE_layer_collection_get_active(sl);
|
||||
return BKE_layer_collection_get_active(view_layer);
|
||||
}
|
||||
|
||||
SceneCollection *CTX_data_scene_collection(const bContext *C)
|
||||
|
|
|
@ -488,7 +488,7 @@ static void scene_setSubframe(Scene *scene, float subframe)
|
|||
scene->r.subframe = subframe;
|
||||
}
|
||||
|
||||
static int surface_getBrushFlags(DynamicPaintSurface *surface, const ViewLayer *sl)
|
||||
static int surface_getBrushFlags(DynamicPaintSurface *surface, const ViewLayer *view_layer)
|
||||
{
|
||||
Base *base = NULL;
|
||||
GroupObject *go = NULL;
|
||||
|
@ -500,7 +500,7 @@ static int surface_getBrushFlags(DynamicPaintSurface *surface, const ViewLayer *
|
|||
if (surface->brush_group)
|
||||
go = surface->brush_group->gobject.first;
|
||||
else
|
||||
base = FIRSTBASE(sl);
|
||||
base = FIRSTBASE(view_layer);
|
||||
|
||||
while (base || go) {
|
||||
brushObj = NULL;
|
||||
|
@ -5639,7 +5639,7 @@ static void dynamic_paint_generate_bake_data_cb(void *userdata, const int index)
|
|||
}
|
||||
}
|
||||
|
||||
static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, const ViewLayer *sl, Object *ob)
|
||||
static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, const ViewLayer *view_layer, Object *ob)
|
||||
{
|
||||
PaintSurfaceData *sData = surface->data;
|
||||
PaintBakeData *bData = sData->bData;
|
||||
|
@ -5647,7 +5647,7 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, const Vie
|
|||
int index;
|
||||
bool new_bdata = false;
|
||||
const bool do_velocity_data = ((surface->effect & MOD_DPAINT_EFFECT_DO_DRIP) ||
|
||||
(surface_getBrushFlags(surface, sl) & BRUSH_USES_VELOCITY));
|
||||
(surface_getBrushFlags(surface, view_layer) & BRUSH_USES_VELOCITY));
|
||||
const bool do_accel_data = (surface->effect & MOD_DPAINT_EFFECT_DO_DRIP) != 0;
|
||||
|
||||
int canvasNumOfVerts = dm->getNumVerts(dm);
|
||||
|
@ -5783,7 +5783,7 @@ static int dynamicPaint_doStep(const struct EvaluationContext *eval_ctx, Scene *
|
|||
GroupObject *go = NULL;
|
||||
Object *brushObj = NULL;
|
||||
ModifierData *md = NULL;
|
||||
ViewLayer *sl = eval_ctx->view_layer;
|
||||
ViewLayer *view_layer = eval_ctx->view_layer;
|
||||
|
||||
/* backup current scene frame */
|
||||
int scene_frame = scene->r.cfra;
|
||||
|
@ -5793,7 +5793,7 @@ static int dynamicPaint_doStep(const struct EvaluationContext *eval_ctx, Scene *
|
|||
if (surface->brush_group)
|
||||
go = surface->brush_group->gobject.first;
|
||||
else
|
||||
base = FIRSTBASE(sl);
|
||||
base = FIRSTBASE(view_layer);
|
||||
|
||||
while (base || go) {
|
||||
brushObj = NULL;
|
||||
|
|
|
@ -213,17 +213,17 @@ ListBase *pdInitEffectors(
|
|||
const struct EvaluationContext *eval_ctx, Scene *scene, Object *ob_src, ParticleSystem *psys_src,
|
||||
EffectorWeights *weights, bool for_simulation)
|
||||
{
|
||||
ViewLayer *sl;
|
||||
ViewLayer *view_layer;
|
||||
Base *base;
|
||||
unsigned int layer= ob_src->lay;
|
||||
ListBase *effectors = NULL;
|
||||
|
||||
/* eval_ctx is NULL during deg build */
|
||||
if (eval_ctx) {
|
||||
sl = eval_ctx->view_layer;
|
||||
view_layer = eval_ctx->view_layer;
|
||||
}
|
||||
else {
|
||||
sl = BKE_view_layer_context_active_PLACEHOLDER(scene);
|
||||
view_layer = BKE_view_layer_context_active_PLACEHOLDER(scene);
|
||||
}
|
||||
|
||||
if (weights->group) {
|
||||
|
@ -244,7 +244,7 @@ ListBase *pdInitEffectors(
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if ( base->object->pd && base->object->pd->forcefield )
|
||||
add_object_to_effectors(&effectors, eval_ctx, scene, weights, base->object, ob_src, for_simulation);
|
||||
|
||||
|
|
|
@ -57,9 +57,9 @@
|
|||
|
||||
/* prototype */
|
||||
struct EngineSettingsCB_Type;
|
||||
static void layer_collection_free(ViewLayer *sl, LayerCollection *lc);
|
||||
static void layer_collection_objects_populate(ViewLayer *sl, LayerCollection *lc, ListBase *objects);
|
||||
static LayerCollection *layer_collection_add(ViewLayer *sl, LayerCollection *parent, SceneCollection *sc);
|
||||
static void layer_collection_free(ViewLayer *view_layer, LayerCollection *lc);
|
||||
static void layer_collection_objects_populate(ViewLayer *view_layer, LayerCollection *lc, ListBase *objects);
|
||||
static LayerCollection *layer_collection_add(ViewLayer *view_layer, LayerCollection *parent, SceneCollection *sc);
|
||||
static LayerCollection *find_layer_collection_by_scene_collection(LayerCollection *lc, const SceneCollection *sc);
|
||||
static IDProperty *collection_engine_settings_create(struct EngineSettingsCB_Type *ces_type, const bool populate);
|
||||
static IDProperty *collection_engine_get(IDProperty *root, const int type, const char *engine_name);
|
||||
|
@ -75,9 +75,9 @@ static void object_bases_iterator_next(BLI_Iterator *iter, const int flag);
|
|||
*/
|
||||
ViewLayer *BKE_view_layer_from_scene_get(const Scene *scene)
|
||||
{
|
||||
ViewLayer *sl = BLI_findlink(&scene->view_layers, scene->active_view_layer);
|
||||
BLI_assert(sl);
|
||||
return sl;
|
||||
ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
|
||||
BLI_assert(view_layer);
|
||||
return view_layer;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -140,34 +140,34 @@ ViewLayer *BKE_view_layer_add(Scene *scene, const char *name)
|
|||
/**
|
||||
* Free (or release) any data used by this ViewLayer.
|
||||
*/
|
||||
void BKE_view_layer_free(ViewLayer *sl)
|
||||
void BKE_view_layer_free(ViewLayer *view_layer)
|
||||
{
|
||||
sl->basact = NULL;
|
||||
view_layer->basact = NULL;
|
||||
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (base->collection_properties) {
|
||||
IDP_FreeProperty(base->collection_properties);
|
||||
MEM_freeN(base->collection_properties);
|
||||
}
|
||||
}
|
||||
BLI_freelistN(&sl->object_bases);
|
||||
BLI_freelistN(&view_layer->object_bases);
|
||||
|
||||
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
|
||||
for (LayerCollection *lc = view_layer->layer_collections.first; lc; lc = lc->next) {
|
||||
layer_collection_free(NULL, lc);
|
||||
}
|
||||
BLI_freelistN(&sl->layer_collections);
|
||||
BLI_freelistN(&view_layer->layer_collections);
|
||||
|
||||
if (sl->properties) {
|
||||
IDP_FreeProperty(sl->properties);
|
||||
MEM_freeN(sl->properties);
|
||||
if (view_layer->properties) {
|
||||
IDP_FreeProperty(view_layer->properties);
|
||||
MEM_freeN(view_layer->properties);
|
||||
}
|
||||
|
||||
if (sl->properties_evaluated) {
|
||||
IDP_FreeProperty(sl->properties_evaluated);
|
||||
MEM_freeN(sl->properties_evaluated);
|
||||
if (view_layer->properties_evaluated) {
|
||||
IDP_FreeProperty(view_layer->properties_evaluated);
|
||||
MEM_freeN(view_layer->properties_evaluated);
|
||||
}
|
||||
|
||||
for (ViewLayerEngineData *sled = sl->drawdata.first; sled; sled = sled->next) {
|
||||
for (ViewLayerEngineData *sled = view_layer->drawdata.first; sled; sled = sled->next) {
|
||||
if (sled->storage) {
|
||||
if (sled->free) {
|
||||
sled->free(sled->storage);
|
||||
|
@ -175,26 +175,26 @@ void BKE_view_layer_free(ViewLayer *sl)
|
|||
MEM_freeN(sled->storage);
|
||||
}
|
||||
}
|
||||
BLI_freelistN(&sl->drawdata);
|
||||
BLI_freelistN(&view_layer->drawdata);
|
||||
|
||||
MEM_SAFE_FREE(sl->stats);
|
||||
MEM_SAFE_FREE(view_layer->stats);
|
||||
|
||||
BKE_freestyle_config_free(&sl->freestyle_config);
|
||||
BKE_freestyle_config_free(&view_layer->freestyle_config);
|
||||
|
||||
if (sl->id_properties) {
|
||||
IDP_FreeProperty(sl->id_properties);
|
||||
MEM_freeN(sl->id_properties);
|
||||
if (view_layer->id_properties) {
|
||||
IDP_FreeProperty(view_layer->id_properties);
|
||||
MEM_freeN(view_layer->id_properties);
|
||||
}
|
||||
|
||||
MEM_freeN(sl);
|
||||
MEM_freeN(view_layer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tag all the selected objects of a renderlayer
|
||||
*/
|
||||
void BKE_view_layer_selected_objects_tag(ViewLayer *sl, const int tag)
|
||||
void BKE_view_layer_selected_objects_tag(ViewLayer *view_layer, const int tag)
|
||||
{
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if ((base->flag & BASE_SELECTED) != 0) {
|
||||
base->object->flag |= tag;
|
||||
}
|
||||
|
@ -240,9 +240,9 @@ Object *BKE_view_layer_camera_find(ViewLayer *view_layer)
|
|||
*/
|
||||
ViewLayer *BKE_view_layer_find_from_collection(const Scene *scene, LayerCollection *lc)
|
||||
{
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
if (find_scene_collection_in_scene_collections(&sl->layer_collections, lc)) {
|
||||
return sl;
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
if (find_scene_collection_in_scene_collections(&view_layer->layer_collections, lc)) {
|
||||
return view_layer;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
|
@ -250,36 +250,36 @@ ViewLayer *BKE_view_layer_find_from_collection(const Scene *scene, LayerCollecti
|
|||
|
||||
/* Base */
|
||||
|
||||
Base *BKE_view_layer_base_find(ViewLayer *sl, Object *ob)
|
||||
Base *BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
|
||||
{
|
||||
return BLI_findptr(&sl->object_bases, ob, offsetof(Base, object));
|
||||
return BLI_findptr(&view_layer->object_bases, ob, offsetof(Base, object));
|
||||
}
|
||||
|
||||
void BKE_view_layer_base_deselect_all(ViewLayer *sl)
|
||||
void BKE_view_layer_base_deselect_all(ViewLayer *view_layer)
|
||||
{
|
||||
Base *base;
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
base->flag &= ~BASE_SELECTED;
|
||||
}
|
||||
}
|
||||
|
||||
void BKE_view_layer_base_select(struct ViewLayer *sl, Base *selbase)
|
||||
void BKE_view_layer_base_select(struct ViewLayer *view_layer, Base *selbase)
|
||||
{
|
||||
sl->basact = selbase;
|
||||
view_layer->basact = selbase;
|
||||
if ((selbase->flag & BASE_SELECTABLED) != 0) {
|
||||
selbase->flag |= BASE_SELECTED;
|
||||
}
|
||||
}
|
||||
|
||||
static void view_layer_object_base_unref(ViewLayer *sl, Base *base)
|
||||
static void view_layer_object_base_unref(ViewLayer *view_layer, Base *base)
|
||||
{
|
||||
base->refcount--;
|
||||
|
||||
/* It only exists in the RenderLayer */
|
||||
if (base->refcount == 0) {
|
||||
if (sl->basact == base) {
|
||||
sl->basact = NULL;
|
||||
if (view_layer->basact == base) {
|
||||
view_layer->basact = NULL;
|
||||
}
|
||||
|
||||
if (base->collection_properties) {
|
||||
|
@ -287,7 +287,7 @@ static void view_layer_object_base_unref(ViewLayer *sl, Base *base)
|
|||
MEM_freeN(base->collection_properties);
|
||||
}
|
||||
|
||||
BLI_remlink(&sl->object_bases, base);
|
||||
BLI_remlink(&view_layer->object_bases, base);
|
||||
MEM_freeN(base);
|
||||
}
|
||||
}
|
||||
|
@ -296,17 +296,17 @@ static void view_layer_object_base_unref(ViewLayer *sl, Base *base)
|
|||
* Return the base if existent, or create it if necessary
|
||||
* Always bump the refcount
|
||||
*/
|
||||
static Base *object_base_add(ViewLayer *sl, Object *ob)
|
||||
static Base *object_base_add(ViewLayer *view_layer, Object *ob)
|
||||
{
|
||||
Base *base;
|
||||
base = BKE_view_layer_base_find(sl, ob);
|
||||
base = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
if (base == NULL) {
|
||||
base = MEM_callocN(sizeof(Base), "Object Base");
|
||||
|
||||
/* Do not bump user count, leave it for SceneCollections. */
|
||||
base->object = ob;
|
||||
BLI_addtail(&sl->object_bases, base);
|
||||
BLI_addtail(&view_layer->object_bases, base);
|
||||
|
||||
IDPropertyTemplate val = {0};
|
||||
base->collection_properties = IDP_New(IDP_GROUP, &val, ROOT_PROP);
|
||||
|
@ -318,11 +318,11 @@ static Base *object_base_add(ViewLayer *sl, Object *ob)
|
|||
|
||||
/* LayerCollection */
|
||||
|
||||
static void layer_collection_objects_unpopulate(ViewLayer *sl, LayerCollection *lc)
|
||||
static void layer_collection_objects_unpopulate(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
if (sl) {
|
||||
if (view_layer) {
|
||||
for (LinkData *link = lc->object_bases.first; link; link = link->next) {
|
||||
view_layer_object_base_unref(sl, link->data);
|
||||
view_layer_object_base_unref(view_layer, link->data);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -333,9 +333,9 @@ static void layer_collection_objects_unpopulate(ViewLayer *sl, LayerCollection *
|
|||
* When freeing the entire ViewLayer at once we don't bother with unref
|
||||
* otherwise ViewLayer is passed to keep the syncing of the LayerCollection tree
|
||||
*/
|
||||
static void layer_collection_free(ViewLayer *sl, LayerCollection *lc)
|
||||
static void layer_collection_free(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
layer_collection_objects_unpopulate(sl, lc);
|
||||
layer_collection_objects_unpopulate(view_layer, lc);
|
||||
BLI_freelistN(&lc->overrides);
|
||||
|
||||
if (lc->properties) {
|
||||
|
@ -349,7 +349,7 @@ static void layer_collection_free(ViewLayer *sl, LayerCollection *lc)
|
|||
}
|
||||
|
||||
for (LayerCollection *nlc = lc->layer_collections.first; nlc; nlc = nlc->next) {
|
||||
layer_collection_free(sl, nlc);
|
||||
layer_collection_free(view_layer, nlc);
|
||||
}
|
||||
|
||||
BLI_freelistN(&lc->layer_collections);
|
||||
|
@ -359,9 +359,9 @@ static void layer_collection_free(ViewLayer *sl, LayerCollection *lc)
|
|||
* Free (or release) LayerCollection from ViewLayer
|
||||
* (does not free the LayerCollection itself).
|
||||
*/
|
||||
void BKE_layer_collection_free(ViewLayer *sl, LayerCollection *lc)
|
||||
void BKE_layer_collection_free(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
layer_collection_free(sl, lc);
|
||||
layer_collection_free(view_layer, lc);
|
||||
}
|
||||
|
||||
/* LayerCollection */
|
||||
|
@ -389,19 +389,19 @@ static LayerCollection *collection_from_index(ListBase *lb, const int number, in
|
|||
/**
|
||||
* Get the collection for a given index
|
||||
*/
|
||||
LayerCollection *BKE_layer_collection_from_index(ViewLayer *sl, const int index)
|
||||
LayerCollection *BKE_layer_collection_from_index(ViewLayer *view_layer, const int index)
|
||||
{
|
||||
int i = 0;
|
||||
return collection_from_index(&sl->layer_collections, index, &i);
|
||||
return collection_from_index(&view_layer->layer_collections, index, &i);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the active collection
|
||||
*/
|
||||
LayerCollection *BKE_layer_collection_get_active(ViewLayer *sl)
|
||||
LayerCollection *BKE_layer_collection_get_active(ViewLayer *view_layer)
|
||||
{
|
||||
int i = 0;
|
||||
return collection_from_index(&sl->layer_collections, sl->active_collection, &i);
|
||||
return collection_from_index(&view_layer->layer_collections, view_layer->active_collection, &i);
|
||||
}
|
||||
|
||||
|
||||
|
@ -409,17 +409,17 @@ LayerCollection *BKE_layer_collection_get_active(ViewLayer *sl)
|
|||
* Return layer collection to add new object(s).
|
||||
* Create one if none exists.
|
||||
*/
|
||||
LayerCollection *BKE_layer_collection_get_active_ensure(Scene *scene, ViewLayer *sl)
|
||||
LayerCollection *BKE_layer_collection_get_active_ensure(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
LayerCollection *lc = BKE_layer_collection_get_active(sl);
|
||||
LayerCollection *lc = BKE_layer_collection_get_active(view_layer);
|
||||
|
||||
if (lc == NULL) {
|
||||
BLI_assert(BLI_listbase_is_empty(&sl->layer_collections));
|
||||
BLI_assert(BLI_listbase_is_empty(&view_layer->layer_collections));
|
||||
/* When there is no collection linked to this ViewLayer, create one. */
|
||||
SceneCollection *sc = BKE_collection_add(scene, NULL, NULL);
|
||||
lc = BKE_collection_link(sl, sc);
|
||||
lc = BKE_collection_link(view_layer, sc);
|
||||
/* New collection has to be the active one. */
|
||||
BLI_assert(lc == BKE_layer_collection_get_active(sl));
|
||||
BLI_assert(lc == BKE_layer_collection_get_active(view_layer));
|
||||
}
|
||||
|
||||
return lc;
|
||||
|
@ -441,9 +441,9 @@ static int collection_count(ListBase *lb)
|
|||
* Get the total number of collections
|
||||
* (including all the nested collections)
|
||||
*/
|
||||
int BKE_layer_collection_count(ViewLayer *sl)
|
||||
int BKE_layer_collection_count(ViewLayer *view_layer)
|
||||
{
|
||||
return collection_count(&sl->layer_collections);
|
||||
return collection_count(&view_layer->layer_collections);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -469,10 +469,10 @@ static int index_from_collection(ListBase *lb, const LayerCollection *lc, int *i
|
|||
/**
|
||||
* Return -1 if not found
|
||||
*/
|
||||
int BKE_layer_collection_findindex(ViewLayer *sl, const LayerCollection *lc)
|
||||
int BKE_layer_collection_findindex(ViewLayer *view_layer, const LayerCollection *lc)
|
||||
{
|
||||
int i = 0;
|
||||
return index_from_collection(&sl->layer_collections, lc, &i);
|
||||
return index_from_collection(&view_layer->layer_collections, lc, &i);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -534,15 +534,15 @@ static ListBase *scene_collection_listbase_find(ListBase *lb, SceneCollection *s
|
|||
*/
|
||||
|
||||
static void layer_collection_swap(
|
||||
ViewLayer *sl, ListBase *lb_a, ListBase *lb_b,
|
||||
ViewLayer *view_layer, ListBase *lb_a, ListBase *lb_b,
|
||||
LayerCollection *lc_a, LayerCollection *lc_b)
|
||||
{
|
||||
if (lb_a == NULL) {
|
||||
lb_a = layer_collection_listbase_find(&sl->layer_collections, lc_a);
|
||||
lb_a = layer_collection_listbase_find(&view_layer->layer_collections, lc_a);
|
||||
}
|
||||
|
||||
if (lb_b == NULL) {
|
||||
lb_b = layer_collection_listbase_find(&sl->layer_collections, lc_b);
|
||||
lb_b = layer_collection_listbase_find(&view_layer->layer_collections, lc_b);
|
||||
}
|
||||
|
||||
BLI_assert(lb_a);
|
||||
|
@ -557,10 +557,10 @@ static void layer_collection_swap(
|
|||
*/
|
||||
bool BKE_layer_collection_move_into(const Scene *scene, LayerCollection *lc_dst, LayerCollection *lc_src)
|
||||
{
|
||||
ViewLayer *sl = BKE_view_layer_find_from_collection(scene, lc_src);
|
||||
ViewLayer *view_layer = BKE_view_layer_find_from_collection(scene, lc_src);
|
||||
bool is_directly_linked = false;
|
||||
|
||||
if ((!sl) || (sl != BKE_view_layer_find_from_collection(scene, lc_dst))) {
|
||||
if ((!view_layer) || (view_layer != BKE_view_layer_find_from_collection(scene, lc_dst))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -578,29 +578,29 @@ bool BKE_layer_collection_move_into(const Scene *scene, LayerCollection *lc_dst,
|
|||
* but we want to swap it in the layer tree still */
|
||||
if (lc_dst->scene_collection->scene_collections.last == lc_src->scene_collection) {
|
||||
LayerCollection *lc_swap = lc_dst->layer_collections.last;
|
||||
layer_collection_swap(sl, &lc_dst->layer_collections, NULL, lc_dst->layer_collections.last, lc_src);
|
||||
layer_collection_swap(view_layer, &lc_dst->layer_collections, NULL, lc_dst->layer_collections.last, lc_src);
|
||||
|
||||
if (BLI_findindex(&sl->layer_collections, lc_swap) != -1) {
|
||||
BKE_collection_unlink(sl, lc_swap);
|
||||
if (BLI_findindex(&view_layer->layer_collections, lc_swap) != -1) {
|
||||
BKE_collection_unlink(view_layer, lc_swap);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
LayerCollection *lc_temp;
|
||||
is_directly_linked = BLI_findindex(&sl->layer_collections, lc_src) != -1;
|
||||
is_directly_linked = BLI_findindex(&view_layer->layer_collections, lc_src) != -1;
|
||||
|
||||
if (!is_directly_linked) {
|
||||
/* lc_src will be invalid after BKE_collection_move_into!
|
||||
* so we swap it with lc_temp to preserve its settings */
|
||||
lc_temp = BKE_collection_link(sl, lc_src->scene_collection);
|
||||
layer_collection_swap(sl, &sl->layer_collections, NULL, lc_temp, lc_src);
|
||||
lc_temp = BKE_collection_link(view_layer, lc_src->scene_collection);
|
||||
layer_collection_swap(view_layer, &view_layer->layer_collections, NULL, lc_temp, lc_src);
|
||||
}
|
||||
|
||||
if (!BKE_collection_move_into(scene, lc_dst->scene_collection, lc_src->scene_collection)) {
|
||||
if (!is_directly_linked) {
|
||||
/* Swap back and remove */
|
||||
layer_collection_swap(sl, NULL, NULL, lc_temp, lc_src);
|
||||
BKE_collection_unlink(sl, lc_temp);
|
||||
layer_collection_swap(view_layer, NULL, NULL, lc_temp, lc_src);
|
||||
BKE_collection_unlink(view_layer, lc_temp);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
@ -608,27 +608,27 @@ bool BKE_layer_collection_move_into(const Scene *scene, LayerCollection *lc_dst,
|
|||
|
||||
LayerCollection *lc_new = BLI_findptr(&lc_dst->layer_collections, lc_src->scene_collection, offsetof(LayerCollection, scene_collection));
|
||||
BLI_assert(lc_new);
|
||||
layer_collection_swap(sl, &lc_dst->layer_collections, NULL, lc_new, lc_src);
|
||||
layer_collection_swap(view_layer, &lc_dst->layer_collections, NULL, lc_new, lc_src);
|
||||
|
||||
/* If it's directly linked, unlink it after the swap */
|
||||
if (BLI_findindex(&sl->layer_collections, lc_new) != -1) {
|
||||
BKE_collection_unlink(sl, lc_new);
|
||||
if (BLI_findindex(&view_layer->layer_collections, lc_new) != -1) {
|
||||
BKE_collection_unlink(view_layer, lc_new);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Move \a lc_src above \a lc_dst. Both have to be stored in \a sl.
|
||||
* Move \a lc_src above \a lc_dst. Both have to be stored in \a view_layer.
|
||||
* If \a lc_src is directly linked to the ViewLayer it's unlinked
|
||||
*/
|
||||
bool BKE_layer_collection_move_above(const Scene *scene, LayerCollection *lc_dst, LayerCollection *lc_src)
|
||||
{
|
||||
ViewLayer *sl = BKE_view_layer_find_from_collection(scene, lc_src);
|
||||
const bool is_directly_linked_src = BLI_findindex(&sl->layer_collections, lc_src) != -1;
|
||||
const bool is_directly_linked_dst = BLI_findindex(&sl->layer_collections, lc_dst) != -1;
|
||||
ViewLayer *view_layer = BKE_view_layer_find_from_collection(scene, lc_src);
|
||||
const bool is_directly_linked_src = BLI_findindex(&view_layer->layer_collections, lc_src) != -1;
|
||||
const bool is_directly_linked_dst = BLI_findindex(&view_layer->layer_collections, lc_dst) != -1;
|
||||
|
||||
if ((!sl) || (sl != BKE_view_layer_find_from_collection(scene, lc_dst))) {
|
||||
if ((!view_layer) || (view_layer != BKE_view_layer_find_from_collection(scene, lc_dst))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -641,10 +641,10 @@ bool BKE_layer_collection_move_above(const Scene *scene, LayerCollection *lc_dst
|
|||
* but we want to swap it in the layer tree still */
|
||||
if (lc_dst->prev && lc_dst->prev->scene_collection == lc_src->scene_collection) {
|
||||
LayerCollection *lc_swap = lc_dst->prev;
|
||||
layer_collection_swap(sl, NULL, NULL, lc_dst->prev, lc_src);
|
||||
layer_collection_swap(view_layer, NULL, NULL, lc_dst->prev, lc_src);
|
||||
|
||||
if (BLI_findindex(&sl->layer_collections, lc_swap) != -1) {
|
||||
BKE_collection_unlink(sl, lc_swap);
|
||||
if (BLI_findindex(&view_layer->layer_collections, lc_swap) != -1) {
|
||||
BKE_collection_unlink(view_layer, lc_swap);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
@ -653,8 +653,8 @@ bool BKE_layer_collection_move_above(const Scene *scene, LayerCollection *lc_dst
|
|||
else if (is_directly_linked_dst) {
|
||||
/* Both directly linked to the ViewLayer, just need to swap */
|
||||
if (is_directly_linked_src) {
|
||||
BLI_remlink(&sl->layer_collections, lc_src);
|
||||
BLI_insertlinkbefore(&sl->layer_collections, lc_dst, lc_src);
|
||||
BLI_remlink(&view_layer->layer_collections, lc_src);
|
||||
BLI_insertlinkbefore(&view_layer->layer_collections, lc_dst, lc_src);
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
|
@ -667,15 +667,15 @@ bool BKE_layer_collection_move_above(const Scene *scene, LayerCollection *lc_dst
|
|||
if (!is_directly_linked_src) {
|
||||
/* lc_src will be invalid after BKE_collection_move_into!
|
||||
* so we swap it with lc_temp to preserve its settings */
|
||||
lc_temp = BKE_collection_link(sl, lc_src->scene_collection);
|
||||
layer_collection_swap(sl, &sl->layer_collections, NULL, lc_temp, lc_src);
|
||||
lc_temp = BKE_collection_link(view_layer, lc_src->scene_collection);
|
||||
layer_collection_swap(view_layer, &view_layer->layer_collections, NULL, lc_temp, lc_src);
|
||||
}
|
||||
|
||||
if (!BKE_collection_move_above(scene, lc_dst->scene_collection, lc_src->scene_collection)) {
|
||||
if (!is_directly_linked_src) {
|
||||
/* Swap back and remove */
|
||||
layer_collection_swap(sl, NULL, NULL, lc_temp, lc_src);
|
||||
BKE_collection_unlink(sl, lc_temp);
|
||||
layer_collection_swap(view_layer, NULL, NULL, lc_temp, lc_src);
|
||||
BKE_collection_unlink(view_layer, lc_temp);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
@ -683,11 +683,11 @@ bool BKE_layer_collection_move_above(const Scene *scene, LayerCollection *lc_dst
|
|||
|
||||
LayerCollection *lc_new = lc_dst->prev;
|
||||
BLI_assert(lc_new);
|
||||
layer_collection_swap(sl, NULL, NULL, lc_new, lc_src);
|
||||
layer_collection_swap(view_layer, NULL, NULL, lc_new, lc_src);
|
||||
|
||||
/* If it's directly linked, unlink it after the swap */
|
||||
if (BLI_findindex(&sl->layer_collections, lc_new) != -1) {
|
||||
BKE_collection_unlink(sl, lc_new);
|
||||
if (BLI_findindex(&view_layer->layer_collections, lc_new) != -1) {
|
||||
BKE_collection_unlink(view_layer, lc_new);
|
||||
}
|
||||
|
||||
return true;
|
||||
|
@ -699,11 +699,11 @@ bool BKE_layer_collection_move_above(const Scene *scene, LayerCollection *lc_dst
|
|||
*/
|
||||
bool BKE_layer_collection_move_below(const Scene *scene, LayerCollection *lc_dst, LayerCollection *lc_src)
|
||||
{
|
||||
ViewLayer *sl = BKE_view_layer_find_from_collection(scene, lc_src);
|
||||
const bool is_directly_linked_src = BLI_findindex(&sl->layer_collections, lc_src) != -1;
|
||||
const bool is_directly_linked_dst = BLI_findindex(&sl->layer_collections, lc_dst) != -1;
|
||||
ViewLayer *view_layer = BKE_view_layer_find_from_collection(scene, lc_src);
|
||||
const bool is_directly_linked_src = BLI_findindex(&view_layer->layer_collections, lc_src) != -1;
|
||||
const bool is_directly_linked_dst = BLI_findindex(&view_layer->layer_collections, lc_dst) != -1;
|
||||
|
||||
if ((!sl) || (sl != BKE_view_layer_find_from_collection(scene, lc_dst))) {
|
||||
if ((!view_layer) || (view_layer != BKE_view_layer_find_from_collection(scene, lc_dst))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -716,10 +716,10 @@ bool BKE_layer_collection_move_below(const Scene *scene, LayerCollection *lc_dst
|
|||
* but we want to swap it in the layer tree still */
|
||||
if (lc_dst->next && lc_dst->next->scene_collection == lc_src->scene_collection) {
|
||||
LayerCollection *lc_swap = lc_dst->next;
|
||||
layer_collection_swap(sl, NULL, NULL, lc_dst->next, lc_src);
|
||||
layer_collection_swap(view_layer, NULL, NULL, lc_dst->next, lc_src);
|
||||
|
||||
if (BLI_findindex(&sl->layer_collections, lc_swap) != -1) {
|
||||
BKE_collection_unlink(sl, lc_swap);
|
||||
if (BLI_findindex(&view_layer->layer_collections, lc_swap) != -1) {
|
||||
BKE_collection_unlink(view_layer, lc_swap);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
@ -728,8 +728,8 @@ bool BKE_layer_collection_move_below(const Scene *scene, LayerCollection *lc_dst
|
|||
else if (is_directly_linked_dst) {
|
||||
/* Both directly linked to the ViewLayer, just need to swap */
|
||||
if (is_directly_linked_src) {
|
||||
BLI_remlink(&sl->layer_collections, lc_src);
|
||||
BLI_insertlinkafter(&sl->layer_collections, lc_dst, lc_src);
|
||||
BLI_remlink(&view_layer->layer_collections, lc_src);
|
||||
BLI_insertlinkafter(&view_layer->layer_collections, lc_dst, lc_src);
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
|
@ -742,15 +742,15 @@ bool BKE_layer_collection_move_below(const Scene *scene, LayerCollection *lc_dst
|
|||
if (!is_directly_linked_src) {
|
||||
/* lc_src will be invalid after BKE_collection_move_into!
|
||||
* so we swap it with lc_temp to preserve its settings */
|
||||
lc_temp = BKE_collection_link(sl, lc_src->scene_collection);
|
||||
layer_collection_swap(sl, &sl->layer_collections, NULL, lc_temp, lc_src);
|
||||
lc_temp = BKE_collection_link(view_layer, lc_src->scene_collection);
|
||||
layer_collection_swap(view_layer, &view_layer->layer_collections, NULL, lc_temp, lc_src);
|
||||
}
|
||||
|
||||
if (!BKE_collection_move_below(scene, lc_dst->scene_collection, lc_src->scene_collection)) {
|
||||
if (!is_directly_linked_src) {
|
||||
/* Swap back and remove */
|
||||
layer_collection_swap(sl, NULL, NULL, lc_temp, lc_src);
|
||||
BKE_collection_unlink(sl, lc_temp);
|
||||
layer_collection_swap(view_layer, NULL, NULL, lc_temp, lc_src);
|
||||
BKE_collection_unlink(view_layer, lc_temp);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
@ -758,17 +758,17 @@ bool BKE_layer_collection_move_below(const Scene *scene, LayerCollection *lc_dst
|
|||
|
||||
LayerCollection *lc_new = lc_dst->next;
|
||||
BLI_assert(lc_new);
|
||||
layer_collection_swap(sl, NULL, NULL, lc_new, lc_src);
|
||||
layer_collection_swap(view_layer, NULL, NULL, lc_new, lc_src);
|
||||
|
||||
/* If it's directly linked, unlink it after the swap */
|
||||
if (BLI_findindex(&sl->layer_collections, lc_new) != -1) {
|
||||
BKE_collection_unlink(sl, lc_new);
|
||||
if (BLI_findindex(&view_layer->layer_collections, lc_new) != -1) {
|
||||
BKE_collection_unlink(view_layer, lc_new);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool layer_collection_resync(ViewLayer *sl, LayerCollection *lc, const SceneCollection *sc)
|
||||
static bool layer_collection_resync(ViewLayer *view_layer, LayerCollection *lc, const SceneCollection *sc)
|
||||
{
|
||||
if (lc->scene_collection == sc) {
|
||||
ListBase collections = {NULL};
|
||||
|
@ -781,12 +781,12 @@ static bool layer_collection_resync(ViewLayer *sl, LayerCollection *lc, const Sc
|
|||
BLI_addtail(&lc->layer_collections, lc_nested);
|
||||
}
|
||||
else {
|
||||
layer_collection_add(sl, lc, sc_nested);
|
||||
layer_collection_add(view_layer, lc, sc_nested);
|
||||
}
|
||||
}
|
||||
|
||||
for (LayerCollection *lc_nested = collections.first; lc_nested; lc_nested = lc_nested->next) {
|
||||
layer_collection_free(sl, lc_nested);
|
||||
layer_collection_free(view_layer, lc_nested);
|
||||
}
|
||||
BLI_freelistN(&collections);
|
||||
|
||||
|
@ -797,7 +797,7 @@ static bool layer_collection_resync(ViewLayer *sl, LayerCollection *lc, const Sc
|
|||
}
|
||||
|
||||
for (LayerCollection *lc_nested = lc->layer_collections.first; lc_nested; lc_nested = lc_nested->next) {
|
||||
if (layer_collection_resync(sl, lc_nested, sc)) {
|
||||
if (layer_collection_resync(view_layer, lc_nested, sc)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
@ -811,9 +811,9 @@ static bool layer_collection_resync(ViewLayer *sl, LayerCollection *lc, const Sc
|
|||
*/
|
||||
void BKE_layer_collection_resync(const Scene *scene, const SceneCollection *sc)
|
||||
{
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
|
||||
layer_collection_resync(sl, lc, sc);
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (LayerCollection *lc = view_layer->layer_collections.first; lc; lc = lc->next) {
|
||||
layer_collection_resync(view_layer, lc, sc);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -824,10 +824,10 @@ void BKE_layer_collection_resync(const Scene *scene, const SceneCollection *sc)
|
|||
* Link a collection to a renderlayer
|
||||
* The collection needs to be created separately
|
||||
*/
|
||||
LayerCollection *BKE_collection_link(ViewLayer *sl, SceneCollection *sc)
|
||||
LayerCollection *BKE_collection_link(ViewLayer *view_layer, SceneCollection *sc)
|
||||
{
|
||||
LayerCollection *lc = layer_collection_add(sl, NULL, sc);
|
||||
sl->active_collection = BKE_layer_collection_findindex(sl, lc);
|
||||
LayerCollection *lc = layer_collection_add(view_layer, NULL, sc);
|
||||
view_layer->active_collection = BKE_layer_collection_findindex(view_layer, lc);
|
||||
return lc;
|
||||
}
|
||||
|
||||
|
@ -835,23 +835,23 @@ LayerCollection *BKE_collection_link(ViewLayer *sl, SceneCollection *sc)
|
|||
* Unlink a collection base from a renderlayer
|
||||
* The corresponding collection is not removed from the master collection
|
||||
*/
|
||||
void BKE_collection_unlink(ViewLayer *sl, LayerCollection *lc)
|
||||
void BKE_collection_unlink(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
BKE_layer_collection_free(sl, lc);
|
||||
BLI_remlink(&sl->layer_collections, lc);
|
||||
BKE_layer_collection_free(view_layer, lc);
|
||||
BLI_remlink(&view_layer->layer_collections, lc);
|
||||
MEM_freeN(lc);
|
||||
sl->active_collection = 0;
|
||||
view_layer->active_collection = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively enable nested collections
|
||||
*/
|
||||
static void layer_collection_enable(ViewLayer *sl, LayerCollection *lc)
|
||||
static void layer_collection_enable(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
layer_collection_objects_populate(sl, lc, &lc->scene_collection->objects);
|
||||
layer_collection_objects_populate(view_layer, lc, &lc->scene_collection->objects);
|
||||
|
||||
for (LayerCollection *nlc = lc->layer_collections.first; nlc; nlc = nlc->next) {
|
||||
layer_collection_enable(sl, nlc);
|
||||
layer_collection_enable(view_layer, nlc);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -860,25 +860,25 @@ static void layer_collection_enable(ViewLayer *sl, LayerCollection *lc)
|
|||
* Add its objects bases to ViewLayer
|
||||
* Depsgraph needs to be rebuilt afterwards
|
||||
*/
|
||||
void BKE_collection_enable(ViewLayer *sl, LayerCollection *lc)
|
||||
void BKE_collection_enable(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
if ((lc->flag & COLLECTION_DISABLED) == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
lc->flag &= ~COLLECTION_DISABLED;
|
||||
layer_collection_enable(sl, lc);
|
||||
layer_collection_enable(view_layer, lc);
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively disable nested collections
|
||||
*/
|
||||
static void layer_collection_disable(ViewLayer *sl, LayerCollection *lc)
|
||||
static void layer_collection_disable(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
layer_collection_objects_unpopulate(sl, lc);
|
||||
layer_collection_objects_unpopulate(view_layer, lc);
|
||||
|
||||
for (LayerCollection *nlc = lc->layer_collections.first; nlc; nlc = nlc->next) {
|
||||
layer_collection_disable(sl, nlc);
|
||||
layer_collection_disable(view_layer, nlc);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -887,19 +887,19 @@ static void layer_collection_disable(ViewLayer *sl, LayerCollection *lc)
|
|||
* Remove all its object bases from ViewLayer
|
||||
* Depsgraph needs to be rebuilt afterwards
|
||||
*/
|
||||
void BKE_collection_disable(ViewLayer *sl, LayerCollection *lc)
|
||||
void BKE_collection_disable(ViewLayer *view_layer, LayerCollection *lc)
|
||||
{
|
||||
if ((lc->flag & COLLECTION_DISABLED) != 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
lc->flag |= COLLECTION_DISABLED;
|
||||
layer_collection_disable(sl, lc);
|
||||
layer_collection_disable(view_layer, lc);
|
||||
}
|
||||
|
||||
static void layer_collection_object_add(ViewLayer *sl, LayerCollection *lc, Object *ob)
|
||||
static void layer_collection_object_add(ViewLayer *view_layer, LayerCollection *lc, Object *ob)
|
||||
{
|
||||
Base *base = object_base_add(sl, ob);
|
||||
Base *base = object_base_add(view_layer, ob);
|
||||
|
||||
/* Only add an object once - prevent SceneCollection->objects and
|
||||
* SceneCollection->filter_objects to add the same object. */
|
||||
|
@ -922,36 +922,36 @@ static void layer_collection_object_add(ViewLayer *sl, LayerCollection *lc, Obje
|
|||
BLI_addtail(&lc->object_bases, BLI_genericNodeN(base));
|
||||
}
|
||||
|
||||
static void layer_collection_object_remove(ViewLayer *sl, LayerCollection *lc, Object *ob)
|
||||
static void layer_collection_object_remove(ViewLayer *view_layer, LayerCollection *lc, Object *ob)
|
||||
{
|
||||
Base *base;
|
||||
base = BKE_view_layer_base_find(sl, ob);
|
||||
base = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
LinkData *link = BLI_findptr(&lc->object_bases, base, offsetof(LinkData, data));
|
||||
BLI_remlink(&lc->object_bases, link);
|
||||
MEM_freeN(link);
|
||||
|
||||
view_layer_object_base_unref(sl, base);
|
||||
view_layer_object_base_unref(view_layer, base);
|
||||
}
|
||||
|
||||
static void layer_collection_objects_populate(ViewLayer *sl, LayerCollection *lc, ListBase *objects)
|
||||
static void layer_collection_objects_populate(ViewLayer *view_layer, LayerCollection *lc, ListBase *objects)
|
||||
{
|
||||
for (LinkData *link = objects->first; link; link = link->next) {
|
||||
layer_collection_object_add(sl, lc, link->data);
|
||||
layer_collection_object_add(view_layer, lc, link->data);
|
||||
}
|
||||
}
|
||||
|
||||
static void layer_collection_populate(ViewLayer *sl, LayerCollection *lc, SceneCollection *sc)
|
||||
static void layer_collection_populate(ViewLayer *view_layer, LayerCollection *lc, SceneCollection *sc)
|
||||
{
|
||||
layer_collection_objects_populate(sl, lc, &sc->objects);
|
||||
layer_collection_objects_populate(sl, lc, &sc->filter_objects);
|
||||
layer_collection_objects_populate(view_layer, lc, &sc->objects);
|
||||
layer_collection_objects_populate(view_layer, lc, &sc->filter_objects);
|
||||
|
||||
for (SceneCollection *nsc = sc->scene_collections.first; nsc; nsc = nsc->next) {
|
||||
layer_collection_add(sl, lc, nsc);
|
||||
layer_collection_add(view_layer, lc, nsc);
|
||||
}
|
||||
}
|
||||
|
||||
static LayerCollection *layer_collection_add(ViewLayer *sl, LayerCollection *parent, SceneCollection *sc)
|
||||
static LayerCollection *layer_collection_add(ViewLayer *view_layer, LayerCollection *parent, SceneCollection *sc)
|
||||
{
|
||||
IDPropertyTemplate val = {0};
|
||||
LayerCollection *lc = MEM_callocN(sizeof(LayerCollection), "Collection Base");
|
||||
|
@ -966,10 +966,10 @@ static LayerCollection *layer_collection_add(ViewLayer *sl, LayerCollection *par
|
|||
BLI_addtail(&parent->layer_collections, lc);
|
||||
}
|
||||
else {
|
||||
BLI_addtail(&sl->layer_collections, lc);
|
||||
BLI_addtail(&view_layer->layer_collections, lc);
|
||||
}
|
||||
|
||||
layer_collection_populate(sl, lc, sc);
|
||||
layer_collection_populate(view_layer, lc, sc);
|
||||
|
||||
return lc;
|
||||
}
|
||||
|
@ -979,9 +979,9 @@ static LayerCollection *layer_collection_add(ViewLayer *sl, LayerCollection *par
|
|||
/**
|
||||
* See if render layer has the scene collection linked directly, or indirectly (nested)
|
||||
*/
|
||||
bool BKE_view_layer_has_collection(ViewLayer *sl, const SceneCollection *sc)
|
||||
bool BKE_view_layer_has_collection(ViewLayer *view_layer, const SceneCollection *sc)
|
||||
{
|
||||
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
|
||||
for (LayerCollection *lc = view_layer->layer_collections.first; lc; lc = lc->next) {
|
||||
if (find_layer_collection_by_scene_collection(lc, sc) != NULL) {
|
||||
return true;
|
||||
}
|
||||
|
@ -994,8 +994,8 @@ bool BKE_view_layer_has_collection(ViewLayer *sl, const SceneCollection *sc)
|
|||
*/
|
||||
bool BKE_scene_has_object(Scene *scene, Object *ob)
|
||||
{
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
Base *base = BKE_view_layer_base_find(sl, ob);
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
Base *base = BKE_view_layer_base_find(view_layer, ob);
|
||||
if (base) {
|
||||
return true;
|
||||
}
|
||||
|
@ -1027,11 +1027,11 @@ static LayerCollection *find_layer_collection_by_scene_collection(LayerCollectio
|
|||
*/
|
||||
void BKE_layer_sync_new_scene_collection(Scene *scene, const SceneCollection *sc_parent, SceneCollection *sc)
|
||||
{
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (LayerCollection *lc = view_layer->layer_collections.first; lc; lc = lc->next) {
|
||||
LayerCollection *lc_parent = find_layer_collection_by_scene_collection(lc, sc_parent);
|
||||
if (lc_parent) {
|
||||
layer_collection_add(sl, lc_parent, sc);
|
||||
layer_collection_add(view_layer, lc_parent, sc);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1042,11 +1042,11 @@ void BKE_layer_sync_new_scene_collection(Scene *scene, const SceneCollection *sc
|
|||
*/
|
||||
void BKE_layer_sync_object_link(const Scene *scene, SceneCollection *sc, Object *ob)
|
||||
{
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (LayerCollection *lc = view_layer->layer_collections.first; lc; lc = lc->next) {
|
||||
LayerCollection *found = find_layer_collection_by_scene_collection(lc, sc);
|
||||
if (found) {
|
||||
layer_collection_object_add(sl, found, ob);
|
||||
layer_collection_object_add(view_layer, found, ob);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1058,11 +1058,11 @@ void BKE_layer_sync_object_link(const Scene *scene, SceneCollection *sc, Object
|
|||
*/
|
||||
void BKE_layer_sync_object_unlink(const Scene *scene, SceneCollection *sc, Object *ob)
|
||||
{
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (LayerCollection *lc = view_layer->layer_collections.first; lc; lc = lc->next) {
|
||||
LayerCollection *found = find_layer_collection_by_scene_collection(lc, sc);
|
||||
if (found) {
|
||||
layer_collection_object_remove(sl, found, ob);
|
||||
layer_collection_object_remove(view_layer, found, ob);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1152,8 +1152,8 @@ static void create_layer_collection_engines_settings_scene(Scene *scene, EngineS
|
|||
/* Populate the scene with the new settings. */
|
||||
create_layer_collection_engine_settings_scene(scene, es_type);
|
||||
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (LayerCollection *lc = view_layer->layer_collections.first; lc; lc = lc->next) {
|
||||
create_layer_collection_engine_settings_collection(lc, es_type);
|
||||
}
|
||||
}
|
||||
|
@ -1165,14 +1165,14 @@ static void create_view_layer_engines_settings_scene(Scene *scene, EngineSetting
|
|||
create_view_layer_engine_settings_scene(scene, es_type);
|
||||
}
|
||||
|
||||
static void create_view_layer_engines_settings_layer(ViewLayer *sl, EngineSettingsCB_Type *es_type)
|
||||
static void create_view_layer_engines_settings_layer(ViewLayer *view_layer, EngineSettingsCB_Type *es_type)
|
||||
{
|
||||
if (BKE_view_layer_engine_layer_get(sl, COLLECTION_MODE_NONE, es_type->name)) {
|
||||
if (BKE_view_layer_engine_layer_get(view_layer, COLLECTION_MODE_NONE, es_type->name)) {
|
||||
return;
|
||||
}
|
||||
|
||||
IDProperty *props = collection_engine_settings_create(es_type, false);
|
||||
IDP_AddToGroup(sl->properties, props);
|
||||
IDP_AddToGroup(view_layer->properties, props);
|
||||
}
|
||||
|
||||
static EngineSettingsCB_Type *engine_settings_callback_register(const char *engine_name, EngineSettingsCB func, ListBase *lb)
|
||||
|
@ -1220,8 +1220,8 @@ void BKE_view_layer_engine_settings_callback_register(
|
|||
for (Scene *scene = bmain->scene.first; scene; scene = scene->id.next) {
|
||||
create_view_layer_engines_settings_scene(scene, es_type);
|
||||
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
create_view_layer_engines_settings_layer(sl, es_type);
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
create_view_layer_engines_settings_layer(view_layer, es_type);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1440,17 +1440,17 @@ IDProperty *BKE_view_layer_engine_scene_get(Scene *scene, const int type, const
|
|||
/**
|
||||
* Return scene layer engine settings for specified engine
|
||||
*/
|
||||
IDProperty *BKE_view_layer_engine_layer_get(ViewLayer *sl, const int type, const char *engine_name)
|
||||
IDProperty *BKE_view_layer_engine_layer_get(ViewLayer *view_layer, const int type, const char *engine_name)
|
||||
{
|
||||
return collection_engine_get(sl->properties, type, engine_name);
|
||||
return collection_engine_get(view_layer->properties, type, engine_name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return scene layer evaluated engine settings for specified engine
|
||||
*/
|
||||
IDProperty *BKE_view_layer_engine_evaluated_get(ViewLayer *sl, const int type, const char *engine_name)
|
||||
IDProperty *BKE_view_layer_engine_evaluated_get(ViewLayer *view_layer, const int type, const char *engine_name)
|
||||
{
|
||||
return collection_engine_get(sl->properties_evaluated, type, engine_name);
|
||||
return collection_engine_get(view_layer->properties_evaluated, type, engine_name);
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
@ -1702,13 +1702,13 @@ void BKE_view_layer_engine_settings_validate_scene(Scene *scene)
|
|||
/**
|
||||
* Make sure Scene has all required collection settings.
|
||||
*/
|
||||
void BKE_view_layer_engine_settings_validate_layer(ViewLayer *sl)
|
||||
void BKE_view_layer_engine_settings_validate_layer(ViewLayer *view_layer)
|
||||
{
|
||||
if (root_reference.view_layer == NULL) {
|
||||
engine_settings_validate_init();
|
||||
}
|
||||
|
||||
IDP_MergeGroup(sl->properties, root_reference.view_layer, false);
|
||||
IDP_MergeGroup(view_layer->properties, root_reference.view_layer, false);
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
@ -1716,8 +1716,8 @@ void BKE_view_layer_engine_settings_validate_layer(ViewLayer *sl)
|
|||
|
||||
static void object_bases_iterator_begin(BLI_Iterator *iter, void *data_in, const int flag)
|
||||
{
|
||||
ViewLayer *sl = data_in;
|
||||
Base *base = sl->object_bases.first;
|
||||
ViewLayer *view_layer = data_in;
|
||||
Base *base = view_layer->object_bases.first;
|
||||
|
||||
/* when there are no objects */
|
||||
if (base == NULL) {
|
||||
|
@ -1834,8 +1834,8 @@ void BKE_renderable_objects_iterator_begin(BLI_Iterator *iter, void *data_in)
|
|||
ObjectsRenderableIteratorData *data = data_in;
|
||||
|
||||
for (Scene *scene = data->scene; scene; scene = scene->set) {
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
base->object->id.flag |= LIB_TAG_DOIT;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -372,8 +372,8 @@ Object *BKE_mball_basis_find(Scene *scene, Object *basis)
|
|||
|
||||
BLI_split_name_num(basisname, &basisnr, basis->id.name + 2, '.');
|
||||
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
Object *ob = base->object;
|
||||
if ((ob->type == OB_MBALL) && !(base->flag & OB_FROMDUPLI)) {
|
||||
if (ob != bob) {
|
||||
|
|
|
@ -864,9 +864,9 @@ static LodLevel *lod_level_select(Object *ob, const float camera_position[3])
|
|||
return current;
|
||||
}
|
||||
|
||||
bool BKE_object_lod_is_usable(Object *ob, ViewLayer *sl)
|
||||
bool BKE_object_lod_is_usable(Object *ob, ViewLayer *view_layer)
|
||||
{
|
||||
bool active = (sl) ? ob == OBACT(sl) : false;
|
||||
bool active = (view_layer) ? ob == OBACT(view_layer) : false;
|
||||
return (ob->mode == OB_MODE_OBJECT || !active);
|
||||
}
|
||||
|
||||
|
@ -880,11 +880,11 @@ void BKE_object_lod_update(Object *ob, const float camera_position[3])
|
|||
}
|
||||
}
|
||||
|
||||
static Object *lod_ob_get(Object *ob, ViewLayer *sl, int flag)
|
||||
static Object *lod_ob_get(Object *ob, ViewLayer *view_layer, int flag)
|
||||
{
|
||||
LodLevel *current = ob->currentlod;
|
||||
|
||||
if (!current || !BKE_object_lod_is_usable(ob, sl))
|
||||
if (!current || !BKE_object_lod_is_usable(ob, view_layer))
|
||||
return ob;
|
||||
|
||||
while (current->prev && (!(current->flags & flag) || !current->source || current->source->type != OB_MESH)) {
|
||||
|
@ -894,14 +894,14 @@ static Object *lod_ob_get(Object *ob, ViewLayer *sl, int flag)
|
|||
return current->source;
|
||||
}
|
||||
|
||||
struct Object *BKE_object_lod_meshob_get(Object *ob, ViewLayer *sl)
|
||||
struct Object *BKE_object_lod_meshob_get(Object *ob, ViewLayer *view_layer)
|
||||
{
|
||||
return lod_ob_get(ob, sl, OB_LOD_USE_MESH);
|
||||
return lod_ob_get(ob, view_layer, OB_LOD_USE_MESH);
|
||||
}
|
||||
|
||||
struct Object *BKE_object_lod_matob_get(Object *ob, ViewLayer *sl)
|
||||
struct Object *BKE_object_lod_matob_get(Object *ob, ViewLayer *view_layer)
|
||||
{
|
||||
return lod_ob_get(ob, sl, OB_LOD_USE_MAT);
|
||||
return lod_ob_get(ob, view_layer, OB_LOD_USE_MAT);
|
||||
}
|
||||
|
||||
#endif /* WITH_GAMEENGINE */
|
||||
|
@ -2566,13 +2566,13 @@ void BKE_object_foreach_display_point(
|
|||
}
|
||||
|
||||
void BKE_scene_foreach_display_point(
|
||||
Scene *scene, ViewLayer *sl,
|
||||
Scene *scene, ViewLayer *view_layer,
|
||||
void (*func_cb)(const float[3], void *), void *user_data)
|
||||
{
|
||||
Base *base;
|
||||
Object *ob;
|
||||
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if (((base->flag & BASE_VISIBLED) != 0) && ((base->flag & BASE_SELECTED) != 0)) {
|
||||
ob = base->object;
|
||||
|
||||
|
|
|
@ -75,9 +75,9 @@ const char PAINT_CURSOR_TEXTURE_PAINT[3] = {255, 255, 255};
|
|||
|
||||
static eOverlayControlFlags overlay_flags = 0;
|
||||
|
||||
void BKE_paint_invalidate_overlay_tex(Scene *scene, ViewLayer *sl, const Tex *tex)
|
||||
void BKE_paint_invalidate_overlay_tex(Scene *scene, ViewLayer *view_layer, const Tex *tex)
|
||||
{
|
||||
Paint *p = BKE_paint_get_active(scene, sl);
|
||||
Paint *p = BKE_paint_get_active(scene, view_layer);
|
||||
Brush *br = p->brush;
|
||||
|
||||
if (!br)
|
||||
|
@ -89,9 +89,9 @@ void BKE_paint_invalidate_overlay_tex(Scene *scene, ViewLayer *sl, const Tex *te
|
|||
overlay_flags |= PAINT_INVALID_OVERLAY_TEXTURE_SECONDARY;
|
||||
}
|
||||
|
||||
void BKE_paint_invalidate_cursor_overlay(Scene *scene, ViewLayer *sl, CurveMapping *curve)
|
||||
void BKE_paint_invalidate_cursor_overlay(Scene *scene, ViewLayer *view_layer, CurveMapping *curve)
|
||||
{
|
||||
Paint *p = BKE_paint_get_active(scene, sl);
|
||||
Paint *p = BKE_paint_get_active(scene, view_layer);
|
||||
Brush *br = p->brush;
|
||||
|
||||
if (br && br->curve == curve)
|
||||
|
@ -157,13 +157,13 @@ Paint *BKE_paint_get_active_from_paintmode(Scene *sce, ePaintMode mode)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
Paint *BKE_paint_get_active(Scene *sce, ViewLayer *sl)
|
||||
Paint *BKE_paint_get_active(Scene *sce, ViewLayer *view_layer)
|
||||
{
|
||||
if (sce && sl) {
|
||||
if (sce && view_layer) {
|
||||
ToolSettings *ts = sce->toolsettings;
|
||||
|
||||
if (sl->basact && sl->basact->object) {
|
||||
switch (sl->basact->object->mode) {
|
||||
if (view_layer->basact && view_layer->basact->object) {
|
||||
switch (view_layer->basact->object->mode) {
|
||||
case OB_MODE_SCULPT:
|
||||
return &ts->sculpt->paint;
|
||||
case OB_MODE_VERTEX_PAINT:
|
||||
|
@ -189,15 +189,15 @@ Paint *BKE_paint_get_active(Scene *sce, ViewLayer *sl)
|
|||
Paint *BKE_paint_get_active_from_context(const bContext *C)
|
||||
{
|
||||
Scene *sce = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
SpaceImage *sima;
|
||||
|
||||
if (sce && sl) {
|
||||
if (sce && view_layer) {
|
||||
ToolSettings *ts = sce->toolsettings;
|
||||
Object *obact = NULL;
|
||||
|
||||
if (sl->basact && sl->basact->object)
|
||||
obact = sl->basact->object;
|
||||
if (view_layer->basact && view_layer->basact->object)
|
||||
obact = view_layer->basact->object;
|
||||
|
||||
if ((sima = CTX_wm_space_image(C)) != NULL) {
|
||||
if (obact && obact->mode == OB_MODE_EDIT) {
|
||||
|
@ -240,15 +240,15 @@ Paint *BKE_paint_get_active_from_context(const bContext *C)
|
|||
ePaintMode BKE_paintmode_get_active_from_context(const bContext *C)
|
||||
{
|
||||
Scene *sce = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
SpaceImage *sima;
|
||||
|
||||
if (sce && sl) {
|
||||
if (sce && view_layer) {
|
||||
ToolSettings *ts = sce->toolsettings;
|
||||
Object *obact = NULL;
|
||||
|
||||
if (sl->basact && sl->basact->object)
|
||||
obact = sl->basact->object;
|
||||
if (view_layer->basact && view_layer->basact->object)
|
||||
obact = view_layer->basact->object;
|
||||
|
||||
if ((sima = CTX_wm_space_image(C)) != NULL) {
|
||||
if (obact && obact->mode == OB_MODE_EDIT) {
|
||||
|
|
|
@ -213,14 +213,14 @@ static void layer_collections_sync_flags(ListBase *layer_collections_dst, const
|
|||
|
||||
/* recreate the LayerCollection tree */
|
||||
static void layer_collections_recreate(
|
||||
ViewLayer *sl_dst, ListBase *lb_src, SceneCollection *mc_dst, SceneCollection *mc_src)
|
||||
ViewLayer *view_layer_dst, ListBase *lb_src, SceneCollection *mc_dst, SceneCollection *mc_src)
|
||||
{
|
||||
for (LayerCollection *lc_src = lb_src->first; lc_src; lc_src = lc_src->next) {
|
||||
SceneCollection *sc_dst = scene_collection_from_new_tree(lc_src->scene_collection, mc_dst, mc_src);
|
||||
BLI_assert(sc_dst);
|
||||
|
||||
/* instead of synchronizing both trees we simply re-create it */
|
||||
BKE_collection_link(sl_dst, sc_dst);
|
||||
BKE_collection_link(view_layer_dst, sc_dst);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -641,11 +641,11 @@ void BKE_scene_free_ex(Scene *sce, const bool do_id_user)
|
|||
BKE_previewimg_free(&sce->preview);
|
||||
curvemapping_free_data(&sce->r.mblur_shutter_curve);
|
||||
|
||||
for (ViewLayer *sl = sce->view_layers.first, *sl_next; sl; sl = sl_next) {
|
||||
sl_next = sl->next;
|
||||
for (ViewLayer *view_layer = sce->view_layers.first, *view_layer_next; view_layer; view_layer = view_layer_next) {
|
||||
view_layer_next = view_layer->next;
|
||||
|
||||
BLI_remlink(&sce->view_layers, sl);
|
||||
BKE_view_layer_free(sl);
|
||||
BLI_remlink(&sce->view_layers, view_layer);
|
||||
BKE_view_layer_free(view_layer);
|
||||
}
|
||||
|
||||
/* Master Collection */
|
||||
|
|
|
@ -695,16 +695,16 @@ void smokeModifier_copy(struct SmokeModifierData *smd, struct SmokeModifierData
|
|||
#ifdef WITH_SMOKE
|
||||
|
||||
// forward decleration
|
||||
static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *sl);
|
||||
static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *view_layer);
|
||||
static float calc_voxel_transp(float *result, float *input, int res[3], int *pixel, float *tRay, float correct);
|
||||
|
||||
static int get_lamp(ViewLayer *sl, float *light)
|
||||
static int get_lamp(ViewLayer *view_layer, float *light)
|
||||
{
|
||||
Base *base_tmp = NULL;
|
||||
int found_lamp = 0;
|
||||
|
||||
// try to find a lamp, preferably local
|
||||
for (base_tmp = FIRSTBASE(sl); base_tmp; base_tmp = base_tmp->next) {
|
||||
for (base_tmp = FIRSTBASE(view_layer); base_tmp; base_tmp = base_tmp->next) {
|
||||
if (base_tmp->object->type == OB_LAMP) {
|
||||
Lamp *la = base_tmp->object->data;
|
||||
|
||||
|
@ -2950,7 +2950,7 @@ static void bresenham_linie_3D(int x1, int y1, int z1, int x2, int y2, int z2, f
|
|||
cb(result, input, res, pixel, tRay, correct);
|
||||
}
|
||||
|
||||
static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *sl)
|
||||
static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *view_layer)
|
||||
{
|
||||
float bv[6] = {0};
|
||||
float light[3];
|
||||
|
@ -2958,7 +2958,7 @@ static void smoke_calc_transparency(SmokeDomainSettings *sds, ViewLayer *sl)
|
|||
float *density = smoke_get_density(sds->fluid);
|
||||
float correct = -7.0f * sds->dx;
|
||||
|
||||
if (!get_lamp(sl, light)) return;
|
||||
if (!get_lamp(view_layer, light)) return;
|
||||
|
||||
/* convert light pos to sim cell space */
|
||||
mul_m4_v3(sds->imat, light);
|
||||
|
|
|
@ -514,7 +514,7 @@ static void ccd_build_deflector_hash_single(GHash *hash, Object *ob)
|
|||
/**
|
||||
* \note group overrides scene when not NULL.
|
||||
*/
|
||||
static void ccd_build_deflector_hash(ViewLayer *sl, Group *group, Object *vertexowner, GHash *hash)
|
||||
static void ccd_build_deflector_hash(ViewLayer *view_layer, Group *group, Object *vertexowner, GHash *hash)
|
||||
{
|
||||
Object *ob;
|
||||
|
||||
|
@ -532,7 +532,7 @@ static void ccd_build_deflector_hash(ViewLayer *sl, Group *group, Object *vertex
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (Base *base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (Base *base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
/*Only proceed for mesh object in same layer */
|
||||
if (base->object->type == OB_MESH) {
|
||||
ob = base->object;
|
||||
|
@ -560,7 +560,7 @@ static void ccd_update_deflector_hash_single(GHash *hash, Object *ob)
|
|||
/**
|
||||
* \note group overrides scene when not NULL.
|
||||
*/
|
||||
static void ccd_update_deflector_hash(ViewLayer *sl, Group *group, Object *vertexowner, GHash *hash)
|
||||
static void ccd_update_deflector_hash(ViewLayer *view_layer, Group *group, Object *vertexowner, GHash *hash)
|
||||
{
|
||||
Object *ob;
|
||||
|
||||
|
@ -578,7 +578,7 @@ static void ccd_update_deflector_hash(ViewLayer *sl, Group *group, Object *verte
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (Base *base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (Base *base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
/*Only proceed for mesh object in same layer */
|
||||
if (base->object->type == OB_MESH) {
|
||||
ob = base->object;
|
||||
|
@ -979,7 +979,7 @@ static void free_softbody_intern(SoftBody *sb)
|
|||
/**
|
||||
* \note group overrides scene when not NULL.
|
||||
*/
|
||||
static bool are_there_deflectors(ViewLayer *sl, Group *group)
|
||||
static bool are_there_deflectors(ViewLayer *view_layer, Group *group)
|
||||
{
|
||||
if (group) {
|
||||
for (GroupObject *go = group->gobject.first; go; go = go->next) {
|
||||
|
@ -988,7 +988,7 @@ static bool are_there_deflectors(ViewLayer *sl, Group *group)
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (Base *base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (Base *base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if (base->object->pd) {
|
||||
if (base->object->pd->deflect)
|
||||
return 1;
|
||||
|
@ -999,9 +999,9 @@ static bool are_there_deflectors(ViewLayer *sl, Group *group)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int query_external_colliders(ViewLayer *sl, Group *group)
|
||||
static int query_external_colliders(ViewLayer *view_layer, Group *group)
|
||||
{
|
||||
return(are_there_deflectors(sl, group));
|
||||
return(are_there_deflectors(view_layer, group));
|
||||
}
|
||||
/* --- dependency information functions*/
|
||||
|
||||
|
|
|
@ -132,11 +132,11 @@ static void animedit_get_yscale_factor(bAnimContext *ac)
|
|||
/* Note: there's a similar function in key.c (BKE_key_from_object) */
|
||||
static Key *actedit_get_shapekeys(bAnimContext *ac)
|
||||
{
|
||||
ViewLayer *sl = ac->view_layer;
|
||||
ViewLayer *view_layer = ac->view_layer;
|
||||
Object *ob;
|
||||
Key *key;
|
||||
|
||||
ob = OBACT(sl);
|
||||
ob = OBACT(view_layer);
|
||||
if (ob == NULL)
|
||||
return NULL;
|
||||
|
||||
|
@ -1686,7 +1686,7 @@ static size_t animdata_filter_gpencil(bAnimContext *ac, ListBase *anim_data, voi
|
|||
|
||||
if (ads->filterflag & ADS_FILTER_GP_3DONLY) {
|
||||
Scene *scene = (Scene *)ads->source;
|
||||
ViewLayer *sl = (ViewLayer *)ac->view_layer;
|
||||
ViewLayer *view_layer = (ViewLayer *)ac->view_layer;
|
||||
Base *base;
|
||||
|
||||
/* Active scene's GPencil block first - No parent item needed... */
|
||||
|
@ -1695,7 +1695,7 @@ static size_t animdata_filter_gpencil(bAnimContext *ac, ListBase *anim_data, voi
|
|||
}
|
||||
|
||||
/* Objects in the scene */
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
/* Only consider this object if it has got some GP data (saving on all the other tests) */
|
||||
if (base->object && base->object->gpd) {
|
||||
Object *ob = base->object;
|
||||
|
@ -2941,14 +2941,14 @@ static int ds_base_sorting_cmp(const void *base1_ptr, const void *base2_ptr)
|
|||
}
|
||||
|
||||
/* Get a sorted list of all the bases - for inclusion in dopesheet (when drawing channels) */
|
||||
static Base **animdata_filter_ds_sorted_bases(bDopeSheet *ads, ViewLayer *sl, int filter_mode, size_t *r_usable_bases)
|
||||
static Base **animdata_filter_ds_sorted_bases(bDopeSheet *ads, ViewLayer *view_layer, int filter_mode, size_t *r_usable_bases)
|
||||
{
|
||||
/* Create an array with space for all the bases, but only containing the usable ones */
|
||||
size_t tot_bases = BLI_listbase_count(&sl->object_bases);
|
||||
size_t tot_bases = BLI_listbase_count(&view_layer->object_bases);
|
||||
size_t num_bases = 0;
|
||||
|
||||
Base **sorted_bases = MEM_mallocN(sizeof(Base *) * tot_bases, "Dopesheet Usable Sorted Bases");
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (animdata_filter_base_is_ok(ads, base, filter_mode)) {
|
||||
sorted_bases[num_bases++] = base;
|
||||
}
|
||||
|
@ -2967,7 +2967,7 @@ static Base **animdata_filter_ds_sorted_bases(bDopeSheet *ads, ViewLayer *sl, in
|
|||
static size_t animdata_filter_dopesheet(bAnimContext *ac, ListBase *anim_data, bDopeSheet *ads, int filter_mode)
|
||||
{
|
||||
Scene *scene = (Scene *)ads->source;
|
||||
ViewLayer *sl = (ViewLayer *)ac->view_layer;
|
||||
ViewLayer *view_layer = (ViewLayer *)ac->view_layer;
|
||||
size_t items = 0;
|
||||
|
||||
/* check that we do indeed have a scene */
|
||||
|
@ -3006,14 +3006,14 @@ static size_t animdata_filter_dopesheet(bAnimContext *ac, ListBase *anim_data, b
|
|||
* - Don't do this if there's just a single object
|
||||
*/
|
||||
if ((filter_mode & ANIMFILTER_LIST_CHANNELS) && !(ads->flag & ADS_FLAG_NO_DB_SORT) &&
|
||||
(sl->object_bases.first != sl->object_bases.last))
|
||||
(view_layer->object_bases.first != view_layer->object_bases.last))
|
||||
{
|
||||
/* Filter list of bases (i.e. objects), sort them, then add their contents normally... */
|
||||
// TODO: Cache the old sorted order - if the set of bases hasn't changed, don't re-sort...
|
||||
Base **sorted_bases;
|
||||
size_t num_bases;
|
||||
|
||||
sorted_bases = animdata_filter_ds_sorted_bases(ads, sl, filter_mode, &num_bases);
|
||||
sorted_bases = animdata_filter_ds_sorted_bases(ads, view_layer, filter_mode, &num_bases);
|
||||
if (sorted_bases) {
|
||||
/* Add the necessary channels for these bases... */
|
||||
for (size_t i = 0; i < num_bases; i++) {
|
||||
|
@ -3030,7 +3030,7 @@ static size_t animdata_filter_dopesheet(bAnimContext *ac, ListBase *anim_data, b
|
|||
/* Filter and add contents of each base (i.e. object) without them sorting first
|
||||
* NOTE: This saves performance in cases where order doesn't matter
|
||||
*/
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (animdata_filter_base_is_ok(ads, base, filter_mode)) {
|
||||
/* since we're still here, this object should be usable */
|
||||
items += animdata_filter_dopesheet_ob(ac, anim_data, ads, base, filter_mode);
|
||||
|
|
|
@ -582,7 +582,7 @@ static int separate_armature_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
Object *oldob, *newob;
|
||||
Base *oldbase, *newbase;
|
||||
|
@ -617,7 +617,7 @@ static int separate_armature_exec(bContext *C, wmOperator *op)
|
|||
|
||||
/* 1) store starting settings and exit editmode */
|
||||
oldob = obedit;
|
||||
oldbase = sl->basact;
|
||||
oldbase = view_layer->basact;
|
||||
oldob->mode &= ~OB_MODE_POSE;
|
||||
//oldbase->flag &= ~OB_POSEMODE;
|
||||
|
||||
|
@ -625,7 +625,7 @@ static int separate_armature_exec(bContext *C, wmOperator *op)
|
|||
ED_armature_edit_free(obedit->data);
|
||||
|
||||
/* 2) duplicate base */
|
||||
newbase = ED_object_add_duplicate(bmain, scene, sl, oldbase, USER_DUP_ARM); /* only duplicate linked armature */
|
||||
newbase = ED_object_add_duplicate(bmain, scene, view_layer, oldbase, USER_DUP_ARM); /* only duplicate linked armature */
|
||||
DEG_relations_tag_update(bmain);
|
||||
|
||||
newob = newbase->object;
|
||||
|
|
|
@ -147,7 +147,7 @@ static RigGraph *TEMPLATE_RIGG = NULL;
|
|||
void BIF_makeListTemplates(const bContext *C)
|
||||
{
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ToolSettings *ts = CTX_data_tool_settings(C);
|
||||
int index = 0;
|
||||
|
||||
|
@ -158,7 +158,7 @@ void BIF_makeListTemplates(const bContext *C)
|
|||
TEMPLATES_HASH = BLI_ghash_int_new("makeListTemplates gh");
|
||||
TEMPLATES_CURRENT = 0;
|
||||
|
||||
FOREACH_OBJECT(sl, ob)
|
||||
FOREACH_OBJECT(view_layer, ob)
|
||||
{
|
||||
if (ob != obedit && ob->type == OB_ARMATURE) {
|
||||
index++;
|
||||
|
|
|
@ -134,7 +134,7 @@ void ED_pose_bone_select(Object *ob, bPoseChannel *pchan, bool select)
|
|||
/* called from editview.c, for mode-less pose selection */
|
||||
/* assumes scene obact and basact is still on old situation */
|
||||
bool ED_do_pose_selectbuffer(
|
||||
Scene *scene, ViewLayer *sl, Base *base, const unsigned int *buffer, short hits,
|
||||
Scene *scene, ViewLayer *view_layer, Base *base, const unsigned int *buffer, short hits,
|
||||
bool extend, bool deselect, bool toggle, bool do_nearest)
|
||||
{
|
||||
Object *ob = base->object;
|
||||
|
@ -146,7 +146,7 @@ bool ED_do_pose_selectbuffer(
|
|||
|
||||
/* if the bone cannot be affected, don't do anything */
|
||||
if ((nearBone) && !(nearBone->flag & BONE_UNSELECTABLE)) {
|
||||
Object *ob_act = OBACT(sl);
|
||||
Object *ob_act = OBACT(view_layer);
|
||||
bArmature *arm = ob->data;
|
||||
|
||||
/* since we do unified select, we don't shift+select a bone if the
|
||||
|
|
|
@ -1288,7 +1288,7 @@ static int separate_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *oldob, *newob;
|
||||
Base *oldbase, *newbase;
|
||||
Curve *oldcu, *newcu;
|
||||
|
@ -1316,7 +1316,7 @@ static int separate_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
|
||||
/* 2. duplicate the object and data */
|
||||
newbase = ED_object_add_duplicate(bmain, scene, sl, oldbase, 0); /* 0 = fully linked */
|
||||
newbase = ED_object_add_duplicate(bmain, scene, view_layer, oldbase, 0); /* 0 = fully linked */
|
||||
DEG_relations_tag_update(bmain);
|
||||
|
||||
newob = newbase->object;
|
||||
|
|
|
@ -423,7 +423,7 @@ static void txt_add_object(bContext *C, TextLine *firstline, int totline, const
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
EvaluationContext eval_ctx;
|
||||
Curve *cu;
|
||||
Object *obedit;
|
||||
|
@ -436,8 +436,8 @@ static void txt_add_object(bContext *C, TextLine *firstline, int totline, const
|
|||
|
||||
CTX_data_eval_ctx(C, &eval_ctx);
|
||||
|
||||
obedit = BKE_object_add(bmain, scene, sl, OB_FONT, NULL);
|
||||
base = sl->basact;
|
||||
obedit = BKE_object_add(bmain, scene, view_layer, OB_FONT, NULL);
|
||||
base = view_layer->basact;
|
||||
|
||||
/* seems to assume view align ? TODO - look into this, could be an operator option */
|
||||
ED_object_base_init_transform(C, base, NULL, rot);
|
||||
|
|
|
@ -1125,7 +1125,7 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
|
|||
{
|
||||
struct Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
SceneCollection *sc = CTX_data_scene_collection(C);
|
||||
bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, CFRA, 0);
|
||||
bGPDstroke *gps, *prev_gps = NULL;
|
||||
|
@ -1157,7 +1157,7 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
|
|||
ob = BKE_object_add_only_object(bmain, OB_CURVE, gpl->info);
|
||||
cu = ob->data = BKE_curve_add(bmain, gpl->info, OB_CURVE);
|
||||
BKE_collection_object_add(scene, sc, ob);
|
||||
base_new = BKE_view_layer_base_find(sl, ob);
|
||||
base_new = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
cu->flag |= CU_3D;
|
||||
|
||||
|
|
|
@ -143,7 +143,7 @@ void ED_armature_deselect_all(struct Object *obedit);
|
|||
void ED_armature_deselect_all_visible(struct Object *obedit);
|
||||
|
||||
bool ED_do_pose_selectbuffer(
|
||||
struct Scene *scene, struct ViewLayer *sl, struct Base *base, const unsigned int *buffer, short hits,
|
||||
struct Scene *scene, struct ViewLayer *view_layer, struct Base *base, const unsigned int *buffer, short hits,
|
||||
bool extend, bool deselect, bool toggle, bool do_nearest);
|
||||
bool ED_armature_select_pick(struct bContext *C, const int mval[2], bool extend, bool deselect, bool toggle);
|
||||
int join_armature_exec(struct bContext *C, struct wmOperator *op);
|
||||
|
|
|
@ -75,7 +75,7 @@ bool ED_space_image_show_uvedit(struct SpaceImage *sima, struct Object *obedit);
|
|||
|
||||
bool ED_space_image_paint_curve(const struct bContext *C);
|
||||
|
||||
bool ED_space_image_check_show_maskedit(struct ViewLayer *sl, struct SpaceImage *sima);
|
||||
bool ED_space_image_check_show_maskedit(struct ViewLayer *view_layer, struct SpaceImage *sima);
|
||||
int ED_space_image_maskedit_poll(struct bContext *C);
|
||||
int ED_space_image_maskedit_mask_poll(struct bContext *C);
|
||||
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
#define __ED_INFO_H__
|
||||
|
||||
/* info_stats.c */
|
||||
void ED_info_stats_clear(struct ViewLayer *sl);
|
||||
const char *ED_info_stats_string(struct Scene *scene, struct ViewLayer *sl);
|
||||
void ED_info_stats_clear(struct ViewLayer *view_layer);
|
||||
const char *ED_info_stats_string(struct Scene *scene, struct ViewLayer *view_layer);
|
||||
|
||||
#endif /* __ED_INFO_H__ */
|
||||
|
|
|
@ -109,7 +109,7 @@ void ED_object_base_activate(struct bContext *C, struct Base *base);
|
|||
void ED_object_base_free_and_unlink(struct Main *bmain, struct Scene *scene, struct Object *ob);
|
||||
|
||||
/* single object duplicate, if (dupflag == 0), fully linked, else it uses the flags given */
|
||||
struct Base *ED_object_add_duplicate(struct Main *bmain, struct Scene *scene, struct ViewLayer *sl, struct Base *base, int dupflag);
|
||||
struct Base *ED_object_add_duplicate(struct Main *bmain, struct Scene *scene, struct ViewLayer *view_layer, struct Base *base, int dupflag);
|
||||
|
||||
void ED_object_parent(struct Object *ob, struct Object *parent, const int type, const char *substr);
|
||||
|
||||
|
@ -195,7 +195,7 @@ void ED_object_modifier_clear(struct Main *bmain, struct Object *ob);
|
|||
int ED_object_modifier_move_down(struct ReportList *reports, struct Object *ob, struct ModifierData *md);
|
||||
int ED_object_modifier_move_up(struct ReportList *reports, struct Object *ob, struct ModifierData *md);
|
||||
int ED_object_modifier_convert(struct ReportList *reports, struct Main *bmain, struct Scene *scene,
|
||||
struct ViewLayer *sl, struct Object *ob, struct ModifierData *md);
|
||||
struct ViewLayer *view_layer, struct Object *ob, struct ModifierData *md);
|
||||
int ED_object_modifier_apply(struct ReportList *reports, const struct bContext *C, struct Scene *scene,
|
||||
struct Object *ob, struct ModifierData *md, int mode);
|
||||
int ED_object_modifier_copy(struct ReportList *reports, struct Object *ob, struct ModifierData *md);
|
||||
|
|
|
@ -45,17 +45,17 @@ void PE_free_ptcache_edit(struct PTCacheEdit *edit);
|
|||
int PE_start_edit(struct PTCacheEdit *edit);
|
||||
|
||||
/* access */
|
||||
struct PTCacheEdit *PE_get_current(struct Scene *scene, struct ViewLayer *sl, struct Object *ob);
|
||||
struct PTCacheEdit *PE_get_current(struct Scene *scene, struct ViewLayer *view_layer, struct Object *ob);
|
||||
struct PTCacheEdit *PE_create_current(const struct EvaluationContext *eval_ctx, struct Scene *scene, struct Object *ob);
|
||||
void PE_current_changed(const struct EvaluationContext *eval_ctx, struct Scene *scene, struct Object *ob);
|
||||
int PE_minmax(struct Scene *scene, struct ViewLayer *sl, float min[3], float max[3]);
|
||||
int PE_minmax(struct Scene *scene, struct ViewLayer *view_layer, float min[3], float max[3]);
|
||||
struct ParticleEditSettings *PE_settings(struct Scene *scene);
|
||||
|
||||
/* update calls */
|
||||
void PE_hide_keys_time(struct Scene *scene, struct PTCacheEdit *edit, float cfra);
|
||||
void PE_update_object(
|
||||
const struct EvaluationContext *eval_ctx, struct Scene *scene,
|
||||
struct ViewLayer *sl, struct Object *ob, int useflag);
|
||||
struct ViewLayer *view_layer, struct Object *ob, int useflag);
|
||||
|
||||
/* selection tools */
|
||||
int PE_mouse_particles(struct bContext *C, const int mval[2], bool extend, bool deselect, bool toggle);
|
||||
|
@ -65,13 +65,13 @@ int PE_lasso_select(struct bContext *C, const int mcords[][2], const short moves
|
|||
void PE_deselect_all_visible(struct PTCacheEdit *edit);
|
||||
|
||||
/* undo */
|
||||
void PE_undo_push(struct Scene *scene, struct ViewLayer *sl, const char *str);
|
||||
void PE_undo_step(struct Scene *scene, struct ViewLayer *sl, int step);
|
||||
void PE_undo(struct Scene *scene, struct ViewLayer *sl);
|
||||
void PE_redo(struct Scene *scene, struct ViewLayer *sl);
|
||||
bool PE_undo_is_valid(struct Scene *scene, struct ViewLayer *sl);
|
||||
void PE_undo_number(struct Scene *scene, struct ViewLayer *sl, int nr);
|
||||
const char *PE_undo_get_name(struct Scene *scene, struct ViewLayer *sl, int nr, bool *r_active);
|
||||
void PE_undo_push(struct Scene *scene, struct ViewLayer *view_layer, const char *str);
|
||||
void PE_undo_step(struct Scene *scene, struct ViewLayer *view_layer, int step);
|
||||
void PE_undo(struct Scene *scene, struct ViewLayer *view_layer);
|
||||
void PE_redo(struct Scene *scene, struct ViewLayer *view_layer);
|
||||
bool PE_undo_is_valid(struct Scene *scene, struct ViewLayer *view_layer);
|
||||
void PE_undo_number(struct Scene *scene, struct ViewLayer *view_layer, int nr);
|
||||
const char *PE_undo_get_name(struct Scene *scene, struct ViewLayer *view_layer, int nr, bool *r_active);
|
||||
|
||||
#endif /* __ED_PARTICLE_H__ */
|
||||
|
||||
|
|
|
@ -76,9 +76,9 @@ struct SnapObjectParams {
|
|||
|
||||
typedef struct SnapObjectContext SnapObjectContext;
|
||||
SnapObjectContext *ED_transform_snap_object_context_create(
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *sl, struct RenderEngineType *engine, int flag);
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *view_layer, struct RenderEngineType *engine, int flag);
|
||||
SnapObjectContext *ED_transform_snap_object_context_create_view3d(
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *sl, struct RenderEngineType *engine, int flag,
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *view_layer, struct RenderEngineType *engine, int flag,
|
||||
/* extra args for view3d */
|
||||
const struct ARegion *ar, const struct View3D *v3d);
|
||||
void ED_transform_snap_object_context_destroy(SnapObjectContext *sctx);
|
||||
|
|
|
@ -112,7 +112,7 @@ void ED_unwrap_lscm(struct Scene *scene, struct Object *obedit, const short sel)
|
|||
|
||||
/* uvedit_draw.c */
|
||||
void ED_image_draw_cursor(struct ARegion *ar, const float cursor[2]);
|
||||
void ED_uvedit_draw_main(struct SpaceImage *sima, struct ARegion *ar, struct Scene *scene, struct ViewLayer *sl, struct Object *obedit, struct Object *obact, struct Depsgraph *depsgraph);
|
||||
void ED_uvedit_draw_main(struct SpaceImage *sima, struct ARegion *ar, struct Scene *scene, struct ViewLayer *view_layer, struct Object *obedit, struct Object *obact, struct Depsgraph *depsgraph);
|
||||
|
||||
/* uvedit_buttons.c */
|
||||
void ED_uvedit_buttons_register(struct ARegionType *art);
|
||||
|
|
|
@ -374,7 +374,7 @@ void ED_draw_object_facemap(const struct EvaluationContext *eval_ctx, struct Sc
|
|||
bool ED_view3d_context_activate(struct bContext *C);
|
||||
void ED_view3d_draw_offscreen_init(
|
||||
const struct EvaluationContext *eval_ctx, struct Scene *scene,
|
||||
struct ViewLayer *sl, struct View3D *v3d);
|
||||
struct ViewLayer *view_layer, struct View3D *v3d);
|
||||
void ED_view3d_draw_offscreen(
|
||||
const struct EvaluationContext *eval_ctx, struct Scene *scene,
|
||||
struct ViewLayer *view_layer, struct View3D *v3d, struct ARegion *ar, int winx, int winy, float viewmat[4][4],
|
||||
|
|
|
@ -5215,8 +5215,8 @@ static int ui_do_but_COLOR(
|
|||
if (!event->ctrl) {
|
||||
float color[3];
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Paint *paint = BKE_paint_get_active(scene, sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Paint *paint = BKE_paint_get_active(scene, view_layer);
|
||||
Brush *brush = BKE_paint_brush(paint);
|
||||
|
||||
if (brush->flag & BRUSH_USE_GRADIENT) {
|
||||
|
@ -6124,7 +6124,7 @@ static int ui_do_but_CURVE(
|
|||
int mx, my, a;
|
||||
bool changed = false;
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
|
||||
mx = event->x;
|
||||
my = event->y;
|
||||
|
@ -6253,7 +6253,7 @@ static int ui_do_but_CURVE(
|
|||
}
|
||||
else {
|
||||
curvemapping_changed(cumap, true); /* remove doubles */
|
||||
BKE_paint_invalidate_cursor_overlay(scene, sl, cumap);
|
||||
BKE_paint_invalidate_cursor_overlay(scene, view_layer, cumap);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -3030,7 +3030,7 @@ enum {
|
|||
MESH_SEPARATE_LOOSE = 2,
|
||||
};
|
||||
|
||||
static Base *mesh_separate_tagged(Main *bmain, Scene *scene, ViewLayer *sl, Base *base_old, BMesh *bm_old)
|
||||
static Base *mesh_separate_tagged(Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base_old, BMesh *bm_old)
|
||||
{
|
||||
Base *base_new;
|
||||
Object *obedit = base_old->object;
|
||||
|
@ -3051,7 +3051,7 @@ static Base *mesh_separate_tagged(Main *bmain, Scene *scene, ViewLayer *sl, Base
|
|||
CustomData_bmesh_init_pool(&bm_new->ldata, bm_mesh_allocsize_default.totloop, BM_LOOP);
|
||||
CustomData_bmesh_init_pool(&bm_new->pdata, bm_mesh_allocsize_default.totface, BM_FACE);
|
||||
|
||||
base_new = ED_object_add_duplicate(bmain, scene, sl, base_old, USER_DUP_MESH);
|
||||
base_new = ED_object_add_duplicate(bmain, scene, view_layer, base_old, USER_DUP_MESH);
|
||||
/* DAG_relations_tag_update(bmain); */ /* normally would call directly after but in this case delay recalc */
|
||||
assign_matarar(base_new->object, give_matarar(obedit), *give_totcolp(obedit)); /* new in 2.5 */
|
||||
|
||||
|
@ -3077,7 +3077,7 @@ static Base *mesh_separate_tagged(Main *bmain, Scene *scene, ViewLayer *sl, Base
|
|||
return base_new;
|
||||
}
|
||||
|
||||
static bool mesh_separate_selected(Main *bmain, Scene *scene, ViewLayer *sl, Base *base_old, BMesh *bm_old)
|
||||
static bool mesh_separate_selected(Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base_old, BMesh *bm_old)
|
||||
{
|
||||
/* we may have tags from previous operators */
|
||||
BM_mesh_elem_hflag_disable_all(bm_old, BM_FACE | BM_EDGE | BM_VERT, BM_ELEM_TAG, false);
|
||||
|
@ -3085,7 +3085,7 @@ static bool mesh_separate_selected(Main *bmain, Scene *scene, ViewLayer *sl, Bas
|
|||
/* sel -> tag */
|
||||
BM_mesh_elem_hflag_enable_test(bm_old, BM_FACE | BM_EDGE | BM_VERT, BM_ELEM_TAG, true, false, BM_ELEM_SELECT);
|
||||
|
||||
return (mesh_separate_tagged(bmain, scene, sl, base_old, bm_old) != NULL);
|
||||
return (mesh_separate_tagged(bmain, scene, view_layer, base_old, bm_old) != NULL);
|
||||
}
|
||||
|
||||
/* flush a hflag to from verts to edges/faces */
|
||||
|
@ -3184,7 +3184,7 @@ static void mesh_separate_material_assign_mat_nr(Main *bmain, Object *ob, const
|
|||
}
|
||||
}
|
||||
|
||||
static bool mesh_separate_material(Main *bmain, Scene *scene, ViewLayer *sl, Base *base_old, BMesh *bm_old)
|
||||
static bool mesh_separate_material(Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base_old, BMesh *bm_old)
|
||||
{
|
||||
BMFace *f_cmp, *f;
|
||||
BMIter iter;
|
||||
|
@ -3225,7 +3225,7 @@ static bool mesh_separate_material(Main *bmain, Scene *scene, ViewLayer *sl, Bas
|
|||
}
|
||||
|
||||
/* Move selection into a separate object */
|
||||
base_new = mesh_separate_tagged(bmain, scene, sl, base_old, bm_old);
|
||||
base_new = mesh_separate_tagged(bmain, scene, view_layer, base_old, bm_old);
|
||||
if (base_new) {
|
||||
mesh_separate_material_assign_mat_nr(bmain, base_new->object, mat_nr);
|
||||
}
|
||||
|
@ -3236,7 +3236,7 @@ static bool mesh_separate_material(Main *bmain, Scene *scene, ViewLayer *sl, Bas
|
|||
return result;
|
||||
}
|
||||
|
||||
static bool mesh_separate_loose(Main *bmain, Scene *scene, ViewLayer *sl, Base *base_old, BMesh *bm_old)
|
||||
static bool mesh_separate_loose(Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base_old, BMesh *bm_old)
|
||||
{
|
||||
int i;
|
||||
BMEdge *e;
|
||||
|
@ -3289,7 +3289,7 @@ static bool mesh_separate_loose(Main *bmain, Scene *scene, ViewLayer *sl, Base *
|
|||
bm_mesh_hflag_flush_vert(bm_old, BM_ELEM_TAG);
|
||||
|
||||
/* Move selection into a separate object */
|
||||
result |= (mesh_separate_tagged(bmain, scene, sl, base_old, bm_old) != NULL);
|
||||
result |= (mesh_separate_tagged(bmain, scene, view_layer, base_old, bm_old) != NULL);
|
||||
}
|
||||
|
||||
return result;
|
||||
|
@ -3299,7 +3299,7 @@ static int edbm_separate_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
const int type = RNA_enum_get(op->ptr, "type");
|
||||
int retval = 0;
|
||||
|
||||
|
@ -3320,13 +3320,13 @@ static int edbm_separate_exec(bContext *C, wmOperator *op)
|
|||
/* editmode separate */
|
||||
switch (type) {
|
||||
case MESH_SEPARATE_SELECTED:
|
||||
retval = mesh_separate_selected(bmain, scene, sl, base, em->bm);
|
||||
retval = mesh_separate_selected(bmain, scene, view_layer, base, em->bm);
|
||||
break;
|
||||
case MESH_SEPARATE_MATERIAL:
|
||||
retval = mesh_separate_material(bmain, scene, sl, base, em->bm);
|
||||
retval = mesh_separate_material(bmain, scene, view_layer, base, em->bm);
|
||||
break;
|
||||
case MESH_SEPARATE_LOOSE:
|
||||
retval = mesh_separate_loose(bmain, scene, sl, base, em->bm);
|
||||
retval = mesh_separate_loose(bmain, scene, view_layer, base, em->bm);
|
||||
break;
|
||||
default:
|
||||
BLI_assert(0);
|
||||
|
@ -3361,10 +3361,10 @@ static int edbm_separate_exec(bContext *C, wmOperator *op)
|
|||
|
||||
switch (type) {
|
||||
case MESH_SEPARATE_MATERIAL:
|
||||
retval_iter = mesh_separate_material(bmain, scene, sl, base_iter, bm_old);
|
||||
retval_iter = mesh_separate_material(bmain, scene, view_layer, base_iter, bm_old);
|
||||
break;
|
||||
case MESH_SEPARATE_LOOSE:
|
||||
retval_iter = mesh_separate_loose(bmain, scene, sl, base_iter, bm_old);
|
||||
retval_iter = mesh_separate_loose(bmain, scene, view_layer, base_iter, bm_old);
|
||||
break;
|
||||
default:
|
||||
BLI_assert(0);
|
||||
|
|
|
@ -428,7 +428,7 @@ Object *ED_object_add_type(
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob;
|
||||
|
||||
/* for as long scene has editmode... */
|
||||
|
@ -436,12 +436,12 @@ Object *ED_object_add_type(
|
|||
ED_object_editmode_exit(C, EM_FREEDATA | EM_FREEUNDO | EM_WAITCURSOR | EM_DO_UNDO); /* freedata, and undo */
|
||||
|
||||
/* deselects all, sets scene->basact */
|
||||
ob = BKE_object_add(bmain, scene, sl, type, name);
|
||||
ob = BKE_object_add(bmain, scene, view_layer, type, name);
|
||||
/* editor level activate, notifiers */
|
||||
ED_object_base_activate(C, sl->basact);
|
||||
ED_object_base_activate(C, view_layer->basact);
|
||||
|
||||
/* more editor stuff */
|
||||
ED_object_base_init_transform(C, sl->basact, loc, rot);
|
||||
ED_object_base_init_transform(C, view_layer->basact, loc, rot);
|
||||
|
||||
/* Ignore collisions by default for non-mesh objects */
|
||||
if (type != OB_MESH) {
|
||||
|
@ -1426,7 +1426,7 @@ static void make_object_duplilist_real(bContext *C, Scene *scene, Base *base,
|
|||
const bool use_hierarchy)
|
||||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ListBase *lb_duplis;
|
||||
DupliObject *dob;
|
||||
GHash *dupli_gh, *parent_gh = NULL;
|
||||
|
@ -1460,7 +1460,7 @@ static void make_object_duplilist_real(bContext *C, Scene *scene, Base *base,
|
|||
}
|
||||
|
||||
BKE_collection_object_add_from(scene, base->object, ob_dst);
|
||||
base_dst = BKE_view_layer_base_find(sl, ob_dst);
|
||||
base_dst = BKE_view_layer_base_find(view_layer, ob_dst);
|
||||
BLI_assert(base_dst != NULL);
|
||||
|
||||
BKE_scene_object_base_flag_sync_from_base(base_dst);
|
||||
|
@ -1674,7 +1674,7 @@ static int convert_poll(bContext *C)
|
|||
}
|
||||
|
||||
/* Helper for convert_exec */
|
||||
static Base *duplibase_for_convert(Main *bmain, Scene *scene, ViewLayer *sl, Base *base, Object *ob)
|
||||
static Base *duplibase_for_convert(Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base, Object *ob)
|
||||
{
|
||||
Object *obn;
|
||||
Base *basen;
|
||||
|
@ -1687,7 +1687,7 @@ static Base *duplibase_for_convert(Main *bmain, Scene *scene, ViewLayer *sl, Bas
|
|||
DEG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
|
||||
BKE_collection_object_add_from(scene, ob, obn);
|
||||
|
||||
basen = BKE_view_layer_base_find(sl, obn);
|
||||
basen = BKE_view_layer_base_find(view_layer, obn);
|
||||
ED_object_base_select(basen, BA_SELECT);
|
||||
ED_object_base_select(basen, BA_DESELECT);
|
||||
return basen;
|
||||
|
@ -2077,7 +2077,7 @@ void OBJECT_OT_convert(wmOperatorType *ot)
|
|||
/* used below, assumes id.new is correct */
|
||||
/* leaves selection of base/object unaltered */
|
||||
/* Does set ID->newid pointers. */
|
||||
static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, ViewLayer *sl, Object *ob, int dupflag)
|
||||
static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, ViewLayer *view_layer, Object *ob, int dupflag)
|
||||
{
|
||||
#define ID_NEW_REMAP_US(a) if ( (a)->id.newid) { (a) = (void *)(a)->id.newid; (a)->id.us++; }
|
||||
#define ID_NEW_REMAP_US2(a) if (((ID *)a)->newid) { (a) = ((ID *)a)->newid; ((ID *)a)->us++; }
|
||||
|
@ -2096,7 +2096,7 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, ViewLayer
|
|||
DEG_id_tag_update(&obn->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
|
||||
|
||||
BKE_collection_object_add_from(scene, ob, obn);
|
||||
basen = BKE_view_layer_base_find(sl, obn);
|
||||
basen = BKE_view_layer_base_find(view_layer, obn);
|
||||
|
||||
/* 1) duplis should end up in same group as the original
|
||||
* 2) Rigid Body sim participants MUST always be part of a group...
|
||||
|
@ -2319,14 +2319,14 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, ViewLayer
|
|||
* note: don't call this within a loop since clear_* funcs loop over the entire database.
|
||||
* note: caller must do DAG_relations_tag_update(bmain);
|
||||
* this is not done automatic since we may duplicate many objects in a batch */
|
||||
Base *ED_object_add_duplicate(Main *bmain, Scene *scene, ViewLayer *sl, Base *base, int dupflag)
|
||||
Base *ED_object_add_duplicate(Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base, int dupflag)
|
||||
{
|
||||
Base *basen;
|
||||
Object *ob;
|
||||
|
||||
clear_sca_new_poins(); /* BGE logic */
|
||||
|
||||
basen = object_add_duplicate_internal(bmain, scene, sl, base->object, dupflag);
|
||||
basen = object_add_duplicate_internal(bmain, scene, view_layer, base->object, dupflag);
|
||||
if (basen == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
@ -2353,7 +2353,7 @@ static int duplicate_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
const bool linked = RNA_boolean_get(op->ptr, "linked");
|
||||
int dupflag = (linked) ? 0 : U.dupflag;
|
||||
|
||||
|
@ -2361,7 +2361,7 @@ static int duplicate_exec(bContext *C, wmOperator *op)
|
|||
|
||||
CTX_DATA_BEGIN (C, Base *, base, selected_bases)
|
||||
{
|
||||
Base *basen = object_add_duplicate_internal(bmain, scene, sl, base->object, dupflag);
|
||||
Base *basen = object_add_duplicate_internal(bmain, scene, view_layer, base->object, dupflag);
|
||||
|
||||
/* note that this is safe to do with this context iterator,
|
||||
* the list is made in advance */
|
||||
|
@ -2373,7 +2373,7 @@ static int duplicate_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
|
||||
/* new object becomes active */
|
||||
if (BASACT(sl) == base)
|
||||
if (BASACT(view_layer) == base)
|
||||
ED_object_base_activate(C, basen);
|
||||
|
||||
if (basen->object->data) {
|
||||
|
@ -2425,7 +2425,7 @@ static int add_named_exec(bContext *C, wmOperator *op)
|
|||
const wmEvent *event = win ? win->eventstate : NULL;
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Base *basen;
|
||||
Object *ob;
|
||||
const bool linked = RNA_boolean_get(op->ptr, "linked");
|
||||
|
@ -2444,7 +2444,7 @@ static int add_named_exec(bContext *C, wmOperator *op)
|
|||
/* prepare dupli */
|
||||
clear_sca_new_poins(); /* BGE logic */
|
||||
|
||||
basen = object_add_duplicate_internal(bmain, scene, sl, ob, dupflag);
|
||||
basen = object_add_duplicate_internal(bmain, scene, view_layer, ob, dupflag);
|
||||
BKE_scene_object_base_flag_sync_from_object(basen);
|
||||
|
||||
if (basen == NULL) {
|
||||
|
|
|
@ -616,7 +616,7 @@ static int test_bake_internal(bContext *C, ReportList *reports)
|
|||
static void init_bake_internal(BakeRender *bkr, bContext *C)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
bScreen *sc = CTX_wm_screen(C);
|
||||
|
||||
/* get editmode results */
|
||||
|
@ -625,7 +625,7 @@ static void init_bake_internal(BakeRender *bkr, bContext *C)
|
|||
bkr->sa = sc ? BKE_screen_find_big_area(sc, SPACE_IMAGE, 10) : NULL; /* can be NULL */
|
||||
bkr->main = CTX_data_main(C);
|
||||
bkr->scene = scene;
|
||||
bkr->actob = (scene->r.bake_flag & R_BAKE_TO_ACTIVE) ? OBACT(sl) : NULL;
|
||||
bkr->actob = (scene->r.bake_flag & R_BAKE_TO_ACTIVE) ? OBACT(view_layer) : NULL;
|
||||
bkr->re = RE_NewRender("_Bake View_");
|
||||
|
||||
if (scene->r.bake_mode == RE_BAKE_AO) {
|
||||
|
@ -838,7 +838,7 @@ static int bake_image_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
int result = OPERATOR_CANCELLED;
|
||||
|
||||
if (is_multires_bake(scene)) {
|
||||
|
@ -858,7 +858,7 @@ static int bake_image_exec(bContext *C, wmOperator *op)
|
|||
RE_test_break_cb(bkr.re, NULL, thread_break);
|
||||
G.is_break = false; /* BKE_blender_test_break uses this global */
|
||||
|
||||
RE_Database_Baking(bkr.re, bmain, scene, scene->lay, scene->r.bake_mode, (scene->r.bake_flag & R_BAKE_TO_ACTIVE) ? OBACT(sl) : NULL);
|
||||
RE_Database_Baking(bkr.re, bmain, scene, scene->lay, scene->r.bake_mode, (scene->r.bake_flag & R_BAKE_TO_ACTIVE) ? OBACT(view_layer) : NULL);
|
||||
|
||||
/* baking itself is threaded, cannot use test_break in threads */
|
||||
BLI_init_threads(&threads, do_bake_render, 1);
|
||||
|
|
|
@ -235,7 +235,7 @@ void ED_object_editmode_exit(bContext *C, int flag)
|
|||
/* Note! only in exceptional cases should 'EM_DO_UNDO' NOT be in the flag */
|
||||
/* Note! if 'EM_FREEDATA' isn't in the flag, use ED_object_editmode_load directly */
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
const bool freedata = (flag & EM_FREEDATA) != 0;
|
||||
|
||||
|
@ -244,8 +244,8 @@ void ED_object_editmode_exit(bContext *C, int flag)
|
|||
if (ED_object_editmode_load_ex(CTX_data_main(C), obedit, freedata) == false) {
|
||||
/* in rare cases (background mode) its possible active object
|
||||
* is flagged for editmode, without 'obedit' being set [#35489] */
|
||||
if (UNLIKELY(sl->basact && (sl->basact->object->mode & OB_MODE_EDIT))) {
|
||||
sl->basact->object->mode &= ~OB_MODE_EDIT;
|
||||
if (UNLIKELY(view_layer->basact && (view_layer->basact->object->mode & OB_MODE_EDIT))) {
|
||||
view_layer->basact->object->mode &= ~OB_MODE_EDIT;
|
||||
}
|
||||
if (flag & EM_WAITCURSOR) waitcursor(0);
|
||||
return;
|
||||
|
@ -290,7 +290,7 @@ void ED_object_editmode_exit(bContext *C, int flag)
|
|||
void ED_object_editmode_enter(bContext *C, int flag)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob;
|
||||
bool ok = false;
|
||||
|
||||
|
@ -302,7 +302,7 @@ void ED_object_editmode_enter(bContext *C, int flag)
|
|||
if (ob == NULL) return;
|
||||
}
|
||||
else {
|
||||
ob = sl->basact->object;
|
||||
ob = view_layer->basact->object;
|
||||
}
|
||||
|
||||
if (ELEM(NULL, ob, ob->data)) return;
|
||||
|
@ -512,7 +512,7 @@ void OBJECT_OT_posemode_toggle(wmOperatorType *ot)
|
|||
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
|
||||
}
|
||||
|
||||
static void copymenu_properties(ViewLayer *sl, Object *ob)
|
||||
static void copymenu_properties(ViewLayer *view_layer, Object *ob)
|
||||
{
|
||||
//XXX no longer used - to be removed - replaced by game_properties_copy_exec
|
||||
bProperty *prop;
|
||||
|
@ -545,8 +545,8 @@ static void copymenu_properties(ViewLayer *sl, Object *ob)
|
|||
nr = pupmenu(str);
|
||||
|
||||
if (nr == 1 || nr == 2) {
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
if ((base != BASACT(sl)) && (TESTBASELIB(base))) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if ((base != BASACT(view_layer)) && (TESTBASELIB(base))) {
|
||||
if (nr == 1) { /* replace */
|
||||
BKE_bproperty_copy_list(&base->object->prop, &ob->prop);
|
||||
}
|
||||
|
@ -562,8 +562,8 @@ static void copymenu_properties(ViewLayer *sl, Object *ob)
|
|||
prop = BLI_findlink(&ob->prop, nr - 4); /* account for first 3 menu items & menu index starting at 1*/
|
||||
|
||||
if (prop) {
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
if ((base != BASACT(sl)) && (TESTBASELIB(base))) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if ((base != BASACT(view_layer)) && (TESTBASELIB(base))) {
|
||||
BKE_bproperty_object_set(base->object, prop);
|
||||
}
|
||||
}
|
||||
|
@ -573,12 +573,12 @@ static void copymenu_properties(ViewLayer *sl, Object *ob)
|
|||
|
||||
}
|
||||
|
||||
static void copymenu_logicbricks(ViewLayer *sl, Object *ob)
|
||||
static void copymenu_logicbricks(ViewLayer *view_layer, Object *ob)
|
||||
{
|
||||
//XXX no longer used - to be removed - replaced by logicbricks_copy_exec
|
||||
Base *base;
|
||||
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if (base->object != ob) {
|
||||
if (TESTBASELIB(base)) {
|
||||
|
||||
|
@ -659,7 +659,7 @@ static void copy_texture_space(Object *to, Object *ob)
|
|||
}
|
||||
|
||||
/* UNUSED, keep in case we want to copy functionality for use elsewhere */
|
||||
static void copy_attr(Main *bmain, Scene *scene, ViewLayer *sl, short event)
|
||||
static void copy_attr(Main *bmain, Scene *scene, ViewLayer *view_layer, short event)
|
||||
{
|
||||
Object *ob;
|
||||
Base *base;
|
||||
|
@ -669,18 +669,18 @@ static void copy_attr(Main *bmain, Scene *scene, ViewLayer *sl, short event)
|
|||
|
||||
if (ID_IS_LINKED(scene)) return;
|
||||
|
||||
if (!(ob = OBACT(sl))) return;
|
||||
if (!(ob = OBACT(view_layer))) return;
|
||||
|
||||
if (scene->obedit) { // XXX get from context
|
||||
/* obedit_copymenu(); */
|
||||
return;
|
||||
}
|
||||
if (event == 9) {
|
||||
copymenu_properties(sl, ob);
|
||||
copymenu_properties(view_layer, ob);
|
||||
return;
|
||||
}
|
||||
else if (event == 10) {
|
||||
copymenu_logicbricks(sl, ob);
|
||||
copymenu_logicbricks(view_layer, ob);
|
||||
return;
|
||||
}
|
||||
else if (event == 24) {
|
||||
|
@ -689,8 +689,8 @@ static void copy_attr(Main *bmain, Scene *scene, ViewLayer *sl, short event)
|
|||
return;
|
||||
}
|
||||
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
if (base != BASACT(sl)) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if (base != BASACT(view_layer)) {
|
||||
if (TESTBASELIB(base)) {
|
||||
DEG_id_tag_update(&base->object->id, OB_RECALC_DATA);
|
||||
|
||||
|
@ -910,13 +910,13 @@ static void copy_attr(Main *bmain, Scene *scene, ViewLayer *sl, short event)
|
|||
DEG_relations_tag_update(bmain);
|
||||
}
|
||||
|
||||
static void UNUSED_FUNCTION(copy_attr_menu) (Main *bmain, Scene *scene, ViewLayer *sl)
|
||||
static void UNUSED_FUNCTION(copy_attr_menu) (Main *bmain, Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
Object *ob;
|
||||
short event;
|
||||
char str[512];
|
||||
|
||||
if (!(ob = OBACT(sl))) return;
|
||||
if (!(ob = OBACT(view_layer))) return;
|
||||
|
||||
if (scene->obedit) { /* XXX get from context */
|
||||
/* if (ob->type == OB_MESH) */
|
||||
|
@ -964,7 +964,7 @@ static void UNUSED_FUNCTION(copy_attr_menu) (Main *bmain, Scene *scene, ViewLaye
|
|||
event = pupmenu(str);
|
||||
if (event <= 0) return;
|
||||
|
||||
copy_attr(bmain, scene, sl, event);
|
||||
copy_attr(bmain, scene, view_layer, event);
|
||||
}
|
||||
|
||||
/* ******************* force field toggle operator ***************** */
|
||||
|
@ -1334,7 +1334,7 @@ void OBJECT_OT_shade_smooth(wmOperatorType *ot)
|
|||
|
||||
/* ********************** */
|
||||
|
||||
static void UNUSED_FUNCTION(image_aspect) (Scene *scene, ViewLayer *sl)
|
||||
static void UNUSED_FUNCTION(image_aspect) (Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
/* all selected objects with an image map: scale in image aspect */
|
||||
Base *base;
|
||||
|
@ -1347,7 +1347,7 @@ static void UNUSED_FUNCTION(image_aspect) (Scene *scene, ViewLayer *sl)
|
|||
if (scene->obedit) return; // XXX get from context
|
||||
if (ID_IS_LINKED(scene)) return;
|
||||
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if (TESTBASELIB(base)) {
|
||||
ob = base->object;
|
||||
done = false;
|
||||
|
|
|
@ -200,8 +200,8 @@ void GROUP_OT_objects_add_active(wmOperatorType *ot)
|
|||
static int objects_remove_active_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(view_layer);
|
||||
int single_group_index = RNA_enum_get(op->ptr, "group");
|
||||
Group *single_group = group_object_active_find_index(ob, single_group_index);
|
||||
Group *group;
|
||||
|
|
|
@ -448,26 +448,26 @@ static int hook_op_edit_poll(bContext *C)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static Object *add_hook_object_new(Main *bmain, Scene *scene, ViewLayer *sl, Object *obedit)
|
||||
static Object *add_hook_object_new(Main *bmain, Scene *scene, ViewLayer *view_layer, Object *obedit)
|
||||
{
|
||||
Base *base, *basedit;
|
||||
Object *ob;
|
||||
|
||||
ob = BKE_object_add(bmain, scene, sl, OB_EMPTY, NULL);
|
||||
ob = BKE_object_add(bmain, scene, view_layer, OB_EMPTY, NULL);
|
||||
|
||||
basedit = BKE_view_layer_base_find(sl, obedit);
|
||||
base = sl->basact;
|
||||
basedit = BKE_view_layer_base_find(view_layer, obedit);
|
||||
base = view_layer->basact;
|
||||
base->lay = ob->lay = obedit->lay;
|
||||
BLI_assert(sl->basact->object == ob);
|
||||
BLI_assert(view_layer->basact->object == ob);
|
||||
|
||||
/* icky, BKE_object_add sets new base as active.
|
||||
* so set it back to the original edit object */
|
||||
sl->basact = basedit;
|
||||
view_layer->basact = basedit;
|
||||
|
||||
return ob;
|
||||
}
|
||||
|
||||
static int add_hook_object(const bContext *C, Main *bmain, Scene *scene, ViewLayer *sl, Object *obedit, Object *ob, int mode, ReportList *reports)
|
||||
static int add_hook_object(const bContext *C, Main *bmain, Scene *scene, ViewLayer *view_layer, Object *obedit, Object *ob, int mode, ReportList *reports)
|
||||
{
|
||||
ModifierData *md = NULL;
|
||||
HookModifierData *hmd = NULL;
|
||||
|
@ -488,7 +488,7 @@ static int add_hook_object(const bContext *C, Main *bmain, Scene *scene, ViewLay
|
|||
|
||||
if (mode == OBJECT_ADDHOOK_NEWOB && !ob) {
|
||||
|
||||
ob = add_hook_object_new(bmain, scene, sl, obedit);
|
||||
ob = add_hook_object_new(bmain, scene, view_layer, obedit);
|
||||
|
||||
/* transform cent to global coords for loc */
|
||||
mul_v3_m4v3(ob->loc, obedit->obmat, cent);
|
||||
|
@ -562,7 +562,7 @@ static int object_add_hook_selob_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
Object *obsel = NULL;
|
||||
const bool use_bone = RNA_boolean_get(op->ptr, "use_bone");
|
||||
|
@ -587,7 +587,7 @@ static int object_add_hook_selob_exec(bContext *C, wmOperator *op)
|
|||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
if (add_hook_object(C, bmain, scene, sl, obedit, obsel, mode, op->reports)) {
|
||||
if (add_hook_object(C, bmain, scene, view_layer, obedit, obsel, mode, op->reports)) {
|
||||
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, obedit);
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
@ -618,10 +618,10 @@ static int object_add_hook_newob_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
|
||||
if (add_hook_object(C, bmain, scene, sl, obedit, NULL, OBJECT_ADDHOOK_NEWOB, op->reports)) {
|
||||
if (add_hook_object(C, bmain, scene, view_layer, obedit, NULL, OBJECT_ADDHOOK_NEWOB, op->reports)) {
|
||||
WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
|
||||
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, obedit);
|
||||
return OPERATOR_FINISHED;
|
||||
|
|
|
@ -413,7 +413,7 @@ int ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *
|
|||
return 1;
|
||||
}
|
||||
|
||||
int ED_object_modifier_convert(ReportList *UNUSED(reports), Main *bmain, Scene *scene, ViewLayer *sl, Object *ob, ModifierData *md)
|
||||
int ED_object_modifier_convert(ReportList *UNUSED(reports), Main *bmain, Scene *scene, ViewLayer *view_layer, Object *ob, ModifierData *md)
|
||||
{
|
||||
Object *obn;
|
||||
ParticleSystem *psys;
|
||||
|
@ -465,7 +465,7 @@ int ED_object_modifier_convert(ReportList *UNUSED(reports), Main *bmain, Scene *
|
|||
if (totvert == 0) return 0;
|
||||
|
||||
/* add new mesh */
|
||||
obn = BKE_object_add(bmain, scene, sl, OB_MESH, NULL);
|
||||
obn = BKE_object_add(bmain, scene, view_layer, OB_MESH, NULL);
|
||||
me = obn->data;
|
||||
|
||||
me->totvert = totvert;
|
||||
|
@ -882,7 +882,7 @@ ModifierData *edit_modifier_property_get(wmOperator *op, Object *ob, int type)
|
|||
static int modifier_remove_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = ED_object_active_context(C);
|
||||
ModifierData *md = edit_modifier_property_get(op, ob, 0);
|
||||
int mode_orig = ob->mode;
|
||||
|
@ -895,7 +895,7 @@ static int modifier_remove_exec(bContext *C, wmOperator *op)
|
|||
/* if cloth/softbody was removed, particle mode could be cleared */
|
||||
if (mode_orig & OB_MODE_PARTICLE_EDIT)
|
||||
if ((ob->mode & OB_MODE_PARTICLE_EDIT) == 0)
|
||||
if (sl->basact && sl->basact->object == ob)
|
||||
if (view_layer->basact && view_layer->basact->object == ob)
|
||||
WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_OBJECT, NULL);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1058,11 +1058,11 @@ static int modifier_convert_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = ED_object_active_context(C);
|
||||
ModifierData *md = edit_modifier_property_get(op, ob, 0);
|
||||
|
||||
if (!md || !ED_object_modifier_convert(op->reports, bmain, scene, sl, ob, md))
|
||||
if (!md || !ED_object_modifier_convert(op->reports, bmain, scene, view_layer, ob, md))
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
|
@ -1698,7 +1698,7 @@ static void skin_armature_bone_create(Object *skin_ob,
|
|||
}
|
||||
}
|
||||
|
||||
static Object *modifier_skin_armature_create(const bContext *C, Scene *scene, ViewLayer *sl, Object *skin_ob)
|
||||
static Object *modifier_skin_armature_create(const bContext *C, Scene *scene, ViewLayer *view_layer, Object *skin_ob)
|
||||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
EvaluationContext eval_ctx;
|
||||
|
@ -1725,7 +1725,7 @@ static Object *modifier_skin_armature_create(const bContext *C, Scene *scene, Vi
|
|||
NULL,
|
||||
me->totvert);
|
||||
|
||||
arm_ob = BKE_object_add(bmain, scene, sl, OB_ARMATURE, NULL);
|
||||
arm_ob = BKE_object_add(bmain, scene, view_layer, OB_ARMATURE, NULL);
|
||||
BKE_object_transform_copy(arm_ob, skin_ob);
|
||||
arm = arm_ob->data;
|
||||
arm->layer = 1;
|
||||
|
@ -1784,7 +1784,7 @@ static int skin_armature_create_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = CTX_data_active_object(C), *arm_ob;
|
||||
Mesh *me = ob->data;
|
||||
ModifierData *skin_md;
|
||||
|
@ -1796,7 +1796,7 @@ static int skin_armature_create_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
|
||||
/* create new armature */
|
||||
arm_ob = modifier_skin_armature_create(C, scene, sl, ob);
|
||||
arm_ob = modifier_skin_armature_create(C, scene, view_layer, ob);
|
||||
|
||||
/* add a modifier to connect the new armature to the mesh */
|
||||
arm_md = (ArmatureModifierData *)modifier_new(eModifierType_Armature);
|
||||
|
|
|
@ -127,7 +127,7 @@ static int vertex_parent_set_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
EvaluationContext eval_ctx;
|
||||
BMVert *eve;
|
||||
|
@ -247,7 +247,7 @@ static int vertex_parent_set_exec(bContext *C, wmOperator *op)
|
|||
else {
|
||||
Object workob;
|
||||
|
||||
ob->parent = BASACT(sl)->object;
|
||||
ob->parent = BASACT(view_layer)->object;
|
||||
if (v3) {
|
||||
ob->partype = PARVERT3;
|
||||
ob->par1 = v1 - 1;
|
||||
|
@ -1698,8 +1698,8 @@ static void single_object_users(Main *bmain, Scene *scene, View3D *v3d, const in
|
|||
single_object_users_scene_collection(bmain, scene, msc, flag, copy_groups);
|
||||
|
||||
/* loop over ViewLayers and assign the pointers accordingly */
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
ID_NEW_REMAP(base->object);
|
||||
}
|
||||
}
|
||||
|
@ -1779,7 +1779,7 @@ static void new_id_matar(Main *bmain, Material **matar, const int totcol)
|
|||
}
|
||||
}
|
||||
|
||||
static void single_obdata_users(Main *bmain, Scene *scene, ViewLayer *sl, const int flag)
|
||||
static void single_obdata_users(Main *bmain, Scene *scene, ViewLayer *view_layer, const int flag)
|
||||
{
|
||||
Lamp *la;
|
||||
Curve *cu;
|
||||
|
@ -1789,7 +1789,7 @@ static void single_obdata_users(Main *bmain, Scene *scene, ViewLayer *sl, const
|
|||
ID *id;
|
||||
int a;
|
||||
|
||||
FOREACH_OBJECT_FLAG(scene, sl, flag, ob)
|
||||
FOREACH_OBJECT_FLAG(scene, view_layer, flag, ob)
|
||||
{
|
||||
if (!ID_IS_LINKED(ob)) {
|
||||
id = ob->data;
|
||||
|
@ -1866,9 +1866,9 @@ static void single_obdata_users(Main *bmain, Scene *scene, ViewLayer *sl, const
|
|||
}
|
||||
}
|
||||
|
||||
static void single_object_action_users(Scene *scene, ViewLayer *sl, const int flag)
|
||||
static void single_object_action_users(Scene *scene, ViewLayer *view_layer, const int flag)
|
||||
{
|
||||
FOREACH_OBJECT_FLAG(scene, sl, flag, ob)
|
||||
FOREACH_OBJECT_FLAG(scene, view_layer, flag, ob)
|
||||
if (!ID_IS_LINKED(ob)) {
|
||||
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
BKE_animdata_copy_id_action(&ob->id, false);
|
||||
|
@ -1876,13 +1876,13 @@ static void single_object_action_users(Scene *scene, ViewLayer *sl, const int fl
|
|||
FOREACH_OBJECT_FLAG_END
|
||||
}
|
||||
|
||||
static void single_mat_users(Main *bmain, Scene *scene, ViewLayer *sl, const int flag, const bool do_textures)
|
||||
static void single_mat_users(Main *bmain, Scene *scene, ViewLayer *view_layer, const int flag, const bool do_textures)
|
||||
{
|
||||
Material *ma, *man;
|
||||
Tex *tex;
|
||||
int a, b;
|
||||
|
||||
FOREACH_OBJECT_FLAG(scene, sl, flag, ob)
|
||||
FOREACH_OBJECT_FLAG(scene, view_layer, flag, ob)
|
||||
if (!ID_IS_LINKED(ob)) {
|
||||
for (a = 1; a <= ob->totcol; a++) {
|
||||
ma = give_current_material(ob, a);
|
||||
|
@ -2132,7 +2132,7 @@ static void tag_localizable_objects(bContext *C, const int mode)
|
|||
* Instance indirectly referenced zero user objects,
|
||||
* otherwise they're lost on reload, see T40595.
|
||||
*/
|
||||
static bool make_local_all__instance_indirect_unused(Main *bmain, Scene *scene, ViewLayer *sl, SceneCollection *sc)
|
||||
static bool make_local_all__instance_indirect_unused(Main *bmain, Scene *scene, ViewLayer *view_layer, SceneCollection *sc)
|
||||
{
|
||||
Object *ob;
|
||||
bool changed = false;
|
||||
|
@ -2144,7 +2144,7 @@ static bool make_local_all__instance_indirect_unused(Main *bmain, Scene *scene,
|
|||
id_us_plus(&ob->id);
|
||||
|
||||
BKE_collection_object_add(scene, sc, ob);
|
||||
base = BKE_view_layer_base_find(sl, ob);
|
||||
base = BKE_view_layer_base_find(view_layer, ob);
|
||||
base->flag |= BASE_SELECTED;
|
||||
BKE_scene_object_base_flag_sync_from_base(base);
|
||||
DEG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
|
||||
|
@ -2334,7 +2334,7 @@ static int make_single_user_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
View3D *v3d = CTX_wm_view3d(C); /* ok if this is NULL */
|
||||
const int flag = (RNA_enum_get(op->ptr, "type") == MAKE_SINGLE_USER_SELECTED) ? SELECT : 0;
|
||||
const bool copy_groups = false;
|
||||
|
@ -2342,7 +2342,7 @@ static int make_single_user_exec(bContext *C, wmOperator *op)
|
|||
|
||||
if (RNA_boolean_get(op->ptr, "object")) {
|
||||
if (flag == SELECT) {
|
||||
BKE_view_layer_selected_objects_tag(sl, OB_DONE);
|
||||
BKE_view_layer_selected_objects_tag(view_layer, OB_DONE);
|
||||
single_object_users(bmain, scene, v3d, OB_DONE, copy_groups);
|
||||
}
|
||||
else {
|
||||
|
@ -2354,11 +2354,11 @@ static int make_single_user_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
|
||||
if (RNA_boolean_get(op->ptr, "obdata")) {
|
||||
single_obdata_users(bmain, scene, sl, flag);
|
||||
single_obdata_users(bmain, scene, view_layer, flag);
|
||||
}
|
||||
|
||||
if (RNA_boolean_get(op->ptr, "material")) {
|
||||
single_mat_users(bmain, scene, sl, flag, RNA_boolean_get(op->ptr, "texture"));
|
||||
single_mat_users(bmain, scene, view_layer, flag, RNA_boolean_get(op->ptr, "texture"));
|
||||
}
|
||||
|
||||
#if 0 /* can't do this separate from materials */
|
||||
|
@ -2366,7 +2366,7 @@ static int make_single_user_exec(bContext *C, wmOperator *op)
|
|||
single_mat_users(scene, flag, true);
|
||||
#endif
|
||||
if (RNA_boolean_get(op->ptr, "animation")) {
|
||||
single_object_action_users(scene, sl, flag);
|
||||
single_object_action_users(scene, view_layer, flag);
|
||||
}
|
||||
|
||||
BKE_main_id_clear_newpoins(bmain);
|
||||
|
|
|
@ -548,7 +548,7 @@ static bool select_grouped_children(bContext *C, Object *ob, const bool recursiv
|
|||
|
||||
static bool select_grouped_parent(bContext *C) /* Makes parent active and de-selected OBACT */
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Base *baspar, *basact = CTX_data_active_base(C);
|
||||
bool changed = false;
|
||||
|
||||
|
@ -556,7 +556,7 @@ static bool select_grouped_parent(bContext *C) /* Makes parent active and de-sel
|
|||
return 0; /* we know OBACT is valid */
|
||||
}
|
||||
|
||||
baspar = BKE_view_layer_base_find(sl, basact->object->parent);
|
||||
baspar = BKE_view_layer_base_find(view_layer, basact->object->parent);
|
||||
|
||||
/* can be NULL if parent in other scene */
|
||||
if (baspar && BASE_SELECTABLE(baspar)) {
|
||||
|
@ -616,7 +616,7 @@ static bool select_grouped_group(bContext *C, Object *ob) /* Select objects in
|
|||
|
||||
static bool select_grouped_object_hooks(bContext *C, Object *ob)
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
|
||||
bool changed = false;
|
||||
Base *base;
|
||||
|
@ -627,7 +627,7 @@ static bool select_grouped_object_hooks(bContext *C, Object *ob)
|
|||
if (md->type == eModifierType_Hook) {
|
||||
hmd = (HookModifierData *) md;
|
||||
if (hmd->object && !(hmd->object->flag & SELECT)) {
|
||||
base = BKE_view_layer_base_find(sl, hmd->object);
|
||||
base = BKE_view_layer_base_find(view_layer, hmd->object);
|
||||
if (base && (BASE_SELECTABLE(base))) {
|
||||
ED_object_base_select(base, BA_SELECT);
|
||||
changed = true;
|
||||
|
@ -1014,7 +1014,7 @@ void OBJECT_OT_select_same_group(wmOperatorType *ot)
|
|||
static int object_select_mirror_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
bool extend;
|
||||
|
||||
extend = RNA_boolean_get(op->ptr, "extend");
|
||||
|
@ -1028,7 +1028,7 @@ static int object_select_mirror_exec(bContext *C, wmOperator *op)
|
|||
if (!STREQ(name_flip, primbase->object->id.name + 2)) {
|
||||
Object *ob = (Object *)BKE_libblock_find_name(ID_OB, name_flip);
|
||||
if (ob) {
|
||||
Base *secbase = BKE_view_layer_base_find(sl, ob);
|
||||
Base *secbase = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
if (secbase) {
|
||||
ED_object_base_select(secbase, BA_SELECT);
|
||||
|
|
|
@ -460,7 +460,7 @@ static int dynamicpaint_bake_exec(struct bContext *C, struct wmOperator *op)
|
|||
DynamicPaintCanvasSettings *canvas;
|
||||
Object *ob = ED_object_context(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
EvaluationContext *eval_ctx = MEM_mallocN(sizeof(*eval_ctx), "EvaluationContext");
|
||||
|
||||
CTX_data_eval_ctx(C, eval_ctx);
|
||||
|
@ -491,7 +491,7 @@ static int dynamicpaint_bake_exec(struct bContext *C, struct wmOperator *op)
|
|||
DynamicPaintBakeJob *job = MEM_mallocN(sizeof(DynamicPaintBakeJob), "DynamicPaintBakeJob");
|
||||
job->bmain = CTX_data_main(C);
|
||||
job->scene = scene;
|
||||
job->view_layer = sl;
|
||||
job->view_layer = view_layer;
|
||||
job->depsgraph = CTX_data_depsgraph(C);
|
||||
job->ob = ob;
|
||||
job->canvas = canvas;
|
||||
|
|
|
@ -87,7 +87,7 @@
|
|||
#include "physics_intern.h"
|
||||
|
||||
void PE_create_particle_edit(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, Object *ob,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, Object *ob,
|
||||
PointCache *cache, ParticleSystem *psys);
|
||||
void PTCacheUndo_clear(PTCacheEdit *edit);
|
||||
void recalc_lengths(PTCacheEdit *edit);
|
||||
|
@ -114,26 +114,26 @@ void update_world_cos(Object *ob, PTCacheEdit *edit);
|
|||
int PE_poll(bContext *C)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
|
||||
if (!scene || !sl || !ob || !(ob->mode & OB_MODE_PARTICLE_EDIT))
|
||||
if (!scene || !view_layer || !ob || !(ob->mode & OB_MODE_PARTICLE_EDIT))
|
||||
return 0;
|
||||
|
||||
return (PE_get_current(scene, sl, ob) != NULL);
|
||||
return (PE_get_current(scene, view_layer, ob) != NULL);
|
||||
}
|
||||
|
||||
int PE_hair_poll(bContext *C)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit;
|
||||
|
||||
if (!scene || !ob || !(ob->mode & OB_MODE_PARTICLE_EDIT))
|
||||
return 0;
|
||||
|
||||
edit= PE_get_current(scene, sl, ob);
|
||||
edit= PE_get_current(scene, view_layer, ob);
|
||||
|
||||
return (edit && edit->psys);
|
||||
}
|
||||
|
@ -219,7 +219,7 @@ static float pe_brush_size_get(const Scene *UNUSED(scene), ParticleBrushData *br
|
|||
* note: this function runs on poll, therefor it can runs many times a second
|
||||
* keep it fast! */
|
||||
static PTCacheEdit *pe_get_current(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, Object *ob, int create)
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, Object *ob, int create)
|
||||
{
|
||||
ParticleEditSettings *pset= PE_settings(scene);
|
||||
PTCacheEdit *edit = NULL;
|
||||
|
@ -230,7 +230,7 @@ static PTCacheEdit *pe_get_current(
|
|||
return NULL;
|
||||
|
||||
pset->scene = scene;
|
||||
pset->view_layer = sl;
|
||||
pset->view_layer = view_layer;
|
||||
pset->object = ob;
|
||||
|
||||
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
|
||||
|
@ -259,18 +259,18 @@ static PTCacheEdit *pe_get_current(
|
|||
if (psys->part && psys->part->type == PART_HAIR) {
|
||||
if (psys->flag & PSYS_HAIR_DYNAMICS && psys->pointcache->flag & PTCACHE_BAKED) {
|
||||
if (create && !psys->pointcache->edit)
|
||||
PE_create_particle_edit(eval_ctx, scene, sl, ob, pid->cache, NULL);
|
||||
PE_create_particle_edit(eval_ctx, scene, view_layer, ob, pid->cache, NULL);
|
||||
edit = pid->cache->edit;
|
||||
}
|
||||
else {
|
||||
if (create && !psys->edit && psys->flag & PSYS_HAIR_DONE)
|
||||
PE_create_particle_edit(eval_ctx, scene, sl, ob, NULL, psys);
|
||||
PE_create_particle_edit(eval_ctx, scene, view_layer, ob, NULL, psys);
|
||||
edit = psys->edit;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (create && pid->cache->flag & PTCACHE_BAKED && !pid->cache->edit)
|
||||
PE_create_particle_edit(eval_ctx, scene, sl, ob, pid->cache, psys);
|
||||
PE_create_particle_edit(eval_ctx, scene, view_layer, ob, pid->cache, psys);
|
||||
edit = pid->cache->edit;
|
||||
}
|
||||
|
||||
|
@ -281,7 +281,7 @@ static PTCacheEdit *pe_get_current(
|
|||
if (create && pid->cache->flag & PTCACHE_BAKED && !pid->cache->edit) {
|
||||
pset->flag |= PE_FADE_TIME;
|
||||
// NICE TO HAVE but doesn't work: pset->brushtype = PE_BRUSH_COMB;
|
||||
PE_create_particle_edit(eval_ctx, scene, sl, ob, pid->cache, NULL);
|
||||
PE_create_particle_edit(eval_ctx, scene, view_layer, ob, pid->cache, NULL);
|
||||
}
|
||||
edit = pid->cache->edit;
|
||||
break;
|
||||
|
@ -290,7 +290,7 @@ static PTCacheEdit *pe_get_current(
|
|||
if (create && pid->cache->flag & PTCACHE_BAKED && !pid->cache->edit) {
|
||||
pset->flag |= PE_FADE_TIME;
|
||||
// NICE TO HAVE but doesn't work: pset->brushtype = PE_BRUSH_COMB;
|
||||
PE_create_particle_edit(eval_ctx, scene, sl, ob, pid->cache, NULL);
|
||||
PE_create_particle_edit(eval_ctx, scene, view_layer, ob, pid->cache, NULL);
|
||||
}
|
||||
edit = pid->cache->edit;
|
||||
break;
|
||||
|
@ -305,9 +305,9 @@ static PTCacheEdit *pe_get_current(
|
|||
return edit;
|
||||
}
|
||||
|
||||
PTCacheEdit *PE_get_current(Scene *scene, ViewLayer *sl, Object *ob)
|
||||
PTCacheEdit *PE_get_current(Scene *scene, ViewLayer *view_layer, Object *ob)
|
||||
{
|
||||
return pe_get_current(NULL, scene, sl, ob, 0);
|
||||
return pe_get_current(NULL, scene, view_layer, ob, 0);
|
||||
}
|
||||
|
||||
PTCacheEdit *PE_create_current(const EvaluationContext *eval_ctx, Scene *scene, Object *ob)
|
||||
|
@ -1163,9 +1163,9 @@ void recalc_emitter_field(Object *ob, ParticleSystem *psys)
|
|||
BLI_kdtree_balance(edit->emitter_field);
|
||||
}
|
||||
|
||||
static void PE_update_selection(const bContext *C, Scene *scene, ViewLayer *sl, Object *ob, int useflag)
|
||||
static void PE_update_selection(const bContext *C, Scene *scene, ViewLayer *view_layer, Object *ob, int useflag)
|
||||
{
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
HairKey *hkey;
|
||||
EvaluationContext eval_ctx;
|
||||
POINT_P; KEY_K;
|
||||
|
@ -1273,12 +1273,12 @@ static void update_velocities(PTCacheEdit *edit)
|
|||
}
|
||||
}
|
||||
|
||||
void PE_update_object(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, Object *ob, int useflag)
|
||||
void PE_update_object(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, Object *ob, int useflag)
|
||||
{
|
||||
/* use this to do partial particle updates, not usable when adding or
|
||||
* removing, then a full redo is necessary and calling this may crash */
|
||||
ParticleEditSettings *pset= PE_settings(scene);
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
POINT_P;
|
||||
|
||||
if (!edit)
|
||||
|
@ -1413,9 +1413,9 @@ static void select_action_apply(PTCacheEditPoint *point, PTCacheEditKey *key, in
|
|||
static int pe_select_all_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
POINT_P; KEY_K;
|
||||
int action = RNA_enum_get(op->ptr, "action");
|
||||
|
||||
|
@ -1438,7 +1438,7 @@ static int pe_select_all_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
}
|
||||
|
||||
PE_update_selection(C, scene, sl, ob, 1);
|
||||
PE_update_selection(C, scene, view_layer, ob, 1);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_SELECTED, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1467,9 +1467,9 @@ int PE_mouse_particles(bContext *C, const int mval[2], bool extend, bool deselec
|
|||
{
|
||||
PEData data;
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
POINT_P; KEY_K;
|
||||
|
||||
if (!PE_start_edit(edit))
|
||||
|
@ -1496,7 +1496,7 @@ int PE_mouse_particles(bContext *C, const int mval[2], bool extend, bool deselec
|
|||
else
|
||||
for_mouse_hit_keys(&data, toggle_key_select, 1);
|
||||
|
||||
PE_update_selection(C, scene, sl, ob, 1);
|
||||
PE_update_selection(C, scene, view_layer, ob, 1);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_SELECTED, data.ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1641,7 +1641,7 @@ static int select_random_exec(bContext *C, wmOperator *op)
|
|||
PEData data;
|
||||
int type;
|
||||
Scene *scene;
|
||||
ViewLayer *sl;
|
||||
ViewLayer *view_layer;
|
||||
Object *ob;
|
||||
|
||||
/* used by LOOP_VISIBLE_POINTS, LOOP_VISIBLE_KEYS and LOOP_KEYS */
|
||||
|
@ -1661,9 +1661,9 @@ static int select_random_exec(bContext *C, wmOperator *op)
|
|||
PE_set_data(C, &data);
|
||||
data.select_action = SEL_SELECT;
|
||||
scene = CTX_data_scene(C);
|
||||
sl = CTX_data_view_layer(C);
|
||||
view_layer = CTX_data_view_layer(C);
|
||||
ob = CTX_data_active_object(C);
|
||||
edit = PE_get_current(scene, sl, ob);
|
||||
edit = PE_get_current(scene, view_layer, ob);
|
||||
|
||||
rng = BLI_rng_new_srandom(seed);
|
||||
|
||||
|
@ -1780,9 +1780,9 @@ void PE_deselect_all_visible(PTCacheEdit *edit)
|
|||
int PE_border_select(bContext *C, rcti *rect, bool select, bool extend)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
PEData data;
|
||||
|
||||
if (!PE_start_edit(edit))
|
||||
|
@ -1797,7 +1797,7 @@ int PE_border_select(bContext *C, rcti *rect, bool select, bool extend)
|
|||
|
||||
for_mouse_hit_keys(&data, select_key, 0);
|
||||
|
||||
PE_update_selection(C, scene, sl, ob, 1);
|
||||
PE_update_selection(C, scene, view_layer, ob, 1);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_SELECTED, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1808,9 +1808,9 @@ int PE_border_select(bContext *C, rcti *rect, bool select, bool extend)
|
|||
int PE_circle_select(bContext *C, int selecting, const int mval[2], float rad)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
PEData data;
|
||||
|
||||
if (!PE_start_edit(edit))
|
||||
|
@ -1823,7 +1823,7 @@ int PE_circle_select(bContext *C, int selecting, const int mval[2], float rad)
|
|||
|
||||
for_mouse_hit_keys(&data, select_key, 0);
|
||||
|
||||
PE_update_selection(C, scene, sl, ob, 1);
|
||||
PE_update_selection(C, scene, view_layer, ob, 1);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_SELECTED, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1834,11 +1834,11 @@ int PE_circle_select(bContext *C, int selecting, const int mval[2], float rad)
|
|||
int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, bool extend, bool select)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
ARegion *ar= CTX_wm_region(C);
|
||||
ParticleEditSettings *pset= PE_settings(scene);
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
ParticleSystem *psys = edit->psys;
|
||||
ParticleSystemModifierData *psmd = psys_get_modifier(ob, psys);
|
||||
POINT_P; KEY_K;
|
||||
|
@ -1912,7 +1912,7 @@ int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, bool
|
|||
}
|
||||
}
|
||||
|
||||
PE_update_selection(C, scene, sl, ob, 1);
|
||||
PE_update_selection(C, scene, view_layer, ob, 1);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_SELECTED, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1924,8 +1924,8 @@ static int hide_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
POINT_P; KEY_K;
|
||||
|
||||
if (RNA_enum_get(op->ptr, "unselected")) {
|
||||
|
@ -1947,7 +1947,7 @@ static int hide_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
}
|
||||
|
||||
PE_update_selection(C, scene, sl, ob, 1);
|
||||
PE_update_selection(C, scene, view_layer, ob, 1);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_SELECTED, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -1977,8 +1977,8 @@ static int reveal_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
const bool select = RNA_boolean_get(op->ptr, "select");
|
||||
POINT_P; KEY_K;
|
||||
|
||||
|
@ -1993,7 +1993,7 @@ static int reveal_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
}
|
||||
|
||||
PE_update_selection(C, scene, sl, ob, 1);
|
||||
PE_update_selection(C, scene, view_layer, ob, 1);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_SELECTED, ob);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
@ -2245,9 +2245,9 @@ void PARTICLE_OT_rekey(wmOperatorType *ot)
|
|||
RNA_def_int(ot->srna, "keys_number", 2, 2, INT_MAX, "Number of Keys", "", 2, 100);
|
||||
}
|
||||
|
||||
static void rekey_particle_to_time(const bContext *C, Scene *scene, ViewLayer *sl, Object *ob, int pa_index, float path_time)
|
||||
static void rekey_particle_to_time(const bContext *C, Scene *scene, ViewLayer *view_layer, Object *ob, int pa_index, float path_time)
|
||||
{
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
ParticleSystem *psys;
|
||||
ParticleSimulationData sim = {0};
|
||||
ParticleData *pa;
|
||||
|
@ -2587,9 +2587,9 @@ void PARTICLE_OT_subdivide(wmOperatorType *ot)
|
|||
static int remove_doubles_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
ParticleSystem *psys = edit->psys;
|
||||
ParticleSystemModifierData *psmd;
|
||||
KDTree *tree;
|
||||
|
@ -2680,10 +2680,10 @@ void PARTICLE_OT_remove_doubles(wmOperatorType *ot)
|
|||
static int weight_set_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ParticleEditSettings *pset= PE_settings(scene);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
ParticleSystem *psys = edit->psys;
|
||||
POINT_P;
|
||||
KEY_K;
|
||||
|
@ -2840,11 +2840,11 @@ void PARTICLE_OT_delete(wmOperatorType *ot)
|
|||
|
||||
/*************************** mirror operator **************************/
|
||||
|
||||
static void PE_mirror_x(Scene *scene, ViewLayer *sl, Object *ob, int tagged)
|
||||
static void PE_mirror_x(Scene *scene, ViewLayer *view_layer, Object *ob, int tagged)
|
||||
{
|
||||
Mesh *me= (Mesh *)(ob->data);
|
||||
ParticleSystemModifierData *psmd;
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
ParticleSystem *psys = edit->psys;
|
||||
ParticleData *pa, *newpa, *new_pars;
|
||||
PTCacheEditPoint *newpoint, *new_points;
|
||||
|
@ -2991,11 +2991,11 @@ static void PE_mirror_x(Scene *scene, ViewLayer *sl, Object *ob, int tagged)
|
|||
static int mirror_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
|
||||
PE_mirror_x(scene, sl, ob, 0);
|
||||
PE_mirror_x(scene, view_layer, ob, 0);
|
||||
|
||||
update_world_cos(ob, edit);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_EDITED, ob);
|
||||
|
@ -3768,7 +3768,7 @@ static int brush_add(const bContext *C, PEData *data, short number)
|
|||
|
||||
typedef struct BrushEdit {
|
||||
Scene *scene;
|
||||
ViewLayer *sl;
|
||||
ViewLayer *view_layer;
|
||||
Object *ob;
|
||||
PTCacheEdit *edit;
|
||||
|
||||
|
@ -3783,10 +3783,10 @@ typedef struct BrushEdit {
|
|||
static int brush_edit_init(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= CTX_data_active_object(C);
|
||||
ParticleEditSettings *pset= PE_settings(scene);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
ARegion *ar= CTX_wm_region(C);
|
||||
BrushEdit *bedit;
|
||||
float min[3], max[3];
|
||||
|
@ -3796,7 +3796,7 @@ static int brush_edit_init(bContext *C, wmOperator *op)
|
|||
|
||||
/* set the 'distance factor' for grabbing (used in comb etc) */
|
||||
INIT_MINMAX(min, max);
|
||||
PE_minmax(scene, sl, min, max);
|
||||
PE_minmax(scene, view_layer, min, max);
|
||||
mid_v3_v3v3(min, min, max);
|
||||
|
||||
bedit= MEM_callocN(sizeof(BrushEdit), "BrushEdit");
|
||||
|
@ -3804,7 +3804,7 @@ static int brush_edit_init(bContext *C, wmOperator *op)
|
|||
op->customdata= bedit;
|
||||
|
||||
bedit->scene= scene;
|
||||
bedit->sl = sl;
|
||||
bedit->view_layer = view_layer;
|
||||
bedit->ob= ob;
|
||||
bedit->edit= edit;
|
||||
|
||||
|
@ -3820,7 +3820,7 @@ static void brush_edit_apply(bContext *C, wmOperator *op, PointerRNA *itemptr)
|
|||
{
|
||||
BrushEdit *bedit= op->customdata;
|
||||
Scene *scene= bedit->scene;
|
||||
ViewLayer *sl = bedit->sl;
|
||||
ViewLayer *view_layer = bedit->view_layer;
|
||||
Object *ob= bedit->ob;
|
||||
PTCacheEdit *edit= bedit->edit;
|
||||
ParticleEditSettings *pset= PE_settings(scene);
|
||||
|
@ -4014,14 +4014,14 @@ static void brush_edit_apply(bContext *C, wmOperator *op, PointerRNA *itemptr)
|
|||
|
||||
if (ELEM(pset->brushtype, PE_BRUSH_ADD, PE_BRUSH_CUT) && (added || removed)) {
|
||||
if (pset->brushtype == PE_BRUSH_ADD && pe_x_mirror(ob))
|
||||
PE_mirror_x(scene, sl, ob, 1);
|
||||
PE_mirror_x(scene, view_layer, ob, 1);
|
||||
|
||||
update_world_cos(ob, edit);
|
||||
psys_free_path_cache(NULL, edit);
|
||||
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
}
|
||||
else {
|
||||
PE_update_object(&eval_ctx, scene, sl, ob, 1);
|
||||
PE_update_object(&eval_ctx, scene, view_layer, ob, 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -4246,10 +4246,10 @@ static void shape_cut(PEData *data, int pa_index)
|
|||
static int shape_cut_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
ParticleEditSettings *pset = PE_settings(scene);
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
Object *shapeob = pset->shape_object;
|
||||
int selected = count_selected_keys(scene, edit);
|
||||
int lock_root = pset->flag & PE_LOCK_FIRST;
|
||||
|
@ -4288,7 +4288,7 @@ static int shape_cut_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
}
|
||||
else {
|
||||
PE_update_object(&eval_ctx, scene, sl, ob, 1);
|
||||
PE_update_object(&eval_ctx, scene, view_layer, ob, 1);
|
||||
}
|
||||
|
||||
if (edit->psys) {
|
||||
|
@ -4461,9 +4461,9 @@ static void get_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
|
|||
}
|
||||
}
|
||||
|
||||
void PE_undo_push(Scene *scene, ViewLayer *sl, const char *str)
|
||||
void PE_undo_push(Scene *scene, ViewLayer *view_layer, const char *str)
|
||||
{
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, OBACT(sl));
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
|
||||
PTCacheUndo *undo;
|
||||
int nr;
|
||||
|
||||
|
@ -4503,9 +4503,9 @@ void PE_undo_push(Scene *scene, ViewLayer *sl, const char *str)
|
|||
make_PTCacheUndo(edit, edit->curundo);
|
||||
}
|
||||
|
||||
void PE_undo_step(Scene *scene, ViewLayer *sl, int step)
|
||||
void PE_undo_step(Scene *scene, ViewLayer *view_layer, int step)
|
||||
{
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, OBACT(sl));
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
|
||||
|
||||
if (!edit) return;
|
||||
|
||||
|
@ -4536,12 +4536,12 @@ void PE_undo_step(Scene *scene, ViewLayer *sl, int step)
|
|||
}
|
||||
}
|
||||
|
||||
DEG_id_tag_update(&OBACT(sl)->id, OB_RECALC_DATA);
|
||||
DEG_id_tag_update(&OBACT(view_layer)->id, OB_RECALC_DATA);
|
||||
}
|
||||
|
||||
bool PE_undo_is_valid(Scene *scene, ViewLayer *sl)
|
||||
bool PE_undo_is_valid(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, OBACT(sl));
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
|
||||
|
||||
if (edit) {
|
||||
return (edit->undo.last != edit->undo.first);
|
||||
|
@ -4564,19 +4564,19 @@ void PTCacheUndo_clear(PTCacheEdit *edit)
|
|||
edit->curundo= NULL;
|
||||
}
|
||||
|
||||
void PE_undo(Scene *scene, ViewLayer *sl)
|
||||
void PE_undo(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
PE_undo_step(scene, sl, 1);
|
||||
PE_undo_step(scene, view_layer, 1);
|
||||
}
|
||||
|
||||
void PE_redo(Scene *scene, ViewLayer *sl)
|
||||
void PE_redo(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
PE_undo_step(scene, sl, -1);
|
||||
PE_undo_step(scene, view_layer, -1);
|
||||
}
|
||||
|
||||
void PE_undo_number(Scene *scene, ViewLayer *sl, int nr)
|
||||
void PE_undo_number(Scene *scene, ViewLayer *view_layer, int nr)
|
||||
{
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, OBACT(sl));
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
|
||||
PTCacheUndo *undo;
|
||||
int a=0;
|
||||
|
||||
|
@ -4584,15 +4584,15 @@ void PE_undo_number(Scene *scene, ViewLayer *sl, int nr)
|
|||
if (a==nr) break;
|
||||
}
|
||||
edit->curundo= undo;
|
||||
PE_undo_step(scene, sl, 0);
|
||||
PE_undo_step(scene, view_layer, 0);
|
||||
}
|
||||
|
||||
|
||||
/* get name of undo item, return null if no item with this index */
|
||||
/* if active pointer, set it to 1 if true */
|
||||
const char *PE_undo_get_name(Scene *scene, ViewLayer *sl, int nr, bool *r_active)
|
||||
const char *PE_undo_get_name(Scene *scene, ViewLayer *view_layer, int nr, bool *r_active)
|
||||
{
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, OBACT(sl));
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
|
||||
PTCacheUndo *undo;
|
||||
|
||||
if (r_active) *r_active = false;
|
||||
|
@ -4611,10 +4611,10 @@ const char *PE_undo_get_name(Scene *scene, ViewLayer *sl, int nr, bool *r_active
|
|||
|
||||
/************************ utilities ******************************/
|
||||
|
||||
int PE_minmax(Scene *scene, ViewLayer *sl, float min[3], float max[3])
|
||||
int PE_minmax(Scene *scene, ViewLayer *view_layer, float min[3], float max[3])
|
||||
{
|
||||
Object *ob= OBACT(sl);
|
||||
PTCacheEdit *edit= PE_get_current(scene, sl, ob);
|
||||
Object *ob= OBACT(view_layer);
|
||||
PTCacheEdit *edit= PE_get_current(scene, view_layer, ob);
|
||||
ParticleSystem *psys;
|
||||
ParticleSystemModifierData *psmd = NULL;
|
||||
POINT_P; KEY_K;
|
||||
|
@ -4652,7 +4652,7 @@ int PE_minmax(Scene *scene, ViewLayer *sl, float min[3], float max[3])
|
|||
|
||||
/* initialize needed data for bake edit */
|
||||
void PE_create_particle_edit(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, Object *ob, PointCache *cache, ParticleSystem *psys)
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, Object *ob, PointCache *cache, ParticleSystem *psys)
|
||||
{
|
||||
PTCacheEdit *edit;
|
||||
ParticleSystemModifierData *psmd = (psys) ? psys_get_modifier(ob, psys) : NULL;
|
||||
|
@ -4753,10 +4753,10 @@ void PE_create_particle_edit(
|
|||
recalc_lengths(edit);
|
||||
if (psys && !cache)
|
||||
recalc_emitter_field(ob, psys);
|
||||
PE_update_object(eval_ctx, scene, sl, ob, 1);
|
||||
PE_update_object(eval_ctx, scene, view_layer, ob, 1);
|
||||
|
||||
PTCacheUndo_clear(edit);
|
||||
PE_undo_push(scene, sl, "Original");
|
||||
PE_undo_push(scene, view_layer, "Original");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -4966,8 +4966,8 @@ static int unify_length_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
{
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
float average_length = calculate_average_length(edit);
|
||||
|
||||
if (average_length == 0.0f) {
|
||||
|
@ -4978,7 +4978,7 @@ static int unify_length_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
EvaluationContext eval_ctx;
|
||||
CTX_data_eval_ctx(C, &eval_ctx);
|
||||
|
||||
PE_update_object(&eval_ctx, scene, sl, ob, 1);
|
||||
PE_update_object(&eval_ctx, scene, view_layer, ob, 1);
|
||||
if (edit->psys) {
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE|NA_EDITED, ob);
|
||||
}
|
||||
|
|
|
@ -71,7 +71,7 @@
|
|||
|
||||
#include "physics_intern.h"
|
||||
|
||||
extern void PE_create_particle_edit(const bContext *C, Scene *scene, ViewLayer *sl, Object *ob, PointCache *cache, ParticleSystem *psys);
|
||||
extern void PE_create_particle_edit(const bContext *C, Scene *scene, ViewLayer *view_layer, Object *ob, PointCache *cache, ParticleSystem *psys);
|
||||
extern void PTCacheUndo_clear(PTCacheEdit *edit);
|
||||
extern void recalc_lengths(PTCacheEdit *edit);
|
||||
extern void recalc_emitter_field(Object *ob, ParticleSystem *psys);
|
||||
|
@ -135,7 +135,7 @@ static int particle_system_remove_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
{
|
||||
Object *ob = ED_object_context(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
int mode_orig;
|
||||
|
||||
if (!scene || !ob)
|
||||
|
@ -149,7 +149,7 @@ static int particle_system_remove_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
*/
|
||||
if (mode_orig & OB_MODE_PARTICLE_EDIT) {
|
||||
if ((ob->mode & OB_MODE_PARTICLE_EDIT) == 0) {
|
||||
if (sl->basact && sl->basact->object == ob) {
|
||||
if (view_layer->basact && view_layer->basact->object == ob) {
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_MODE|NS_MODE_OBJECT, NULL);
|
||||
}
|
||||
}
|
||||
|
@ -569,7 +569,7 @@ void PARTICLE_OT_dupliob_move_down(wmOperatorType *ot)
|
|||
/************************ connect/disconnect hair operators *********************/
|
||||
|
||||
static void disconnect_hair(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer,
|
||||
Object *ob, ParticleSystem *psys)
|
||||
{
|
||||
ParticleSystemModifierData *psmd = psys_get_modifier(ob, psys);
|
||||
|
@ -616,13 +616,13 @@ static void disconnect_hair(
|
|||
if (ELEM(pset->brushtype, PE_BRUSH_ADD, PE_BRUSH_PUFF))
|
||||
pset->brushtype = PE_BRUSH_NONE;
|
||||
|
||||
PE_update_object(eval_ctx, scene, sl, ob, 0);
|
||||
PE_update_object(eval_ctx, scene, view_layer, ob, 0);
|
||||
}
|
||||
|
||||
static int disconnect_hair_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= ED_object_context(C);
|
||||
ParticleSystem *psys= NULL;
|
||||
const bool all = RNA_boolean_get(op->ptr, "all");
|
||||
|
@ -635,12 +635,12 @@ static int disconnect_hair_exec(bContext *C, wmOperator *op)
|
|||
|
||||
if (all) {
|
||||
for (psys=ob->particlesystem.first; psys; psys=psys->next) {
|
||||
disconnect_hair(&eval_ctx, scene, sl, ob, psys);
|
||||
disconnect_hair(&eval_ctx, scene, view_layer, ob, psys);
|
||||
}
|
||||
}
|
||||
else {
|
||||
psys = psys_get_current(ob);
|
||||
disconnect_hair(&eval_ctx, scene, sl, ob, psys);
|
||||
disconnect_hair(&eval_ctx, scene, view_layer, ob, psys);
|
||||
}
|
||||
|
||||
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
|
@ -667,7 +667,7 @@ void PARTICLE_OT_disconnect_hair(wmOperatorType *ot)
|
|||
* from/to_mat : additional transform for from/to particles (e.g. for using object space copying)
|
||||
*/
|
||||
static bool remap_hair_emitter(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, Object *ob, ParticleSystem *psys,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, Object *ob, ParticleSystem *psys,
|
||||
Object *target_ob, ParticleSystem *target_psys, PTCacheEdit *target_edit,
|
||||
float from_mat[4][4], float to_mat[4][4], bool from_global, bool to_global)
|
||||
{
|
||||
|
@ -853,13 +853,13 @@ static bool remap_hair_emitter(
|
|||
|
||||
psys_free_path_cache(target_psys, target_edit);
|
||||
|
||||
PE_update_object(eval_ctx, scene, sl, target_ob, 0);
|
||||
PE_update_object(eval_ctx, scene, view_layer, target_ob, 0);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool connect_hair(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer,
|
||||
Object *ob, ParticleSystem *psys)
|
||||
{
|
||||
bool ok;
|
||||
|
@ -868,7 +868,7 @@ static bool connect_hair(
|
|||
return false;
|
||||
|
||||
ok = remap_hair_emitter(
|
||||
eval_ctx, scene, sl, ob, psys, ob, psys, psys->edit,
|
||||
eval_ctx, scene, view_layer, ob, psys, ob, psys, psys->edit,
|
||||
ob->obmat, ob->obmat, psys->flag & PSYS_GLOBAL_HAIR, false);
|
||||
psys->flag &= ~PSYS_GLOBAL_HAIR;
|
||||
|
||||
|
@ -879,7 +879,7 @@ static int connect_hair_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
EvaluationContext eval_ctx;
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob= ED_object_context(C);
|
||||
ParticleSystem *psys= NULL;
|
||||
const bool all = RNA_boolean_get(op->ptr, "all");
|
||||
|
@ -892,12 +892,12 @@ static int connect_hair_exec(bContext *C, wmOperator *op)
|
|||
|
||||
if (all) {
|
||||
for (psys=ob->particlesystem.first; psys; psys=psys->next) {
|
||||
any_connected |= connect_hair(&eval_ctx, scene, sl, ob, psys);
|
||||
any_connected |= connect_hair(&eval_ctx, scene, view_layer, ob, psys);
|
||||
}
|
||||
}
|
||||
else {
|
||||
psys = psys_get_current(ob);
|
||||
any_connected |= connect_hair(&eval_ctx, scene, sl, ob, psys);
|
||||
any_connected |= connect_hair(&eval_ctx, scene, view_layer, ob, psys);
|
||||
}
|
||||
|
||||
if (!any_connected) {
|
||||
|
@ -934,7 +934,7 @@ typedef enum eCopyParticlesSpace {
|
|||
} eCopyParticlesSpace;
|
||||
|
||||
static void copy_particle_edit(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer,
|
||||
Object *ob, ParticleSystem *psys, ParticleSystem *psys_from)
|
||||
{
|
||||
PTCacheEdit *edit_from = psys_from->edit, *edit;
|
||||
|
@ -985,10 +985,10 @@ static void copy_particle_edit(
|
|||
|
||||
recalc_lengths(edit);
|
||||
recalc_emitter_field(ob, psys);
|
||||
PE_update_object(eval_ctx, scene, sl, ob, true);
|
||||
PE_update_object(eval_ctx, scene, view_layer, ob, true);
|
||||
|
||||
PTCacheUndo_clear(edit);
|
||||
PE_undo_push(scene, sl, "Original");
|
||||
PE_undo_push(scene, view_layer, "Original");
|
||||
}
|
||||
|
||||
static void remove_particle_systems_from_object(Object *ob_to)
|
||||
|
@ -1018,7 +1018,7 @@ static void remove_particle_systems_from_object(Object *ob_to)
|
|||
/* single_psys_from is optional, if NULL all psys of ob_from are copied */
|
||||
static bool copy_particle_systems_to_object(const bContext *C,
|
||||
Scene *scene,
|
||||
ViewLayer *sl,
|
||||
ViewLayer *view_layer,
|
||||
Object *ob_from,
|
||||
ParticleSystem *single_psys_from,
|
||||
Object *ob_to,
|
||||
|
@ -1103,7 +1103,7 @@ static bool copy_particle_systems_to_object(const bContext *C,
|
|||
DM_ensure_tessface(psmd->dm_final);
|
||||
|
||||
if (psys_from->edit) {
|
||||
copy_particle_edit(&eval_ctx, scene, sl, ob_to, psys, psys_from);
|
||||
copy_particle_edit(&eval_ctx, scene, view_layer, ob_to, psys, psys_from);
|
||||
}
|
||||
|
||||
if (duplicate_settings) {
|
||||
|
@ -1139,7 +1139,7 @@ static bool copy_particle_systems_to_object(const bContext *C,
|
|||
}
|
||||
if (ob_from != ob_to) {
|
||||
remap_hair_emitter(
|
||||
&eval_ctx, scene, sl, ob_from, psys_from, ob_to, psys, psys->edit,
|
||||
&eval_ctx, scene, view_layer, ob_from, psys_from, ob_to, psys, psys->edit,
|
||||
from_mat, to_mat, psys_from->flag & PSYS_GLOBAL_HAIR, psys->flag & PSYS_GLOBAL_HAIR);
|
||||
}
|
||||
|
||||
|
@ -1174,7 +1174,7 @@ static int copy_particle_systems_exec(bContext *C, wmOperator *op)
|
|||
const bool remove_target_particles = RNA_boolean_get(op->ptr, "remove_target_particles");
|
||||
const bool use_active = RNA_boolean_get(op->ptr, "use_active");
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob_from = ED_object_active_context(C);
|
||||
ParticleSystem *psys_from = use_active ? CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data : NULL;
|
||||
|
||||
|
@ -1189,7 +1189,7 @@ static int copy_particle_systems_exec(bContext *C, wmOperator *op)
|
|||
remove_particle_systems_from_object(ob_to);
|
||||
changed = true;
|
||||
}
|
||||
if (copy_particle_systems_to_object(C, scene, sl, ob_from, psys_from, ob_to, space, false))
|
||||
if (copy_particle_systems_to_object(C, scene, view_layer, ob_from, psys_from, ob_to, space, false))
|
||||
changed = true;
|
||||
else
|
||||
fail++;
|
||||
|
|
|
@ -331,7 +331,7 @@ static void free_all_fluidobject_channels(ListBase *fobjects)
|
|||
static void fluid_init_all_channels(bContext *C, Object *UNUSED(fsDomain), FluidsimSettings *domainSettings, FluidAnimChannels *channels, ListBase *fobjects)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Depsgraph *depsgraph = CTX_data_depsgraph(C);
|
||||
EvaluationContext eval_ctx;
|
||||
Base *base;
|
||||
|
@ -350,7 +350,7 @@ static void fluid_init_all_channels(bContext *C, Object *UNUSED(fsDomain), Fluid
|
|||
channels->DomainTime = MEM_callocN(length * (CHANNEL_FLOAT+1) * sizeof(float), "channel DomainTime");
|
||||
|
||||
/* allocate fluid objects */
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
Object *ob = base->object;
|
||||
FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType(ob, eModifierType_Fluidsim);
|
||||
|
||||
|
@ -409,7 +409,7 @@ static void fluid_init_all_channels(bContext *C, Object *UNUSED(fsDomain), Fluid
|
|||
/* Modifying the global scene isn't nice, but we can do it in
|
||||
* this part of the process before a threaded job is created */
|
||||
scene->r.cfra = (int)eval_time;
|
||||
ED_update_for_newframe(CTX_data_main(C), scene, sl, depsgraph);
|
||||
ED_update_for_newframe(CTX_data_main(C), scene, view_layer, depsgraph);
|
||||
|
||||
/* now scene data should be current according to animation system, so we fill the channels */
|
||||
|
||||
|
@ -580,14 +580,14 @@ static void export_fluid_objects(const bContext *C, ListBase *fobjects, Scene *s
|
|||
}
|
||||
}
|
||||
|
||||
static int fluid_validate_scene(ReportList *reports, ViewLayer *sl, Object *fsDomain)
|
||||
static int fluid_validate_scene(ReportList *reports, ViewLayer *view_layer, Object *fsDomain)
|
||||
{
|
||||
Base *base;
|
||||
Object *newdomain = NULL;
|
||||
int channelObjCount = 0;
|
||||
int fluidInputCount = 0;
|
||||
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
Object *ob = base->object;
|
||||
FluidsimModifierData *fluidmdtmp = (FluidsimModifierData *)modifiers_findByType(ob, eModifierType_Fluidsim);
|
||||
|
||||
|
@ -846,7 +846,7 @@ static void fluidsim_delete_until_lastframe(FluidsimSettings *fss, const char *r
|
|||
static int fluidsimBake(bContext *C, ReportList *reports, Object *fsDomain, short do_job)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Depsgraph *depsgraph = CTX_data_depsgraph(C);
|
||||
int i;
|
||||
FluidsimSettings *domainSettings;
|
||||
|
@ -894,7 +894,7 @@ static int fluidsimBake(bContext *C, ReportList *reports, Object *fsDomain, shor
|
|||
}
|
||||
|
||||
/* check scene for sane object/modifier settings */
|
||||
if (!fluid_validate_scene(reports, sl, fsDomain)) {
|
||||
if (!fluid_validate_scene(reports, view_layer, fsDomain)) {
|
||||
fluidbake_free_data(channels, fobjects, fsset, fb);
|
||||
return 0;
|
||||
}
|
||||
|
@ -959,7 +959,7 @@ static int fluidsimBake(bContext *C, ReportList *reports, Object *fsDomain, shor
|
|||
|
||||
/* reset to original current frame */
|
||||
scene->r.cfra = origFrame;
|
||||
ED_update_for_newframe(CTX_data_main(C), scene, sl, depsgraph);
|
||||
ED_update_for_newframe(CTX_data_main(C), scene, view_layer, depsgraph);
|
||||
|
||||
/* ******** init domain object's matrix ******** */
|
||||
copy_m4_m4(domainMat, fsDomain->obmat);
|
||||
|
|
|
@ -119,9 +119,9 @@ static int rigidbody_con_add_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
RigidBodyWorld *rbw = BKE_rigidbody_get_world(scene);
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
int type = RNA_enum_get(op->ptr, "type");
|
||||
bool changed;
|
||||
|
||||
|
@ -169,8 +169,8 @@ static int rigidbody_con_remove_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(view_layer);
|
||||
|
||||
/* apply to active object */
|
||||
if (ELEM(NULL, ob, ob->rigidbody_constraint)) {
|
||||
|
|
|
@ -396,7 +396,7 @@ static void texture_changed(Main *bmain, Tex *tex)
|
|||
Lamp *la;
|
||||
World *wo;
|
||||
Scene *scene;
|
||||
ViewLayer *sl;
|
||||
ViewLayer *view_layer;
|
||||
Object *ob;
|
||||
bNode *node;
|
||||
bool texture_draw = false;
|
||||
|
@ -406,8 +406,8 @@ static void texture_changed(Main *bmain, Tex *tex)
|
|||
|
||||
/* paint overlays */
|
||||
for (scene = bmain->scene.first; scene; scene = scene->id.next) {
|
||||
for (sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
BKE_paint_invalidate_overlay_tex(scene, sl, tex);
|
||||
for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
BKE_paint_invalidate_overlay_tex(scene, view_layer, tex);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -89,9 +89,9 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
ScrArea *sa = CTX_wm_area(C);
|
||||
Scene *scene = WM_window_get_active_scene(win);
|
||||
WorkSpace *workspace = BKE_workspace_active_get(win->workspace_hook);
|
||||
ViewLayer *sl = BKE_view_layer_from_workspace_get(scene, workspace);
|
||||
ViewLayer *view_layer = BKE_view_layer_from_workspace_get(scene, workspace);
|
||||
Object *obedit = scene->obedit;
|
||||
Object *obact = sl->basact ? sl->basact->object : NULL;
|
||||
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
|
||||
|
||||
if (CTX_data_dir(member)) {
|
||||
CTX_data_dir_set(result, screen_context_dir);
|
||||
|
@ -102,7 +102,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "visible_objects")) {
|
||||
FOREACH_VISIBLE_OBJECT(sl, ob)
|
||||
FOREACH_VISIBLE_OBJECT(view_layer, ob)
|
||||
{
|
||||
CTX_data_id_list_add(result, &ob->id);
|
||||
}
|
||||
|
@ -111,7 +111,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "selectable_objects")) {
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (((base->flag & BASE_VISIBLED) != 0) && ((base->flag & BASE_SELECTABLED) != 0)) {
|
||||
CTX_data_id_list_add(result, &base->object->id);
|
||||
}
|
||||
|
@ -120,7 +120,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "selected_objects")) {
|
||||
FOREACH_SELECTED_OBJECT(sl, ob)
|
||||
FOREACH_SELECTED_OBJECT(view_layer, ob)
|
||||
{
|
||||
CTX_data_id_list_add(result, &ob->id);
|
||||
}
|
||||
|
@ -129,7 +129,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "selected_editable_objects")) {
|
||||
FOREACH_SELECTED_OBJECT(sl, ob)
|
||||
FOREACH_SELECTED_OBJECT(view_layer, ob)
|
||||
{
|
||||
if (0 == BKE_object_is_libdata(ob)) {
|
||||
CTX_data_id_list_add(result, &ob->id);
|
||||
|
@ -141,7 +141,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
}
|
||||
else if (CTX_data_equals(member, "editable_objects")) {
|
||||
/* Visible + Editable, but not necessarily selected */
|
||||
FOREACH_VISIBLE_OBJECT(sl, ob)
|
||||
FOREACH_VISIBLE_OBJECT(view_layer, ob)
|
||||
{
|
||||
if (0 == BKE_object_is_libdata(ob)) {
|
||||
CTX_data_id_list_add(result, &ob->id);
|
||||
|
@ -152,7 +152,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if ( CTX_data_equals(member, "visible_bases")) {
|
||||
FOREACH_VISIBLE_BASE(sl, base)
|
||||
FOREACH_VISIBLE_BASE(view_layer, base)
|
||||
{
|
||||
CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
|
||||
}
|
||||
|
@ -161,7 +161,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "selectable_bases")) {
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if ((base->flag & BASE_SELECTABLED) != 0) {
|
||||
CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
|
||||
}
|
||||
|
@ -170,7 +170,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "selected_bases")) {
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if ((base->flag & BASE_SELECTED) != 0) {
|
||||
CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
|
||||
}
|
||||
|
@ -179,7 +179,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "selected_editable_bases")) {
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if ((base->flag & BASE_SELECTED) != 0) {
|
||||
if (0 == BKE_object_is_libdata(base->object)) {
|
||||
CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
|
||||
|
@ -191,7 +191,7 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
}
|
||||
else if (CTX_data_equals(member, "editable_bases")) {
|
||||
/* Visible + Editable, but not necessarily selected */
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if ((base->flag & BASE_VISIBLED) != 0) {
|
||||
if (0 == BKE_object_is_libdata(base->object)) {
|
||||
CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
|
||||
|
@ -346,8 +346,8 @@ int ed_screen_context(const bContext *C, const char *member, bContextDataResult
|
|||
}
|
||||
}
|
||||
else if (CTX_data_equals(member, "active_base")) {
|
||||
if (sl->basact)
|
||||
CTX_data_pointer_set(result, &scene->id, &RNA_ObjectBase, sl->basact);
|
||||
if (view_layer->basact)
|
||||
CTX_data_pointer_set(result, &scene->id, &RNA_ObjectBase, view_layer->basact);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -574,8 +574,8 @@ int ED_operator_mask(bContext *C)
|
|||
case SPACE_IMAGE:
|
||||
{
|
||||
SpaceImage *sima = sa->spacedata.first;
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
return ED_space_image_check_show_maskedit(sl, sima);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
return ED_space_image_check_show_maskedit(view_layer, sima);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -765,8 +765,8 @@ static PaintOperation *texture_paint_init(bContext *C, wmOperator *op, const flo
|
|||
|
||||
/* initialize from context */
|
||||
if (CTX_wm_region_view3d(C)) {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(view_layer);
|
||||
bool uvs, mat, tex, stencil;
|
||||
if (!BKE_paint_proj_mesh_data_check(scene, ob, &uvs, &mat, &tex, &stencil)) {
|
||||
BKE_paint_data_warning(op->reports, uvs, mat, tex, stencil);
|
||||
|
|
|
@ -5321,12 +5321,12 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
|
|||
{
|
||||
Image *image = BLI_findlink(&CTX_data_main(C)->image, RNA_enum_get(op->ptr, "image"));
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ProjPaintState ps = {NULL};
|
||||
int orig_brush_size;
|
||||
IDProperty *idgroup;
|
||||
IDProperty *view_data = NULL;
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
bool uvs, mat, tex;
|
||||
|
||||
if (ob == NULL || ob->type != OB_MESH) {
|
||||
|
|
|
@ -452,8 +452,8 @@ void paint_sample_color(bContext *C, ARegion *ar, int x, int y, bool texpaint_pr
|
|||
|
||||
if (CTX_wm_view3d(C) && texpaint_proj) {
|
||||
/* first try getting a colour directly from the mesh faces if possible */
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(view_layer);
|
||||
bool sample_success = false;
|
||||
ImagePaintSettings *imapaint = &scene->toolsettings->imapaint;
|
||||
bool use_material = (imapaint->mode == IMAGEPAINT_MODE_MATERIAL);
|
||||
|
@ -567,9 +567,9 @@ static int brush_curve_preset_exec(bContext *C, wmOperator *op)
|
|||
|
||||
if (br) {
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
BKE_brush_curve_preset(br, RNA_enum_get(op->ptr, "shape"));
|
||||
BKE_paint_invalidate_cursor_overlay(scene, sl, br->curve);
|
||||
BKE_paint_invalidate_cursor_overlay(scene, view_layer, br->curve);
|
||||
}
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
|
|
|
@ -186,8 +186,8 @@ static int buttons_context_path_collection(ButsContextPath *path)
|
|||
return 1;
|
||||
}
|
||||
|
||||
ViewLayer *sl = ptr->data;
|
||||
LayerCollection *sc = BKE_layer_collection_get_active(sl);
|
||||
ViewLayer *view_layer = ptr->data;
|
||||
LayerCollection *sc = BKE_layer_collection_get_active(view_layer);
|
||||
|
||||
if (sc) {
|
||||
RNA_pointer_create(NULL, &RNA_LayerCollection, sc, &path->ptr[path->len]);
|
||||
|
@ -208,8 +208,8 @@ static int buttons_context_path_object(ButsContextPath *path)
|
|||
return 1;
|
||||
}
|
||||
|
||||
ViewLayer *sl = ptr->data;
|
||||
Object *ob = (sl->basact) ? sl->basact->object : NULL;
|
||||
ViewLayer *view_layer = ptr->data;
|
||||
Object *ob = (view_layer->basact) ? view_layer->basact->object : NULL;
|
||||
|
||||
if (ob) {
|
||||
RNA_id_pointer_create(&ob->id, &path->ptr[path->len]);
|
||||
|
@ -411,8 +411,8 @@ static int buttons_context_path_brush(const bContext *C, ButsContextPath *path)
|
|||
scene = path->ptr[path->len - 1].data;
|
||||
|
||||
if (scene) {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
br = BKE_paint_brush(BKE_paint_get_active(scene, sl));
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
br = BKE_paint_brush(BKE_paint_get_active(scene, view_layer));
|
||||
}
|
||||
|
||||
if (br) {
|
||||
|
|
|
@ -88,7 +88,7 @@ static Object *get_camera_with_movieclip(Scene *scene, MovieClip *clip)
|
|||
static Object *get_orientation_object(bContext *C)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
SpaceClip *sc = CTX_wm_space_clip(C);
|
||||
MovieClip *clip = ED_space_clip_get_clip(sc);
|
||||
MovieTracking *tracking = &clip->tracking;
|
||||
|
@ -99,7 +99,7 @@ static Object *get_orientation_object(bContext *C)
|
|||
object = get_camera_with_movieclip(scene, clip);
|
||||
}
|
||||
else {
|
||||
object = OBACT(sl);
|
||||
object = OBACT(view_layer);
|
||||
}
|
||||
|
||||
if (object != NULL && object->parent != NULL) {
|
||||
|
@ -113,7 +113,7 @@ static int set_orientation_poll(bContext *C)
|
|||
{
|
||||
SpaceClip *sc = CTX_wm_space_clip(C);
|
||||
if (sc != NULL) {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
MovieClip *clip = ED_space_clip_get_clip(sc);
|
||||
if (clip != NULL) {
|
||||
MovieTracking *tracking = &clip->tracking;
|
||||
|
@ -122,7 +122,7 @@ static int set_orientation_poll(bContext *C)
|
|||
return true;
|
||||
}
|
||||
else {
|
||||
return OBACT(sl) != NULL;
|
||||
return OBACT(view_layer) != NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -374,10 +374,10 @@ bool ED_space_image_show_uvedit(SpaceImage *sima, Object *obedit)
|
|||
}
|
||||
|
||||
/* matches clip function */
|
||||
bool ED_space_image_check_show_maskedit(ViewLayer *sl, SpaceImage *sima)
|
||||
bool ED_space_image_check_show_maskedit(ViewLayer *view_layer, SpaceImage *sima)
|
||||
{
|
||||
/* check editmode - this is reserved for UV editing */
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
if (ob && ob->mode & OB_MODE_EDIT && ED_space_image_show_uvedit(sima, ob)) {
|
||||
return false;
|
||||
}
|
||||
|
@ -390,8 +390,8 @@ int ED_space_image_maskedit_poll(bContext *C)
|
|||
SpaceImage *sima = CTX_wm_space_image(C);
|
||||
|
||||
if (sima) {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
return ED_space_image_check_show_maskedit(sl, sima);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
return ED_space_image_check_show_maskedit(view_layer, sima);
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
|
@ -794,7 +794,7 @@ static int image_view_selected_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
SpaceImage *sima;
|
||||
ARegion *ar;
|
||||
Scene *scene;
|
||||
ViewLayer *sl;
|
||||
ViewLayer *view_layer;
|
||||
Object *obedit;
|
||||
Image *ima;
|
||||
|
||||
|
@ -802,7 +802,7 @@ static int image_view_selected_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
sima = CTX_wm_space_image(C);
|
||||
ar = CTX_wm_region(C);
|
||||
scene = CTX_data_scene(C);
|
||||
sl = CTX_data_view_layer(C);
|
||||
view_layer = CTX_data_view_layer(C);
|
||||
obedit = CTX_data_edit_object(C);
|
||||
|
||||
ima = ED_space_image(sima);
|
||||
|
@ -814,7 +814,7 @@ static int image_view_selected_exec(bContext *C, wmOperator *UNUSED(op))
|
|||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
}
|
||||
else if (ED_space_image_check_show_maskedit(sl, sima)) {
|
||||
else if (ED_space_image_check_show_maskedit(view_layer, sima)) {
|
||||
if (!ED_mask_selected_minmax(C, min, max)) {
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
|
|
@ -537,8 +537,8 @@ static void image_listener(bScreen *UNUSED(sc), ScrArea *sa, wmNotifier *wmn, Sc
|
|||
case ND_TRANSFORM:
|
||||
case ND_MODIFIER:
|
||||
{
|
||||
ViewLayer *sl = BKE_view_layer_from_workspace_get(scene, workspace);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = BKE_view_layer_from_workspace_get(scene, workspace);
|
||||
Object *ob = OBACT(view_layer);
|
||||
if (ob && (ob == wmn->reference) && (ob->mode & OB_MODE_EDIT)) {
|
||||
if (sima->lock && (sima->flag & SI_DRAWSHADOW)) {
|
||||
ED_area_tag_refresh(sa);
|
||||
|
@ -721,7 +721,7 @@ static void image_main_region_draw(const bContext *C, ARegion *ar)
|
|||
Mask *mask = NULL;
|
||||
bool curve = false;
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
View2D *v2d = &ar->v2d;
|
||||
//View2DScrollers *scrollers;
|
||||
float col[3];
|
||||
|
@ -757,7 +757,7 @@ static void image_main_region_draw(const bContext *C, ARegion *ar)
|
|||
|
||||
ED_region_draw_cb_draw(C, ar, REGION_DRAW_PRE_VIEW);
|
||||
|
||||
ED_uvedit_draw_main(sima, ar, scene, sl, obedit, obact, depsgraph);
|
||||
ED_uvedit_draw_main(sima, ar, scene, view_layer, obedit, obact, depsgraph);
|
||||
|
||||
/* check for mask (delay draw) */
|
||||
if (ED_space_image_show_uvedit(sima, obedit)) {
|
||||
|
|
|
@ -345,10 +345,10 @@ static bool stats_is_object_dynamic_topology_sculpt(Object *ob)
|
|||
}
|
||||
|
||||
/* Statistics displayed in info header. Called regularly on scene changes. */
|
||||
static void stats_update(Scene *scene, ViewLayer *sl)
|
||||
static void stats_update(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
SceneStats stats = {0};
|
||||
Object *ob = (sl->basact) ? sl->basact->object : NULL;
|
||||
Object *ob = (view_layer->basact) ? view_layer->basact->object : NULL;
|
||||
Base *base;
|
||||
|
||||
if (scene->obedit) {
|
||||
|
@ -365,25 +365,25 @@ static void stats_update(Scene *scene, ViewLayer *sl)
|
|||
}
|
||||
else {
|
||||
/* Objects */
|
||||
for (base = sl->object_bases.first; base; base = base->next)
|
||||
for (base = view_layer->object_bases.first; base; base = base->next)
|
||||
if (base->flag & BASE_VISIBLED) {
|
||||
stats_dupli_object(base, base->object, &stats);
|
||||
}
|
||||
}
|
||||
|
||||
if (!sl->stats) {
|
||||
sl->stats = MEM_callocN(sizeof(SceneStats), "SceneStats");
|
||||
if (!view_layer->stats) {
|
||||
view_layer->stats = MEM_callocN(sizeof(SceneStats), "SceneStats");
|
||||
}
|
||||
|
||||
*(sl->stats) = stats;
|
||||
*(view_layer->stats) = stats;
|
||||
}
|
||||
|
||||
static void stats_string(Scene *scene, ViewLayer *sl)
|
||||
static void stats_string(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
#define MAX_INFO_MEM_LEN 64
|
||||
SceneStats *stats = sl->stats;
|
||||
SceneStats *stats = view_layer->stats;
|
||||
SceneStatsFmt stats_fmt;
|
||||
Object *ob = (sl->basact) ? sl->basact->object : NULL;
|
||||
Object *ob = (view_layer->basact) ? view_layer->basact->object : NULL;
|
||||
uintptr_t mem_in_use, mmap_in_use;
|
||||
char memstr[MAX_INFO_MEM_LEN];
|
||||
char gpumemstr[MAX_INFO_MEM_LEN] = "";
|
||||
|
@ -490,20 +490,20 @@ static void stats_string(Scene *scene, ViewLayer *sl)
|
|||
|
||||
#undef MAX_INFO_LEN
|
||||
|
||||
void ED_info_stats_clear(ViewLayer *sl)
|
||||
void ED_info_stats_clear(ViewLayer *view_layer)
|
||||
{
|
||||
if (sl->stats) {
|
||||
MEM_freeN(sl->stats);
|
||||
sl->stats = NULL;
|
||||
if (view_layer->stats) {
|
||||
MEM_freeN(view_layer->stats);
|
||||
view_layer->stats = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
const char *ED_info_stats_string(Scene *scene, ViewLayer *sl)
|
||||
const char *ED_info_stats_string(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
if (!sl->stats) {
|
||||
stats_update(scene, sl);
|
||||
if (!view_layer->stats) {
|
||||
stats_update(scene, view_layer);
|
||||
}
|
||||
stats_string(scene, sl);
|
||||
stats_string(scene, view_layer);
|
||||
|
||||
return sl->stats->infostr;
|
||||
return view_layer->stats->infostr;
|
||||
}
|
||||
|
|
|
@ -463,7 +463,7 @@ static ID **get_selected_and_linked_obs(bContext *C, short *count, short scavisf
|
|||
Base *base;
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob, *obt, *obact = CTX_data_active_object(C);
|
||||
ID **idar;
|
||||
bSensor *sens;
|
||||
|
@ -485,7 +485,7 @@ static ID **get_selected_and_linked_obs(bContext *C, short *count, short scavisf
|
|||
ob= ob->id.next;
|
||||
}
|
||||
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if ((base->flag & BASE_VISIBLED) && (base->flag & SELECT)) {
|
||||
if (scavisflag & BUTS_SENS_SEL) base->object->scavisflag |= OB_VIS_SENS;
|
||||
if (scavisflag & BUTS_CONT_SEL) base->object->scavisflag |= OB_VIS_CONT;
|
||||
|
|
|
@ -109,7 +109,7 @@ static SceneCollection *scene_collection_from_index(ListBase *lb, const int numb
|
|||
static int collection_link_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
SceneCollection *sc_master = BKE_collection_master(scene);
|
||||
SceneCollection *sc;
|
||||
|
||||
|
@ -123,7 +123,7 @@ static int collection_link_exec(bContext *C, wmOperator *op)
|
|||
BLI_assert(sc);
|
||||
}
|
||||
|
||||
BKE_collection_link(sl, sc);
|
||||
BKE_collection_link(view_layer, sc);
|
||||
|
||||
DEG_relations_tag_update(CTX_data_main(C));
|
||||
|
||||
|
@ -212,8 +212,8 @@ static int collection_unlink_poll(bContext *C)
|
|||
return 0;
|
||||
}
|
||||
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
return BLI_findindex(&sl->layer_collections, lc) != -1 ? 1 : 0;
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
return BLI_findindex(&view_layer->layer_collections, lc) != -1 ? 1 : 0;
|
||||
}
|
||||
|
||||
static int collection_unlink_exec(bContext *C, wmOperator *op)
|
||||
|
@ -226,8 +226,8 @@ static int collection_unlink_exec(bContext *C, wmOperator *op)
|
|||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
BKE_collection_unlink(sl, lc);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
BKE_collection_unlink(view_layer, lc);
|
||||
|
||||
if (soops) {
|
||||
outliner_cleanup_tree(soops);
|
||||
|
@ -260,10 +260,10 @@ void OUTLINER_OT_collection_unlink(wmOperatorType *ot)
|
|||
static int collection_new_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
|
||||
SceneCollection *sc = BKE_collection_add(scene, NULL, NULL);
|
||||
BKE_collection_link(sl, sc);
|
||||
BKE_collection_link(view_layer, sc);
|
||||
|
||||
DEG_relations_tag_update(CTX_data_main(C));
|
||||
WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
|
||||
|
@ -382,9 +382,9 @@ void OUTLINER_OT_collections_delete(wmOperatorType *ot)
|
|||
|
||||
static int collection_select_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
const int collection_index = RNA_int_get(op->ptr, "collection_index");
|
||||
sl->active_collection = collection_index;
|
||||
view_layer->active_collection = collection_index;
|
||||
WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
|
|
@ -300,7 +300,7 @@ static void namebutton_cb(bContext *C, void *tsep, char *oldname)
|
|||
{
|
||||
SpaceOops *soops = CTX_wm_space_outliner(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
BLI_mempool *ts = soops->treestore;
|
||||
TreeStoreElem *tselem = tsep;
|
||||
|
@ -362,7 +362,7 @@ static void namebutton_cb(bContext *C, void *tsep, char *oldname)
|
|||
BLI_strncpy(newname, ebone->name, sizeof(ebone->name));
|
||||
BLI_strncpy(ebone->name, oldname, sizeof(ebone->name));
|
||||
ED_armature_bone_rename(obedit->data, oldname, newname);
|
||||
WM_event_add_notifier(C, NC_OBJECT | ND_POSE, OBACT(sl));
|
||||
WM_event_add_notifier(C, NC_OBJECT | ND_POSE, OBACT(view_layer));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
@ -374,8 +374,8 @@ static void namebutton_cb(bContext *C, void *tsep, char *oldname)
|
|||
char newname[sizeof(bone->name)];
|
||||
|
||||
/* always make current object active */
|
||||
tree_element_active(C, scene, sl, soops, te, OL_SETSEL_NORMAL, true);
|
||||
ob = OBACT(sl);
|
||||
tree_element_active(C, scene, view_layer, soops, te, OL_SETSEL_NORMAL, true);
|
||||
ob = OBACT(view_layer);
|
||||
|
||||
/* restore bone name */
|
||||
BLI_strncpy(newname, bone->name, sizeof(bone->name));
|
||||
|
@ -391,8 +391,8 @@ static void namebutton_cb(bContext *C, void *tsep, char *oldname)
|
|||
char newname[sizeof(pchan->name)];
|
||||
|
||||
/* always make current pose-bone active */
|
||||
tree_element_active(C, scene, sl, soops, te, OL_SETSEL_NORMAL, true);
|
||||
ob = OBACT(sl);
|
||||
tree_element_active(C, scene, view_layer, soops, te, OL_SETSEL_NORMAL, true);
|
||||
ob = OBACT(view_layer);
|
||||
|
||||
BLI_assert(ob->type == OB_ARMATURE);
|
||||
|
||||
|
@ -1239,7 +1239,7 @@ static void tselem_draw_icon(uiBlock *block, int xmax, float x, float y, TreeSto
|
|||
#undef ICON_DRAW
|
||||
}
|
||||
|
||||
static void outliner_draw_iconrow(bContext *C, uiBlock *block, Scene *scene, ViewLayer *sl, SpaceOops *soops,
|
||||
static void outliner_draw_iconrow(bContext *C, uiBlock *block, Scene *scene, ViewLayer *view_layer, SpaceOops *soops,
|
||||
ListBase *lb, int level, int xmax, int *offsx, int ys, float alpha_fac)
|
||||
{
|
||||
TreeElement *te;
|
||||
|
@ -1259,17 +1259,17 @@ static void outliner_draw_iconrow(bContext *C, uiBlock *block, Scene *scene, Vie
|
|||
/* active blocks get white circle */
|
||||
if (tselem->type == 0) {
|
||||
if (te->idcode == ID_OB) {
|
||||
active = (OBACT(sl) == (Object *)tselem->id) ? OL_DRAWSEL_NORMAL : OL_DRAWSEL_NONE;
|
||||
active = (OBACT(view_layer) == (Object *)tselem->id) ? OL_DRAWSEL_NORMAL : OL_DRAWSEL_NONE;
|
||||
}
|
||||
else if (scene->obedit && scene->obedit->data == tselem->id) {
|
||||
active = OL_DRAWSEL_NORMAL;
|
||||
}
|
||||
else {
|
||||
active = tree_element_active(C, scene, sl, soops, te, OL_SETSEL_NONE, false);
|
||||
active = tree_element_active(C, scene, view_layer, soops, te, OL_SETSEL_NONE, false);
|
||||
}
|
||||
}
|
||||
else {
|
||||
active = tree_element_type_active(C, scene, sl, soops, te, tselem, OL_SETSEL_NONE, false);
|
||||
active = tree_element_type_active(C, scene, view_layer, soops, te, tselem, OL_SETSEL_NONE, false);
|
||||
}
|
||||
|
||||
if (active != OL_DRAWSEL_NONE) {
|
||||
|
@ -1301,7 +1301,7 @@ static void outliner_draw_iconrow(bContext *C, uiBlock *block, Scene *scene, Vie
|
|||
|
||||
/* this tree element always has same amount of branches, so don't draw */
|
||||
if (tselem->type != TSE_R_LAYER)
|
||||
outliner_draw_iconrow(C, block, scene, sl, soops, &te->subtree, level + 1, xmax, offsx, ys, alpha_fac);
|
||||
outliner_draw_iconrow(C, block, scene, view_layer, soops, &te->subtree, level + 1, xmax, offsx, ys, alpha_fac);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -1325,7 +1325,7 @@ static void outliner_set_coord_tree_element(TreeElement *te, int startx, int sta
|
|||
|
||||
|
||||
static void outliner_draw_tree_element(
|
||||
bContext *C, uiBlock *block, const uiFontStyle *fstyle, Scene *scene, ViewLayer *sl,
|
||||
bContext *C, uiBlock *block, const uiFontStyle *fstyle, Scene *scene, ViewLayer *view_layer,
|
||||
ARegion *ar, SpaceOops *soops, TreeElement *te, bool draw_grayed_out,
|
||||
int startx, int *starty, TreeElement **te_edit, TreeElement **te_floating)
|
||||
{
|
||||
|
@ -1365,13 +1365,13 @@ static void outliner_draw_tree_element(
|
|||
else if (te->idcode == ID_OB) {
|
||||
Object *ob = (Object *)tselem->id;
|
||||
|
||||
if (ob == OBACT(sl) || (ob->flag & SELECT)) {
|
||||
if (ob == OBACT(view_layer) || (ob->flag & SELECT)) {
|
||||
char col[4] = {0, 0, 0, 0};
|
||||
|
||||
/* outliner active ob: always white text, circle color now similar to view3d */
|
||||
|
||||
active = OL_DRAWSEL_ACTIVE;
|
||||
if (ob == OBACT(sl)) {
|
||||
if (ob == OBACT(view_layer)) {
|
||||
if (ob->flag & SELECT) {
|
||||
UI_GetThemeColorType4ubv(TH_ACTIVE, SPACE_VIEW3D, col);
|
||||
col[3] = alpha;
|
||||
|
@ -1392,14 +1392,14 @@ static void outliner_draw_tree_element(
|
|||
active = OL_DRAWSEL_ACTIVE;
|
||||
}
|
||||
else {
|
||||
if (tree_element_active(C, scene, sl, soops, te, OL_SETSEL_NONE, false)) {
|
||||
if (tree_element_active(C, scene, view_layer, soops, te, OL_SETSEL_NONE, false)) {
|
||||
rgba_float_args_set(color, 0.85f, 0.85f, 1.0f, alpha);
|
||||
active = OL_DRAWSEL_ACTIVE;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
active = tree_element_type_active(C, scene, sl, soops, te, tselem, OL_SETSEL_NONE, false);
|
||||
active = tree_element_type_active(C, scene, view_layer, soops, te, tselem, OL_SETSEL_NONE, false);
|
||||
rgba_float_args_set(color, 0.85f, 0.85f, 1.0f, alpha);
|
||||
}
|
||||
|
||||
|
@ -1513,7 +1513,7 @@ static void outliner_draw_tree_element(
|
|||
immUnbindProgram();
|
||||
}
|
||||
|
||||
outliner_draw_iconrow(C, block, scene, sl, soops, &te->subtree, 0, xmax, &tempx,
|
||||
outliner_draw_iconrow(C, block, scene, view_layer, soops, &te->subtree, 0, xmax, &tempx,
|
||||
*starty, alpha_fac);
|
||||
|
||||
glDisable(GL_BLEND);
|
||||
|
@ -1533,7 +1533,7 @@ static void outliner_draw_tree_element(
|
|||
/* check if element needs to be drawn grayed out, but also gray out
|
||||
* childs of a grayed out parent (pass on draw_grayed_out to childs) */
|
||||
bool draw_childs_grayed_out = draw_grayed_out || (ten->drag_data != NULL);
|
||||
outliner_draw_tree_element(C, block, fstyle, scene, sl, ar, soops, ten, draw_childs_grayed_out,
|
||||
outliner_draw_tree_element(C, block, fstyle, scene, view_layer, ar, soops, ten, draw_childs_grayed_out,
|
||||
startx + UI_UNIT_X, starty, te_edit, te_floating);
|
||||
}
|
||||
}
|
||||
|
@ -1766,7 +1766,7 @@ static void outliner_draw_highlights(ARegion *ar, SpaceOops *soops, int startx,
|
|||
}
|
||||
|
||||
static void outliner_draw_tree(
|
||||
bContext *C, uiBlock *block, Scene *scene, ViewLayer *sl, ARegion *ar,
|
||||
bContext *C, uiBlock *block, Scene *scene, ViewLayer *view_layer, ARegion *ar,
|
||||
SpaceOops *soops, const bool has_restrict_icons,
|
||||
TreeElement **te_edit)
|
||||
{
|
||||
|
@ -1807,7 +1807,7 @@ static void outliner_draw_tree(
|
|||
starty = (int)ar->v2d.tot.ymax - UI_UNIT_Y - OL_Y_OFFSET;
|
||||
startx = 0;
|
||||
for (TreeElement *te = soops->tree.first; te; te = te->next) {
|
||||
outliner_draw_tree_element(C, block, fstyle, scene, sl, ar, soops, te, te->drag_data != NULL,
|
||||
outliner_draw_tree_element(C, block, fstyle, scene, view_layer, ar, soops, te, te->drag_data != NULL,
|
||||
startx, &starty, te_edit, &te_floating);
|
||||
}
|
||||
if (te_floating && te_floating->drag_data->insert_handle) {
|
||||
|
@ -1888,7 +1888,7 @@ void draw_outliner(const bContext *C)
|
|||
{
|
||||
Main *mainvar = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ARegion *ar = CTX_wm_region(C);
|
||||
View2D *v2d = &ar->v2d;
|
||||
SpaceOops *soops = CTX_wm_space_outliner(C);
|
||||
|
@ -1897,7 +1897,7 @@ void draw_outliner(const bContext *C)
|
|||
TreeElement *te_edit = NULL;
|
||||
bool has_restrict_icons;
|
||||
|
||||
outliner_build_tree(mainvar, scene, sl, soops); // always
|
||||
outliner_build_tree(mainvar, scene, view_layer, soops); // always
|
||||
|
||||
/* get extents of data */
|
||||
outliner_height(soops, &soops->tree, &sizey);
|
||||
|
@ -1947,7 +1947,7 @@ void draw_outliner(const bContext *C)
|
|||
/* draw outliner stuff (background, hierarchy lines and names) */
|
||||
outliner_back(ar);
|
||||
block = UI_block_begin(C, ar, __func__, UI_EMBOSS);
|
||||
outliner_draw_tree((bContext *)C, block, scene, sl, ar, soops, has_restrict_icons, &te_edit);
|
||||
outliner_draw_tree((bContext *)C, block, scene, view_layer, ar, soops, has_restrict_icons, &te_edit);
|
||||
|
||||
if (ELEM(soops->outlinevis, SO_DATABLOCKS, SO_USERDEF)) {
|
||||
/* draw rna buttons */
|
||||
|
|
|
@ -978,14 +978,14 @@ static int outliner_open_back(TreeElement *te)
|
|||
static int outliner_show_active_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
SpaceOops *so = CTX_wm_space_outliner(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ARegion *ar = CTX_wm_region(C);
|
||||
View2D *v2d = &ar->v2d;
|
||||
|
||||
TreeElement *te;
|
||||
int xdelta, ytop;
|
||||
|
||||
Object *obact = OBACT(sl);
|
||||
Object *obact = OBACT(view_layer);
|
||||
|
||||
if (!obact)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
@ -2174,8 +2174,8 @@ static int scene_drop_invoke(bContext *C, wmOperator *op, const wmEvent *event)
|
|||
|
||||
BKE_collection_object_add(scene, sc, ob);
|
||||
|
||||
for (ViewLayer *sl = scene->view_layers.first; sl; sl = sl->next) {
|
||||
Base *base = BKE_view_layer_base_find(sl, ob);
|
||||
for (ViewLayer *view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
|
||||
Base *base = BKE_view_layer_base_find(view_layer, ob);
|
||||
if (base) {
|
||||
ED_object_base_select(base, BA_SELECT);
|
||||
}
|
||||
|
|
|
@ -183,7 +183,7 @@ void outliner_free_tree(ListBase *lb);
|
|||
void outliner_cleanup_tree(struct SpaceOops *soops);
|
||||
void outliner_remove_treestore_element(struct SpaceOops *soops, TreeStoreElem *tselem);
|
||||
|
||||
void outliner_build_tree(struct Main *mainvar, struct Scene *scene, struct ViewLayer *sl, struct SpaceOops *soops);
|
||||
void outliner_build_tree(struct Main *mainvar, struct Scene *scene, struct ViewLayer *view_layer, struct SpaceOops *soops);
|
||||
|
||||
/* outliner_draw.c ---------------------------------------------- */
|
||||
|
||||
|
@ -192,9 +192,9 @@ void restrictbutton_gr_restrict_flag(void *poin, void *poin2, int flag);
|
|||
|
||||
/* outliner_select.c -------------------------------------------- */
|
||||
eOLDrawState tree_element_type_active(
|
||||
struct bContext *C, struct Scene *scene, struct ViewLayer *sl, struct SpaceOops *soops,
|
||||
struct bContext *C, struct Scene *scene, struct ViewLayer *view_layer, struct SpaceOops *soops,
|
||||
TreeElement *te, TreeStoreElem *tselem, const eOLSetState set, bool recursive);
|
||||
eOLDrawState tree_element_active(struct bContext *C, struct Scene *scene, struct ViewLayer *sl, SpaceOops *soops,
|
||||
eOLDrawState tree_element_active(struct bContext *C, struct Scene *scene, struct ViewLayer *view_layer, SpaceOops *soops,
|
||||
TreeElement *te, const eOLSetState set, const bool handle_all_types);
|
||||
|
||||
void outliner_item_do_activate_from_tree_element(
|
||||
|
|
|
@ -99,11 +99,11 @@ static eOLDrawState tree_element_active_renderlayer(
|
|||
* CTRL+LMB: Select/Deselect object and all cildren
|
||||
* CTRL+SHIFT+LMB: Add/Remove object and all children
|
||||
*/
|
||||
static void do_outliner_object_select_recursive(ViewLayer *sl, Object *ob_parent, bool select)
|
||||
static void do_outliner_object_select_recursive(ViewLayer *view_layer, Object *ob_parent, bool select)
|
||||
{
|
||||
Base *base;
|
||||
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
Object *ob = base->object;
|
||||
if ((((base->flag & BASE_VISIBLED) == 0) && BKE_object_is_child_recursive(ob_parent, ob))) {
|
||||
ED_object_base_select(base, select ? BA_SELECT : BA_DESELECT);
|
||||
|
@ -137,7 +137,7 @@ static void do_outliner_ebone_select_recursive(bArmature *arm, EditBone *ebone_p
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_set_active_object(
|
||||
bContext *C, Scene *scene, ViewLayer *sl, SpaceOops *soops,
|
||||
bContext *C, Scene *scene, ViewLayer *view_layer, SpaceOops *soops,
|
||||
TreeElement *te, const eOLSetState set, bool recursive)
|
||||
{
|
||||
TreeStoreElem *tselem = TREESTORE(te);
|
||||
|
@ -151,7 +151,7 @@ static eOLDrawState tree_element_set_active_object(
|
|||
}
|
||||
else {
|
||||
ob = (Object *)outliner_search_back(soops, te, ID_OB);
|
||||
if (ob == OBACT(sl)) {
|
||||
if (ob == OBACT(view_layer)) {
|
||||
return OL_DRAWSEL_NONE;
|
||||
}
|
||||
}
|
||||
|
@ -166,7 +166,7 @@ static eOLDrawState tree_element_set_active_object(
|
|||
}
|
||||
|
||||
/* find associated base in current scene */
|
||||
base = BKE_view_layer_base_find(sl, ob);
|
||||
base = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
if (base) {
|
||||
if (set == OL_SETSEL_EXTEND) {
|
||||
|
@ -178,13 +178,13 @@ static eOLDrawState tree_element_set_active_object(
|
|||
}
|
||||
else {
|
||||
/* deleselect all */
|
||||
BKE_view_layer_base_deselect_all(sl);
|
||||
BKE_view_layer_base_deselect_all(view_layer);
|
||||
ED_object_base_select(base, BA_SELECT);
|
||||
}
|
||||
|
||||
if (recursive) {
|
||||
/* Recursive select/deselect for Object hierarchies */
|
||||
do_outliner_object_select_recursive(sl, ob, (ob->flag & SELECT) != 0);
|
||||
do_outliner_object_select_recursive(view_layer, ob, (ob->flag & SELECT) != 0);
|
||||
}
|
||||
|
||||
if (set != OL_SETSEL_NONE) {
|
||||
|
@ -200,7 +200,7 @@ static eOLDrawState tree_element_set_active_object(
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_active_material(
|
||||
bContext *C, Scene *UNUSED(scene), ViewLayer *sl, SpaceOops *soops,
|
||||
bContext *C, Scene *UNUSED(scene), ViewLayer *view_layer, SpaceOops *soops,
|
||||
TreeElement *te, const eOLSetState set)
|
||||
{
|
||||
TreeElement *tes;
|
||||
|
@ -209,7 +209,7 @@ static eOLDrawState tree_element_active_material(
|
|||
/* we search for the object parent */
|
||||
ob = (Object *)outliner_search_back(soops, te, ID_OB);
|
||||
// note: ob->matbits can be NULL when a local object points to a library mesh.
|
||||
if (ob == NULL || ob != OBACT(sl) || ob->matbits == NULL) {
|
||||
if (ob == NULL || ob != OBACT(view_layer) || ob->matbits == NULL) {
|
||||
return OL_DRAWSEL_NONE; /* just paranoia */
|
||||
}
|
||||
|
||||
|
@ -253,12 +253,12 @@ static eOLDrawState tree_element_active_material(
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_active_texture(
|
||||
bContext *C, Scene *scene, ViewLayer *sl, SpaceOops *UNUSED(soops),
|
||||
bContext *C, Scene *scene, ViewLayer *view_layer, SpaceOops *UNUSED(soops),
|
||||
TreeElement *te, const eOLSetState set)
|
||||
{
|
||||
TreeElement *tep;
|
||||
TreeStoreElem /* *tselem,*/ *tselemp;
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
SpaceButs *sbuts = NULL;
|
||||
|
||||
if (ob == NULL) {
|
||||
|
@ -340,14 +340,14 @@ static eOLDrawState tree_element_active_texture(
|
|||
|
||||
|
||||
static eOLDrawState tree_element_active_lamp(
|
||||
bContext *UNUSED(C), Scene *UNUSED(scene), ViewLayer *sl, SpaceOops *soops,
|
||||
bContext *UNUSED(C), Scene *UNUSED(scene), ViewLayer *view_layer, SpaceOops *soops,
|
||||
TreeElement *te, const eOLSetState set)
|
||||
{
|
||||
Object *ob;
|
||||
|
||||
/* we search for the object parent */
|
||||
ob = (Object *)outliner_search_back(soops, te, ID_OB);
|
||||
if (ob == NULL || ob != OBACT(sl)) {
|
||||
if (ob == NULL || ob != OBACT(view_layer)) {
|
||||
/* just paranoia */
|
||||
return OL_DRAWSEL_NONE;
|
||||
}
|
||||
|
@ -409,7 +409,7 @@ static eOLDrawState tree_element_active_world(
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_active_defgroup(
|
||||
bContext *C, ViewLayer *sl, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set)
|
||||
bContext *C, ViewLayer *view_layer, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set)
|
||||
{
|
||||
Object *ob;
|
||||
|
||||
|
@ -423,7 +423,7 @@ static eOLDrawState tree_element_active_defgroup(
|
|||
WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, ob);
|
||||
}
|
||||
else {
|
||||
if (ob == OBACT(sl))
|
||||
if (ob == OBACT(view_layer))
|
||||
if (ob->actdef == te->index + 1) {
|
||||
return OL_DRAWSEL_NORMAL;
|
||||
}
|
||||
|
@ -432,7 +432,7 @@ static eOLDrawState tree_element_active_defgroup(
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_active_posegroup(
|
||||
bContext *C, Scene *UNUSED(scene), ViewLayer *sl, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set)
|
||||
bContext *C, Scene *UNUSED(scene), ViewLayer *view_layer, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set)
|
||||
{
|
||||
Object *ob = (Object *)tselem->id;
|
||||
|
||||
|
@ -443,7 +443,7 @@ static eOLDrawState tree_element_active_posegroup(
|
|||
}
|
||||
}
|
||||
else {
|
||||
if (ob == OBACT(sl) && ob->pose) {
|
||||
if (ob == OBACT(view_layer) && ob->pose) {
|
||||
if (ob->pose->active_group == te->index + 1) {
|
||||
return OL_DRAWSEL_NORMAL;
|
||||
}
|
||||
|
@ -453,7 +453,7 @@ static eOLDrawState tree_element_active_posegroup(
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_active_posechannel(
|
||||
bContext *C, Scene *UNUSED(scene), ViewLayer *sl, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set, bool recursive)
|
||||
bContext *C, Scene *UNUSED(scene), ViewLayer *view_layer, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set, bool recursive)
|
||||
{
|
||||
Object *ob = (Object *)tselem->id;
|
||||
bArmature *arm = ob->data;
|
||||
|
@ -487,7 +487,7 @@ static eOLDrawState tree_element_active_posechannel(
|
|||
}
|
||||
}
|
||||
else {
|
||||
if (ob == OBACT(sl) && ob->pose) {
|
||||
if (ob == OBACT(view_layer) && ob->pose) {
|
||||
if (pchan->bone->flag & BONE_SELECTED) {
|
||||
return OL_DRAWSEL_NORMAL;
|
||||
}
|
||||
|
@ -497,14 +497,14 @@ static eOLDrawState tree_element_active_posechannel(
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_active_bone(
|
||||
bContext *C, ViewLayer *sl, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set, bool recursive)
|
||||
bContext *C, ViewLayer *view_layer, TreeElement *te, TreeStoreElem *tselem, const eOLSetState set, bool recursive)
|
||||
{
|
||||
bArmature *arm = (bArmature *)tselem->id;
|
||||
Bone *bone = te->directdata;
|
||||
|
||||
if (set != OL_SETSEL_NONE) {
|
||||
if (!(bone->flag & BONE_HIDDEN_P)) {
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
if (ob) {
|
||||
if (set != OL_SETSEL_EXTEND) {
|
||||
/* single select forces all other bones to get unselected */
|
||||
|
@ -533,7 +533,7 @@ static eOLDrawState tree_element_active_bone(
|
|||
}
|
||||
}
|
||||
else {
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
|
||||
if (ob && ob->data == arm) {
|
||||
if (bone->flag & BONE_SELECTED) {
|
||||
|
@ -655,10 +655,10 @@ static eOLDrawState tree_element_active_text(
|
|||
}
|
||||
|
||||
static eOLDrawState tree_element_active_pose(
|
||||
bContext *C, Scene *scene, ViewLayer *sl, TreeElement *UNUSED(te), TreeStoreElem *tselem, const eOLSetState set)
|
||||
bContext *C, Scene *scene, ViewLayer *view_layer, TreeElement *UNUSED(te), TreeStoreElem *tselem, const eOLSetState set)
|
||||
{
|
||||
Object *ob = (Object *)tselem->id;
|
||||
Base *base = BKE_view_layer_base_find(sl, ob);
|
||||
Base *base = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
if (base == NULL) {
|
||||
/* Armature not instantiated in current scene (e.g. inside an appended group...). */
|
||||
|
@ -780,12 +780,12 @@ static eOLDrawState tree_element_active_collection(
|
|||
/* don't allow selecting a scene collection, it can have multiple layer collection
|
||||
* instances (which one would the user want to be selected then?) */
|
||||
else if (tselem->type == TSE_LAYER_COLLECTION) {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
LayerCollection *lc = te->directdata;
|
||||
const int collection_index = BKE_layer_collection_findindex(sl, lc);
|
||||
const int collection_index = BKE_layer_collection_findindex(view_layer, lc);
|
||||
|
||||
BLI_assert(collection_index >= 0);
|
||||
sl->active_collection = collection_index;
|
||||
view_layer->active_collection = collection_index;
|
||||
WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
|
||||
}
|
||||
|
||||
|
@ -795,7 +795,7 @@ static eOLDrawState tree_element_active_collection(
|
|||
/* ---------------------------------------------- */
|
||||
|
||||
/* generic call for ID data check or make/check active in UI */
|
||||
eOLDrawState tree_element_active(bContext *C, Scene *scene, ViewLayer *sl, SpaceOops *soops, TreeElement *te,
|
||||
eOLDrawState tree_element_active(bContext *C, Scene *scene, ViewLayer *view_layer, SpaceOops *soops, TreeElement *te,
|
||||
const eOLSetState set, const bool handle_all_types)
|
||||
{
|
||||
switch (te->idcode) {
|
||||
|
@ -803,21 +803,21 @@ eOLDrawState tree_element_active(bContext *C, Scene *scene, ViewLayer *sl, Space
|
|||
* selection. See do_outliner_item_activate. */
|
||||
case ID_OB:
|
||||
if (handle_all_types) {
|
||||
return tree_element_set_active_object(C, scene, sl, soops, te, set, false);
|
||||
return tree_element_set_active_object(C, scene, view_layer, soops, te, set, false);
|
||||
}
|
||||
break;
|
||||
case ID_MA:
|
||||
return tree_element_active_material(C, scene, sl, soops, te, set);
|
||||
return tree_element_active_material(C, scene, view_layer, soops, te, set);
|
||||
case ID_WO:
|
||||
return tree_element_active_world(C, scene, sl, soops, te, set);
|
||||
return tree_element_active_world(C, scene, view_layer, soops, te, set);
|
||||
case ID_LA:
|
||||
return tree_element_active_lamp(C, scene, sl, soops, te, set);
|
||||
return tree_element_active_lamp(C, scene, view_layer, soops, te, set);
|
||||
case ID_TE:
|
||||
return tree_element_active_texture(C, scene, sl, soops, te, set);
|
||||
return tree_element_active_texture(C, scene, view_layer, soops, te, set);
|
||||
case ID_TXT:
|
||||
return tree_element_active_text(C, scene, sl, soops, te, set);
|
||||
return tree_element_active_text(C, scene, view_layer, soops, te, set);
|
||||
case ID_CA:
|
||||
return tree_element_active_camera(C, scene, sl, soops, te, set);
|
||||
return tree_element_active_camera(C, scene, view_layer, soops, te, set);
|
||||
}
|
||||
return OL_DRAWSEL_NONE;
|
||||
}
|
||||
|
@ -826,44 +826,44 @@ eOLDrawState tree_element_active(bContext *C, Scene *scene, ViewLayer *sl, Space
|
|||
* Generic call for non-id data to make/check active in UI
|
||||
*/
|
||||
eOLDrawState tree_element_type_active(
|
||||
bContext *C, Scene *scene, ViewLayer *sl, SpaceOops *soops,
|
||||
bContext *C, Scene *scene, ViewLayer *view_layer, SpaceOops *soops,
|
||||
TreeElement *te, TreeStoreElem *tselem, const eOLSetState set, bool recursive)
|
||||
{
|
||||
switch (tselem->type) {
|
||||
case TSE_DEFGROUP:
|
||||
return tree_element_active_defgroup(C, sl, te, tselem, set);
|
||||
return tree_element_active_defgroup(C, view_layer, te, tselem, set);
|
||||
case TSE_BONE:
|
||||
return tree_element_active_bone(C, sl, te, tselem, set, recursive);
|
||||
return tree_element_active_bone(C, view_layer, te, tselem, set, recursive);
|
||||
case TSE_EBONE:
|
||||
return tree_element_active_ebone(C, scene, te, tselem, set, recursive);
|
||||
case TSE_MODIFIER:
|
||||
return tree_element_active_modifier(C, scene, sl, te, tselem, set);
|
||||
return tree_element_active_modifier(C, scene, view_layer, te, tselem, set);
|
||||
case TSE_LINKED_OB:
|
||||
if (set != OL_SETSEL_NONE) {
|
||||
tree_element_set_active_object(C, scene, sl, soops, te, set, false);
|
||||
tree_element_set_active_object(C, scene, view_layer, soops, te, set, false);
|
||||
}
|
||||
else if (tselem->id == (ID *)OBACT(sl)) {
|
||||
else if (tselem->id == (ID *)OBACT(view_layer)) {
|
||||
return OL_DRAWSEL_NORMAL;
|
||||
}
|
||||
break;
|
||||
case TSE_LINKED_PSYS:
|
||||
return tree_element_active_psys(C, scene, te, tselem, set);
|
||||
case TSE_POSE_BASE:
|
||||
return tree_element_active_pose(C, scene, sl, te, tselem, set);
|
||||
return tree_element_active_pose(C, scene, view_layer, te, tselem, set);
|
||||
case TSE_POSE_CHANNEL:
|
||||
return tree_element_active_posechannel(C, scene, sl, te, tselem, set, recursive);
|
||||
return tree_element_active_posechannel(C, scene, view_layer, te, tselem, set, recursive);
|
||||
case TSE_CONSTRAINT:
|
||||
return tree_element_active_constraint(C, scene, sl, te, tselem, set);
|
||||
return tree_element_active_constraint(C, scene, view_layer, te, tselem, set);
|
||||
case TSE_R_LAYER:
|
||||
return tree_element_active_renderlayer(C, scene, sl, te, tselem, set);
|
||||
return tree_element_active_renderlayer(C, scene, view_layer, te, tselem, set);
|
||||
case TSE_POSEGRP:
|
||||
return tree_element_active_posegroup(C, scene, sl, te, tselem, set);
|
||||
return tree_element_active_posegroup(C, scene, view_layer, te, tselem, set);
|
||||
case TSE_SEQUENCE:
|
||||
return tree_element_active_sequence(C, scene, te, tselem, set);
|
||||
case TSE_SEQUENCE_DUP:
|
||||
return tree_element_active_sequence_dup(scene, te, tselem, set);
|
||||
case TSE_KEYMAP_ITEM:
|
||||
return tree_element_active_keymap_item(C, scene, sl, te, tselem, set);
|
||||
return tree_element_active_keymap_item(C, scene, view_layer, te, tselem, set);
|
||||
case TSE_GP_LAYER:
|
||||
//return tree_element_active_gplayer(C, scene, s, te, tselem, set);
|
||||
break;
|
||||
|
@ -883,7 +883,7 @@ eOLDrawState tree_element_type_active(
|
|||
* Needed to run from operators accessed from a menu.
|
||||
*/
|
||||
static void do_outliner_item_activate_tree_element(
|
||||
bContext *C, Scene *scene, ViewLayer *sl, SpaceOops *soops,
|
||||
bContext *C, Scene *scene, ViewLayer *view_layer, SpaceOops *soops,
|
||||
TreeElement *te, TreeStoreElem *tselem,
|
||||
const bool extend, const bool recursive)
|
||||
{
|
||||
|
@ -892,7 +892,7 @@ static void do_outliner_item_activate_tree_element(
|
|||
* to switch out of edit mode (see T48328 for details). */
|
||||
if (!ELEM(tselem->type, TSE_SEQUENCE, TSE_SEQ_STRIP, TSE_SEQUENCE_DUP, TSE_EBONE, TSE_LAYER_COLLECTION)) {
|
||||
tree_element_set_active_object(
|
||||
C, scene, sl, soops, te,
|
||||
C, scene, view_layer, soops, te,
|
||||
(extend && tselem->type == 0) ? OL_SETSEL_EXTEND : OL_SETSEL_NORMAL,
|
||||
recursive && tselem->type == 0);
|
||||
}
|
||||
|
@ -918,14 +918,14 @@ static void do_outliner_item_activate_tree_element(
|
|||
}
|
||||
|
||||
for (gob = gr->gobject.first; gob; gob = gob->next) {
|
||||
ED_object_base_select(BKE_view_layer_base_find(sl, gob->ob), sel);
|
||||
ED_object_base_select(BKE_view_layer_base_find(view_layer, gob->ob), sel);
|
||||
}
|
||||
}
|
||||
else {
|
||||
BKE_view_layer_base_deselect_all(sl);
|
||||
BKE_view_layer_base_deselect_all(view_layer);
|
||||
|
||||
for (gob = gr->gobject.first; gob; gob = gob->next) {
|
||||
Base *base = BKE_view_layer_base_find(sl, gob->ob);
|
||||
Base *base = BKE_view_layer_base_find(view_layer, gob->ob);
|
||||
/* Object may not be in this scene */
|
||||
if (base != NULL) {
|
||||
if ((base->flag & BASE_SELECTED) == 0) {
|
||||
|
@ -941,12 +941,12 @@ static void do_outliner_item_activate_tree_element(
|
|||
WM_operator_name_call(C, "OBJECT_OT_editmode_toggle", WM_OP_INVOKE_REGION_WIN, NULL);
|
||||
}
|
||||
else { // rest of types
|
||||
tree_element_active(C, scene, sl, soops, te, OL_SETSEL_NORMAL, false);
|
||||
tree_element_active(C, scene, view_layer, soops, te, OL_SETSEL_NORMAL, false);
|
||||
}
|
||||
|
||||
}
|
||||
else {
|
||||
tree_element_type_active(C, scene, sl, soops, te, tselem,
|
||||
tree_element_type_active(C, scene, view_layer, soops, te, tselem,
|
||||
extend ? OL_SETSEL_EXTEND : OL_SETSEL_NORMAL,
|
||||
recursive);
|
||||
}
|
||||
|
@ -1004,11 +1004,11 @@ void outliner_item_do_activate_from_tree_element(
|
|||
bool extend, bool recursive)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
SpaceOops *soops = CTX_wm_space_outliner(C);
|
||||
|
||||
do_outliner_item_activate_tree_element(
|
||||
C, scene, sl, soops,
|
||||
C, scene, view_layer, soops,
|
||||
te, tselem,
|
||||
extend, recursive);
|
||||
}
|
||||
|
@ -1044,13 +1044,13 @@ int outliner_item_do_activate_from_cursor(
|
|||
}
|
||||
else {
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
/* the row may also contain children, if one is hovered we want this instead of current te */
|
||||
TreeElement *activate_te = outliner_find_item_at_x_in_row(soops, te, view_mval[0]);
|
||||
TreeStoreElem *activate_tselem = TREESTORE(activate_te);
|
||||
|
||||
outliner_item_select(soops, activate_te, extend, extend);
|
||||
do_outliner_item_activate_tree_element(C, scene, sl, soops, activate_te, activate_tselem, extend, recursive);
|
||||
do_outliner_item_activate_tree_element(C, scene, view_layer, soops, activate_te, activate_tselem, extend, recursive);
|
||||
changed = true;
|
||||
}
|
||||
|
||||
|
|
|
@ -366,9 +366,9 @@ static void object_select_cb(
|
|||
bContext *C, ReportList *UNUSED(reports), Scene *UNUSED(scene), TreeElement *UNUSED(te),
|
||||
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = (Object *)tselem->id;
|
||||
Base *base = BKE_view_layer_base_find(sl, ob);
|
||||
Base *base = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
if (base && ((base->flag & BASE_VISIBLED) != 0)) {
|
||||
base->flag |= BASE_SELECTED;
|
||||
|
@ -388,9 +388,9 @@ static void object_deselect_cb(
|
|||
bContext *C, ReportList *UNUSED(reports), Scene *UNUSED(scene), TreeElement *UNUSED(te),
|
||||
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = (Object *)tselem->id;
|
||||
Base *base = BKE_view_layer_base_find(sl, ob);
|
||||
Base *base = BKE_view_layer_base_find(view_layer, ob);
|
||||
|
||||
if (base) {
|
||||
base->flag &= ~BASE_SELECTED;
|
||||
|
@ -522,18 +522,18 @@ static void group_linkobs2scene_cb(
|
|||
bContext *C, ReportList *UNUSED(reports), Scene *scene, TreeElement *UNUSED(te),
|
||||
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
SceneCollection *sc = CTX_data_scene_collection(C);
|
||||
Group *group = (Group *)tselem->id;
|
||||
GroupObject *gob;
|
||||
Base *base;
|
||||
|
||||
for (gob = group->gobject.first; gob; gob = gob->next) {
|
||||
base = BKE_view_layer_base_find(sl, gob->ob);
|
||||
base = BKE_view_layer_base_find(view_layer, gob->ob);
|
||||
if (!base) {
|
||||
/* link to scene */
|
||||
BKE_collection_object_add(scene, sc, gob->ob);
|
||||
base = BKE_view_layer_base_find(sl, gob->ob);
|
||||
base = BKE_view_layer_base_find(view_layer, gob->ob);
|
||||
id_us_plus(&gob->ob->id);
|
||||
}
|
||||
|
||||
|
@ -933,12 +933,12 @@ static void object_delete_hierarchy_cb(
|
|||
bContext *C, ReportList *reports, Scene *scene,
|
||||
TreeElement *te, TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Base *base = (Base *)te->directdata;
|
||||
Object *obedit = scene->obedit;
|
||||
|
||||
if (!base) {
|
||||
base = BKE_view_layer_base_find(sl, (Object *)tselem->id);
|
||||
base = BKE_view_layer_base_find(view_layer, (Object *)tselem->id);
|
||||
}
|
||||
if (base) {
|
||||
/* Check also library later. */
|
||||
|
|
|
@ -346,7 +346,7 @@ static void time_draw_idblock_keyframes(View2D *v2d, ID *id, short onlysel, cons
|
|||
BLI_dlrbTree_free(&keys);
|
||||
}
|
||||
|
||||
static void time_draw_caches_keyframes(Main *bmain, ViewLayer *sl, View2D *v2d, bool onlysel, const unsigned char color[3])
|
||||
static void time_draw_caches_keyframes(Main *bmain, ViewLayer *view_layer, View2D *v2d, bool onlysel, const unsigned char color[3])
|
||||
{
|
||||
CacheFile *cache_file;
|
||||
|
||||
|
@ -357,7 +357,7 @@ static void time_draw_caches_keyframes(Main *bmain, ViewLayer *sl, View2D *v2d,
|
|||
cache_file->draw_flag &= ~CACHEFILE_KEYFRAME_DRAWN;
|
||||
}
|
||||
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
Object *ob = base->object;
|
||||
|
||||
ModifierData *md = modifiers_findByType(ob, eModifierType_MeshSequenceCache);
|
||||
|
@ -400,7 +400,7 @@ static void time_draw_caches_keyframes(Main *bmain, ViewLayer *sl, View2D *v2d,
|
|||
static void time_draw_keyframes(const bContext *C, ARegion *ar)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
View2D *v2d = &ar->v2d;
|
||||
bool onlysel = ((scene->flag & SCE_KEYS_NO_SELONLY) == 0);
|
||||
|
@ -411,7 +411,7 @@ static void time_draw_keyframes(const bContext *C, ARegion *ar)
|
|||
|
||||
/* draw cache files keyframes (if available) */
|
||||
UI_GetThemeColor3ubv(TH_TIME_KEYFRAME, color);
|
||||
time_draw_caches_keyframes(CTX_data_main(C), sl, v2d, onlysel, color);
|
||||
time_draw_caches_keyframes(CTX_data_main(C), view_layer, v2d, onlysel, color);
|
||||
|
||||
/* draw grease pencil keyframes (if available) */
|
||||
UI_GetThemeColor3ubv(TH_TIME_GP_KEYFRAME, color);
|
||||
|
|
|
@ -1612,7 +1612,7 @@ static void draw_bone(const short dt, int armflag, int boneflag, short constflag
|
|||
|
||||
static void draw_custom_bone(
|
||||
const struct EvaluationContext *eval_ctx,
|
||||
Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, Object *ob,
|
||||
Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, Object *ob,
|
||||
const short dt, int armflag, int boneflag, unsigned int id, float length)
|
||||
{
|
||||
if (ob == NULL) return;
|
||||
|
@ -1628,7 +1628,7 @@ static void draw_custom_bone(
|
|||
GPU_select_load_id((GLuint) id | BONESEL_BONE);
|
||||
}
|
||||
|
||||
draw_object_instance(eval_ctx, scene, sl, v3d, rv3d, ob, dt, armflag & ARM_POSEMODE, fcolor);
|
||||
draw_object_instance(eval_ctx, scene, view_layer, v3d, rv3d, ob, dt, armflag & ARM_POSEMODE, fcolor);
|
||||
}
|
||||
|
||||
|
||||
|
@ -1933,7 +1933,7 @@ static void bone_matrix_translate_y(float mat[4][4], float y)
|
|||
|
||||
/* assumes object is Armature with pose */
|
||||
static void draw_pose_bones(
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, ARegion *ar, Base *base,
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, ARegion *ar, Base *base,
|
||||
const short dt, const unsigned char ob_wire_col[4],
|
||||
const bool do_const_color, const bool is_outline)
|
||||
{
|
||||
|
@ -2060,7 +2060,7 @@ static void draw_pose_bones(
|
|||
glDisable(GL_CULL_FACE);
|
||||
}
|
||||
|
||||
draw_custom_bone(eval_ctx, scene, sl, v3d, rv3d, pchan->custom,
|
||||
draw_custom_bone(eval_ctx, scene, view_layer, v3d, rv3d, pchan->custom,
|
||||
OB_SOLID, arm->flag, flag, index, PCHAN_CUSTOM_DRAW_SIZE(pchan));
|
||||
}
|
||||
}
|
||||
|
@ -2156,7 +2156,7 @@ static void draw_pose_bones(
|
|||
if (bone == arm->act_bone)
|
||||
flag |= BONE_DRAW_ACTIVE;
|
||||
|
||||
draw_custom_bone(eval_ctx, scene, sl, v3d, rv3d, pchan->custom,
|
||||
draw_custom_bone(eval_ctx, scene, view_layer, v3d, rv3d, pchan->custom,
|
||||
OB_WIRE, arm->flag, flag, index, PCHAN_CUSTOM_DRAW_SIZE(pchan));
|
||||
|
||||
gpuPopMatrix();
|
||||
|
@ -2667,7 +2667,7 @@ static void ghost_poses_tag_unselected(Object *ob, short unset)
|
|||
* note: object should be in posemode
|
||||
*/
|
||||
static void draw_ghost_poses_range(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, ARegion *ar, Base *base)
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, ARegion *ar, Base *base)
|
||||
{
|
||||
Object *ob = base->object;
|
||||
AnimData *adt = BKE_animdata_from_id(&ob->id);
|
||||
|
@ -2712,7 +2712,7 @@ static void draw_ghost_poses_range(
|
|||
|
||||
BKE_animsys_evaluate_animdata(scene, &ob->id, adt, (float)CFRA, ADT_RECALC_ALL);
|
||||
BKE_pose_where_is(eval_ctx, scene, ob);
|
||||
draw_pose_bones(eval_ctx, scene, sl, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
draw_pose_bones(eval_ctx, scene, view_layer, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
}
|
||||
glDisable(GL_BLEND);
|
||||
if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
|
||||
|
@ -2735,7 +2735,7 @@ static void draw_ghost_poses_range(
|
|||
* - object should be in posemode
|
||||
*/
|
||||
static void draw_ghost_poses_keys(
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl,
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer,
|
||||
View3D *v3d, ARegion *ar, Base *base)
|
||||
{
|
||||
Object *ob = base->object;
|
||||
|
@ -2795,7 +2795,7 @@ static void draw_ghost_poses_keys(
|
|||
|
||||
BKE_animsys_evaluate_animdata(scene, &ob->id, adt, (float)CFRA, ADT_RECALC_ALL);
|
||||
BKE_pose_where_is(eval_ctx, scene, ob);
|
||||
draw_pose_bones(eval_ctx, scene, sl, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
draw_pose_bones(eval_ctx, scene, view_layer, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
}
|
||||
glDisable(GL_BLEND);
|
||||
if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
|
||||
|
@ -2819,7 +2819,7 @@ static void draw_ghost_poses_keys(
|
|||
* - object is supposed to be armature in posemode
|
||||
*/
|
||||
static void draw_ghost_poses(
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl,
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer,
|
||||
View3D *v3d, ARegion *ar, Base *base)
|
||||
{
|
||||
Object *ob = base->object;
|
||||
|
@ -2875,7 +2875,7 @@ static void draw_ghost_poses(
|
|||
if (CFRA != cfrao) {
|
||||
BKE_animsys_evaluate_animdata(scene, &ob->id, adt, (float)CFRA, ADT_RECALC_ALL);
|
||||
BKE_pose_where_is(eval_ctx, scene, ob);
|
||||
draw_pose_bones(eval_ctx, scene, sl, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
draw_pose_bones(eval_ctx, scene, view_layer, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2890,7 +2890,7 @@ static void draw_ghost_poses(
|
|||
if (CFRA != cfrao) {
|
||||
BKE_animsys_evaluate_animdata(scene, &ob->id, adt, (float)CFRA, ADT_RECALC_ALL);
|
||||
BKE_pose_where_is(eval_ctx, scene, ob);
|
||||
draw_pose_bones(eval_ctx, scene, sl, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
draw_pose_bones(eval_ctx, scene, view_layer, v3d, ar, base, OB_WIRE, col, true, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2916,7 +2916,7 @@ static void draw_ghost_poses(
|
|||
/* called from drawobject.c, return true if nothing was drawn
|
||||
* (ob_wire_col == NULL) when drawing ghost */
|
||||
bool draw_armature(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, ARegion *ar, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, ARegion *ar, Base *base,
|
||||
const short dt, const short dflag, const unsigned char ob_wire_col[4],
|
||||
const bool is_outline)
|
||||
{
|
||||
|
@ -2976,27 +2976,27 @@ bool draw_armature(
|
|||
}
|
||||
else if (ob->mode & OB_MODE_POSE) {
|
||||
if (arm->ghosttype == ARM_GHOST_RANGE) {
|
||||
draw_ghost_poses_range(eval_ctx, scene, sl, v3d, ar, base);
|
||||
draw_ghost_poses_range(eval_ctx, scene, view_layer, v3d, ar, base);
|
||||
}
|
||||
else if (arm->ghosttype == ARM_GHOST_KEYS) {
|
||||
draw_ghost_poses_keys(eval_ctx, scene, sl, v3d, ar, base);
|
||||
draw_ghost_poses_keys(eval_ctx, scene, view_layer, v3d, ar, base);
|
||||
}
|
||||
else if (arm->ghosttype == ARM_GHOST_CUR) {
|
||||
if (arm->ghostep)
|
||||
draw_ghost_poses(eval_ctx, scene, sl, v3d, ar, base);
|
||||
draw_ghost_poses(eval_ctx, scene, view_layer, v3d, ar, base);
|
||||
}
|
||||
if ((dflag & DRAW_SCENESET) == 0) {
|
||||
if (ob == OBACT(sl))
|
||||
if (ob == OBACT(view_layer))
|
||||
arm->flag |= ARM_POSEMODE;
|
||||
else if (OBACT(sl) && (OBACT(sl)->mode & OB_MODE_WEIGHT_PAINT)) {
|
||||
if (ob == modifiers_isDeformedByArmature(OBACT(sl)))
|
||||
else if (OBACT(view_layer) && (OBACT(view_layer)->mode & OB_MODE_WEIGHT_PAINT)) {
|
||||
if (ob == modifiers_isDeformedByArmature(OBACT(view_layer)))
|
||||
arm->flag |= ARM_POSEMODE;
|
||||
}
|
||||
draw_pose_paths(scene, v3d, ar, ob);
|
||||
}
|
||||
}
|
||||
}
|
||||
draw_pose_bones(eval_ctx, scene, sl, v3d, ar, base, dt, ob_wire_col, (dflag & DRAW_CONSTCOLOR), is_outline);
|
||||
draw_pose_bones(eval_ctx, scene, view_layer, v3d, ar, base, dt, ob_wire_col, (dflag & DRAW_CONSTCOLOR), is_outline);
|
||||
arm->flag &= ~ARM_POSEMODE;
|
||||
}
|
||||
else {
|
||||
|
|
|
@ -220,10 +220,10 @@ typedef struct TexMatCallback {
|
|||
bool two_sided_lighting;
|
||||
} TexMatCallback;
|
||||
|
||||
void draw_mesh_textured(Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d,
|
||||
void draw_mesh_textured(Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d,
|
||||
Object *ob, DerivedMesh *dm, const int draw_flags)
|
||||
{
|
||||
UNUSED_VARS(scene, sl, v3d, rv3d, ob, dm, draw_flags);
|
||||
UNUSED_VARS(scene, view_layer, v3d, rv3d, ob, dm, draw_flags);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -314,13 +314,13 @@ static bool check_ob_drawface_dot(Scene *sce, View3D *vd, char dt)
|
|||
|
||||
/* check for glsl drawing */
|
||||
|
||||
bool draw_glsl_material(Scene *scene, ViewLayer *sl, Object *ob, View3D *v3d, const char dt)
|
||||
bool draw_glsl_material(Scene *scene, ViewLayer *view_layer, Object *ob, View3D *v3d, const char dt)
|
||||
{
|
||||
if (G.f & G_PICKSEL)
|
||||
return false;
|
||||
if (!check_object_draw_texture(scene, v3d, dt))
|
||||
return false;
|
||||
if (ob == OBACT(sl) && (ob && ob->mode & OB_MODE_WEIGHT_PAINT))
|
||||
if (ob == OBACT(view_layer) && (ob && ob->mode & OB_MODE_WEIGHT_PAINT))
|
||||
return false;
|
||||
|
||||
if (v3d->flag2 & V3D_SHOW_SOLID_MATCAP)
|
||||
|
@ -3894,7 +3894,7 @@ static DMDrawOption draw_em_fancy__setGLSLFaceOpts(void *userData, int index)
|
|||
}
|
||||
}
|
||||
|
||||
static void draw_em_fancy(Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d,
|
||||
static void draw_em_fancy(Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d,
|
||||
Object *ob, BMEditMesh *em, DerivedMesh *cageDM, DerivedMesh *finalDM, const char dt)
|
||||
|
||||
{
|
||||
|
@ -3932,7 +3932,7 @@ static void draw_em_fancy(Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d,
|
|||
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
||||
}
|
||||
else if (check_object_draw_texture(scene, v3d, dt)) {
|
||||
if (draw_glsl_material(scene, sl, ob, v3d, dt)) {
|
||||
if (draw_glsl_material(scene, view_layer, ob, v3d, dt)) {
|
||||
glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
|
||||
|
||||
finalDM->drawMappedFacesGLSL(finalDM, GPU_object_material_bind,
|
||||
|
@ -3942,7 +3942,7 @@ static void draw_em_fancy(Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d,
|
|||
glFrontFace(GL_CCW);
|
||||
}
|
||||
else {
|
||||
draw_mesh_textured(scene, sl, v3d, rv3d, ob, finalDM, 0);
|
||||
draw_mesh_textured(scene, view_layer, v3d, rv3d, ob, finalDM, 0);
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
@ -4300,11 +4300,11 @@ static bool object_is_halo(Scene *scene, Object *ob)
|
|||
}
|
||||
|
||||
static void draw_mesh_fancy(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const unsigned char ob_wire_col[4], const short dflag)
|
||||
{
|
||||
#ifdef WITH_GAMEENGINE
|
||||
Object *ob = (rv3d->rflag & RV3D_IS_GAME_ENGINE) ? BKE_object_lod_meshob_get(base->object, sl) : base->object;
|
||||
Object *ob = (rv3d->rflag & RV3D_IS_GAME_ENGINE) ? BKE_object_lod_meshob_get(base->object, view_layer) : base->object;
|
||||
#else
|
||||
Object *ob = base->object;
|
||||
#endif
|
||||
|
@ -4312,7 +4312,7 @@ static void draw_mesh_fancy(
|
|||
eWireDrawMode draw_wire = OBDRAW_WIRE_OFF;
|
||||
bool /* no_verts,*/ no_edges, no_faces;
|
||||
DerivedMesh *dm = mesh_get_derived_final(eval_ctx, scene, ob, scene->customdata_mask);
|
||||
const bool is_obact = (ob == OBACT(sl));
|
||||
const bool is_obact = (ob == OBACT(view_layer));
|
||||
int draw_flags = (is_obact && BKE_paint_select_face_test(ob)) ? DRAW_FACE_SELECT : 0;
|
||||
|
||||
if (!dm)
|
||||
|
@ -4373,12 +4373,12 @@ static void draw_mesh_fancy(
|
|||
draw_mesh_object_outline(v3d, ob, dm, ob_wire_col);
|
||||
}
|
||||
|
||||
if (draw_glsl_material(scene, sl, ob, v3d, dt) && !(draw_flags & DRAW_MODIFIERS_PREVIEW)) {
|
||||
if (draw_glsl_material(scene, view_layer, ob, v3d, dt) && !(draw_flags & DRAW_MODIFIERS_PREVIEW)) {
|
||||
Paint *p;
|
||||
|
||||
glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
|
||||
|
||||
if ((v3d->flag2 & V3D_SHOW_SOLID_MATCAP) && ob->sculpt && (p = BKE_paint_get_active(scene, sl))) {
|
||||
if ((v3d->flag2 & V3D_SHOW_SOLID_MATCAP) && ob->sculpt && (p = BKE_paint_get_active(scene, view_layer))) {
|
||||
GPUVertexAttribs gattribs;
|
||||
float planes[4][4];
|
||||
float (*fpl)[4] = NULL;
|
||||
|
@ -4411,7 +4411,7 @@ static void draw_mesh_fancy(
|
|||
draw_mesh_face_select(rv3d, me, dm, false);
|
||||
}
|
||||
else {
|
||||
draw_mesh_textured(scene, sl, v3d, rv3d, ob, dm, draw_flags);
|
||||
draw_mesh_textured(scene, view_layer, v3d, rv3d, ob, dm, draw_flags);
|
||||
}
|
||||
|
||||
if (draw_loose && !(draw_flags & DRAW_FACE_SELECT)) {
|
||||
|
@ -4470,7 +4470,7 @@ static void draw_mesh_fancy(
|
|||
|
||||
glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
|
||||
|
||||
if (ob->sculpt && (p = BKE_paint_get_active(scene, sl))) {
|
||||
if (ob->sculpt && (p = BKE_paint_get_active(scene, view_layer))) {
|
||||
float planes[4][4];
|
||||
float (*fpl)[4] = NULL;
|
||||
const bool fast = (p->flags & PAINT_FAST_NAVIGATE) && (rv3d->rflag & RV3D_NAVIGATING);
|
||||
|
@ -4565,7 +4565,7 @@ static void draw_mesh_fancy(
|
|||
|
||||
/* returns true if nothing was drawn, for detecting to draw an object center */
|
||||
static bool draw_mesh_object(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const unsigned char ob_wire_col[4], const short dflag)
|
||||
{
|
||||
Object *ob = base->object;
|
||||
|
@ -4619,13 +4619,13 @@ static bool draw_mesh_object(
|
|||
|
||||
if (use_material) {
|
||||
if (dt > OB_WIRE) {
|
||||
const bool glsl = draw_glsl_material(scene, sl, ob, v3d, dt);
|
||||
const bool glsl = draw_glsl_material(scene, view_layer, ob, v3d, dt);
|
||||
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, glsl, NULL);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, glsl, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
draw_em_fancy(scene, sl, ar, v3d, ob, em, cageDM, finalDM, dt);
|
||||
draw_em_fancy(scene, view_layer, ar, v3d, ob, em, cageDM, finalDM, dt);
|
||||
|
||||
if (use_material) {
|
||||
GPU_end_object_materials();
|
||||
|
@ -4638,16 +4638,16 @@ static bool draw_mesh_object(
|
|||
/* ob->bb was set by derived mesh system, do NULL check just to be sure */
|
||||
if (me->totpoly <= 4 || (!ob->bb || ED_view3d_boundbox_clip(rv3d, ob->bb))) {
|
||||
if (dt > OB_WIRE) {
|
||||
const bool glsl = draw_glsl_material(scene, sl, ob, v3d, dt);
|
||||
const bool glsl = draw_glsl_material(scene, view_layer, ob, v3d, dt);
|
||||
|
||||
if (dt == OB_SOLID || glsl) {
|
||||
const bool check_alpha = check_alpha_pass(base);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, glsl,
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, glsl,
|
||||
(check_alpha) ? &do_alpha_after : NULL);
|
||||
}
|
||||
}
|
||||
|
||||
draw_mesh_fancy(eval_ctx, scene, sl, ar, v3d, rv3d, base, dt, ob_wire_col, dflag);
|
||||
draw_mesh_fancy(eval_ctx, scene, view_layer, ar, v3d, rv3d, base, dt, ob_wire_col, dflag);
|
||||
|
||||
GPU_end_object_materials();
|
||||
|
||||
|
@ -4709,18 +4709,18 @@ static void make_color_variations(const unsigned char base_ubyte[4], float low[4
|
|||
high[3] = base[3];
|
||||
}
|
||||
|
||||
static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const unsigned char ob_wire_col[4], const short dflag, const bool other_obedit)
|
||||
{
|
||||
if (dflag & (DRAW_PICKING | DRAW_CONSTCOLOR)) {
|
||||
/* too complicated! use existing methods */
|
||||
/* TODO: move this into a separate depth pre-pass */
|
||||
draw_mesh_fancy(eval_ctx, scene, sl, ar, v3d, rv3d, base, dt, ob_wire_col, dflag);
|
||||
draw_mesh_fancy(eval_ctx, scene, view_layer, ar, v3d, rv3d, base, dt, ob_wire_col, dflag);
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef WITH_GAMEENGINE
|
||||
Object *ob = (rv3d->rflag & RV3D_IS_GAME_ENGINE) ? BKE_object_lod_meshob_get(base->object, sl) : base->object;
|
||||
Object *ob = (rv3d->rflag & RV3D_IS_GAME_ENGINE) ? BKE_object_lod_meshob_get(base->object, view_layer) : base->object;
|
||||
#else
|
||||
Object *ob = base->object;
|
||||
#endif
|
||||
|
@ -4728,7 +4728,7 @@ static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewL
|
|||
eWireDrawMode draw_wire = OBDRAW_WIRE_OFF; /* could be bool draw_wire_overlay */
|
||||
bool no_edges, no_faces;
|
||||
DerivedMesh *dm = mesh_get_derived_final(eval_ctx, scene, ob, scene->customdata_mask);
|
||||
const bool is_obact = (ob == OBACT(sl));
|
||||
const bool is_obact = (ob == OBACT(view_layer));
|
||||
int draw_flags = (is_obact && BKE_paint_select_face_test(ob)) ? DRAW_FACE_SELECT : 0;
|
||||
|
||||
if (!dm)
|
||||
|
@ -4849,15 +4849,15 @@ static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewL
|
|||
!(G.f & G_PICKSEL || (draw_flags & DRAW_FACE_SELECT)) &&
|
||||
(draw_wire == OBDRAW_WIRE_OFF))
|
||||
{
|
||||
draw_mesh_object_outline_new(v3d, rv3d, ob, me, (ob == OBACT(sl)));
|
||||
draw_mesh_object_outline_new(v3d, rv3d, ob, me, (ob == OBACT(view_layer)));
|
||||
}
|
||||
|
||||
if (draw_glsl_material(scene, sl, ob, v3d, dt) && !(draw_flags & DRAW_MODIFIERS_PREVIEW)) {
|
||||
if (draw_glsl_material(scene, view_layer, ob, v3d, dt) && !(draw_flags & DRAW_MODIFIERS_PREVIEW)) {
|
||||
Paint *p;
|
||||
|
||||
glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
|
||||
|
||||
if ((v3d->flag2 & V3D_SHOW_SOLID_MATCAP) && ob->sculpt && (p = BKE_paint_get_active(scene, sl))) {
|
||||
if ((v3d->flag2 & V3D_SHOW_SOLID_MATCAP) && ob->sculpt && (p = BKE_paint_get_active(scene, view_layer))) {
|
||||
GPUVertexAttribs gattribs;
|
||||
float planes[4][4];
|
||||
float (*fpl)[4] = NULL;
|
||||
|
@ -4886,7 +4886,7 @@ static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewL
|
|||
draw_mesh_face_select(rv3d, me, dm, false);
|
||||
}
|
||||
else {
|
||||
draw_mesh_textured(scene, sl, v3d, rv3d, ob, dm, draw_flags);
|
||||
draw_mesh_textured(scene, view_layer, v3d, rv3d, ob, dm, draw_flags);
|
||||
}
|
||||
|
||||
if (draw_loose && !(draw_flags & DRAW_FACE_SELECT)) {
|
||||
|
@ -4916,7 +4916,7 @@ static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewL
|
|||
(draw_wire == OBDRAW_WIRE_OFF) &&
|
||||
(ob->sculpt == NULL))
|
||||
{
|
||||
draw_mesh_object_outline_new(v3d, rv3d, ob, me, (ob == OBACT(sl)));
|
||||
draw_mesh_object_outline_new(v3d, rv3d, ob, me, (ob == OBACT(view_layer)));
|
||||
}
|
||||
|
||||
/* materials arent compatible with vertex colors */
|
||||
|
@ -4941,12 +4941,12 @@ static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewL
|
|||
(ob->sculpt == NULL))
|
||||
{
|
||||
/* TODO: move this into a separate pass */
|
||||
draw_mesh_object_outline_new(v3d, rv3d, ob, me, (ob == OBACT(sl)));
|
||||
draw_mesh_object_outline_new(v3d, rv3d, ob, me, (ob == OBACT(view_layer)));
|
||||
}
|
||||
|
||||
glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
|
||||
|
||||
if (ob->sculpt && (p = BKE_paint_get_active(scene, sl))) {
|
||||
if (ob->sculpt && (p = BKE_paint_get_active(scene, view_layer))) {
|
||||
float planes[4][4];
|
||||
float (*fpl)[4] = NULL;
|
||||
const bool fast = (p->flags & PAINT_FAST_NAVIGATE) && (rv3d->rflag & RV3D_NAVIGATING);
|
||||
|
@ -5027,7 +5027,7 @@ static void draw_mesh_fancy_new(EvaluationContext *eval_ctx, Scene *scene, ViewL
|
|||
dm->release(dm);
|
||||
}
|
||||
|
||||
static bool UNUSED_FUNCTION(draw_mesh_object_new)(const bContext *C, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
static bool UNUSED_FUNCTION(draw_mesh_object_new)(const bContext *C, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const unsigned char ob_wire_col[4], const short dflag)
|
||||
{
|
||||
EvaluationContext eval_ctx;
|
||||
|
@ -5087,9 +5087,9 @@ static bool UNUSED_FUNCTION(draw_mesh_object_new)(const bContext *C, Scene *scen
|
|||
DM_update_materials(cageDM, ob);
|
||||
}
|
||||
|
||||
const bool glsl = draw_glsl_material(scene, sl, ob, v3d, dt);
|
||||
const bool glsl = draw_glsl_material(scene, view_layer, ob, v3d, dt);
|
||||
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, glsl, NULL);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, glsl, NULL);
|
||||
}
|
||||
|
||||
draw_em_fancy_new(scene, ar, v3d, ob, me, em, cageDM, finalDM, dt);
|
||||
|
@ -5105,18 +5105,18 @@ static bool UNUSED_FUNCTION(draw_mesh_object_new)(const bContext *C, Scene *scen
|
|||
/* ob->bb was set by derived mesh system, do NULL check just to be sure */
|
||||
if (me->totpoly <= 4 || (!ob->bb || ED_view3d_boundbox_clip(rv3d, ob->bb))) {
|
||||
if (solid) {
|
||||
const bool glsl = draw_glsl_material(scene, sl, ob, v3d, dt);
|
||||
const bool glsl = draw_glsl_material(scene, view_layer, ob, v3d, dt);
|
||||
|
||||
if (dt == OB_SOLID || glsl) {
|
||||
const bool check_alpha = check_alpha_pass(base);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, glsl,
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, glsl,
|
||||
(check_alpha) ? &do_alpha_after : NULL);
|
||||
}
|
||||
}
|
||||
|
||||
const bool other_obedit = obedit && (obedit != ob);
|
||||
|
||||
draw_mesh_fancy_new(&eval_ctx, scene, sl, ar, v3d, rv3d, base, dt, ob_wire_col, dflag, other_obedit);
|
||||
draw_mesh_fancy_new(&eval_ctx, scene, view_layer, ar, v3d, rv3d, base, dt, ob_wire_col, dflag, other_obedit);
|
||||
|
||||
GPU_end_object_materials();
|
||||
|
||||
|
@ -5427,7 +5427,7 @@ static void drawCurveDMWired(Object *ob)
|
|||
}
|
||||
|
||||
/* return true when nothing was drawn */
|
||||
static bool drawCurveDerivedMesh(Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, Base *base, const char dt)
|
||||
static bool drawCurveDerivedMesh(Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, Base *base, const char dt)
|
||||
{
|
||||
Object *ob = base->object;
|
||||
DerivedMesh *dm = ob->derivedFinal;
|
||||
|
@ -5441,8 +5441,8 @@ static bool drawCurveDerivedMesh(Scene *scene, ViewLayer *sl, View3D *v3d, Regio
|
|||
glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
|
||||
|
||||
if (dt > OB_WIRE && dm->getNumPolys(dm)) {
|
||||
bool glsl = draw_glsl_material(scene, sl, ob, v3d, dt);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, glsl, NULL);
|
||||
bool glsl = draw_glsl_material(scene, view_layer, ob, v3d, dt);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, glsl, NULL);
|
||||
|
||||
if (!glsl)
|
||||
dm->drawFacesSolid(dm, NULL, 0, GPU_object_material_bind);
|
||||
|
@ -5463,7 +5463,7 @@ static bool drawCurveDerivedMesh(Scene *scene, ViewLayer *sl, View3D *v3d, Regio
|
|||
* Only called by #drawDispList
|
||||
* \return true when nothing was drawn
|
||||
*/
|
||||
static bool drawDispList_nobackface(Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
static bool drawDispList_nobackface(Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const short dflag, const unsigned char ob_wire_col[4])
|
||||
{
|
||||
Object *ob = base->object;
|
||||
|
@ -5504,13 +5504,13 @@ static bool drawDispList_nobackface(Scene *scene, ViewLayer *sl, View3D *v3d, Re
|
|||
/* pass */
|
||||
}
|
||||
else {
|
||||
if (draw_glsl_material(scene, sl, ob, v3d, dt)) {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, 1, NULL);
|
||||
if (draw_glsl_material(scene, view_layer, ob, v3d, dt)) {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, 1, NULL);
|
||||
drawDispListsolid(lb, ob, dflag, ob_wire_col, true);
|
||||
GPU_end_object_materials();
|
||||
}
|
||||
else {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, 0, NULL);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, 0, NULL);
|
||||
drawDispListsolid(lb, ob, dflag, ob_wire_col, false);
|
||||
GPU_end_object_materials();
|
||||
}
|
||||
|
@ -5539,13 +5539,13 @@ static bool drawDispList_nobackface(Scene *scene, ViewLayer *sl, View3D *v3d, Re
|
|||
|
||||
if (dl->nors == NULL) BKE_displist_normals_add(lb);
|
||||
|
||||
if (draw_glsl_material(scene, sl, ob, v3d, dt)) {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, 1, NULL);
|
||||
if (draw_glsl_material(scene, view_layer, ob, v3d, dt)) {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, 1, NULL);
|
||||
drawDispListsolid(lb, ob, dflag, ob_wire_col, true);
|
||||
GPU_end_object_materials();
|
||||
}
|
||||
else {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, 0, NULL);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, 0, NULL);
|
||||
drawDispListsolid(lb, ob, dflag, ob_wire_col, false);
|
||||
GPU_end_object_materials();
|
||||
}
|
||||
|
@ -5564,13 +5564,13 @@ static bool drawDispList_nobackface(Scene *scene, ViewLayer *sl, View3D *v3d, Re
|
|||
|
||||
if (solid) {
|
||||
|
||||
if (draw_glsl_material(scene, sl, ob, v3d, dt)) {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, 1, NULL);
|
||||
if (draw_glsl_material(scene, view_layer, ob, v3d, dt)) {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, 1, NULL);
|
||||
drawDispListsolid(lb, ob, dflag, ob_wire_col, true);
|
||||
GPU_end_object_materials();
|
||||
}
|
||||
else {
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, 0, NULL);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, 0, NULL);
|
||||
drawDispListsolid(lb, ob, dflag, ob_wire_col, false);
|
||||
GPU_end_object_materials();
|
||||
}
|
||||
|
@ -5585,7 +5585,7 @@ static bool drawDispList_nobackface(Scene *scene, ViewLayer *sl, View3D *v3d, Re
|
|||
return false;
|
||||
}
|
||||
static bool drawDispList(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const short dflag, const unsigned char ob_wire_col[4])
|
||||
{
|
||||
bool retval;
|
||||
|
@ -5601,7 +5601,7 @@ static bool drawDispList(
|
|||
ensure_curve_cache(eval_ctx, scene, base->object);
|
||||
#endif
|
||||
|
||||
if (drawCurveDerivedMesh(scene, sl, v3d, rv3d, base, dt) == false) {
|
||||
if (drawCurveDerivedMesh(scene, view_layer, v3d, rv3d, base, dt) == false) {
|
||||
retval = false;
|
||||
}
|
||||
else {
|
||||
|
@ -5617,7 +5617,7 @@ static bool drawDispList(
|
|||
|
||||
glFrontFace(mode);
|
||||
|
||||
retval = drawDispList_nobackface(scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
retval = drawDispList_nobackface(scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
|
||||
if (mode != GL_CCW) {
|
||||
glFrontFace(GL_CCW);
|
||||
|
@ -6595,10 +6595,10 @@ static void draw_new_particle_system(
|
|||
}
|
||||
|
||||
static void draw_update_ptcache_edit(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, Object *ob, PTCacheEdit *edit)
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, Object *ob, PTCacheEdit *edit)
|
||||
{
|
||||
if (edit->psys && edit->psys->flag & PSYS_HAIR_UPDATED)
|
||||
PE_update_object(eval_ctx, scene, sl, ob, 0);
|
||||
PE_update_object(eval_ctx, scene, view_layer, ob, 0);
|
||||
|
||||
/* create path and child path cache if it doesn't exist already */
|
||||
if (edit->pathcache == NULL) {
|
||||
|
@ -7337,7 +7337,7 @@ static void draw_editnurb_splines(Object *ob, Nurb *nurb, const bool sel)
|
|||
}
|
||||
|
||||
static void draw_editnurb(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer,
|
||||
View3D *v3d, RegionView3D *rv3d, Base *base, Nurb *nurb,
|
||||
const char dt, const short dflag, const unsigned char UNUSED(ob_wire_col[4]))
|
||||
{
|
||||
|
@ -7352,7 +7352,7 @@ static void draw_editnurb(
|
|||
/* DispList */
|
||||
UI_GetThemeColor3ubv(TH_WIRE_EDIT, wire_col);
|
||||
|
||||
drawDispList(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, wire_col);
|
||||
drawDispList(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, wire_col);
|
||||
|
||||
/* for shadows only show solid faces */
|
||||
if (v3d->flag2 & V3D_RENDER_SHADOW)
|
||||
|
@ -7478,7 +7478,7 @@ static void draw_editfont_textcurs(RegionView3D *rv3d, float textcurs[4][2])
|
|||
}
|
||||
|
||||
static void draw_editfont(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const short dflag, const unsigned char ob_wire_col[4])
|
||||
{
|
||||
Object *ob = base->object;
|
||||
|
@ -7491,11 +7491,11 @@ static void draw_editfont(
|
|||
if (cu->flag & CU_FAST) {
|
||||
imm_cpack(0xFFFFFF);
|
||||
set_inverted_drawing(1);
|
||||
drawDispList(eval_ctx, scene, sl, v3d, rv3d, base, OB_WIRE, dflag, ob_wire_col);
|
||||
drawDispList(eval_ctx, scene, view_layer, v3d, rv3d, base, OB_WIRE, dflag, ob_wire_col);
|
||||
set_inverted_drawing(0);
|
||||
}
|
||||
else {
|
||||
drawDispList(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
drawDispList(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
}
|
||||
|
||||
if (cu->linewidth != 0.0f) {
|
||||
|
@ -7798,7 +7798,7 @@ static void imm_drawcone(const float vec[3], float radius, float height, float t
|
|||
|
||||
/* return true if nothing was drawn */
|
||||
static bool drawmball(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, Base *base,
|
||||
const char dt, const short dflag, const unsigned char ob_wire_col[4])
|
||||
{
|
||||
Object *ob = base->object;
|
||||
|
@ -7812,13 +7812,13 @@ static bool drawmball(
|
|||
if ((G.f & G_PICKSEL) == 0) {
|
||||
unsigned char wire_col[4];
|
||||
UI_GetThemeColor4ubv(TH_WIRE_EDIT, wire_col);
|
||||
drawDispList(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, wire_col);
|
||||
drawDispList(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, wire_col);
|
||||
}
|
||||
ml = mb->editelems->first;
|
||||
}
|
||||
else {
|
||||
if ((base->flag_legacy & OB_FROMDUPLI) == 0) {
|
||||
drawDispList(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
drawDispList(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
}
|
||||
ml = mb->elems.first;
|
||||
}
|
||||
|
@ -8266,7 +8266,7 @@ static void drawtexspace(Object *ob, const unsigned char ob_wire_col[3])
|
|||
|
||||
/* draws wire outline */
|
||||
static void draw_object_selected_outline(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, ARegion *ar, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, ARegion *ar, Base *base,
|
||||
const unsigned char ob_wire_col[4])
|
||||
{
|
||||
RegionView3D *rv3d = ar->regiondata;
|
||||
|
@ -8313,9 +8313,9 @@ static void draw_object_selected_outline(
|
|||
}
|
||||
}
|
||||
else if (ob->type == OB_ARMATURE) {
|
||||
if (!(ob->mode & OB_MODE_POSE && base == sl->basact)) {
|
||||
if (!(ob->mode & OB_MODE_POSE && base == view_layer->basact)) {
|
||||
glLineWidth(UI_GetThemeValuef(TH_OUTLINE_WIDTH) * 2.0f);
|
||||
draw_armature(eval_ctx, scene, sl, v3d, ar, base, OB_WIRE, 0, ob_wire_col, true);
|
||||
draw_armature(eval_ctx, scene, view_layer, v3d, ar, base, OB_WIRE, 0, ob_wire_col, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -8423,7 +8423,7 @@ static void draw_rigid_body_pivot(bRigidBodyJointConstraint *data,
|
|||
immUnbindProgram();
|
||||
}
|
||||
|
||||
void draw_object_wire_color(Scene *scene, ViewLayer *sl, Base *base, unsigned char r_ob_wire_col[4])
|
||||
void draw_object_wire_color(Scene *scene, ViewLayer *view_layer, Base *base, unsigned char r_ob_wire_col[4])
|
||||
{
|
||||
Object *ob = base->object;
|
||||
int colindex = 0;
|
||||
|
@ -8453,7 +8453,7 @@ void draw_object_wire_color(Scene *scene, ViewLayer *sl, Base *base, unsigned ch
|
|||
/* uses darker active color for non-active + selected */
|
||||
theme_id = TH_GROUP_ACTIVE;
|
||||
|
||||
if (sl->basact != base) {
|
||||
if (view_layer->basact != base) {
|
||||
theme_shade = -32;
|
||||
}
|
||||
}
|
||||
|
@ -8463,7 +8463,7 @@ void draw_object_wire_color(Scene *scene, ViewLayer *sl, Base *base, unsigned ch
|
|||
}
|
||||
else {
|
||||
if ((base->flag & BASE_SELECTED) || (base->flag_legacy & BA_WAS_SEL)) {
|
||||
theme_id = sl->basact == base ? TH_ACTIVE : TH_SELECT;
|
||||
theme_id = view_layer->basact == base ? TH_ACTIVE : TH_SELECT;
|
||||
}
|
||||
else {
|
||||
if (ob->type == OB_LAMP) theme_id = TH_LAMP;
|
||||
|
@ -8568,7 +8568,7 @@ void draw_rigidbody_shape(Object *ob, const unsigned char ob_wire_col[4])
|
|||
* \param dflag (draw flag) can be DRAW_PICKING and/or DRAW_CONSTCOLOR, DRAW_SCENESET
|
||||
*/
|
||||
void draw_object(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d,
|
||||
Base *base, const short dflag)
|
||||
{
|
||||
ModifierData *md = NULL;
|
||||
|
@ -8578,7 +8578,7 @@ void draw_object(
|
|||
unsigned char _ob_wire_col[4]; /* dont initialize this */
|
||||
const unsigned char *ob_wire_col = NULL; /* dont initialize this, use NULL crashes as a way to find invalid use */
|
||||
bool zbufoff = false, is_paint = false, empty_object = false;
|
||||
const bool is_obact = (ob == OBACT(sl));
|
||||
const bool is_obact = (ob == OBACT(view_layer));
|
||||
const bool render_override = (v3d->flag2 & V3D_RENDER_OVERRIDE) != 0;
|
||||
const bool is_picking = (G.f & G_PICKSEL) != 0;
|
||||
const bool has_particles = (ob->particlesystem.first != NULL);
|
||||
|
@ -8695,7 +8695,7 @@ void draw_object(
|
|||
|
||||
ED_view3d_project_base(ar, base);
|
||||
|
||||
draw_object_wire_color(scene, sl, base, _ob_wire_col);
|
||||
draw_object_wire_color(scene, view_layer, base, _ob_wire_col);
|
||||
ob_wire_col = _ob_wire_col;
|
||||
|
||||
//glColor3ubv(ob_wire_col);
|
||||
|
@ -8751,7 +8751,7 @@ void draw_object(
|
|||
if ((v3d->flag & V3D_SELECT_OUTLINE) && !render_override && ob->type != OB_MESH) {
|
||||
if (dt > OB_WIRE && (ob->mode & OB_MODE_EDIT) == 0 && (dflag & DRAW_SCENESET) == 0) {
|
||||
if (!(ob->dtx & OB_DRAWWIRE) && (base->flag & BASE_SELECTED) && !(dflag & (DRAW_PICKING | DRAW_CONSTCOLOR))) {
|
||||
draw_object_selected_outline(eval_ctx, scene, sl, v3d, ar, base, ob_wire_col);
|
||||
draw_object_selected_outline(eval_ctx, scene, view_layer, v3d, ar, base, ob_wire_col);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -8765,7 +8765,7 @@ void draw_object(
|
|||
|
||||
switch (ob->type) {
|
||||
case OB_MESH:
|
||||
empty_object = draw_mesh_object(eval_ctx, scene, sl, ar, v3d, rv3d, base, dt, ob_wire_col, dflag);
|
||||
empty_object = draw_mesh_object(eval_ctx, scene, view_layer, ar, v3d, rv3d, base, dt, ob_wire_col, dflag);
|
||||
if ((dflag & DRAW_CONSTCOLOR) == 0) {
|
||||
/* mesh draws wire itself */
|
||||
dtx &= ~OB_DRAWWIRE;
|
||||
|
@ -8775,7 +8775,7 @@ void draw_object(
|
|||
case OB_FONT:
|
||||
cu = ob->data;
|
||||
if (cu->editfont) {
|
||||
draw_editfont(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
draw_editfont(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
}
|
||||
else if (dt == OB_BOUNDBOX) {
|
||||
if ((render_override && v3d->drawtype >= OB_WIRE) == 0) {
|
||||
|
@ -8786,7 +8786,7 @@ void draw_object(
|
|||
}
|
||||
}
|
||||
else if (ED_view3d_boundbox_clip(rv3d, ob->bb)) {
|
||||
empty_object = drawDispList(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
empty_object = drawDispList(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
}
|
||||
|
||||
break;
|
||||
|
@ -8796,7 +8796,7 @@ void draw_object(
|
|||
|
||||
if (cu->editnurb) {
|
||||
ListBase *nurbs = BKE_curve_editNurbs_get(cu);
|
||||
draw_editnurb(eval_ctx, scene, sl, v3d, rv3d, base, nurbs->first, dt, dflag, ob_wire_col);
|
||||
draw_editnurb(eval_ctx, scene, view_layer, v3d, rv3d, base, nurbs->first, dt, dflag, ob_wire_col);
|
||||
}
|
||||
else if (dt == OB_BOUNDBOX) {
|
||||
if ((render_override && (v3d->drawtype >= OB_WIRE)) == 0) {
|
||||
|
@ -8807,7 +8807,7 @@ void draw_object(
|
|||
}
|
||||
}
|
||||
else if (ED_view3d_boundbox_clip(rv3d, ob->bb)) {
|
||||
empty_object = drawDispList(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
empty_object = drawDispList(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
}
|
||||
break;
|
||||
case OB_MBALL:
|
||||
|
@ -8815,7 +8815,7 @@ void draw_object(
|
|||
MetaBall *mb = ob->data;
|
||||
|
||||
if (mb->editelems)
|
||||
drawmball(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
drawmball(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
else if (dt == OB_BOUNDBOX) {
|
||||
if ((render_override && (v3d->drawtype >= OB_WIRE)) == 0) {
|
||||
#ifdef SEQUENCER_DAG_WORKAROUND
|
||||
|
@ -8825,7 +8825,7 @@ void draw_object(
|
|||
}
|
||||
}
|
||||
else
|
||||
empty_object = drawmball(eval_ctx, scene, sl, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
empty_object = drawmball(eval_ctx, scene, view_layer, v3d, rv3d, base, dt, dflag, ob_wire_col);
|
||||
break;
|
||||
}
|
||||
case OB_EMPTY:
|
||||
|
@ -8889,7 +8889,7 @@ void draw_object(
|
|||
else
|
||||
copy_v4_v4_uchar(arm_col, ob_wire_col);
|
||||
|
||||
empty_object = draw_armature(eval_ctx, scene, sl, v3d, ar, base, dt, dflag, arm_col, false);
|
||||
empty_object = draw_armature(eval_ctx, scene, view_layer, v3d, ar, base, dt, dflag, arm_col, false);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
@ -8944,7 +8944,7 @@ afterdraw:
|
|||
if (ob->mode & OB_MODE_PARTICLE_EDIT && is_obact) {
|
||||
PTCacheEdit *edit = PE_create_current(eval_ctx, scene, ob);
|
||||
if (edit && edit->psys == psys)
|
||||
draw_update_ptcache_edit(eval_ctx, scene, sl, ob, edit);
|
||||
draw_update_ptcache_edit(eval_ctx, scene, view_layer, ob, edit);
|
||||
}
|
||||
|
||||
draw_new_particle_system(eval_ctx, scene, v3d, rv3d, base, psys, dt, dflag);
|
||||
|
@ -8966,7 +8966,7 @@ afterdraw:
|
|||
PTCacheEdit *edit = PE_create_current(eval_ctx, scene, ob);
|
||||
if (edit) {
|
||||
gpuLoadMatrix(rv3d->viewmat);
|
||||
draw_update_ptcache_edit(eval_ctx, scene, sl, ob, edit);
|
||||
draw_update_ptcache_edit(eval_ctx, scene, view_layer, ob, edit);
|
||||
draw_ptcache_edit(scene, v3d, edit);
|
||||
gpuMultMatrix(ob->obmat);
|
||||
}
|
||||
|
@ -9331,11 +9331,11 @@ afterdraw:
|
|||
* caller must have called 'GPU_select_load_id(base->selcode)' first.
|
||||
*/
|
||||
void draw_object_select(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d,
|
||||
Base *base, const short dflag)
|
||||
{
|
||||
BLI_assert(dflag & DRAW_PICKING && dflag & DRAW_CONSTCOLOR);
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, base, dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, base, dflag);
|
||||
|
||||
/* we draw duplicators for selection too */
|
||||
if ((base->object->transflag & OB_DUPLI)) {
|
||||
|
@ -9358,7 +9358,7 @@ void draw_object_select(
|
|||
char dt = tbase.object->dt; tbase.object->dt = MIN2(tbase.object->dt, base->object->dt);
|
||||
short dtx = tbase.object->dtx; tbase.object->dtx = base->object->dtx;
|
||||
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, &tbase, dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, &tbase, dflag);
|
||||
|
||||
tbase.object->dt = dt;
|
||||
tbase.object->dtx = dtx;
|
||||
|
@ -9816,7 +9816,7 @@ void draw_object_backbufsel(
|
|||
|
||||
/* helper function for drawing object instances - meshes */
|
||||
static void draw_object_mesh_instance(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d,
|
||||
Object *ob, const short dt, int outline, const unsigned char ob_wire_col[4])
|
||||
{
|
||||
Mesh *me = ob->data;
|
||||
|
@ -9843,8 +9843,8 @@ static void draw_object_mesh_instance(
|
|||
draw_mesh_object_outline(v3d, ob, dm ? dm : edm, ob_wire_col);
|
||||
|
||||
if (dm) {
|
||||
bool glsl = draw_glsl_material(scene, sl, ob, v3d, dt);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, sl, ob, glsl, NULL);
|
||||
bool glsl = draw_glsl_material(scene, view_layer, ob, v3d, dt);
|
||||
GPU_begin_object_materials(v3d, rv3d, scene, view_layer, ob, glsl, NULL);
|
||||
}
|
||||
|
||||
glFrontFace((ob->transflag & OB_NEG_SCALE) ? GL_CW : GL_CCW);
|
||||
|
@ -9863,7 +9863,7 @@ static void draw_object_mesh_instance(
|
|||
if (dm) dm->release(dm);
|
||||
}
|
||||
|
||||
void draw_object_instance(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, Object *ob, const char dt, int outline, const float wire_col[4])
|
||||
void draw_object_instance(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, Object *ob, const char dt, int outline, const float wire_col[4])
|
||||
{
|
||||
if (ob == NULL)
|
||||
return;
|
||||
|
@ -9873,7 +9873,7 @@ void draw_object_instance(const EvaluationContext *eval_ctx, Scene *scene, ViewL
|
|||
|
||||
switch (ob->type) {
|
||||
case OB_MESH:
|
||||
draw_object_mesh_instance(eval_ctx, scene, sl, v3d, rv3d, ob, dt, outline, bcol);
|
||||
draw_object_mesh_instance(eval_ctx, scene, view_layer, v3d, rv3d, ob, dt, outline, bcol);
|
||||
break;
|
||||
case OB_EMPTY:
|
||||
if (ob->empty_drawtype == OB_EMPTY_IMAGE) {
|
||||
|
|
|
@ -1323,23 +1323,23 @@ static int view3d_context(const bContext *C, const char *member, bContextDataRes
|
|||
}
|
||||
else if (CTX_data_equals(member, "active_base")) {
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
if (sl->basact) {
|
||||
Object *ob = sl->basact->object;
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
if (view_layer->basact) {
|
||||
Object *ob = view_layer->basact->object;
|
||||
/* if hidden but in edit mode, we still display, can happen with animation */
|
||||
if ((sl->basact->flag & BASE_VISIBLED) != 0 || (ob->mode & OB_MODE_EDIT)) {
|
||||
CTX_data_pointer_set(result, &scene->id, &RNA_ObjectBase, sl->basact);
|
||||
if ((view_layer->basact->flag & BASE_VISIBLED) != 0 || (ob->mode & OB_MODE_EDIT)) {
|
||||
CTX_data_pointer_set(result, &scene->id, &RNA_ObjectBase, view_layer->basact);
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
else if (CTX_data_equals(member, "active_object")) {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
if (sl->basact) {
|
||||
Object *ob = sl->basact->object;
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
if (view_layer->basact) {
|
||||
Object *ob = view_layer->basact->object;
|
||||
/* if hidden but in edit mode, we still display, can happen with animation */
|
||||
if ((sl->basact->flag & BASE_VISIBLED) != 0 || (ob->mode & OB_MODE_EDIT) != 0) {
|
||||
if ((view_layer->basact->flag & BASE_VISIBLED) != 0 || (ob->mode & OB_MODE_EDIT) != 0) {
|
||||
CTX_data_id_pointer_set(result, &ob->id);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -777,8 +777,8 @@ static void do_view3d_vgroup_buttons(bContext *C, void *UNUSED(arg), int event)
|
|||
return;
|
||||
}
|
||||
else {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = sl->basact->object;
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = view_layer->basact->object;
|
||||
ED_vgroup_vert_active_mirror(ob, event - B_VGRP_PNL_EDIT_SINGLE);
|
||||
DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
|
||||
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
|
||||
|
@ -787,8 +787,8 @@ static void do_view3d_vgroup_buttons(bContext *C, void *UNUSED(arg), int event)
|
|||
|
||||
static int view3d_panel_vgroup_poll(const bContext *C, PanelType *UNUSED(pt))
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(view_layer);
|
||||
if (ob && (BKE_object_is_in_editmode_vgroup(ob) ||
|
||||
BKE_object_is_in_wpaint_select_vert(ob)))
|
||||
{
|
||||
|
@ -806,8 +806,8 @@ static void view3d_panel_vgroup(const bContext *C, Panel *pa)
|
|||
{
|
||||
uiBlock *block = uiLayoutAbsoluteBlock(pa->layout);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = sl->basact->object;
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = view_layer->basact->object;
|
||||
|
||||
MDeformVert *dv;
|
||||
|
||||
|
@ -1097,9 +1097,9 @@ static void v3d_editmetaball_buts(uiLayout *layout, Object *ob)
|
|||
|
||||
static void do_view3d_region_buttons(bContext *C, void *UNUSED(index), int event)
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
View3D *v3d = CTX_wm_view3d(C);
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
|
||||
switch (event) {
|
||||
|
||||
|
@ -1121,17 +1121,17 @@ static void do_view3d_region_buttons(bContext *C, void *UNUSED(index), int event
|
|||
|
||||
static int view3d_panel_transform_poll(const bContext *C, PanelType *UNUSED(pt))
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
return (sl->basact != NULL);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
return (view_layer->basact != NULL);
|
||||
}
|
||||
|
||||
static void view3d_panel_transform(const bContext *C, Panel *pa)
|
||||
{
|
||||
uiBlock *block;
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
Object *ob = sl->basact->object;
|
||||
Object *ob = view_layer->basact->object;
|
||||
uiLayout *col;
|
||||
|
||||
block = uiLayoutGetBlock(pa->layout);
|
||||
|
|
|
@ -1314,9 +1314,9 @@ float ED_view3d_grid_scale(Scene *scene, View3D *v3d, const char **grid_unit)
|
|||
return v3d->grid * ED_scene_grid_scale(scene, grid_unit);
|
||||
}
|
||||
|
||||
static bool is_cursor_visible(Scene *scene, ViewLayer *sl)
|
||||
static bool is_cursor_visible(Scene *scene, ViewLayer *view_layer)
|
||||
{
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
|
||||
/* don't draw cursor in paint modes, but with a few exceptions */
|
||||
if (ob && ob->mode & OB_MODE_ALL_PAINT) {
|
||||
|
@ -1328,7 +1328,7 @@ static bool is_cursor_visible(Scene *scene, ViewLayer *sl)
|
|||
}
|
||||
/* exception: object in texture paint mode, clone brush, use_clone_layer disabled */
|
||||
else if (ob->mode & OB_MODE_TEXTURE_PAINT) {
|
||||
const Paint *p = BKE_paint_get_active(scene, sl);
|
||||
const Paint *p = BKE_paint_get_active(scene, view_layer);
|
||||
|
||||
if (p && p->brush && p->brush->imagepaint_tool == PAINT_TOOL_CLONE) {
|
||||
if ((scene->toolsettings->imapaint.flag & IMAGEPAINT_PROJECT_LAYER_CLONE) == 0) {
|
||||
|
@ -1846,8 +1846,8 @@ void view3d_draw_region_info(const bContext *C, ARegion *ar, const int offset)
|
|||
}
|
||||
|
||||
if (U.uiflag & USER_DRAWVIEWINFO) {
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(view_layer);
|
||||
draw_selected_name(scene, ob, &rect);
|
||||
}
|
||||
#if 0 /* TODO */
|
||||
|
@ -1930,12 +1930,12 @@ static void view3d_stereo3d_setup_offscreen(
|
|||
}
|
||||
}
|
||||
|
||||
void ED_view3d_draw_offscreen_init(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, View3D *v3d)
|
||||
void ED_view3d_draw_offscreen_init(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, View3D *v3d)
|
||||
{
|
||||
RenderEngineType *type = eval_ctx->engine;
|
||||
if (type->flag & RE_USE_LEGACY_PIPELINE) {
|
||||
/* shadow buffers, before we setup matrices */
|
||||
if (draw_glsl_material(scene, sl, NULL, v3d, v3d->drawtype)) {
|
||||
if (draw_glsl_material(scene, view_layer, NULL, v3d, v3d->drawtype)) {
|
||||
VP_deprecated_gpu_update_lamps_shadows_world(eval_ctx, scene, v3d);
|
||||
}
|
||||
}
|
||||
|
@ -2320,9 +2320,9 @@ ImBuf *ED_view3d_draw_offscreen_imbuf_simple(
|
|||
*
|
||||
* \{ */
|
||||
|
||||
void VP_legacy_drawcursor(Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d)
|
||||
void VP_legacy_drawcursor(Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d)
|
||||
{
|
||||
if (is_cursor_visible(scene, sl)) {
|
||||
if (is_cursor_visible(scene, view_layer)) {
|
||||
drawcursor(scene, ar, v3d);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -211,10 +211,10 @@ static void draw_view_icon(RegionView3D *rv3d, rcti *rect)
|
|||
|
||||
/* *********************** backdraw for selection *************** */
|
||||
|
||||
static void backdrawview3d(const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, wmWindow *win, ARegion *ar, View3D *v3d)
|
||||
static void backdrawview3d(const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, wmWindow *win, ARegion *ar, View3D *v3d)
|
||||
{
|
||||
RegionView3D *rv3d = ar->regiondata;
|
||||
struct Base *base = sl->basact;
|
||||
struct Base *base = view_layer->basact;
|
||||
int multisample_enabled;
|
||||
|
||||
BLI_assert(ar->regiontype == RGN_TYPE_WINDOW);
|
||||
|
@ -825,7 +825,7 @@ void ED_view3d_after_add(ListBase *lb, Base *base, const short dflag)
|
|||
|
||||
/* disables write in zbuffer and draws it over */
|
||||
static void view3d_draw_transp(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d)
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d)
|
||||
{
|
||||
View3DAfter *v3da;
|
||||
|
||||
|
@ -833,7 +833,7 @@ static void view3d_draw_transp(
|
|||
v3d->transp = true;
|
||||
|
||||
while ((v3da = BLI_pophead(&v3d->afterdraw_transp))) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, v3da->base, v3da->dflag);
|
||||
MEM_freeN(v3da);
|
||||
}
|
||||
v3d->transp = false;
|
||||
|
@ -844,7 +844,7 @@ static void view3d_draw_transp(
|
|||
|
||||
/* clears zbuffer and draws it over */
|
||||
static void view3d_draw_xray(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, bool *clear)
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, bool *clear)
|
||||
{
|
||||
if (*clear && v3d->zbuf) {
|
||||
glClear(GL_DEPTH_BUFFER_BIT);
|
||||
|
@ -854,7 +854,7 @@ static void view3d_draw_xray(
|
|||
v3d->xray = true;
|
||||
View3DAfter *v3da;
|
||||
while ((v3da = BLI_pophead(&v3d->afterdraw_xray))) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, v3da->base, v3da->dflag);
|
||||
MEM_freeN(v3da);
|
||||
}
|
||||
v3d->xray = false;
|
||||
|
@ -863,7 +863,7 @@ static void view3d_draw_xray(
|
|||
|
||||
/* clears zbuffer and draws it over */
|
||||
static void view3d_draw_xraytransp(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, const bool clear)
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, const bool clear)
|
||||
{
|
||||
if (clear && v3d->zbuf)
|
||||
glClear(GL_DEPTH_BUFFER_BIT);
|
||||
|
@ -875,7 +875,7 @@ static void view3d_draw_xraytransp(
|
|||
|
||||
View3DAfter *v3da;
|
||||
while ((v3da = BLI_pophead(&v3d->afterdraw_xraytransp))) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, v3da->base, v3da->dflag);
|
||||
MEM_freeN(v3da);
|
||||
}
|
||||
|
||||
|
@ -888,7 +888,7 @@ static void view3d_draw_xraytransp(
|
|||
/* clears zbuffer and draws it over,
|
||||
* note that in the select version we don't care about transparent flag as with regular drawing */
|
||||
static void view3d_draw_xray_select(
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, bool *clear)
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, bool *clear)
|
||||
{
|
||||
/* Not ideal, but we need to read from the previous depths before clearing
|
||||
* otherwise we could have a function to load the depths after drawing.
|
||||
|
@ -908,7 +908,7 @@ static void view3d_draw_xray_select(
|
|||
v3d->xray = true;
|
||||
while ((v3da = BLI_pophead(&v3d->afterdraw_xray))) {
|
||||
if (GPU_select_load_id(v3da->base->object->select_color)) {
|
||||
draw_object_select(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);
|
||||
draw_object_select(eval_ctx, scene, view_layer, ar, v3d, v3da->base, v3da->dflag);
|
||||
}
|
||||
MEM_freeN(v3da);
|
||||
}
|
||||
|
@ -944,7 +944,7 @@ static DupliObject *dupli_step(DupliObject *dob)
|
|||
}
|
||||
|
||||
static void draw_dupli_objects_color(
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, Base *base,
|
||||
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, Base *base,
|
||||
const short dflag, const int color)
|
||||
{
|
||||
RegionView3D *rv3d = ar->regiondata;
|
||||
|
@ -1027,7 +1027,7 @@ static void draw_dupli_objects_color(
|
|||
if (!testbb || ED_view3d_boundbox_clip_ex(rv3d, &bb, dob->mat)) {
|
||||
copy_m4_m4(dob->ob->obmat, dob->mat);
|
||||
GPU_begin_dupli_object(dob);
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, &tbase, dflag_dupli);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, &tbase, dflag_dupli);
|
||||
GPU_end_dupli_object();
|
||||
}
|
||||
|
||||
|
@ -1045,7 +1045,7 @@ static void draw_dupli_objects_color(
|
|||
free_object_duplilist(lb);
|
||||
}
|
||||
|
||||
void draw_dupli_objects(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, Base *base)
|
||||
void draw_dupli_objects(const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, Base *base)
|
||||
{
|
||||
/* define the color here so draw_dupli_objects_color can be called
|
||||
* from the set loop */
|
||||
|
@ -1055,7 +1055,7 @@ void draw_dupli_objects(const EvaluationContext *eval_ctx, Scene *scene, ViewLay
|
|||
if (base->object->dup_group && base->object->dup_group->id.us < 1)
|
||||
color = TH_REDALERT;
|
||||
|
||||
draw_dupli_objects_color(eval_ctx, scene, sl, ar, v3d, base, 0, color);
|
||||
draw_dupli_objects_color(eval_ctx, scene, view_layer, ar, v3d, base, 0, color);
|
||||
}
|
||||
|
||||
/* XXX warning, not using gpu offscreen here */
|
||||
|
@ -1192,7 +1192,7 @@ void ED_view3d_draw_depth_gpencil(
|
|||
void ED_view3d_draw_depth_loop(const EvaluationContext *eval_ctx, Scene *scene, ARegion *ar, View3D *v3d)
|
||||
{
|
||||
Base *base;
|
||||
ViewLayer *sl = eval_ctx->view_layer;
|
||||
ViewLayer *view_layer = eval_ctx->view_layer;
|
||||
/* no need for color when drawing depth buffer */
|
||||
const short dflag_depth = DRAW_CONSTCOLOR;
|
||||
|
||||
|
@ -1201,21 +1201,21 @@ void ED_view3d_draw_depth_loop(const EvaluationContext *eval_ctx, Scene *scene,
|
|||
Scene *sce_iter;
|
||||
for (SETLOOPER(scene->set, sce_iter, base)) {
|
||||
if ((base->flag & BASE_VISIBLED) != 0) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, base, 0);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, base, 0);
|
||||
if (base->object->transflag & OB_DUPLI) {
|
||||
draw_dupli_objects_color(eval_ctx, scene, sl, ar, v3d, base, dflag_depth, TH_UNDEFINED);
|
||||
draw_dupli_objects_color(eval_ctx, scene, view_layer, ar, v3d, base, dflag_depth, TH_UNDEFINED);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if ((base->flag & BASE_VISIBLED) != 0) {
|
||||
/* dupli drawing */
|
||||
if (base->object->transflag & OB_DUPLI) {
|
||||
draw_dupli_objects_color(eval_ctx, scene, sl, ar, v3d, base, dflag_depth, TH_UNDEFINED);
|
||||
draw_dupli_objects_color(eval_ctx, scene, view_layer, ar, v3d, base, dflag_depth, TH_UNDEFINED);
|
||||
}
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, base, dflag_depth);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, base, dflag_depth);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1236,7 +1236,7 @@ void ED_view3d_draw_depth_loop(const EvaluationContext *eval_ctx, Scene *scene,
|
|||
if (v3d->afterdraw_xray.first || v3d->afterdraw_xraytransp.first) {
|
||||
glDepthFunc(GL_ALWAYS); /* always write into the depth bufer, overwriting front z values */
|
||||
for (v3da = v3d->afterdraw_xray.first; v3da; v3da = v3da->next) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, dflag_depth);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, v3da->base, dflag_depth);
|
||||
}
|
||||
glDepthFunc(GL_LEQUAL); /* Now write the depth buffer normally */
|
||||
}
|
||||
|
@ -1245,21 +1245,21 @@ void ED_view3d_draw_depth_loop(const EvaluationContext *eval_ctx, Scene *scene,
|
|||
v3d->xray = false;
|
||||
v3d->transp = true;
|
||||
while ((v3da = BLI_pophead(&v3d->afterdraw_transp))) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, dflag_depth);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, v3da->base, dflag_depth);
|
||||
MEM_freeN(v3da);
|
||||
}
|
||||
|
||||
v3d->xray = true;
|
||||
v3d->transp = false;
|
||||
while ((v3da = BLI_pophead(&v3d->afterdraw_xray))) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, dflag_depth);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, v3da->base, dflag_depth);
|
||||
MEM_freeN(v3da);
|
||||
}
|
||||
|
||||
v3d->xray = true;
|
||||
v3d->transp = true;
|
||||
while ((v3da = BLI_pophead(&v3d->afterdraw_xraytransp))) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, dflag_depth);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, v3da->base, dflag_depth);
|
||||
MEM_freeN(v3da);
|
||||
}
|
||||
|
||||
|
@ -1272,7 +1272,7 @@ void ED_view3d_draw_depth_loop(const EvaluationContext *eval_ctx, Scene *scene,
|
|||
}
|
||||
|
||||
void ED_view3d_draw_select_loop(
|
||||
const struct EvaluationContext *eval_ctx, ViewContext *vc, Scene *scene, ViewLayer *sl,
|
||||
const struct EvaluationContext *eval_ctx, ViewContext *vc, Scene *scene, ViewLayer *view_layer,
|
||||
View3D *v3d, ARegion *ar, bool use_obedit_skip, bool use_nearest)
|
||||
{
|
||||
struct bThemeState theme_state;
|
||||
|
@ -1285,18 +1285,18 @@ void ED_view3d_draw_select_loop(
|
|||
UI_SetTheme(SPACE_VIEW3D, RGN_TYPE_WINDOW);
|
||||
|
||||
if (vc->obedit && vc->obedit->type == OB_MBALL) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, BASACT(sl), dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, BASACT(view_layer), dflag);
|
||||
}
|
||||
else if ((vc->obedit && vc->obedit->type == OB_ARMATURE)) {
|
||||
/* if not drawing sketch, draw bones */
|
||||
if (!BDR_drawSketchNames(vc)) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, BASACT(sl), dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, BASACT(view_layer), dflag);
|
||||
}
|
||||
}
|
||||
else {
|
||||
Base *base;
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if ((base->flag & BASE_VISIBLED) != 0) {
|
||||
if (((base->flag & BASE_SELECTABLED) == 0) ||
|
||||
(use_obedit_skip && (scene->obedit->data == base->object->data)))
|
||||
|
@ -1311,7 +1311,7 @@ void ED_view3d_draw_select_loop(
|
|||
}
|
||||
else {
|
||||
if (GPU_select_load_id(code)) {
|
||||
draw_object(eval_ctx, scene, sl, ar, v3d, base, dflag);
|
||||
draw_object(eval_ctx, scene, view_layer, ar, v3d, base, dflag);
|
||||
}
|
||||
}
|
||||
code++;
|
||||
|
@ -1322,7 +1322,7 @@ void ED_view3d_draw_select_loop(
|
|||
if (use_nearest) {
|
||||
bool xrayclear = true;
|
||||
if (v3d->afterdraw_xray.first) {
|
||||
view3d_draw_xray_select(eval_ctx, scene, sl, ar, v3d, &xrayclear);
|
||||
view3d_draw_xray_select(eval_ctx, scene, view_layer, ar, v3d, &xrayclear);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1942,7 +1942,7 @@ static void update_lods(Scene *scene, float camera_pos[3])
|
|||
}
|
||||
#endif
|
||||
|
||||
static void view3d_main_region_draw_objects(const bContext *C, Scene *scene, ViewLayer *sl, View3D *v3d,
|
||||
static void view3d_main_region_draw_objects(const bContext *C, Scene *scene, ViewLayer *view_layer, View3D *v3d,
|
||||
ARegion *ar, const char **grid_unit)
|
||||
{
|
||||
wmWindow *win = CTX_wm_window(C);
|
||||
|
@ -1956,7 +1956,7 @@ static void view3d_main_region_draw_objects(const bContext *C, Scene *scene, Vie
|
|||
bool do_compositing = false;
|
||||
|
||||
/* shadow buffers, before we setup matrices */
|
||||
if (draw_glsl_material(scene, sl, NULL, v3d, v3d->drawtype))
|
||||
if (draw_glsl_material(scene, view_layer, NULL, v3d, v3d->drawtype))
|
||||
gpu_update_lamps_shadows_world(&eval_ctx, scene, v3d);
|
||||
|
||||
/* reset default OpenGL lights if needed (i.e. after preferences have been altered) */
|
||||
|
@ -2104,7 +2104,7 @@ void view3d_main_region_draw_legacy(const bContext *C, ARegion *ar)
|
|||
{
|
||||
EvaluationContext eval_ctx;
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
View3D *v3d = CTX_wm_view3d(C);
|
||||
const char *grid_unit = NULL;
|
||||
rcti border_rect;
|
||||
|
@ -2124,7 +2124,7 @@ void view3d_main_region_draw_legacy(const bContext *C, ARegion *ar)
|
|||
/* draw viewport using opengl */
|
||||
if (v3d->drawtype != OB_RENDER || !view3d_main_region_do_render_draw(scene) || clip_border) {
|
||||
VP_view3d_main_region_clear(scene, v3d, ar); /* background */
|
||||
view3d_main_region_draw_objects(C, scene, sl, v3d, ar, &grid_unit);
|
||||
view3d_main_region_draw_objects(C, scene, view_layer, v3d, ar, &grid_unit);
|
||||
|
||||
if (G.debug & G_DEBUG_SIMDATA)
|
||||
draw_sim_debug_data(scene, v3d, ar);
|
||||
|
|
|
@ -624,8 +624,8 @@ static bool view3d_orbit_calc_center(bContext *C, float r_dyn_ofs[3])
|
|||
bool is_set = false;
|
||||
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob_act = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob_act = OBACT(view_layer);
|
||||
|
||||
if (ob_act && (ob_act->mode & OB_MODE_ALL_PAINT) &&
|
||||
/* with weight-paint + pose-mode, fall through to using calculateTransformCenter */
|
||||
|
@ -667,7 +667,7 @@ static bool view3d_orbit_calc_center(bContext *C, float r_dyn_ofs[3])
|
|||
float select_center[3];
|
||||
|
||||
zero_v3(select_center);
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if (TESTBASE(base)) {
|
||||
/* use the boundbox if we can */
|
||||
Object *ob = base->object;
|
||||
|
@ -2990,7 +2990,7 @@ static int view3d_all_exec(bContext *C, wmOperator *op) /* was view3d_home() in
|
|||
ARegion *ar = CTX_wm_region(C);
|
||||
View3D *v3d = CTX_wm_view3d(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Base *base;
|
||||
float *curs;
|
||||
const bool use_all_regions = RNA_boolean_get(op->ptr, "use_all_regions");
|
||||
|
@ -3014,7 +3014,7 @@ static int view3d_all_exec(bContext *C, wmOperator *op) /* was view3d_home() in
|
|||
INIT_MINMAX(min, max);
|
||||
}
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (BASE_VISIBLE(base)) {
|
||||
changed = true;
|
||||
|
||||
|
|
|
@ -280,10 +280,10 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C)
|
|||
ScrArea *sa = CTX_wm_area(C);
|
||||
View3D *v3d = sa->spacedata.first;
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ToolSettings *ts = CTX_data_tool_settings(C);
|
||||
PointerRNA v3dptr, toolsptr, sceneptr;
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
bGPdata *gpd = CTX_data_gpencil_data(C);
|
||||
uiBlock *block;
|
||||
|
|
|
@ -147,16 +147,16 @@ void draw_motion_paths_cleanup(View3D *v3d);
|
|||
|
||||
/* drawobject.c */
|
||||
void draw_object(
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *sl, struct ARegion *ar, View3D *v3d,
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *view_layer, struct ARegion *ar, View3D *v3d,
|
||||
struct Base *base, const short dflag);
|
||||
void draw_object_select(
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *sl, struct ARegion *ar, View3D *v3d,
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *view_layer, struct ARegion *ar, View3D *v3d,
|
||||
Base *base, const short dflag);
|
||||
|
||||
void draw_mesh_object_outline(View3D *v3d, Object *ob, struct DerivedMesh *dm, const unsigned char ob_wire_col[4]);
|
||||
|
||||
bool draw_glsl_material(Scene *scene, struct ViewLayer *sl, struct Object *ob, View3D *v3d, const char dt);
|
||||
void draw_object_instance(const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *sl, View3D *v3d, RegionView3D *rv3d, struct Object *ob, const char dt, int outline, const float wire_col[4]);
|
||||
bool draw_glsl_material(Scene *scene, struct ViewLayer *view_layer, struct Object *ob, View3D *v3d, const char dt);
|
||||
void draw_object_instance(const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d, struct Object *ob, const char dt, int outline, const float wire_col[4]);
|
||||
void draw_object_backbufsel(const struct EvaluationContext *eval_ctx, Scene *scene, View3D *v3d, RegionView3D *rv3d, struct Object *ob);
|
||||
|
||||
void draw_object_wire_color(Scene *scene, struct ViewLayer *, Base *base, unsigned char r_ob_wire_col[4]);
|
||||
|
@ -190,12 +190,12 @@ int view3d_effective_drawtype(const struct View3D *v3d);
|
|||
|
||||
/* drawarmature.c */
|
||||
bool draw_armature(
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *sl, View3D *v3d, ARegion *ar, Base *base,
|
||||
const struct EvaluationContext *eval_ctx, Scene *scene, struct ViewLayer *view_layer, View3D *v3d, ARegion *ar, Base *base,
|
||||
const short dt, const short dflag, const unsigned char ob_wire_col[4],
|
||||
const bool is_outline);
|
||||
|
||||
/* drawmesh.c */
|
||||
void draw_mesh_textured(Scene *scene, struct ViewLayer *sl, View3D *v3d, RegionView3D *rv3d,
|
||||
void draw_mesh_textured(Scene *scene, struct ViewLayer *view_layer, View3D *v3d, RegionView3D *rv3d,
|
||||
struct Object *ob, struct DerivedMesh *dm, const int draw_flags);
|
||||
void draw_mesh_face_select(
|
||||
struct RegionView3D *rv3d, struct Mesh *me, struct DerivedMesh *dm,
|
||||
|
@ -227,7 +227,7 @@ void view3d_main_region_draw_legacy(const struct bContext *C, struct ARegion *ar
|
|||
void ED_view3d_draw_depth_gpencil(const struct EvaluationContext *eval_ctx, Scene *scene, ARegion *ar, View3D *v3d);
|
||||
|
||||
void ED_view3d_draw_select_loop(
|
||||
const struct EvaluationContext *eval_ctx, ViewContext *vc, Scene *scene, struct ViewLayer *sl, View3D *v3d, ARegion *ar,
|
||||
const struct EvaluationContext *eval_ctx, ViewContext *vc, Scene *scene, struct ViewLayer *view_layer, View3D *v3d, ARegion *ar,
|
||||
bool use_obedit_skip, bool use_nearest);
|
||||
|
||||
void ED_view3d_draw_depth_loop(
|
||||
|
@ -362,7 +362,7 @@ extern bool view3d_camera_border_hack_test;
|
|||
#endif
|
||||
|
||||
/* temporary for legacy viewport to work */
|
||||
void VP_legacy_drawcursor(Scene *scene, struct ViewLayer *sl, ARegion *ar, View3D *v3d);
|
||||
void VP_legacy_drawcursor(Scene *scene, struct ViewLayer *view_layer, ARegion *ar, View3D *v3d);
|
||||
void VP_legacy_draw_view_axis(RegionView3D *rv3d, rcti *rect);
|
||||
void VP_legacy_draw_viewport_name(ARegion *ar, View3D *v3d, rcti *rect);
|
||||
void VP_legacy_draw_selected_name(Scene *scene, Object *ob, rcti *rect);
|
||||
|
@ -371,7 +371,7 @@ void VP_legacy_drawfloor(Scene *scene, View3D *v3d, const char **grid_unit, bool
|
|||
void VP_legacy_view3d_main_region_setup_view(const struct EvaluationContext *eval_ctx, Scene *scene, View3D *v3d, ARegion *ar, float viewmat[4][4], float winmat[4][4]);
|
||||
bool VP_legacy_view3d_stereo3d_active(struct wmWindow *win, Scene *scene, View3D *v3d, RegionView3D *rv3d);
|
||||
void VP_legacy_view3d_stereo3d_setup(const struct EvaluationContext *eval_ctx, Scene *scene, View3D *v3d, ARegion *ar);
|
||||
void draw_dupli_objects(const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *sl, ARegion *ar, View3D *v3d, Base *base);
|
||||
void draw_dupli_objects(const struct EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, ARegion *ar, View3D *v3d, Base *base);
|
||||
bool VP_legacy_use_depth(Scene *scene, View3D *v3d);
|
||||
void VP_drawviewborder(Scene *scene, ARegion *ar, View3D *v3d);
|
||||
void VP_drawrenderborder(ARegion *ar, View3D *v3d);
|
||||
|
|
|
@ -294,8 +294,8 @@ static bool WIDGETGROUP_camera_view_poll(const bContext *C, wmManipulatorGroupTy
|
|||
* stealing mouse clicks from regular usage.
|
||||
* We could change the rules for when to show. */
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
if (scene->camera != OBACT(sl)) {
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
if (scene->camera != OBACT(view_layer)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -376,11 +376,11 @@ static void do_lasso_select_pose(ViewContext *vc, Object *ob, const int mcords[]
|
|||
}
|
||||
}
|
||||
|
||||
static void object_deselect_all_visible(ViewLayer *sl)
|
||||
static void object_deselect_all_visible(ViewLayer *view_layer)
|
||||
{
|
||||
Base *base;
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (BASE_SELECTABLE(base)) {
|
||||
ED_object_base_select(base, BA_DESELECT);
|
||||
}
|
||||
|
@ -1057,9 +1057,9 @@ void VIEW3D_OT_select_menu(wmOperatorType *ot)
|
|||
RNA_def_boolean(ot->srna, "toggle", 0, "Toggle", "Toggle selection instead of deselecting everything first");
|
||||
}
|
||||
|
||||
static void deselectall_except(ViewLayer *sl, Base *b) /* deselect all except b */
|
||||
static void deselectall_except(ViewLayer *view_layer, Base *b) /* deselect all except b */
|
||||
{
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (base->flag & BASE_SELECTED) {
|
||||
if (b != base) {
|
||||
ED_object_base_select(base, BA_DESELECT);
|
||||
|
@ -1274,7 +1274,7 @@ finally:
|
|||
static Base *mouse_select_eval_buffer(ViewContext *vc, unsigned int *buffer, int hits,
|
||||
Base *startbase, bool has_bones, bool do_nearest)
|
||||
{
|
||||
ViewLayer *sl = vc->view_layer;
|
||||
ViewLayer *view_layer = vc->view_layer;
|
||||
Base *base, *basact = NULL;
|
||||
int a;
|
||||
|
||||
|
@ -1294,8 +1294,8 @@ static Base *mouse_select_eval_buffer(ViewContext *vc, unsigned int *buffer, int
|
|||
}
|
||||
else {
|
||||
/* only exclude active object when it is selected... */
|
||||
if (BASACT(sl) && (BASACT(sl)->flag & BASE_SELECTED) && hits > 1) {
|
||||
notcol = BASACT(sl)->object->select_color;
|
||||
if (BASACT(view_layer) && (BASACT(view_layer)->flag & BASE_SELECTED) && hits > 1) {
|
||||
notcol = BASACT(view_layer)->object->select_color;
|
||||
}
|
||||
|
||||
for (a = 0; a < hits; a++) {
|
||||
|
@ -1306,7 +1306,7 @@ static Base *mouse_select_eval_buffer(ViewContext *vc, unsigned int *buffer, int
|
|||
}
|
||||
}
|
||||
|
||||
base = FIRSTBASE(sl);
|
||||
base = FIRSTBASE(view_layer);
|
||||
while (base) {
|
||||
if (BASE_SELECTABLE(base)) {
|
||||
if (base->object->select_color == selcol) break;
|
||||
|
@ -1323,7 +1323,7 @@ static Base *mouse_select_eval_buffer(ViewContext *vc, unsigned int *buffer, int
|
|||
* with an un-selectable choice */
|
||||
if ((base->flag & BASE_SELECTABLED) == 0) {
|
||||
base = base->next;
|
||||
if (base == NULL) base = FIRSTBASE(sl);
|
||||
if (base == NULL) base = FIRSTBASE(view_layer);
|
||||
if (base == startbase) break;
|
||||
}
|
||||
|
||||
|
@ -1346,7 +1346,7 @@ static Base *mouse_select_eval_buffer(ViewContext *vc, unsigned int *buffer, int
|
|||
if (basact) break;
|
||||
|
||||
base = base->next;
|
||||
if (base == NULL) base = FIRSTBASE(sl);
|
||||
if (base == NULL) base = FIRSTBASE(view_layer);
|
||||
if (base == startbase) break;
|
||||
}
|
||||
}
|
||||
|
@ -1408,7 +1408,7 @@ static bool ed_object_select_pick(
|
|||
ViewContext vc;
|
||||
ARegion *ar = CTX_wm_region(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Base *base, *startbase = NULL, *basact = NULL, *oldbasact = NULL;
|
||||
bool is_obedit;
|
||||
float dist = ED_view3d_select_dist_px() * 1.3333f;
|
||||
|
@ -1428,8 +1428,8 @@ static bool ed_object_select_pick(
|
|||
}
|
||||
|
||||
/* always start list from basact in wire mode */
|
||||
startbase = FIRSTBASE(sl);
|
||||
if (BASACT(sl) && BASACT(sl)->next) startbase = BASACT(sl)->next;
|
||||
startbase = FIRSTBASE(view_layer);
|
||||
if (BASACT(view_layer) && BASACT(view_layer)->next) startbase = BASACT(view_layer)->next;
|
||||
|
||||
/* This block uses the control key to make the object selected by its center point rather than its contents */
|
||||
/* in editmode do not activate */
|
||||
|
@ -1448,7 +1448,7 @@ static bool ed_object_select_pick(
|
|||
V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN | V3D_PROJ_TEST_CLIP_NEAR) == V3D_PROJ_RET_OK)
|
||||
{
|
||||
float dist_temp = len_manhattan_v2v2(mval_fl, screen_co);
|
||||
if (base == BASACT(sl)) dist_temp += 10.0f;
|
||||
if (base == BASACT(view_layer)) dist_temp += 10.0f;
|
||||
if (dist_temp < dist) {
|
||||
dist = dist_temp;
|
||||
basact = base;
|
||||
|
@ -1457,7 +1457,7 @@ static bool ed_object_select_pick(
|
|||
}
|
||||
base = base->next;
|
||||
|
||||
if (base == NULL) base = FIRSTBASE(sl);
|
||||
if (base == NULL) base = FIRSTBASE(view_layer);
|
||||
if (base == startbase) break;
|
||||
}
|
||||
}
|
||||
|
@ -1487,7 +1487,7 @@ static bool ed_object_select_pick(
|
|||
|
||||
if (has_bones && basact) {
|
||||
if (basact->object->type == OB_CAMERA) {
|
||||
if (BASACT(sl) == basact) {
|
||||
if (BASACT(view_layer) == basact) {
|
||||
int i, hitresult;
|
||||
bool changed = false;
|
||||
|
||||
|
@ -1544,7 +1544,7 @@ static bool ed_object_select_pick(
|
|||
}
|
||||
}
|
||||
}
|
||||
else if (ED_do_pose_selectbuffer(scene, sl, basact, buffer, hits, extend, deselect, toggle, do_nearest)) {
|
||||
else if (ED_do_pose_selectbuffer(scene, view_layer, basact, buffer, hits, extend, deselect, toggle, do_nearest)) {
|
||||
/* then bone is found */
|
||||
|
||||
/* we make the armature selected:
|
||||
|
@ -1557,14 +1557,14 @@ static bool ed_object_select_pick(
|
|||
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_ACTIVE, basact->object);
|
||||
|
||||
/* in weightpaint, we use selected bone to select vertexgroup, so no switch to new active object */
|
||||
if (BASACT(sl) && (BASACT(sl)->object->mode & OB_MODE_WEIGHT_PAINT)) {
|
||||
if (BASACT(view_layer) && (BASACT(view_layer)->object->mode & OB_MODE_WEIGHT_PAINT)) {
|
||||
/* prevent activating */
|
||||
basact = NULL;
|
||||
}
|
||||
|
||||
}
|
||||
/* prevent bone selecting to pass on to object selecting */
|
||||
if (basact == BASACT(sl))
|
||||
if (basact == BASACT(view_layer))
|
||||
basact = NULL;
|
||||
}
|
||||
}
|
||||
|
@ -1576,13 +1576,13 @@ static bool ed_object_select_pick(
|
|||
|
||||
if (vc.obedit) {
|
||||
/* only do select */
|
||||
deselectall_except(sl, basact);
|
||||
deselectall_except(view_layer, basact);
|
||||
ED_object_base_select(basact, BA_SELECT);
|
||||
}
|
||||
/* also prevent making it active on mouse selection */
|
||||
else if (BASE_SELECTABLE(basact)) {
|
||||
|
||||
oldbasact = BASACT(sl);
|
||||
oldbasact = BASACT(view_layer);
|
||||
|
||||
if (extend) {
|
||||
ED_object_base_select(basact, BA_SELECT);
|
||||
|
@ -1601,7 +1601,7 @@ static bool ed_object_select_pick(
|
|||
}
|
||||
}
|
||||
else {
|
||||
deselectall_except(sl, basact);
|
||||
deselectall_except(view_layer, basact);
|
||||
ED_object_base_select(basact, BA_SELECT);
|
||||
}
|
||||
|
||||
|
@ -2828,7 +2828,7 @@ static void obedit_circle_select(
|
|||
|
||||
static bool object_circle_select(ViewContext *vc, const bool select, const int mval[2], float rad)
|
||||
{
|
||||
ViewLayer *sl = vc->view_layer;
|
||||
ViewLayer *view_layer = vc->view_layer;
|
||||
const float radius_squared = rad * rad;
|
||||
const float mval_fl[2] = {mval[0], mval[1]};
|
||||
bool changed = false;
|
||||
|
@ -2836,7 +2836,7 @@ static bool object_circle_select(ViewContext *vc, const bool select, const int m
|
|||
|
||||
|
||||
Base *base;
|
||||
for (base = FIRSTBASE(sl); base; base = base->next) {
|
||||
for (base = FIRSTBASE(view_layer); base; base = base->next) {
|
||||
if (BASE_SELECTABLE(base) && ((base->flag & BASE_SELECTED) != select_flag)) {
|
||||
float screen_co[2];
|
||||
if (ED_view3d_project_float_global(vc->ar, base->object->obmat[3], screen_co,
|
||||
|
|
|
@ -546,7 +546,7 @@ void VIEW3D_OT_camera_to_view(wmOperatorType *ot)
|
|||
static int view3d_camera_to_view_selected_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
View3D *v3d = CTX_wm_view3d(C); /* can be NULL */
|
||||
Object *camera_ob = v3d ? v3d->camera : scene->camera;
|
||||
|
||||
|
@ -559,7 +559,7 @@ static int view3d_camera_to_view_selected_exec(bContext *C, wmOperator *op)
|
|||
}
|
||||
|
||||
/* this function does all the important stuff */
|
||||
if (BKE_camera_view_frame_fit_to_scene(scene, sl, camera_ob, r_co, &r_scale)) {
|
||||
if (BKE_camera_view_frame_fit_to_scene(scene, view_layer, camera_ob, r_co, &r_scale)) {
|
||||
ObjectTfmProtectedChannels obtfm;
|
||||
float obmat_new[4][4];
|
||||
|
||||
|
|
|
@ -1905,8 +1905,8 @@ static void drawTransformPixel(const struct bContext *UNUSED(C), ARegion *ar, vo
|
|||
{
|
||||
TransInfo *t = arg;
|
||||
Scene *scene = t->scene;
|
||||
ViewLayer *sl = t->view_layer;
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Object *ob = OBACT(view_layer);
|
||||
|
||||
/* draw autokeyframing hint in the corner
|
||||
* - only draw if enabled (advanced users may be distracted/annoyed),
|
||||
|
|
|
@ -661,7 +661,7 @@ bool transdata_check_local_islands(TransInfo *t, short around);
|
|||
int count_set_pose_transflags(int *out_mode, short around, struct Object *ob);
|
||||
|
||||
/* auto-keying stuff used by special_aftertrans_update */
|
||||
void autokeyframe_ob_cb_func(struct bContext *C, struct Scene *scene, struct ViewLayer *sl, struct View3D *v3d, struct Object *ob, int tmode);
|
||||
void autokeyframe_ob_cb_func(struct bContext *C, struct Scene *scene, struct ViewLayer *view_layer, struct View3D *v3d, struct Object *ob, int tmode);
|
||||
void autokeyframe_pose_cb_func(struct bContext *C, struct Scene *scene, struct View3D *v3d, struct Object *ob, int tmode, short targetless_ik);
|
||||
|
||||
/*********************** Constraints *****************************/
|
||||
|
|
|
@ -286,13 +286,13 @@ static void set_prop_dist(TransInfo *t, const bool with_dist)
|
|||
|
||||
static void createTransTexspace(TransInfo *t)
|
||||
{
|
||||
ViewLayer *sl = t->view_layer;
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
TransData *td;
|
||||
Object *ob;
|
||||
ID *id;
|
||||
short *texflag;
|
||||
|
||||
ob = OBACT(sl);
|
||||
ob = OBACT(view_layer);
|
||||
|
||||
if (ob == NULL) { // Shouldn't logically happen, but still...
|
||||
t->total = 0;
|
||||
|
@ -2010,9 +2010,9 @@ static void createTransParticleVerts(bContext *C, TransInfo *t)
|
|||
void flushTransParticles(TransInfo *t)
|
||||
{
|
||||
Scene *scene = t->scene;
|
||||
ViewLayer *sl = t->view_layer;
|
||||
Object *ob = OBACT(sl);
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Object *ob = OBACT(view_layer);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
ParticleSystem *psys = edit->psys;
|
||||
ParticleSystemModifierData *psmd = NULL;
|
||||
PTCacheEditPoint *point;
|
||||
|
@ -2053,7 +2053,7 @@ void flushTransParticles(TransInfo *t)
|
|||
|
||||
EvaluationContext eval_ctx;
|
||||
CTX_data_eval_ctx(t->context, &eval_ctx);
|
||||
PE_update_object(&eval_ctx, scene, sl, OBACT(sl), 1);
|
||||
PE_update_object(&eval_ctx, scene, view_layer, OBACT(view_layer), 1);
|
||||
}
|
||||
|
||||
/* ********************* mesh ****************** */
|
||||
|
@ -5538,9 +5538,9 @@ static void set_trans_object_base_flags(TransInfo *t)
|
|||
{
|
||||
/* TODO(sergey): Get rid of global, use explicit main. */
|
||||
Main *bmain = G.main;
|
||||
ViewLayer *sl = t->view_layer;
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Scene *scene = t->scene;
|
||||
Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, sl, true);
|
||||
Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
|
||||
|
||||
/*
|
||||
* if Base selected and has parent selected:
|
||||
|
@ -5556,21 +5556,21 @@ static void set_trans_object_base_flags(TransInfo *t)
|
|||
BKE_scene_base_flag_to_objects(t->view_layer);
|
||||
|
||||
/* Make sure depsgraph is here. */
|
||||
DEG_graph_relations_update(depsgraph, bmain, scene, sl);
|
||||
DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
|
||||
|
||||
/* handle pending update events, otherwise they got copied below */
|
||||
EvaluationContext eval_ctx;
|
||||
DEG_evaluation_context_init_from_scene(&eval_ctx,
|
||||
t->scene, t->view_layer, t->engine,
|
||||
DAG_EVAL_VIEWPORT);
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (base->object->recalc & OB_RECALC_ALL) {
|
||||
/* TODO(sergey): Ideally, it's not needed. */
|
||||
BKE_object_handle_update(&eval_ctx, t->scene, base->object);
|
||||
}
|
||||
}
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
base->flag_legacy &= ~BA_WAS_SEL;
|
||||
|
||||
if (TESTBASELIB_BGMODE(base)) {
|
||||
|
@ -5580,7 +5580,7 @@ static void set_trans_object_base_flags(TransInfo *t)
|
|||
/* if parent selected, deselect */
|
||||
while (parsel) {
|
||||
if (parsel->base_flag & BASE_SELECTED) {
|
||||
Base *parbase = BKE_view_layer_base_find(sl, parsel);
|
||||
Base *parbase = BKE_view_layer_base_find(view_layer, parsel);
|
||||
if (parbase) { /* in rare cases this can fail */
|
||||
if (TESTBASELIB_BGMODE(parbase)) {
|
||||
break;
|
||||
|
@ -5611,7 +5611,7 @@ static void set_trans_object_base_flags(TransInfo *t)
|
|||
|
||||
/* and we store them temporal in base (only used for transform code) */
|
||||
/* this because after doing updates, the object->recalc is cleared */
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (base->object->recalc & OB_RECALC_OB)
|
||||
base->flag_legacy |= BA_HAS_RECALC_OB;
|
||||
if (base->object->recalc & OB_RECALC_DATA)
|
||||
|
@ -5639,9 +5639,9 @@ static int count_proportional_objects(TransInfo *t)
|
|||
int total = 0;
|
||||
/* TODO(sergey): Get rid of global, use explicit main. */
|
||||
Main *bmain = G.main;
|
||||
ViewLayer *sl = t->view_layer;
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Scene *scene = t->scene;
|
||||
Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, sl, true);
|
||||
Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
|
||||
Base *base;
|
||||
|
||||
/* rotations around local centers are allowed to propagate, so we take all objects */
|
||||
|
@ -5649,7 +5649,7 @@ static int count_proportional_objects(TransInfo *t)
|
|||
(t->mode == TFM_ROTATION || t->mode == TFM_TRACKBALL)))
|
||||
{
|
||||
/* mark all parents */
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (TESTBASELIB_BGMODE(base)) {
|
||||
Object *parent = base->object->parent;
|
||||
|
||||
|
@ -5662,7 +5662,7 @@ static int count_proportional_objects(TransInfo *t)
|
|||
}
|
||||
|
||||
/* mark all children */
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
/* all base not already selected or marked that is editable */
|
||||
if ((base->object->flag & (BA_TRANSFORM_CHILD | BA_TRANSFORM_PARENT)) == 0 &&
|
||||
(base->flag & BASE_SELECTED) == 0 &&
|
||||
|
@ -5673,7 +5673,7 @@ static int count_proportional_objects(TransInfo *t)
|
|||
}
|
||||
}
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
Object *ob = base->object;
|
||||
|
||||
/* if base is not selected, not a parent of selection or not a child of selection and it is editable */
|
||||
|
@ -5690,12 +5690,12 @@ static int count_proportional_objects(TransInfo *t)
|
|||
|
||||
|
||||
/* all recalc flags get flushed to all layers, so a layer flip later on works fine */
|
||||
DEG_graph_relations_update(depsgraph, bmain, scene, sl);
|
||||
DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
|
||||
DEG_graph_flush_update(bmain, depsgraph);
|
||||
|
||||
/* and we store them temporal in base (only used for transform code) */
|
||||
/* this because after doing updates, the object->recalc is cleared */
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (base->object->recalc & OB_RECALC_OB)
|
||||
base->flag_legacy |= BA_HAS_RECALC_OB;
|
||||
if (base->object->recalc & OB_RECALC_DATA)
|
||||
|
@ -5707,10 +5707,10 @@ static int count_proportional_objects(TransInfo *t)
|
|||
|
||||
static void clear_trans_object_base_flags(TransInfo *t)
|
||||
{
|
||||
ViewLayer *sl = t->view_layer;
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Base *base;
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (base->flag_legacy & BA_WAS_SEL) {
|
||||
base->flag |= BASE_SELECTED;
|
||||
}
|
||||
|
@ -5723,7 +5723,7 @@ static void clear_trans_object_base_flags(TransInfo *t)
|
|||
* tmode: should be a transform mode
|
||||
*/
|
||||
// NOTE: context may not always be available, so must check before using it as it's a luxury for a few cases
|
||||
void autokeyframe_ob_cb_func(bContext *C, Scene *scene, ViewLayer *sl, View3D *v3d, Object *ob, int tmode)
|
||||
void autokeyframe_ob_cb_func(bContext *C, Scene *scene, ViewLayer *view_layer, View3D *v3d, Object *ob, int tmode)
|
||||
{
|
||||
ID *id = &ob->id;
|
||||
FCurve *fcu;
|
||||
|
@ -5772,7 +5772,7 @@ void autokeyframe_ob_cb_func(bContext *C, Scene *scene, ViewLayer *sl, View3D *v
|
|||
}
|
||||
else if (ELEM(tmode, TFM_ROTATION, TFM_TRACKBALL)) {
|
||||
if (v3d->around == V3D_AROUND_ACTIVE) {
|
||||
if (ob != OBACT(sl))
|
||||
if (ob != OBACT(view_layer))
|
||||
do_loc = true;
|
||||
}
|
||||
else if (v3d->around == V3D_AROUND_CURSOR)
|
||||
|
@ -5783,7 +5783,7 @@ void autokeyframe_ob_cb_func(bContext *C, Scene *scene, ViewLayer *sl, View3D *v
|
|||
}
|
||||
else if (tmode == TFM_RESIZE) {
|
||||
if (v3d->around == V3D_AROUND_ACTIVE) {
|
||||
if (ob != OBACT(sl))
|
||||
if (ob != OBACT(view_layer))
|
||||
do_loc = true;
|
||||
}
|
||||
else if (v3d->around == V3D_AROUND_CURSOR)
|
||||
|
@ -8084,8 +8084,8 @@ static void createTransGPencil(bContext *C, TransInfo *t)
|
|||
void createTransData(bContext *C, TransInfo *t)
|
||||
{
|
||||
Scene *scene = t->scene;
|
||||
ViewLayer *sl = t->view_layer;
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Object *ob = OBACT(view_layer);
|
||||
|
||||
/* if tests must match recalcData for correct updates */
|
||||
if (t->options & CTX_TEXTURE) {
|
||||
|
@ -8259,7 +8259,7 @@ void createTransData(bContext *C, TransInfo *t)
|
|||
|
||||
}
|
||||
}
|
||||
else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT) && PE_start_edit(PE_get_current(scene, sl, ob))) {
|
||||
else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT) && PE_start_edit(PE_get_current(scene, view_layer, ob))) {
|
||||
createTransParticleVerts(C, t);
|
||||
t->flag |= T_POINTS;
|
||||
|
||||
|
|
|
@ -318,7 +318,7 @@ static bool fcu_test_selected(FCurve *fcu)
|
|||
/* helper for recalcData() - for Action Editor transforms */
|
||||
static void recalcData_actedit(TransInfo *t)
|
||||
{
|
||||
ViewLayer *sl = t->view_layer;
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
SpaceAction *saction = (SpaceAction *)t->sa->spacedata.first;
|
||||
|
||||
bAnimContext ac = {NULL};
|
||||
|
@ -330,7 +330,7 @@ static void recalcData_actedit(TransInfo *t)
|
|||
/* NOTE: sync this with the code in ANIM_animdata_get_context() */
|
||||
ac.scene = t->scene;
|
||||
ac.view_layer = t->view_layer;
|
||||
ac.obact = OBACT(sl);
|
||||
ac.obact = OBACT(view_layer);
|
||||
ac.sa = t->sa;
|
||||
ac.ar = t->ar;
|
||||
ac.sl = (t->sa) ? t->sa->spacedata.first : NULL;
|
||||
|
@ -367,7 +367,7 @@ static void recalcData_actedit(TransInfo *t)
|
|||
static void recalcData_graphedit(TransInfo *t)
|
||||
{
|
||||
SpaceIpo *sipo = (SpaceIpo *)t->sa->spacedata.first;
|
||||
ViewLayer *sl = t->view_layer;
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
|
||||
ListBase anim_data = {NULL, NULL};
|
||||
bAnimContext ac = {NULL};
|
||||
|
@ -380,7 +380,7 @@ static void recalcData_graphedit(TransInfo *t)
|
|||
/* NOTE: sync this with the code in ANIM_animdata_get_context() */
|
||||
ac.scene = t->scene;
|
||||
ac.view_layer = t->view_layer;
|
||||
ac.obact = OBACT(sl);
|
||||
ac.obact = OBACT(view_layer);
|
||||
ac.sa = t->sa;
|
||||
ac.ar = t->ar;
|
||||
ac.sl = (t->sa) ? t->sa->spacedata.first : NULL;
|
||||
|
@ -1116,7 +1116,7 @@ static int initTransInfo_edit_pet_to_flag(const int proportional)
|
|||
void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *event)
|
||||
{
|
||||
Scene *sce = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
ToolSettings *ts = CTX_data_tool_settings(C);
|
||||
ARegion *ar = CTX_wm_region(C);
|
||||
ScrArea *sa = CTX_wm_area(C);
|
||||
|
@ -1127,7 +1127,7 @@ void initTransInfo(bContext *C, TransInfo *t, wmOperator *op, const wmEvent *eve
|
|||
PropertyRNA *prop;
|
||||
|
||||
t->scene = sce;
|
||||
t->view_layer = sl;
|
||||
t->view_layer = view_layer;
|
||||
t->engine = engine;
|
||||
t->sa = sa;
|
||||
t->ar = ar;
|
||||
|
@ -1802,8 +1802,8 @@ bool calculateCenterActive(TransInfo *t, bool select_only, float r_center[3])
|
|||
}
|
||||
}
|
||||
else if (t->flag & T_POSE) {
|
||||
ViewLayer *sl = t->view_layer;
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Object *ob = OBACT(view_layer);
|
||||
if (ob) {
|
||||
bPoseChannel *pchan = BKE_pose_channel_active(ob);
|
||||
if (pchan && (!select_only || (pchan->bone->flag & BONE_SELECTED))) {
|
||||
|
@ -1822,9 +1822,9 @@ bool calculateCenterActive(TransInfo *t, bool select_only, float r_center[3])
|
|||
}
|
||||
else {
|
||||
/* object mode */
|
||||
ViewLayer *sl = t->view_layer;
|
||||
Object *ob = OBACT(sl);
|
||||
Base *base = BASACT(sl);
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Object *ob = OBACT(view_layer);
|
||||
Base *base = BASACT(view_layer);
|
||||
if (ob && ((!select_only) || ((base->flag & BASE_SELECTED) != 0))) {
|
||||
copy_v3_v3(r_center, ob->obmat[3]);
|
||||
ok = true;
|
||||
|
|
|
@ -591,12 +591,12 @@ static int calc_manipulator_stats(
|
|||
ScrArea *sa = CTX_wm_area(C);
|
||||
ARegion *ar = CTX_wm_region(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
View3D *v3d = sa->spacedata.first;
|
||||
RegionView3D *rv3d = ar->regiondata;
|
||||
Base *base;
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
bGPdata *gpd = CTX_data_gpencil_data(C);
|
||||
const bool is_gp_edit = ((gpd) && (gpd->flag & GP_DATA_STROKE_EDITMODE));
|
||||
int a, totsel = 0;
|
||||
|
@ -972,7 +972,7 @@ static int calc_manipulator_stats(
|
|||
/* pass */
|
||||
}
|
||||
else if (ob && ob->mode & OB_MODE_PARTICLE_EDIT) {
|
||||
PTCacheEdit *edit = PE_get_current(scene, sl, ob);
|
||||
PTCacheEdit *edit = PE_get_current(scene, view_layer, ob);
|
||||
PTCacheEditPoint *point;
|
||||
PTCacheEditKey *ek;
|
||||
int k;
|
||||
|
@ -998,11 +998,11 @@ static int calc_manipulator_stats(
|
|||
else {
|
||||
|
||||
/* we need the one selected object, if its not active */
|
||||
base = BASACT(sl);
|
||||
ob = OBACT(sl);
|
||||
base = BASACT(view_layer);
|
||||
ob = OBACT(view_layer);
|
||||
if (base && ((base->flag & BASE_SELECTED) == 0)) ob = NULL;
|
||||
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (TESTBASELIB(base)) {
|
||||
if (ob == NULL)
|
||||
ob = base->object;
|
||||
|
@ -1055,14 +1055,14 @@ static void manipulator_prepare_mat(
|
|||
const bContext *C, View3D *v3d, RegionView3D *rv3d, const struct TransformBounds *tbounds)
|
||||
{
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
|
||||
switch (v3d->around) {
|
||||
case V3D_AROUND_CENTER_BOUNDS:
|
||||
case V3D_AROUND_ACTIVE:
|
||||
{
|
||||
bGPdata *gpd = CTX_data_gpencil_data(C);
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
|
||||
if (((v3d->around == V3D_AROUND_ACTIVE) && (scene->obedit == NULL)) &&
|
||||
((gpd == NULL) || !(gpd->flag & GP_DATA_STROKE_EDITMODE)) &&
|
||||
|
@ -1590,8 +1590,8 @@ static void WIDGETGROUP_xform_cage_draw_prepare(const bContext *C, wmManipulator
|
|||
struct XFormCageWidgetGroup *xmgroup = mgroup->customdata;
|
||||
wmManipulator *mpr = xmgroup->manipulator;
|
||||
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(sl);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob = OBACT(view_layer);
|
||||
if (ob && ob->mode & OB_MODE_EDIT) {
|
||||
copy_m4_m4(mpr->matrix_space, ob->obmat);
|
||||
}
|
||||
|
|
|
@ -578,10 +578,10 @@ static unsigned int bm_mesh_faces_select_get_n(BMesh *bm, BMVert **elems, const
|
|||
|
||||
int getTransformOrientation_ex(const bContext *C, float normal[3], float plane[3], const short around)
|
||||
{
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
Base *base;
|
||||
Object *ob = OBACT(sl);
|
||||
Object *ob = OBACT(view_layer);
|
||||
int result = ORIENTATION_NONE;
|
||||
const bool activeOnly = (around == V3D_AROUND_ACTIVE);
|
||||
|
||||
|
@ -1044,15 +1044,15 @@ int getTransformOrientation_ex(const bContext *C, float normal[3], float plane[3
|
|||
}
|
||||
else {
|
||||
/* we need the one selected object, if its not active */
|
||||
base = BASACT(sl);
|
||||
ob = OBACT(sl);
|
||||
base = BASACT(view_layer);
|
||||
ob = OBACT(view_layer);
|
||||
if (base && ((base->flag & BASE_SELECTED) != 0)) {
|
||||
/* pass */
|
||||
}
|
||||
else {
|
||||
/* first selected */
|
||||
ob = NULL;
|
||||
for (base = sl->object_bases.first; base; base = base->next) {
|
||||
for (base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (TESTBASELIB(base)) {
|
||||
ob = base->object;
|
||||
break;
|
||||
|
|
|
@ -503,8 +503,8 @@ static void initSnappingMode(TransInfo *t)
|
|||
{
|
||||
ToolSettings *ts = t->settings;
|
||||
Object *obedit = t->obedit;
|
||||
ViewLayer *sl = t->view_layer;
|
||||
Base *base_act = sl->basact;
|
||||
ViewLayer *view_layer = t->view_layer;
|
||||
Base *base_act = view_layer->basact;
|
||||
|
||||
if (t->spacetype == SPACE_NODE) {
|
||||
/* force project off when not supported */
|
||||
|
|
|
@ -2096,7 +2096,7 @@ static bool snapObjectsRay(
|
|||
* \{ */
|
||||
|
||||
SnapObjectContext *ED_transform_snap_object_context_create(
|
||||
Main *bmain, Scene *scene, ViewLayer *sl, RenderEngineType *engine, int flag)
|
||||
Main *bmain, Scene *scene, ViewLayer *view_layer, RenderEngineType *engine, int flag)
|
||||
{
|
||||
SnapObjectContext *sctx = MEM_callocN(sizeof(*sctx), __func__);
|
||||
|
||||
|
@ -2105,7 +2105,7 @@ SnapObjectContext *ED_transform_snap_object_context_create(
|
|||
sctx->bmain = bmain;
|
||||
sctx->scene = scene;
|
||||
|
||||
DEG_evaluation_context_init_from_scene(&sctx->eval_ctx, scene, sl, engine, DAG_EVAL_VIEWPORT);
|
||||
DEG_evaluation_context_init_from_scene(&sctx->eval_ctx, scene, view_layer, engine, DAG_EVAL_VIEWPORT);
|
||||
|
||||
sctx->cache.object_map = BLI_ghash_ptr_new(__func__);
|
||||
sctx->cache.mem_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
|
||||
|
@ -2114,11 +2114,11 @@ SnapObjectContext *ED_transform_snap_object_context_create(
|
|||
}
|
||||
|
||||
SnapObjectContext *ED_transform_snap_object_context_create_view3d(
|
||||
Main *bmain, Scene *scene, ViewLayer *sl, RenderEngineType *engine, int flag,
|
||||
Main *bmain, Scene *scene, ViewLayer *view_layer, RenderEngineType *engine, int flag,
|
||||
/* extra args for view3d */
|
||||
const ARegion *ar, const View3D *v3d)
|
||||
{
|
||||
SnapObjectContext *sctx = ED_transform_snap_object_context_create(bmain, scene, sl, engine, flag);
|
||||
SnapObjectContext *sctx = ED_transform_snap_object_context_create(bmain, scene, view_layer, engine, flag);
|
||||
|
||||
sctx->use_v3d = true;
|
||||
sctx->v3d_data.ar = ar;
|
||||
|
|
|
@ -88,8 +88,8 @@ void ED_editors_init(bContext *C)
|
|||
wmWindowManager *wm = CTX_wm_manager(C);
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *sce = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
Object *ob, *obact = (sl && sl->basact) ? sl->basact->object : NULL;
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *ob, *obact = (view_layer && view_layer->basact) ? view_layer->basact->object : NULL;
|
||||
ID *data;
|
||||
|
||||
/* This is called during initialization, so we don't want to store any reports */
|
||||
|
|
|
@ -120,7 +120,7 @@ static int ed_undo_step(bContext *C, int step, const char *undoname)
|
|||
wmWindow *win = CTX_wm_window(C);
|
||||
Main *bmain = CTX_data_main(C);
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
ViewLayer *sl = CTX_data_view_layer(C);
|
||||
ViewLayer *view_layer = CTX_data_view_layer(C);
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
Object *obact = CTX_data_active_object(C);
|
||||
ScrArea *sa = CTX_wm_area(C);
|
||||
|
@ -181,9 +181,9 @@ static int ed_undo_step(bContext *C, int step, const char *undoname)
|
|||
}
|
||||
else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
|
||||
if (step == 1)
|
||||
PE_undo(scene, sl);
|
||||
PE_undo(scene, view_layer);
|
||||
else
|
||||
PE_redo(scene, sl);
|
||||
PE_redo(scene, view_layer);
|
||||
}
|
||||
else if (U.uiflag & USER_GLOBALUNDO) {
|
||||
// note python defines not valid here anymore.
|
||||
|
|
|
@ -517,7 +517,7 @@ static void draw_uvs_other_mesh(Object *ob, const Image *curimage, const bool ne
|
|||
}
|
||||
}
|
||||
|
||||
static void draw_uvs_other(ViewLayer *sl, Object *obedit, const Image *curimage, const bool new_shading_nodes,
|
||||
static void draw_uvs_other(ViewLayer *view_layer, Object *obedit, const Image *curimage, const bool new_shading_nodes,
|
||||
const int other_uv_filter)
|
||||
{
|
||||
unsigned int pos = GWN_vertformat_attr_add(immVertexFormat(), "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
|
||||
|
@ -526,7 +526,7 @@ static void draw_uvs_other(ViewLayer *sl, Object *obedit, const Image *curimage,
|
|||
|
||||
immUniformThemeColor(TH_UV_OTHERS);
|
||||
|
||||
for (Base *base = sl->object_bases.first; base; base = base->next) {
|
||||
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
|
||||
if (((base->flag & BASE_SELECTED) != 0) &&
|
||||
((base->flag & BASE_VISIBLED) != 0))
|
||||
{
|
||||
|
@ -539,7 +539,7 @@ static void draw_uvs_other(ViewLayer *sl, Object *obedit, const Image *curimage,
|
|||
immUnbindProgram();
|
||||
}
|
||||
|
||||
static void draw_uvs_texpaint(SpaceImage *sima, Scene *scene, ViewLayer *sl, Object *ob)
|
||||
static void draw_uvs_texpaint(SpaceImage *sima, Scene *scene, ViewLayer *view_layer, Object *ob)
|
||||
{
|
||||
const bool new_shading_nodes = BKE_scene_use_new_shading_nodes(scene);
|
||||
Image *curimage = ED_space_image(sima);
|
||||
|
@ -547,7 +547,7 @@ static void draw_uvs_texpaint(SpaceImage *sima, Scene *scene, ViewLayer *sl, Obj
|
|||
Material *ma;
|
||||
|
||||
if (sima->flag & SI_DRAW_OTHER) {
|
||||
draw_uvs_other(sl, ob, curimage, new_shading_nodes, sima->other_uv_filter);
|
||||
draw_uvs_other(view_layer, ob, curimage, new_shading_nodes, sima->other_uv_filter);
|
||||
}
|
||||
|
||||
ma = give_current_material(ob, ob->actcol);
|
||||
|
@ -604,7 +604,7 @@ static void draw_uvs_looptri(BMEditMesh *em, unsigned int *r_loop_index, const i
|
|||
}
|
||||
|
||||
/* draws uv's in the image space */
|
||||
static void draw_uvs(SpaceImage *sima, Scene *scene, ViewLayer *sl, Object *obedit, Depsgraph *depsgraph)
|
||||
static void draw_uvs(SpaceImage *sima, Scene *scene, ViewLayer *view_layer, Object *obedit, Depsgraph *depsgraph)
|
||||
{
|
||||
const bool new_shading_nodes = BKE_scene_use_new_shading_nodes(scene);
|
||||
ToolSettings *ts;
|
||||
|
@ -649,7 +649,7 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, ViewLayer *sl, Object *obed
|
|||
curimage = (efa_act) ? BKE_object_material_edit_image_get(obedit, efa_act->mat_nr) : ima;
|
||||
}
|
||||
|
||||
draw_uvs_other(sl, obedit, curimage, new_shading_nodes, sima->other_uv_filter);
|
||||
draw_uvs_other(view_layer, obedit, curimage, new_shading_nodes, sima->other_uv_filter);
|
||||
}
|
||||
|
||||
/* 1. draw shadow mesh */
|
||||
|
@ -1045,7 +1045,7 @@ static void draw_uv_shadows_get(SpaceImage *sima, Object *ob, Object *obedit, bo
|
|||
*show_texpaint = (ob && ob->type == OB_MESH && ob->mode == OB_MODE_TEXTURE_PAINT);
|
||||
}
|
||||
|
||||
void ED_uvedit_draw_main(SpaceImage *sima, ARegion *ar, Scene *scene, ViewLayer *sl, Object *obedit, Object *obact, Depsgraph *depsgraph)
|
||||
void ED_uvedit_draw_main(SpaceImage *sima, ARegion *ar, Scene *scene, ViewLayer *view_layer, Object *obedit, Object *obact, Depsgraph *depsgraph)
|
||||
{
|
||||
ToolSettings *toolsettings = scene->toolsettings;
|
||||
bool show_uvedit, show_uvshadow, show_texpaint_uvshadow;
|
||||
|
@ -1057,9 +1057,9 @@ void ED_uvedit_draw_main(SpaceImage *sima, ARegion *ar, Scene *scene, ViewLayer
|
|||
if (show_uvshadow)
|
||||
draw_uvs_shadow(obedit);
|
||||
else if (show_uvedit)
|
||||
draw_uvs(sima, scene, sl, obedit, depsgraph);
|
||||
draw_uvs(sima, scene, view_layer, obedit, depsgraph);
|
||||
else
|
||||
draw_uvs_texpaint(sima, scene, sl, obact);
|
||||
draw_uvs_texpaint(sima, scene, view_layer, obact);
|
||||
|
||||
if (show_uvedit && !(toolsettings->use_uv_sculpt))
|
||||
ED_image_draw_cursor(ar, sima->cursor);
|
||||
|
|
|
@ -1927,10 +1927,10 @@ extern const char *RE_engine_id_CYCLES;
|
|||
#define BASE_VISIBLE(base) ( \
|
||||
((base)->flag & BASE_VISIBLED) != 0)
|
||||
|
||||
#define FIRSTBASE(_sl) ((_sl)->object_bases.first)
|
||||
#define LASTBASE(_sl) ((_sl)->object_bases.last)
|
||||
#define BASACT(_sl) ((_sl)->basact)
|
||||
#define OBACT(_sl) (BASACT(_sl) ? BASACT(_sl)->object: NULL)
|
||||
#define FIRSTBASE(_view_layer) ((_view_layer)->object_bases.first)
|
||||
#define LASTBASE(_view_layer) ((_view_layer)->object_bases.last)
|
||||
#define BASACT(_view_layer) ((_view_layer)->basact)
|
||||
#define OBACT(_view_layer) (BASACT(_view_layer) ? BASACT(_view_layer)->object: NULL)
|
||||
|
||||
#define V3D_CAMERA_LOCAL(v3d) ((!(v3d)->scenelock && (v3d)->camera) ? (v3d)->camera : NULL)
|
||||
#define V3D_CAMERA_SCENE(scene, v3d) ((!(v3d)->scenelock && (v3d)->camera) ? (v3d)->camera : (scene)->camera)
|
||||
|
|
|
@ -476,7 +476,7 @@ void ED_fsmenu_entry_set_path(struct FSMenuEntry *fsentry, const char *name) RET
|
|||
char *ED_fsmenu_entry_get_name(struct FSMenuEntry *fsentry) RET_NULL
|
||||
void ED_fsmenu_entry_set_name(struct FSMenuEntry *fsentry, const char *name) RET_NONE
|
||||
|
||||
struct PTCacheEdit *PE_get_current(struct Scene *scene, struct ViewLayer *sl, struct Object *ob) RET_NULL
|
||||
struct PTCacheEdit *PE_get_current(struct Scene *scene, struct ViewLayer *view_layer, struct Object *ob) RET_NULL
|
||||
void PE_current_changed(const struct EvaluationContext *eval_ctx, struct Scene *scene, struct Object *ob) RET_NONE
|
||||
|
||||
/* rna keymap */
|
||||
|
@ -516,7 +516,7 @@ bool ANIM_remove_driver(struct ReportList *reports, struct ID *id, const char rn
|
|||
void ED_space_image_release_buffer(struct SpaceImage *sima, struct ImBuf *ibuf, void *lock) RET_NONE
|
||||
struct ImBuf *ED_space_image_acquire_buffer(struct SpaceImage *sima, void **r_lock) RET_NULL
|
||||
void ED_space_image_get_zoom(struct SpaceImage *sima, struct ARegion *ar, float *zoomx, float *zoomy) RET_NONE
|
||||
const char *ED_info_stats_string(struct Scene *scene, struct ViewLayer *sl) RET_NULL
|
||||
const char *ED_info_stats_string(struct Scene *scene, struct ViewLayer *view_layer) RET_NULL
|
||||
void ED_area_tag_redraw(struct ScrArea *sa) RET_NONE
|
||||
void ED_area_tag_refresh(struct ScrArea *sa) RET_NONE
|
||||
void ED_area_newspace(struct bContext *C, struct ScrArea *sa, int type, const bool skip_ar_exit) RET_NONE
|
||||
|
@ -596,7 +596,7 @@ int ED_mesh_mirror_spatial_table(struct Object *ob, struct BMEditMesh *em, struc
|
|||
|
||||
float ED_rollBoneToVector(EditBone *bone, const float new_up_axis[3], const bool axis_only) RET_ZERO
|
||||
void ED_space_image_get_size(struct SpaceImage *sima, int *width, int *height) RET_NONE
|
||||
bool ED_space_image_check_show_maskedit(struct ViewLayer *sl, struct SpaceImage *sima) RET_ZERO
|
||||
bool ED_space_image_check_show_maskedit(struct ViewLayer *view_layer, struct SpaceImage *sima) RET_ZERO
|
||||
|
||||
bool ED_texture_context_check_world(const struct bContext *C) RET_ZERO
|
||||
bool ED_texture_context_check_material(const struct bContext *C) RET_ZERO
|
||||
|
@ -607,9 +607,9 @@ bool ED_texture_context_check_others(const struct bContext *C) RET_ZERO
|
|||
bool ED_text_region_location_from_cursor(SpaceText *st, ARegion *ar, const int cursor_co[2], int r_pixel_co[2]) RET_ZERO
|
||||
|
||||
SnapObjectContext *ED_transform_snap_object_context_create(
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *sl, struct RenderEngineType *engine, int flag) RET_NULL
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *view_layer, struct RenderEngineType *engine, int flag) RET_NULL
|
||||
SnapObjectContext *ED_transform_snap_object_context_create_view3d(
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *sl, struct RenderEngineType *engine, int flag,
|
||||
struct Main *bmain, struct Scene *scene, struct ViewLayer *view_layer, struct RenderEngineType *engine, int flag,
|
||||
const struct ARegion *ar, const struct View3D *v3d) RET_NULL
|
||||
void ED_transform_snap_object_context_destroy(SnapObjectContext *sctx) RET_NONE
|
||||
bool ED_transform_snap_object_project_ray_ex(
|
||||
|
@ -758,9 +758,9 @@ void RE_engine_update_memory_stats(struct RenderEngine *engine, float mem_used,
|
|||
struct RenderEngine *RE_engine_create(struct RenderEngineType *type) RET_NULL
|
||||
void RE_engine_frame_set(struct RenderEngine *engine, int frame, float subframe) RET_NONE
|
||||
void RE_FreePersistentData(void) RET_NONE
|
||||
void RE_point_density_cache(struct Scene *scene, struct ViewLayer *sl, struct PointDensity *pd, const bool use_render_params) RET_NONE
|
||||
void RE_point_density_minmax(struct Scene *scene, struct ViewLayer *sl, struct PointDensity *pd, const bool use_render_params, float r_min[3], float r_max[3]) RET_NONE
|
||||
void RE_point_density_sample(struct Scene *scene, struct ViewLayer *sl, struct PointDensity *pd, const int resolution, const bool use_render_params, float *values) RET_NONE
|
||||
void RE_point_density_cache(struct Scene *scene, struct ViewLayer *view_layer, struct PointDensity *pd, const bool use_render_params) RET_NONE
|
||||
void RE_point_density_minmax(struct Scene *scene, struct ViewLayer *view_layer, struct PointDensity *pd, const bool use_render_params, float r_min[3], float r_max[3]) RET_NONE
|
||||
void RE_point_density_sample(struct Scene *scene, struct ViewLayer *view_layer, struct PointDensity *pd, const int resolution, const bool use_render_params, float *values) RET_NONE
|
||||
void RE_point_density_free(struct PointDensity *pd) RET_NONE
|
||||
void RE_instance_get_particle_info(struct ObjectInstanceRen *obi, float *index, float *age, float *lifetime, float co[3], float *size, float vel[3], float angvel[3]) RET_NONE
|
||||
void RE_FreeAllPersistentData(void) RET_NONE
|
||||
|
|
Loading…
Reference in New Issue