Revert to master - those changes are globally valid, but remain incomplete, free-refcount-ids
authorBastien Montagne <montagne29@wanadoo.fr>
Tue, 13 Oct 2015 13:44:58 +0000 (15:44 +0200)
committerBastien Montagne <montagne29@wanadoo.fr>
Tue, 13 Oct 2015 13:44:58 +0000 (15:44 +0200)
and total new code is being done in id-remap anyway, not worth bothering with this for now...

71 files changed:
source/blender/blenkernel/BKE_action.h
source/blender/blenkernel/BKE_armature.h
source/blender/blenkernel/BKE_brush.h
source/blender/blenkernel/BKE_camera.h
source/blender/blenkernel/BKE_curve.h
source/blender/blenkernel/BKE_font.h
source/blender/blenkernel/BKE_gpencil.h
source/blender/blenkernel/BKE_group.h
source/blender/blenkernel/BKE_image.h
source/blender/blenkernel/BKE_key.h
source/blender/blenkernel/BKE_lamp.h
source/blender/blenkernel/BKE_lattice.h
source/blender/blenkernel/BKE_linestyle.h
source/blender/blenkernel/BKE_mask.h
source/blender/blenkernel/BKE_material.h
source/blender/blenkernel/BKE_mball.h
source/blender/blenkernel/BKE_mesh.h
source/blender/blenkernel/BKE_movieclip.h
source/blender/blenkernel/BKE_node.h
source/blender/blenkernel/BKE_object.h
source/blender/blenkernel/BKE_paint.h
source/blender/blenkernel/BKE_particle.h
source/blender/blenkernel/BKE_scene.h
source/blender/blenkernel/BKE_screen.h
source/blender/blenkernel/BKE_sound.h
source/blender/blenkernel/BKE_speaker.h
source/blender/blenkernel/BKE_text.h
source/blender/blenkernel/BKE_texture.h
source/blender/blenkernel/BKE_world.h
source/blender/blenkernel/intern/action.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/brush.c
source/blender/blenkernel/intern/camera.c
source/blender/blenkernel/intern/curve.c
source/blender/blenkernel/intern/font.c
source/blender/blenkernel/intern/gpencil.c
source/blender/blenkernel/intern/group.c
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/key.c
source/blender/blenkernel/intern/lamp.c
source/blender/blenkernel/intern/lattice.c
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/linestyle.c
source/blender/blenkernel/intern/mask.c
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/mball.c
source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/movieclip.c
source/blender/blenkernel/intern/node.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/paint.c
source/blender/blenkernel/intern/particle.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/screen.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/sound.c
source/blender/blenkernel/intern/speaker.c
source/blender/blenkernel/intern/text.c
source/blender/blenkernel/intern/texture.c
source/blender/blenkernel/intern/world.c
source/blender/compositor/operations/COM_MaskOperation.cpp
source/blender/editors/gpencil/gpencil_undo.c
source/blender/editors/mesh/editmesh_utils.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/render/render_preview.c
source/blender/editors/screen/screen_edit.c
source/blender/editors/sound/sound_ops.c
source/blender/editors/space_node/node_group.c
source/blender/makesrna/intern/rna_main_api.c
source/blender/nodes/shader/node_shader_tree.c
source/blender/render/intern/source/render_texture.c

index e9adec8f3b23ffcd011c136024413ea2fc1fe980..3fceef5d95dd5f86264c7fbb7ac237c0f8b72439 100644 (file)
@@ -61,7 +61,7 @@ struct bAction *add_empty_action(struct Main *bmain, const char name[]);
 struct bAction *BKE_action_copy(struct bAction *src);
 
 /* Deallocate all of the Action's data, but not the Action itself */
-void BKE_action_free(struct bAction *act, const bool do_id_user);
+void BKE_action_free(struct bAction *act);
 
 // XXX is this needed?
 void BKE_action_make_local(struct bAction *act);
index 80066cdc9a2bf019a30b6a15c9b7258f0a240471..e1885e46b24d6e0b771e59aebccee34a196cf0e8 100644 (file)
@@ -73,7 +73,7 @@ extern "C" {
 struct bArmature *BKE_armature_add(struct Main *bmain, const char *name);
 struct bArmature *BKE_armature_from_object(struct Object *ob);
 void BKE_armature_bonelist_free(struct ListBase *lb);
-void BKE_armature_free(struct bArmature *arm, const bool do_id_user);
+void BKE_armature_free(struct bArmature *arm);
 void BKE_armature_make_local(struct bArmature *arm);
 struct bArmature *BKE_armature_copy(struct bArmature *arm);
 
index d2c8f97602ca994724fb50e30e4bbe2838629258..aff3fb08df66734fb57a551cb483ece40d571f03 100644 (file)
@@ -44,7 +44,7 @@ struct Brush *BKE_brush_add(struct Main *bmain, const char *name, short ob_mode)
 struct Brush *BKE_brush_first_search(struct Main *bmain, short ob_mode);
 struct Brush *BKE_brush_copy(struct Brush *brush);
 void BKE_brush_make_local(struct Brush *brush);
-void BKE_brush_free(struct Brush *brush, const bool do_id_user);
+void BKE_brush_free(struct Brush *brush);
 
 void BKE_brush_sculpt_reset(struct Brush *brush);
 
index 3dcda194cacb1e1d5e139ac5dadba94593b458a1..aacb7a4066bb742037eeae33eaf6496434665e3e 100644 (file)
@@ -53,7 +53,7 @@ struct GPUFXSettings;
 void *BKE_camera_add(struct Main *bmain, const char *name);
 struct Camera *BKE_camera_copy(struct Camera *cam);
 void BKE_camera_make_local(struct Camera *cam);
-void BKE_camera_free(struct Camera *ca, const bool do_id_user);
+void BKE_camera_free(struct Camera *ca);
 
 /* Camera Usage */
 
index 17836ced2baeaaa25923898f3a3aeff1b3c5459a..a03dd2871467d0d617971c215bb67f9e8e4dcb4d 100644 (file)
@@ -66,7 +66,8 @@ typedef struct CurveCache {
 #define CU_DO_2DFILL(cu)  ((((cu)->flag & CU_3D) == 0) && (((cu)->flag & (CU_FRONT | CU_BACK)) != 0))
 
 /* ** Curve ** */
-void BKE_curve_free(struct Curve *cu, const bool do_id_user);
+void BKE_curve_unlink(struct Curve *cu);
+void BKE_curve_free(struct Curve *cu);
 void BKE_curve_editfont_free(struct Curve *cu);
 struct Curve *BKE_curve_add(struct Main *bmain, const char *name, int type);
 struct Curve *BKE_curve_copy(struct Curve *cu);
index 0c96107a47f5b41f8329e7a1e78f5564eafd9148..f20c166aa6dfdf7be4f49fbacd4f4d26051b2f58 100644 (file)
@@ -78,7 +78,7 @@ bool BKE_vfont_is_builtin(struct VFont *vfont);
 void BKE_vfont_builtin_register(void *mem, int size);
 
 void BKE_vfont_free_data(struct VFont *vfont);
-void BKE_vfont_free(struct VFont *sc, const bool do_id_user);
+void BKE_vfont_free(struct VFont *sc); 
 struct VFont *BKE_vfont_builtin_get(void);
 struct VFont *BKE_vfont_load(struct Main *bmain, const char *filepath);
 struct VFont *BKE_vfont_load_exists_ex(struct Main *bmain, const char *filepath, bool *r_exists);
index 2d287172e90c4ee1a072243d78f08f1fd02b2184..084c5527f211076bdb2fdb5ce37a3c64a0304242 100644 (file)
@@ -42,7 +42,7 @@ struct bGPDstroke;
 bool free_gpencil_strokes(struct bGPDframe *gpf);
 void free_gpencil_frames(struct bGPDlayer *gpl);
 void free_gpencil_layers(struct ListBase *list);
-void BKE_gpencil_free(struct bGPdata *gpd, const bool do_id_user);
+void BKE_gpencil_free(struct bGPdata *gpd);
 
 void gpencil_stroke_sync_selection(struct bGPDstroke *gps);
 
index d27bdd32a586a2b3e961e872e36d60ab1440a0dd..d856e90a340fc39033e410e5a7e951f2cc1d1b52 100644 (file)
@@ -40,7 +40,7 @@ struct Main;
 struct Object;
 struct Scene;
 
-void          BKE_group_free(struct Group *group, const bool do_id_user);
+void          BKE_group_free(struct Group *group);
 void          BKE_group_unlink(struct Group *group);
 struct Group *BKE_group_add(struct Main *bmain, const char *name);
 struct Group *BKE_group_copy(struct Group *group);
index baea56ac751bb6c60e6149f7241e4ae098fb27f2..94afc8a16eadbd652273f1e408b6c07f432b2112 100644 (file)
@@ -59,7 +59,7 @@ void    BKE_image_free_packedfiles(struct Image *image);
 void    BKE_image_free_views(struct Image *image);
 void    BKE_image_free_buffers(struct Image *image);
 /* call from library */
-void    BKE_image_free(struct Image *image, const bool do_id_user);
+void    BKE_image_free(struct Image *image);
 
 typedef void (StampCallback)(void *data, const char *propname, char *propvalue, int len);
 
index af466e512f6e41601282156875541f3d5c5ef7b6..1edbb455ca432a9797ab1d10ca4769b6572af96d 100644 (file)
@@ -47,7 +47,7 @@ struct WeightsArrayCache;
 extern "C" {
 #endif
 
-void        BKE_key_free(struct Key *sc, const bool do_id_user);
+void        BKE_key_free(struct Key *sc);
 void        BKE_key_free_nolib(struct Key *key);
 struct Key *BKE_key_add(struct ID *id);
 struct Key *BKE_key_copy(struct Key *key);
index dce0b7c5fdcb74ef43a99949bdd6a538c0f647ad..fb2c4da91ea344c873d7bc48cfc4d9b6879a62b6 100644 (file)
@@ -46,7 +46,7 @@ struct Lamp *BKE_lamp_add(struct Main *bmain, const char *name) ATTR_WARN_UNUSED
 struct Lamp *BKE_lamp_copy(struct Lamp *la) ATTR_WARN_UNUSED_RESULT;
 struct Lamp *localize_lamp(struct Lamp *la) ATTR_WARN_UNUSED_RESULT;
 void BKE_lamp_make_local(struct Lamp *la);
-void BKE_lamp_free(struct Lamp *la, const bool do_id_user);
+void BKE_lamp_free(struct Lamp *la);
 
 void lamp_drivers_update(struct Scene *scene, struct Lamp *la, float ctime);
 
index adf37c6d429f43b53f7c737fb475a9ab9afa15bf..677d8e342290c955d05070cc00db652bc77b8a66 100644 (file)
@@ -47,7 +47,7 @@ struct MDeformVert;
 void BKE_lattice_resize(struct Lattice *lt, int u, int v, int w, struct Object *ltOb);
 struct Lattice *BKE_lattice_add(struct Main *bmain, const char *name);
 struct Lattice *BKE_lattice_copy(struct Lattice *lt);
-void BKE_lattice_free(struct Lattice *lt, const bool do_id_user);
+void BKE_lattice_free(struct Lattice *lt);
 void BKE_lattice_make_local(struct Lattice *lt);
 void calc_lat_fudu(int flag, int res, float *r_fu, float *r_du);
 
index 8d6a860cd02260484d39a0bab447eabe81285124..e77b4f5e8fe5fb8104fee57b5e6f4ec1d32ff3fe 100644 (file)
@@ -50,7 +50,7 @@ struct ColorBand;
 struct bContext;
 
 FreestyleLineStyle *BKE_linestyle_new(struct Main *bmain, const char *name);
-void                BKE_linestyle_free(FreestyleLineStyle *linestyle, const bool do_id_user);
+void                BKE_linestyle_free(FreestyleLineStyle *linestyle);
 FreestyleLineStyle *BKE_linestyle_copy(struct Main *bmain, FreestyleLineStyle *linestyle);
 
 FreestyleLineStyle *BKE_linestyle_active_from_scene(struct Scene *scene);
index cc74869acfbbe25ac396d60289ae462f9def75ff..2f85db4d5d215a165d89f65c1b8186ef19c4db8e 100644 (file)
@@ -123,8 +123,8 @@ struct Mask *BKE_mask_new(struct Main *bmain, const char *name);
 struct Mask *BKE_mask_copy_nolib(struct Mask *mask);
 struct Mask *BKE_mask_copy(struct Mask *mask);
 
-void BKE_mask_free(struct Mask *mask, const bool do_id_user);
-void BKE_mask_unlink(struct Main *bmain, struct Mask *mask);
+void BKE_mask_free_nolib(struct Mask *mask);
+void BKE_mask_free(struct Main *bmain, struct Mask *mask);
 
 void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2]);
 void BKE_mask_coord_from_movieclip(struct MovieClip *clip, struct MovieClipUser *user, float r_co[2], const float co[2]);
index 6804838ddf83d9f1b7e3fa71759f1922031d50b4..a3c61f44ff2acb2cf2a69c0ad3b5b9941646a026 100644 (file)
@@ -45,7 +45,8 @@ struct Scene;
 /* materials */
 
 void init_def_material(void);
-void BKE_material_free(struct Material *ma, const bool do_id_user);
+void BKE_material_free(struct Material *sc); 
+void BKE_material_free_ex(struct Material *ma, bool do_id_user);
 void test_object_materials(struct Main *bmain, struct ID *id);
 void BKE_material_resize_object(struct Object *ob, const short totcol, bool do_id_user);
 void init_material(struct Material *ma);
index 02c53280551fe3d5478f7e5be144df420303cd67..62cd50099fd0d50a36b518ebc65dd8e9e831d2e8 100644 (file)
@@ -38,7 +38,8 @@ struct Object;
 struct Scene;
 struct MetaElem;
 
-void BKE_mball_free(struct MetaBall *mb, const bool do_id_user);
+void BKE_mball_unlink(struct MetaBall *mb);
+void BKE_mball_free(struct MetaBall *mb);
 struct MetaBall *BKE_mball_add(struct Main *bmain, const char *name);
 struct MetaBall *BKE_mball_copy(struct MetaBall *mb);
 
index f26d084e9f436f079cd01a7c710e483c4d63328a..5bd8931ee2efebefba29db107a399f63a2bb1fad 100644 (file)
@@ -80,7 +80,8 @@ int poly_get_adj_loops_from_vert(
 
 int BKE_mesh_edge_other_vert(const struct MEdge *e, int v);
 
-void BKE_mesh_free(struct Mesh *me, const bool do_id_user);
+void BKE_mesh_unlink(struct Mesh *me);
+void BKE_mesh_free(struct Mesh *me, int unlink);
 struct Mesh *BKE_mesh_add(struct Main *bmain, const char *name);
 struct Mesh *BKE_mesh_copy_ex(struct Main *bmain, struct Mesh *me);
 struct Mesh *BKE_mesh_copy(struct Mesh *me);
index bf5f8fac838c019d2c9f1d32aff1023844b0a2da..afca326c727306f30ecb72ec7b44755d20103ca2 100644 (file)
@@ -39,7 +39,7 @@ struct MovieClipScopes;
 struct MovieClipUser;
 struct MovieDistortion;
 
-void BKE_movieclip_free(struct MovieClip *clip, const bool do_id_user);
+void BKE_movieclip_free(struct MovieClip *clip);
 void BKE_movieclip_unlink(struct Main *bmain, struct MovieClip *clip);
 
 struct MovieClip *BKE_movieclip_file_add(struct Main *bmain, const char *name);
index 78a239641dd0c04f40f47906ba706b97d4331a18..b97bf203a7c625262e1b21c46e81b5203885bcd2 100644 (file)
@@ -340,7 +340,8 @@ void ntreeSetTypes(const struct bContext *C, struct bNodeTree *ntree);
 struct bNodeTree *ntreeAddTree(struct Main *bmain, const char *name, const char *idname);
 
 /* copy/free funcs, need to manage ID users */
-void              ntreeFreeTree(struct bNodeTree *ntree, const bool do_id_user);
+void              ntreeFreeTree_ex(struct bNodeTree *ntree, const bool do_id_user);
+void              ntreeFreeTree(struct bNodeTree *ntree);
 struct bNodeTree *ntreeCopyTree_ex(struct bNodeTree *ntree, struct Main *bmain, const bool do_id_user);
 struct bNodeTree *ntreeCopyTree(struct bNodeTree *ntree);
 void              ntreeSwitchID_ex(struct bNodeTree *ntree, struct ID *sce_from, struct ID *sce_to, const bool do_id_user);
index 7e7a6bd1149e845d178fe58f606c65d716cdc3f7..f3a1be24af68f5559d35b37b93a023dd895c1025 100644 (file)
@@ -64,7 +64,8 @@ void BKE_object_free_bulletsoftbody(struct Object *ob);
 void BKE_object_free_curve_cache(struct Object *ob);
 void BKE_object_update_base_layer(struct Scene *scene, struct Object *ob);
 
-void BKE_object_free(struct Object *ob, const bool do_id_user);
+void BKE_object_free(struct Object *ob);
+void BKE_object_free_ex(struct Object *ob, bool do_id_user);
 void BKE_object_free_derived_caches(struct Object *ob);
 void BKE_object_free_caches(struct Object *object);
 
index a2e59e4e913a165d5464a65ad1c53d41f792e337..bf1cfb263eb2568aa90a2bced9b7e38691e00b59 100644 (file)
@@ -97,7 +97,7 @@ void BKE_paint_reset_overlay_invalid(OverlayControlFlags flag);
 void BKE_paint_set_overlay_override(enum OverlayFlags flag);
 
 /* palettes */
-void                 BKE_palette_free(struct Palette *palette, const bool do_id_user);
+void                 BKE_palette_free(struct Palette *palette);
 struct Palette      *BKE_palette_add(struct Main *bmain, const char *name);
 struct PaletteColor *BKE_palette_color_add(struct Palette *palette);
 bool                 BKE_palette_is_empty(const struct Palette *palette);
@@ -106,7 +106,7 @@ void                 BKE_palette_clear(struct Palette *palette);
 
 /* paint curves */
 struct PaintCurve *BKE_paint_curve_add(struct Main *bmain, const char *name);
-void BKE_paint_curve_free(struct PaintCurve *pc, const bool do_id_user);
+void BKE_paint_curve_free(struct PaintCurve *pc);
 
 void BKE_paint_init(struct Scene *sce, PaintMode mode, const char col[3]);
 void BKE_paint_free(struct Paint *p);
index 2269a78275dfb338ab9d1d6e64cf8f85d6b0bdef..00cc48cf713b67b1a19c96cef0b9e9dd9b377ad8 100644 (file)
@@ -297,7 +297,7 @@ void psys_check_group_weights(struct ParticleSettings *part);
 int psys_uses_gravity(struct ParticleSimulationData *sim);
 
 /* free */
-void BKE_particlesettings_free(struct ParticleSettings *part, const bool do_id_user);
+void BKE_particlesettings_free(struct ParticleSettings *part);
 void psys_free_path_cache(struct ParticleSystem *psys, struct PTCacheEdit *edit);
 void psys_free(struct Object *ob, struct ParticleSystem *psys);
 
index a18c1e7cdd2b60f7f6a04fff4d0fef749bf23c98..027bdbbbe58aa1af21b26110aae6919fb0c62440 100644 (file)
@@ -66,7 +66,7 @@ struct Base *_setlooper_base_step(struct Scene **sce_iter, struct Base *base);
 void free_avicodecdata(struct AviCodecData *acd);
 void free_qtcodecdata(struct QuicktimeCodecData *acd);
 
-void BKE_scene_free(struct Scene *sce, const bool do_id_user);
+void BKE_scene_free(struct Scene *sce);
 struct Scene *BKE_scene_add(struct Main *bmain, const char *name);
 
 /* base functions */
index c3a0223e2a29ec6d7f6d985c270156dede2c27fb..48616418e677640c04188dc7da0744f2138e07ef 100644 (file)
@@ -307,7 +307,7 @@ float BKE_screen_view3d_zoom_to_fac(float camzoom);
 float BKE_screen_view3d_zoom_from_fac(float zoomfac);
 
 /* screen */
-void BKE_screen_free(struct bScreen *sc, const bool do_id_user);
+void BKE_screen_free(struct bScreen *sc); 
 unsigned int BKE_screen_visible_layers(struct bScreen *screen, struct Scene *scene);
 
 #endif
index 3431eff55ba0163f1027153541271ba7ca5333f6..67db2537c8fbd81902eacafc706deac8922d3eb5 100644 (file)
@@ -72,13 +72,15 @@ struct bSound *BKE_sound_new_buffer(struct Main *bmain, struct bSound *source);
 struct bSound *BKE_sound_new_limiter(struct Main *bmain, struct bSound *source, float start, float end);
 #endif
 
+void BKE_sound_delete(struct Main *bmain, struct bSound *sound);
+
 void BKE_sound_cache(struct bSound *sound);
 
 void BKE_sound_delete_cache(struct bSound *sound);
 
 void BKE_sound_load(struct Main *main, struct bSound *sound);
 
-void BKE_sound_free(struct bSound *sound, const bool do_id_user);
+void BKE_sound_free(struct bSound *sound);
 
 #if defined(__AUD_C_API_H__) || defined(WITH_SYSTEM_AUDASPACE)
 AUD_Device *BKE_sound_mixdown(struct Scene *scene, AUD_DeviceSpecs specs, int start, float volume);
index 571e6e7cb393e1741000e9fe691c6179e7a6c0d6..5d93b9844ab8f71223fd448bd345268a911c2518 100644 (file)
@@ -33,6 +33,6 @@ struct Main;
 void *BKE_speaker_add(struct Main *bmain, const char *name);
 struct Speaker *BKE_speaker_copy(struct Speaker *spk);
 void BKE_speaker_make_local(struct Speaker *spk);
-void BKE_speaker_free(struct Speaker *spk, const bool do_id_user);
+void BKE_speaker_free(struct Speaker *spk);
 
 #endif
index 6350563adc58a704483b30f0617086d048332edf..a5a59d14c92e26bd22c488d9efb942a12a63893d 100644 (file)
@@ -41,7 +41,7 @@ struct Main;
 struct Text;
 struct TextLine;
 
-void                   BKE_text_free           (struct Text *text, const bool do_id_user);
+void                   BKE_text_free           (struct Text *text);
 void                   txt_set_undostate       (int u);
 int                    txt_get_undostate       (void);
 struct Text    *BKE_text_add   (struct Main *bmain, const char *name);
index 504de22295a8dda0fd5c0577e139727c35149ea9..95918b9ca0be6dc29ead1b773d195a8b88cff00f 100644 (file)
@@ -67,7 +67,7 @@ struct CBData *colorband_element_add(struct ColorBand *coba, float position);
 int colorband_element_remove(struct ColorBand *coba, int index);
 void colorband_update_sort(struct ColorBand *coba);
 
-void         BKE_texture_free(struct Tex *tex, const bool do_id_user);
+void         BKE_texture_free(struct Tex *tex);
 void         BKE_texture_default(struct Tex *tex);
 struct Tex  *BKE_texture_copy(struct Tex *tex);
 struct Tex  *BKE_texture_add(struct Main *bmain, const char *name);
index a77a5b06817ff9e4fb58c4eed161785636751ff9..7f4ba6c615ee4f2fcbc759382d15f4c577db156f 100644 (file)
@@ -36,7 +36,8 @@
 struct Main;
 struct World;
 
-void BKE_world_free(struct World *sc, const bool do_id_user);
+void BKE_world_free(struct World *sc);
+void BKE_world_free_ex(struct World *sc, bool do_id_user);
 struct World *add_world(struct Main *bmian, const char *name);
 struct World *BKE_world_copy(struct World *wrld);
 struct World *localize_world(struct World *wrld);
index ae1604a94b51f042b2dfe3e085db9795afb9c674..b77ae45e94d7ad41e484422bf44103d58936981c 100644 (file)
@@ -159,25 +159,22 @@ void BKE_action_make_local(bAction *act)
 
 /* .................................. */
 
-/**
- * Free (or release) any data used by this action (does not free the action itself).
- *
- * \param act The action to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this action are 'released'
- *                   (their user count is decreased).
- */
-void BKE_action_free(bAction *act, const bool UNUSED(do_id_user))
-{      
-       /* No animdata here. */
-
+void BKE_action_free(bAction *act)
+{
+       /* sanity check */
+       if (act == NULL)
+               return;
+       
        /* Free F-Curves */
        free_fcurves(&act->curves);
        
        /* Free groups */
-       BLI_freelistN(&act->groups);
+       if (act->groups.first)
+               BLI_freelistN(&act->groups);
                
        /* Free pose-references (aka local markers) */
-       BLI_freelistN(&act->markers);
+       if (act->markers.first)
+               BLI_freelistN(&act->markers);
 }
 
 /* .................................. */
index fc698f35b7110817ebffad1e378d7e65b8f515dd..6afe7f1abe906d862652536e1307871b5ca95b9e 100644 (file)
@@ -106,31 +106,30 @@ void BKE_armature_bonelist_free(ListBase *lb)
        BLI_freelistN(lb);
 }
 
-/**
- * Free (or release) any data used by this armature (does not free the armature itself).
- *
- * \param arm The armature to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this armature are 'released'
- *                   (their user count is decreased).
- */
-void BKE_armature_free(bArmature *arm, const bool UNUSED(do_id_user))
+void BKE_armature_free(bArmature *arm)
 {
-       BKE_animdata_free(&arm->id);
+       if (arm) {
+               BKE_armature_bonelist_free(&arm->bonebase);
 
-       BKE_armature_bonelist_free(&arm->bonebase);
+               /* free editmode data */
+               if (arm->edbo) {
+                       BLI_freelistN(arm->edbo);
 
-       /* free editmode data */
-       if (arm->edbo) {
-               BLI_freelistN(arm->edbo);
+                       MEM_freeN(arm->edbo);
+                       arm->edbo = NULL;
+               }
 
-               MEM_freeN(arm->edbo);
-               arm->edbo = NULL;
-       }
+               /* free sketch */
+               if (arm->sketch) {
+                       freeSketch(arm->sketch);
+                       arm->sketch = NULL;
+               }
 
-       /* free sketch */
-       if (arm->sketch) {
-               freeSketch(arm->sketch);
-               arm->sketch = NULL;
+               /* free animation data */
+               if (arm->adt) {
+                       BKE_animdata_free(&arm->id);
+                       arm->adt = NULL;
+               }
        }
 }
 
index 3c7f753e3d82736522f53832fcc94588b50fd33d..e0ffd83080493c33ebf933d103e34b8fcf04ee35 100644 (file)
@@ -197,45 +197,22 @@ Brush *BKE_brush_copy(Brush *brush)
        return brushn;
 }
 
-/**
- * Free (or release) any data used by this brush (does not free the brush itself).
- *
- * \param brush The brush to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this brush are 'released'
- *                   (their user count is decreased).
- */
-void BKE_brush_free(Brush *brush, const bool do_id_user)
+/* not brush itself */
+void BKE_brush_free(Brush *brush)
 {
-       if (do_id_user) {
-               if (brush->mtex.tex) {
-                       id_us_min(&brush->mtex.tex->id);
-                       brush->mtex.tex = NULL;
-               }
+       id_us_min((ID *)brush->mtex.tex);
+       id_us_min((ID *)brush->mask_mtex.tex);
+       id_us_min((ID *)brush->paint_curve);
 
-               if (brush->mask_mtex.tex) {
-                       id_us_min(&brush->mask_mtex.tex->id);
-                       brush->mask_mtex.tex = NULL;
-               }
-
-               if (brush->paint_curve) {
-                       id_us_min(&brush->paint_curve->id);
-                       brush->paint_curve = NULL;
-               }
-
-               /* No ID refcount here... */
-               brush->toggle_brush = NULL;
-               brush->clone.image = NULL;
-       }
-
-       if (brush->icon_imbuf) {
+       if (brush->icon_imbuf)
                IMB_freeImBuf(brush->icon_imbuf);
-       }
 
-       curvemapping_free(brush->curve);
+       BKE_previewimg_free(&(brush->preview));
 
-       MEM_SAFE_FREE(brush->gradient);
+       curvemapping_free(brush->curve);
 
-       BKE_previewimg_free(&(brush->preview));
+       if (brush->gradient)
+               MEM_freeN(brush->gradient);
 }
 
 static void extern_local_brush(Brush *brush)
index eb99022d034f68d2916af05be18db77c910a5c7f..7e043df2808f747bd85f09dac5b624b6ceceeff7 100644 (file)
@@ -144,20 +144,8 @@ void BKE_camera_make_local(Camera *cam)
        }
 }
 
-/**
- * Free (or release) any data used by this camera (does not free the camera itself).
- *
- * \param ca The camera to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this camera are 'released'
- *                   (their user count is decreased).
- */
-void BKE_camera_free(Camera *ca, const bool do_id_user)
+void BKE_camera_free(Camera *ca)
 {
-       if (do_id_user) {
-               /* No ID refcount here... */
-               ca->dof_ob = NULL;
-       }
-
        BKE_animdata_free((ID *)ca);
 }
 
index e01813e0b889823bf917a5fb96cab598d9513aa3..8d7d62be7e4e4d3ef50dafac53c8573e02cf6fb6 100644 (file)
@@ -69,6 +69,35 @@ static int cu_isectLL(const float v1[3], const float v2[3], const float v3[3], c
                       short cox, short coy,
                       float *lambda, float *mu, float vec[3]);
 
+void BKE_curve_unlink(Curve *cu)
+{
+       int a;
+
+       for (a = 0; a < cu->totcol; a++) {
+               if (cu->mat[a]) cu->mat[a]->id.us--;
+               cu->mat[a] = NULL;
+       }
+       if (cu->vfont)
+               cu->vfont->id.us--;
+       cu->vfont = NULL;
+
+       if (cu->vfontb)
+               cu->vfontb->id.us--;
+       cu->vfontb = NULL;
+
+       if (cu->vfonti)
+               cu->vfonti->id.us--;
+       cu->vfonti = NULL;
+
+       if (cu->vfontbi)
+               cu->vfontbi->id.us--;
+       cu->vfontbi = NULL;
+
+       if (cu->key)
+               cu->key->id.us--;
+       cu->key = NULL;
+}
+
 /* frees editcurve entirely */
 void BKE_curve_editfont_free(Curve *cu)
 {
@@ -110,63 +139,26 @@ void BKE_curve_editNurb_free(Curve *cu)
        }
 }
 
-/**
- * Free (or release) any data used by this curve (does not free the curve itself).
- *
- * \param cu The curve to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this curve are 'released'
- *                   (their user count is decreased).
- */
-void BKE_curve_free(Curve *cu, const bool do_id_user)
+/* don't free curve itself */
+void BKE_curve_free(Curve *cu)
 {
-       if (do_id_user) {
-               int a;
-
-               for (a = 0; a < cu->totcol; a++) {
-                       if (cu->mat[a]) {
-                               id_us_min(&cu->mat[a]->id);
-                               cu->mat[a] = NULL;
-                       }
-               }
-               if (cu->vfont) {
-                       id_us_min(&cu->vfont->id);
-                       cu->vfont = NULL;
-               }
-               if (cu->vfontb) {
-                       id_us_min(&cu->vfontb->id);
-                       cu->vfontb = NULL;
-               }
-               if (cu->vfonti) {
-                       id_us_min(&cu->vfonti->id);
-                       cu->vfonti = NULL;
-               }
-               if (cu->vfontbi) {
-                       id_us_min(&cu->vfontbi->id);
-                       cu->vfontbi = NULL;
-               }
-               if (cu->key) {
-                       id_us_min(&cu->key->id);
-                       cu->key = NULL;
-               }
-
-               /* No ID refcount here... */
-               cu->bevobj = NULL;
-               cu->taperobj = NULL;
-               cu->textoncurve = NULL;
-       }
-
-       BKE_animdata_free((ID *)cu);
-
        BKE_nurbList_free(&cu->nurb);
        BKE_curve_editfont_free(cu);
 
        BKE_curve_editNurb_free(cu);
+       BKE_curve_unlink(cu);
+       BKE_animdata_free((ID *)cu);
 
-       MEM_SAFE_FREE(cu->mat);
-       MEM_SAFE_FREE(cu->str);
-       MEM_SAFE_FREE(cu->strinfo);
-       MEM_SAFE_FREE(cu->bb);
-       MEM_SAFE_FREE(cu->tb);
+       if (cu->mat)
+               MEM_freeN(cu->mat);
+       if (cu->str)
+               MEM_freeN(cu->str);
+       if (cu->strinfo)
+               MEM_freeN(cu->strinfo);
+       if (cu->bb)
+               MEM_freeN(cu->bb);
+       if (cu->tb)
+               MEM_freeN(cu->tb);
 }
 
 Curve *BKE_curve_add(Main *bmain, const char *name, int type)
index a8339b567dc24f7685352e00f544bf04565e605d..e3ebb7f908ce96a54100044031baff4d93abe598 100644 (file)
@@ -95,15 +95,10 @@ void BKE_vfont_free_data(struct VFont *vfont)
        }
 }
 
-/**
- * Free (or release) any data used by this font (does not free the font itself).
- *
- * \param vf The font to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this font are 'released'
- *                   (their user count is decreased).
- */
-void BKE_vfont_free(struct VFont *vf, const bool UNUSED(do_id_user))
+void BKE_vfont_free(struct VFont *vf)
 {
+       if (vf == NULL) return;
+
        BKE_vfont_free_data(vf);
 
        if (vf->packedfile) {
index 8779f0d5f0e342db559701c4e4cae3a49642e944..ee5c91923716121789da4b189d98e578a4e5e781 100644 (file)
@@ -112,19 +112,16 @@ void free_gpencil_layers(ListBase *list)
 }
 
 /* Free all of GPencil datablock's related data, but not the block itself */
-/**
- * Free (or release) any data used by this grease pencil (does not free the gpencil itself).
- *
- * \param gpd The grease pencil to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this gpencil are 'released'
- *                   (their user count is decreased).
- */
-void BKE_gpencil_free(bGPdata *gpd, const bool UNUSED(do_id_user))
+void BKE_gpencil_free(bGPdata *gpd)
 {
-       BKE_animdata_free(&gpd->id);
-
        /* free layers */
        free_gpencil_layers(&gpd->layers);
+       
+       /* free animation data */
+       if (gpd->adt) {
+               BKE_animdata_free(&gpd->id);
+               gpd->adt = NULL;
+       }
 }
 
 /* -------- Container Creation ---------- */
index 68987e21a74876bd805bccd65f48e44659e13131..3f68339be11bea5bfd266b60079b2dab8e22fb02 100644 (file)
@@ -60,26 +60,17 @@ static void free_group_object(GroupObject *go)
        MEM_freeN(go);
 }
 
-/**
- * Free (or release) any data used by this group (does not free the group itself).
- *
- * \param group The group to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this group are 'released'
- *                   (their user count is decreased).
- */
-/* Note: technically, groupobjects are ID users (without refcount), but for now we can ignore those. */
-void BKE_group_free(Group *group, const bool UNUSED(do_id_user))
+
+void BKE_group_free(Group *group)
 {
        /* don't free group itself */
        GroupObject *go;
 
-       /* No animdata here. */
+       BKE_previewimg_free(&group->preview);
 
        while ((go = BLI_pophead(&group->gobject))) {
                free_group_object(go);
        }
-
-       BKE_previewimg_free(&group->preview);
 }
 
 void BKE_group_unlink(Group *group)
@@ -141,8 +132,7 @@ void BKE_group_unlink(Group *group)
        }
        
        /* group stays in library, but no members */
-       /* XXX This is suspicious, means we keep a dangling, empty group? Also, does not take into account fakeuser? */
-       BKE_group_free(group, false);
+       BKE_group_free(group);
        group->id.us = 0;
 }
 
index 4563b18a822ad12e0bee087f9c6eae51133fddfe..1b32981549345ba1800e24c7d59c0847e1c56d14 100644 (file)
@@ -329,22 +329,20 @@ void BKE_image_free_buffers(Image *ima)
        ima->ok = IMA_OK;
 }
 
-/**
- * Free (or release) any data used by this image (does not free the image itself).
- *
- * \param ima The image to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this image are 'released'
- *                   (their user count is decreased).
- */
-void BKE_image_free(Image *ima, const bool UNUSED(do_id_user))
+/* called by library too, do not free ima itself */
+void BKE_image_free(Image *ima)
 {
        int a;
 
-       /* Also frees animdata. */
        BKE_image_free_buffers(ima);
 
        image_free_packedfiles(ima);
 
+       BKE_icon_id_delete(&ima->id);
+       ima->id.icon_id = 0;
+
+       BKE_previewimg_free(&ima->preview);
+
        for (a = 0; a < IMA_MAX_RENDER_SLOT; a++) {
                if (ima->renders[a]) {
                        RE_FreeRenderResult(ima->renders[a]);
@@ -353,10 +351,7 @@ void BKE_image_free(Image *ima, const bool UNUSED(do_id_user))
        }
 
        image_free_views(ima);
-       MEM_SAFE_FREE(ima->stereo3d_format);
-
-       BKE_icon_id_delete(&ima->id);
-       BKE_previewimg_free(&ima->preview);
+       MEM_freeN(ima->stereo3d_format);
 }
 
 /* only image block itself */
index b1e12588962994a7e475c6b19c947470b1723690..362f41335d24e52031f0f1993ab60437112a86cd 100644 (file)
 #define IPO_BEZTRIPLE   100
 #define IPO_BPOINT      101
 
-
-/**
- * Free (or release) any data used by this shapekey (does not free the key itself).
- *
- * \param key The shapekey to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this key are 'released'
- *                   (their user count is decreased).
- */
-void BKE_key_free(Key *key, const bool do_id_user)
+void BKE_key_free(Key *key)
 {
        KeyBlock *kb;
-
-       if (do_id_user) {
-               /* No ID refcount here... */
-               key->from = NULL;
-       }
        
        BKE_animdata_free((ID *)key);
 
index 48498440fa9974a09533ecd2d77f668f50982346..44e35c645debc5307ac37a69cbba953d2b035a13 100644 (file)
@@ -210,48 +210,30 @@ void BKE_lamp_make_local(Lamp *la)
        }
 }
 
-/**
- * Free (or release) any data used by this lamp (does not free the lamp itself).
- *
- * \param la The lamp to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this lamp are 'released'
- *                   (their user count is decreased).
- */
-void BKE_lamp_free(Lamp *la, const bool do_id_user)
+void BKE_lamp_free(Lamp *la)
 {
+       MTex *mtex;
        int a;
 
-       if (do_id_user) {
-               MTex *mtex;
-               int a;
-
-               for (a = 0; a < MAX_MTEX; a++) {
-                       mtex = la->mtex[a];
-                       if (mtex && mtex->tex) {
-                               id_us_min(&mtex->tex->id);
-                               mtex->tex = NULL;
-                       }
-               }
-       }
-
-       BKE_animdata_free((ID *)la);
-
        for (a = 0; a < MAX_MTEX; a++) {
-               MEM_SAFE_FREE(la->mtex[a]);
+               mtex = la->mtex[a];
+               if (mtex && mtex->tex) mtex->tex->id.us--;
+               if (mtex) MEM_freeN(mtex);
        }
        
+       BKE_animdata_free((ID *)la);
+
        curvemapping_free(la->curfalloff);
-       la->curfalloff = NULL;
 
        /* is no lib link block, but lamp extension */
        if (la->nodetree) {
-               ntreeFreeTree(la->nodetree, do_id_user);
+               ntreeFreeTree(la->nodetree);
                MEM_freeN(la->nodetree);
-               la->nodetree = NULL;
        }
        
-       BKE_icon_id_delete(&la->id);
        BKE_previewimg_free(&la->preview);
+       BKE_icon_id_delete(&la->id);
+       la->id.icon_id = 0;
 }
 
 /* Calculate all drivers for lamps, see material_drivers_update for why this is a bad hack */
index cb9b0c09f64fa8f952d9ab27f9772fedcd6ab964..009e1d20328650e2d81f2741322595b76bdf3ad1 100644 (file)
@@ -293,40 +293,24 @@ Lattice *BKE_lattice_copy(Lattice *lt)
        return ltn;
 }
 
-/**
- * Free (or release) any data used by this lattice (does not free the lattice itself).
- *
- * \param lt The lattice to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this lattice are 'released'
- *                   (their user count is decreased).
- */
-void BKE_lattice_free(Lattice *lt, const bool do_id_user)
+void BKE_lattice_free(Lattice *lt)
 {
-       if (do_id_user) {
-               if (lt->key) {
-                       id_us_min(&lt->key->id);
-                       lt->key = NULL;
-               }
-       }
-
-       BKE_animdata_free(&lt->id);
-
-       MEM_SAFE_FREE(lt->def);
-       if (lt->dvert) {
-               BKE_defvert_array_free(lt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
-               lt->dvert = NULL;
-       }
+       if (lt->def) MEM_freeN(lt->def);
+       if (lt->dvert) BKE_defvert_array_free(lt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
        if (lt->editlatt) {
                Lattice *editlt = lt->editlatt->latt;
 
-               if (editlt->def)
-                       MEM_freeN(editlt->def);
-               if (editlt->dvert)
-                       BKE_defvert_array_free(editlt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
+               if (editlt->def) MEM_freeN(editlt->def);
+               if (editlt->dvert) BKE_defvert_array_free(editlt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
 
                MEM_freeN(editlt);
                MEM_freeN(lt->editlatt);
-               lt->editlatt = NULL;
+       }
+       
+       /* free animation data */
+       if (lt->adt) {
+               BKE_animdata_free(&lt->id);
+               lt->adt = NULL;
        }
 }
 
index b24eb6510d2f8bde0712a30e86d9a553bfe34058..d6b2a3cea29ac6562bfed831cee3b61d289b63e6 100644 (file)
@@ -890,7 +890,7 @@ void BKE_libblock_relink(ID *id)
        BKE_library_foreach_ID_link(id, id_relink_looper, NULL, 0);
 }
 
-static void library_free(Library *lib, const bool UNUSED(do_id_user))
+static void BKE_library_free(Library *lib)
 {
        if (lib->packedfile)
                freePackedFile(lib->packedfile);
@@ -951,10 +951,7 @@ void BKE_libblock_free_data(Main *bmain, ID *id)
        BKE_animdata_main_cb(bmain, animdata_dtar_clear_cb, (void *)id);
 }
 
-/**
- * used in headerbuttons.c image.c mesh.c screen.c sound.c and library.c
- *
- * \param do_id_user if \a true, try to release other ID's 'references' hold by \a idv. */
+/* used in headerbuttons.c image.c mesh.c screen.c sound.c and library.c */
 void BKE_libblock_free_ex(Main *bmain, void *idv, bool do_id_user)
 {
        ID *id = idv;
@@ -969,107 +966,107 @@ void BKE_libblock_free_ex(Main *bmain, void *idv, bool do_id_user)
 
        switch (type) {    /* GetShort from util.h */
                case ID_SCE:
-                       BKE_scene_free((Scene *)id, do_id_user);
+                       BKE_scene_free((Scene *)id);
                        break;
                case ID_LI:
-                       library_free((Library *)id, do_id_user);
+                       BKE_library_free((Library *)id);
                        break;
                case ID_OB:
-                       BKE_object_free((Object *)id, do_id_user);
+                       BKE_object_free_ex((Object *)id, do_id_user);
                        break;
                case ID_ME:
-                       BKE_mesh_free((Mesh *)id, do_id_user);
+                       BKE_mesh_free((Mesh *)id, 1);
                        break;
                case ID_CU:
-                       BKE_curve_free((Curve *)id, do_id_user);
+                       BKE_curve_free((Curve *)id);
                        break;
                case ID_MB:
-                       BKE_mball_free((MetaBall *)id, do_id_user);
+                       BKE_mball_free((MetaBall *)id);
                        break;
                case ID_MA:
-                       BKE_material_free((Material *)id, do_id_user);
+                       BKE_material_free((Material *)id);
                        break;
                case ID_TE:
-                       BKE_texture_free((Tex *)id, do_id_user);
+                       BKE_texture_free((Tex *)id);
                        break;
                case ID_IM:
-                       BKE_image_free((Image *)id, do_id_user);
+                       BKE_image_free((Image *)id);
                        break;
                case ID_LT:
-                       BKE_lattice_free((Lattice *)id, do_id_user);
+                       BKE_lattice_free((Lattice *)id);
                        break;
                case ID_LA:
-                       BKE_lamp_free((Lamp *)id, do_id_user);
+                       BKE_lamp_free((Lamp *)id);
                        break;
                case ID_CA:
-                       BKE_camera_free((Camera *) id, do_id_user);
+                       BKE_camera_free((Camera *) id);
                        break;
-               case ID_IP:  /* Deprecated. */
+               case ID_IP:
                        BKE_ipo_free((Ipo *)id);
                        break;
                case ID_KE:
-                       BKE_key_free((Key *)id, do_id_user);
+                       BKE_key_free((Key *)id);
                        break;
                case ID_WO:
-                       BKE_world_free((World *)id, do_id_user);
+                       BKE_world_free((World *)id);
                        break;
                case ID_SCR:
-                       BKE_screen_free((bScreen *)id, do_id_user);
+                       BKE_screen_free((bScreen *)id);
                        break;
                case ID_VF:
-                       BKE_vfont_free((VFont *)id, do_id_user);
+                       BKE_vfont_free((VFont *)id);
                        break;
                case ID_TXT:
-                       BKE_text_free((Text *)id, do_id_user);
+                       BKE_text_free((Text *)id);
                        break;
                case ID_SCRIPT:
                        /* deprecated */
                        break;
                case ID_SPK:
-                       BKE_speaker_free((Speaker *)id, do_id_user);
+                       BKE_speaker_free((Speaker *)id);
                        break;
                case ID_SO:
-                       BKE_sound_free((bSound *)id, do_id_user);
+                       BKE_sound_free((bSound *)id);
                        break;
                case ID_GR:
-                       BKE_group_free((Group *)id, do_id_user);
+                       BKE_group_free((Group *)id);
                        break;
                case ID_AR:
-                       BKE_armature_free((bArmature *)id, do_id_user);
+                       BKE_armature_free((bArmature *)id);
                        break;
                case ID_AC:
-                       BKE_action_free((bAction *)id, do_id_user);
+                       BKE_action_free((bAction *)id);
                        break;
                case ID_NT:
-                       ntreeFreeTree((bNodeTree *)id, do_id_user);
+                       ntreeFreeTree_ex((bNodeTree *)id, do_id_user);
                        break;
                case ID_BR:
-                       BKE_brush_free((Brush *)id, do_id_user);
+                       BKE_brush_free((Brush *)id);
                        break;
                case ID_PA:
-                       BKE_particlesettings_free((ParticleSettings *)id, do_id_user);
+                       BKE_particlesettings_free((ParticleSettings *)id);
                        break;
                case ID_WM:
                        if (free_windowmanager_cb)
                                free_windowmanager_cb(NULL, (wmWindowManager *)id);
                        break;
                case ID_GD:
-                       BKE_gpencil_free((bGPdata *)id, do_id_user);
+                       BKE_gpencil_free((bGPdata *)id);
                        break;
                case ID_MC:
-                       BKE_movieclip_free((MovieClip *)id, do_id_user);
+                       BKE_movieclip_free((MovieClip *)id);
                        break;
                case ID_MSK:
-                       BKE_mask_free((Mask *)id, do_id_user);
+                       BKE_mask_free(bmain, (Mask *)id);
                        break;
                case ID_LS:
-                       BKE_linestyle_free((FreestyleLineStyle *)id, do_id_user);
+                       BKE_linestyle_free((FreestyleLineStyle *)id);
                        break;
                case ID_PAL:
-                       BKE_palette_free((Palette *)id, do_id_user);
+                       BKE_palette_free((Palette *)id);
                        break;
                case ID_PC:
-                       BKE_paint_curve_free((PaintCurve *)id, do_id_user);
+                       BKE_paint_curve_free((PaintCurve *)id);
                        break;
        }
 
index 0875321a779a9b89bcc8f99053099078ee4024c4..ac2c4e35dce1d1763846df71c1b7b52e34e9bfd5 100644 (file)
@@ -123,43 +123,24 @@ FreestyleLineStyle *BKE_linestyle_new(struct Main *bmain, const char *name)
        return linestyle;
 }
 
-/**
- * Free (or release) any data used by this linestyle (does not free the linestyle itself).
- *
- * \param linestyle The linestyle to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this linestyle are 'released'
- *                   (their user count is decreased).
- */
-void BKE_linestyle_free(FreestyleLineStyle *linestyle, const bool do_id_user)
+void BKE_linestyle_free(FreestyleLineStyle *linestyle)
 {
        LineStyleModifier *m;
-       int a;
-
-       if (do_id_user) {
-               MTex *mtex;
-
-               for (a = 0; a < MAX_MTEX; a++) {
-                       mtex = linestyle->mtex[a];
-                       if (mtex && mtex->tex) {
-                               id_us_min(&mtex->tex->id);
-                               mtex->tex = NULL;
-                       }
-               }
-       }
 
-       BKE_animdata_free(&linestyle->id);
+       MTex *mtex;
+       int a;
 
        for (a = 0; a < MAX_MTEX; a++) {
-               MEM_SAFE_FREE(linestyle->mtex[a]);
+               mtex = linestyle->mtex[a];
+               if (mtex && mtex->tex) mtex->tex->id.us--;
+               if (mtex) MEM_freeN(mtex);
        }
-
-       /* is no lib link block, but linestyle extension */
        if (linestyle->nodetree) {
-               ntreeFreeTree(linestyle->nodetree, true);  /* XXX Or do_id_user? */
+               ntreeFreeTree(linestyle->nodetree);
                MEM_freeN(linestyle->nodetree);
-               linestyle->nodetree = NULL;
        }
 
+       BKE_animdata_free(&linestyle->id);
        while ((m = (LineStyleModifier *)linestyle->color_modifiers.first))
                BKE_linestyle_color_modifier_remove(linestyle, m);
        while ((m = (LineStyleModifier *)linestyle->alpha_modifiers.first))
@@ -177,7 +158,7 @@ FreestyleLineStyle *BKE_linestyle_copy(struct Main *bmain, FreestyleLineStyle *l
        int a;
 
        new_linestyle = BKE_linestyle_new(bmain, linestyle->id.name + 2);
-       BKE_linestyle_free(new_linestyle, true);
+       BKE_linestyle_free(new_linestyle);
 
        for (a = 0; a < MAX_MTEX; a++) {
                if (linestyle->mtex[a]) {
index 62a2b73a971042fd02b9c78fbbc164fe024560b8..141597e859c41710a7369d724ba22da37745bd1b 100644 (file)
@@ -1016,22 +1016,13 @@ void BKE_mask_layer_free_list(ListBase *masklayers)
        }
 }
 
-/**
- * Free (or release) any data used by this mask (does not free the mask itself).
- *
- * \param mask The mask to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this mask are 'released'
- *                   (their user count is decreased).
- */
-void BKE_mask_free(Mask *mask, const bool UNUSED(do_id_user))
+/** free for temp copy, but don't manage unlinking from other pointers */
+void BKE_mask_free_nolib(Mask *mask)
 {
-       BKE_animdata_free((ID *)mask);
-
-       /* free mask data */
        BKE_mask_layer_free_list(&mask->masklayers);
 }
 
-void BKE_mask_unlink(Main *bmain, Mask *mask)
+void BKE_mask_free(Main *bmain, Mask *mask)
 {
        bScreen *scr;
        ScrArea *area;
@@ -1082,6 +1073,9 @@ void BKE_mask_unlink(Main *bmain, Mask *mask)
        FOREACH_NODETREE(bmain, ntree, id) {
                BKE_node_tree_unlink_id((ID *)mask, ntree);
        } FOREACH_NODETREE_END
+
+       /* free mask data */
+       BKE_mask_layer_free_list(&mask->masklayers);
 }
 
 void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2])
index 300485c2c0ae034a4ddc149ae8eb7fb2b23aa9f7..3e7e98b4a1d03fa4822fdd1adcc7489ff514b28c 100644 (file)
@@ -81,54 +81,45 @@ void init_def_material(void)
        init_material(&defmaterial);
 }
 
-/**
- * Free (or release) any data used by this material (does not free the material itself).
- *
- * \param ma The material to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this material are 'released'
- *                   (their user count is decreased).
- */
-void BKE_material_free(Material *ma, const bool do_id_user)
+/* not material itself */
+void BKE_material_free(Material *ma)
 {
-       int a;
-
-       if (do_id_user)  {
-               MTex *mtex;
-
-               for (a = 0; a < MAX_MTEX; a++) {
-                       mtex = ma->mtex[a];
-                       if (mtex && mtex->tex) {
-                               id_us_min(&mtex->tex->id);
-                               mtex->tex = NULL;
-                       }
-               }
-
-               /* No ID refcount here... */
-               ma->group = NULL;
-       }
+       BKE_material_free_ex(ma, true);
+}
 
-       BKE_animdata_free((ID *)ma);
+/* not material itself */
+void BKE_material_free_ex(Material *ma, bool do_id_user)
+{
+       MTex *mtex;
+       int a;
        
        for (a = 0; a < MAX_MTEX; a++) {
-               MEM_SAFE_FREE(ma->mtex[a]);
+               mtex = ma->mtex[a];
+               if (do_id_user && mtex && mtex->tex) mtex->tex->id.us--;
+               if (mtex) MEM_freeN(mtex);
        }
        
-       MEM_SAFE_FREE(ma->ramp_col);
-       MEM_SAFE_FREE(ma->ramp_spec);
+       if (ma->ramp_col) MEM_freeN(ma->ramp_col);
+       if (ma->ramp_spec) MEM_freeN(ma->ramp_spec);
+       
+       BKE_animdata_free((ID *)ma);
+       
+       if (ma->preview)
+               BKE_previewimg_free(&ma->preview);
+       BKE_icon_id_delete((struct ID *)ma);
+       ma->id.icon_id = 0;
        
        /* is no lib link block, but material extension */
        if (ma->nodetree) {
-               ntreeFreeTree(ma->nodetree, do_id_user);
+               ntreeFreeTree_ex(ma->nodetree, do_id_user);
                MEM_freeN(ma->nodetree);
-               ma->nodetree = NULL;
        }
 
-       MEM_SAFE_FREE(ma->texpaintslot);
-
-       GPU_material_free(&ma->gpumaterial);
+       if (ma->texpaintslot)
+               MEM_freeN(ma->texpaintslot);
 
-       BKE_icon_id_delete((ID *)ma);
-       BKE_previewimg_free(&ma->preview);
+       if (ma->gpumaterial.first)
+               GPU_material_free(&ma->gpumaterial);
 }
 
 void init_material(Material *ma)
@@ -1766,7 +1757,7 @@ void free_matcopybuf(void)
        matcopybuf.ramp_spec = NULL;
 
        if (matcopybuf.nodetree) {
-               ntreeFreeTree(matcopybuf.nodetree, false);
+               ntreeFreeTree_ex(matcopybuf.nodetree, false);
                MEM_freeN(matcopybuf.nodetree);
                matcopybuf.nodetree = NULL;
        }
@@ -1816,7 +1807,7 @@ void paste_matcopybuf(Material *ma)
        }
 
        if (ma->nodetree) {
-               ntreeFreeTree(ma->nodetree, true);  /* XXX Or do_id_user? */
+               ntreeFreeTree(ma->nodetree);
                MEM_freeN(ma->nodetree);
        }
 
index 89c6a7d00b9d51c910bcf70d722c1fa95db4620d..c09cd1aabdcf51a85c41228276efe44bba2a6261 100644 (file)
 
 /* Functions */
 
-/**
- * Free (or release) any data used by this mball (does not free the mball itself).
- *
- * \param mb The mball to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this mball are 'released'
- *                   (their user count is decreased).
- */
-void BKE_mball_free(MetaBall *mb, const bool do_id_user)
+void BKE_mball_unlink(MetaBall *mb)
 {
-       if (do_id_user) {
-               int a;
+       int a;
        
-               for (a = 0; a < mb->totcol; a++) {
-                       if (mb->mat[a]) {
-                               id_us_min(&mb->mat[a]->id);
-                               mb->mat[a] = NULL;
-                       }
-               }
+       for (a = 0; a < mb->totcol; a++) {
+               if (mb->mat[a]) mb->mat[a]->id.us--;
+               mb->mat[a] = NULL;
        }
-       
-       BKE_animdata_free((ID *)mb);
+}
 
-       MEM_SAFE_FREE(mb->mat);
 
+/* do not free mball itself */
+void BKE_mball_free(MetaBall *mb)
+{
+       BKE_mball_unlink(mb);
+       
+       if (mb->adt) {
+               BKE_animdata_free((ID *)mb);
+               mb->adt = NULL;
+       }
+       if (mb->mat) MEM_freeN(mb->mat);
        BLI_freelistN(&mb->elems);
-       BKE_displist_free(&mb->disp);
+       if (mb->disp.first) BKE_displist_free(&mb->disp);
 }
 
 MetaBall *BKE_mball_add(Main *bmain, const char *name)
index 327025c3e9ada36bdc9a2b77b4a6c2e79b4a8b49..b948ed56c567d84064dd7a6219ef5019468ff244 100644 (file)
@@ -430,38 +430,32 @@ bool BKE_mesh_has_custom_loop_normals(Mesh *me)
  * we need a more generic method, like the expand() functions in
  * readfile.c */
 
-
-/**
- * Free (or release) any data used by this mesh (does not free the mesh itself).
- *
- * \param me The mesh to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this mesh are 'released'
- *                   (their user count is decreased).
- */
-void BKE_mesh_free(Mesh *me, const bool do_id_user)
+void BKE_mesh_unlink(Mesh *me)
 {
-       if (do_id_user) {
-               int a;
+       int a;
        
-               if (me->mat) {
-                       for (a = 0; a < me->totcol; a++) {
-                               if (me->mat[a]) {
-                                       id_us_min(&me->mat[a]->id);
-                                       me->mat[a] = NULL;
-                               }
-                       }
-               }
+       if (me == NULL) return;
 
-               if (me->key) {
-                       id_us_min(&me->key->id);
-                       me->key = NULL;
+       if (me->mat) {
+               for (a = 0; a < me->totcol; a++) {
+                       if (me->mat[a]) me->mat[a]->id.us--;
+                       me->mat[a] = NULL;
                }
-       
-               /* No ID refcount here... */
-               me->texcomesh = NULL;
        }
 
-       BKE_animdata_free(&me->id);
+       if (me->key) {
+               me->key->id.us--;
+       }
+       me->key = NULL;
+       
+       if (me->texcomesh) me->texcomesh = NULL;
+}
+
+/* do not free mesh itself */
+void BKE_mesh_free(Mesh *me, int unlink)
+{
+       if (unlink)
+               BKE_mesh_unlink(me);
 
        CustomData_free(&me->vdata, me->totvert);
        CustomData_free(&me->edata, me->totedge);
@@ -469,10 +463,16 @@ void BKE_mesh_free(Mesh *me, const bool do_id_user)
        CustomData_free(&me->ldata, me->totloop);
        CustomData_free(&me->pdata, me->totpoly);
 
-       MEM_SAFE_FREE(me->mat);
-       MEM_SAFE_FREE(me->bb);
-       MEM_SAFE_FREE(me->mselect);
-       MEM_SAFE_FREE(me->edit_btmesh);
+       if (me->adt) {
+               BKE_animdata_free(&me->id);
+               me->adt = NULL;
+       }
+       
+       if (me->mat) MEM_freeN(me->mat);
+       
+       if (me->bb) MEM_freeN(me->bb);
+       if (me->mselect) MEM_freeN(me->mselect);
+       if (me->edit_btmesh) MEM_freeN(me->edit_btmesh);
 }
 
 static void mesh_tessface_clear_intern(Mesh *mesh, int free_customdata)
index 70d36155ad5db5e98773d733b4026f3de39e4448..432ae32f02b8093ee27ddb812152c0dcff0f3056 100644 (file)
@@ -44,7 +44,6 @@
 #include "MEM_guardedalloc.h"
 
 #include "DNA_constraint_types.h"
-#include "DNA_gpencil_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
 #include "DNA_movieclip_types.h"
@@ -1414,23 +1413,8 @@ void BKE_movieclip_build_proxy_frame_for_ibuf(MovieClip *clip, ImBuf *ibuf, stru
        }
 }
 
-/**
- * Free (or release) any data used by this lamp (does not free the lamp itself).
- *
- * \param la The lamp to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this lamp are 'released'
- *                   (their user count is decreased).
- */
-void BKE_movieclip_free(MovieClip *clip, const bool do_id_user)
+void BKE_movieclip_free(MovieClip *clip)
 {
-       if (do_id_user) {
-               if (clip->gpd) {
-                       id_us_min(&clip->gpd->id);
-                       clip->gpd = NULL;
-               }
-       }
-
-       /* Also frees animdata. */
        free_buffers(clip);
 
        BKE_tracking_free(&clip->tracking);
index b256e11c538ec5d7eeb7c4fda3595179c3649644..c656931d18b0779d46c61406602f76d5f78f4c2d 100644 (file)
@@ -38,7 +38,6 @@
 
 #include "DNA_action_types.h"
 #include "DNA_anim_types.h"
-#include "DNA_gpencil_types.h"
 #include "DNA_lamp_types.h"
 #include "DNA_material_types.h"
 #include "DNA_node_types.h"
@@ -1776,35 +1775,21 @@ static void free_localized_node_groups(bNodeTree *ntree)
        for (node = ntree->nodes.first; node; node = node->next) {
                if (node->type == NODE_GROUP && node->id) {
                        bNodeTree *ngroup = (bNodeTree *)node->id;
-                       ntreeFreeTree(ngroup, false);
+                       ntreeFreeTree_ex(ngroup, false);
                        MEM_freeN(ngroup);
                }
        }
 }
 
-/**
- * Free (or release) any data used by this nodetree (does not free the nodetree itself).
- *
- * \param ntree The nodetree to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this nodetree are 'released'
- *                   (their user count is decreased).
- */
-void ntreeFreeTree(bNodeTree *ntree, const bool do_id_user)
+/* do not free ntree itself here, BKE_libblock_free calls this function too */
+void ntreeFreeTree_ex(bNodeTree *ntree, const bool do_id_user)
 {
        bNodeTree *tntree;
        bNode *node, *next;
        bNodeSocket *sock, *nextsock;
-
-       if (do_id_user) {
-               if (ntree->gpd) {
-                       id_us_min(&ntree->gpd->id);
-                       ntree->gpd = NULL;
-               }
-               /* XXX See comment below about id used by nodes... */
-       }
-
-       BKE_animdata_free((ID *)ntree);
-
+       
+       if (ntree == NULL) return;
+       
        /* XXX hack! node trees should not store execution graphs at all.
         * This should be removed when old tree types no longer require it.
         * Currently the execution data for texture nodes remains in the tree
@@ -1828,6 +1813,10 @@ void ntreeFreeTree(bNodeTree *ntree, const bool do_id_user)
        /* unregister associated RNA types */
        ntreeInterfaceTypeFree(ntree);
        
+       BKE_animdata_free((ID *)ntree);
+       
+       id_us_min((ID *)ntree->gpd);
+
        BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
        
        for (node = ntree->nodes.first; node; node = next) {
@@ -1878,6 +1867,11 @@ void ntreeFreeTree(bNodeTree *ntree, const bool do_id_user)
                BKE_libblock_free_data(G.main, &ntree->id);
        }
 }
+/* same as ntreeFreeTree_ex but always manage users */
+void ntreeFreeTree(bNodeTree *ntree)
+{
+       ntreeFreeTree_ex(ntree, true);
+}
 
 void ntreeFreeCache(bNodeTree *ntree)
 {
@@ -2151,7 +2145,7 @@ void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
                if (ntree->typeinfo->local_merge)
                        ntree->typeinfo->local_merge(localtree, ntree);
                
-               ntreeFreeTree(localtree, false);
+               ntreeFreeTree_ex(localtree, false);
                MEM_freeN(localtree);
        }
 }
index 4ef30c06fe5ccf19675acdb1fbadc3587d1a1285..e5f826f670d44beddbcc4ca25d0f538701574f7b 100644 (file)
@@ -40,7 +40,6 @@
 #include "DNA_armature_types.h"
 #include "DNA_camera_types.h"
 #include "DNA_constraint_types.h"
-#include "DNA_gpencil_types.h"
 #include "DNA_group_types.h"
 #include "DNA_key_types.h"
 #include "DNA_lamp_types.h"
@@ -380,63 +379,55 @@ void BKE_object_free_caches(Object *object)
        }
 }
 
-/**
- * Free (or release) any data used by this object (does not free the object itself).
- *
- * \param ob The object to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this object are 'released'
- *                   (their user count is decreased).
- */
-void BKE_object_free(Object *ob, const bool do_id_user)
+/* do not free object itself */
+void BKE_object_free_ex(Object *ob, bool do_id_user)
 {
-       /* Needs valid obdata pointer... */
+       int a;
+       
        BKE_object_free_derived_caches(ob);
-
-       if (do_id_user) {
-               /* Note: This totally ignores indirectly-'linked' datablocks (through constraints, modifiers...).
-                *       That’s fine for now (none of them actually refcount IDs), remap project will rework this deeply anyway. */
-               int a;
-
-               if (ob->data) {
-                       id_us_min((ID *)ob->data);
-                       ob->data = NULL;
-               }
-
-               if (ob->mat) {
-                       for (a = 0; a < ob->totcol; a++) {
-                               if (ob->mat[a]) {
-                                       id_us_min(&ob->mat[a]->id);
-                                       ob->mat[a] = NULL;
-                               }
+       
+       /* disconnect specific data, but not for lib data (might be indirect data, can get relinked) */
+       if (ob->data) {
+               ID *id = ob->data;
+               id->us--;
+               if (id->us == 0 && id->lib == NULL) {
+                       switch (ob->type) {
+                               case OB_MESH:
+                                       BKE_mesh_unlink((Mesh *)id);
+                                       break;
+                               case OB_CURVE:
+                                       BKE_curve_unlink((Curve *)id);
+                                       break;
+                               case OB_MBALL:
+                                       BKE_mball_unlink((MetaBall *)id);
+                                       break;
                        }
                }
+               ob->data = NULL;
+       }
 
-               if (ob->poselib) {
-                       id_us_min(&ob->poselib->id);
-                       ob->poselib = NULL;
-               }
-               if (ob->gpd) {
-                       id_us_min(&ob->gpd->id);
-                       ob->gpd = NULL;
+       if (ob->mat) {
+               for (a = 0; a < ob->totcol; a++) {
+                       if (ob->mat[a]) ob->mat[a]->id.us--;
                }
+               MEM_freeN(ob->mat);
        }
-
-       BKE_animdata_free((ID *)ob);
-
-       MEM_SAFE_FREE(ob->mat);
-       MEM_SAFE_FREE(ob->matbits);
-       MEM_SAFE_FREE(ob->iuser);
-       MEM_SAFE_FREE(ob->bb);
-
-       BLI_freelistN(&ob->defbase);
-       if (ob->pose) {
+       if (ob->matbits) MEM_freeN(ob->matbits);
+       ob->mat = NULL;
+       ob->matbits = NULL;
+       if (ob->iuser) MEM_freeN(ob->iuser);
+       ob->iuser = NULL;
+       if (ob->bb) MEM_freeN(ob->bb); 
+       ob->bb = NULL;
+       if (ob->adt) BKE_animdata_free((ID *)ob);
+       if (ob->poselib) ob->poselib->id.us--;
+       if (ob->gpd) ((ID *)ob->gpd)->us--;
+       if (ob->defbase.first)
+               BLI_freelistN(&ob->defbase);
+       if (ob->pose)
                BKE_pose_free_ex(ob->pose, do_id_user);
-               ob->pose = NULL;
-       }
-       if (ob->mpath) {
+       if (ob->mpath)
                animviz_free_motionpath(ob->mpath);
-               ob->mpath = NULL;
-       }
        BKE_bproperty_free_list(&ob->prop);
        BKE_object_free_modifiers(ob);
        
@@ -450,19 +441,13 @@ void BKE_object_free(Object *ob, const bool do_id_user)
        BKE_rigidbody_free_object(ob);
        BKE_rigidbody_free_constraint(ob);
 
-       if (ob->soft) {
-               sbFree(ob->soft);
-               ob->soft = NULL;
-       }
-       if (ob->bsoft) {
-               bsbFree(ob->bsoft);
-               ob->bsoft = NULL;
-       }
-       GPU_lamp_free(ob);
+       if (ob->soft) sbFree(ob->soft);
+       if (ob->bsoft) bsbFree(ob->bsoft);
+       if (ob->gpulamp.first) GPU_lamp_free(ob);
 
        BKE_sculptsession_free(ob);
 
-       BLI_freelistN(&ob->pc_ids);
+       if (ob->pc_ids.first) BLI_freelistN(&ob->pc_ids);
 
        BLI_freelistN(&ob->lodlevels);
 
@@ -472,12 +457,16 @@ void BKE_object_free(Object *ob, const bool do_id_user)
                if (ob->curve_cache->path)
                        free_path(ob->curve_cache->path);
                MEM_freeN(ob->curve_cache);
-               ob->curve_cache = NULL;
        }
 
        BKE_previewimg_free(&ob->preview);
 }
 
+void BKE_object_free(Object *ob)
+{
+       BKE_object_free_ex(ob, true);
+}
+
 static void unlink_object__unlinkModifierLinks(void *userData, Object *ob, Object **obpoin, int UNUSED(cd_flag))
 {
        Object *unlinkOb = userData;
@@ -489,9 +478,6 @@ static void unlink_object__unlinkModifierLinks(void *userData, Object *ob, Objec
        }
 }
 
-/* XXX Horrific! This pretty much re-does BKE_library_foreach_ID_link() and
- *     BKE_library_callback_free_editor_id_reference_set() & co...
- * TODO This is to be replaced by/merged in more generic 'id-remap' process being worked on in same-named branch... */
 void BKE_object_unlink(Object *ob)
 {
        Main *bmain = G.main;
index 90c07280a61b0fbc1868dcac179666919836a507..06844b09a9b22d1ee69bb962983c57be722893c3 100644 (file)
@@ -298,17 +298,13 @@ void BKE_paint_brush_set(Paint *p, Brush *br)
        }
 }
 
-/**
- * Free (or release) any data used by this paint curve (does not free the pcurve itself).
- *
- * \param pc The paint curve to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this paint curve are 'released'
- *                   (their user count is decreased).
- */
-void BKE_paint_curve_free(PaintCurve *pc, const bool UNUSED(do_id_user))
+void BKE_paint_curve_free(PaintCurve *pc)
 {
-       MEM_SAFE_FREE(pc->points);
-       pc->tot_points = 0;
+       if (pc->points) {
+               MEM_freeN(pc->points);
+               pc->points = NULL;
+               pc->tot_points = 0;
+       }
 }
 
 PaintCurve *BKE_paint_curve_add(Main *bmain, const char *name)
@@ -382,14 +378,7 @@ Palette *BKE_palette_add(Main *bmain, const char *name)
        return palette;
 }
 
-/**
- * Free (or release) any data used by this palette (does not free the palette itself).
- *
- * \param palette The palette to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this palette are 'released'
- *                   (their user count is decreased).
- */
-void BKE_palette_free(Palette *palette, const bool UNUSED(do_id_user))
+void BKE_palette_free(Palette *palette)
 {
        BLI_freelistN(&palette->colors);
 }
index 90c9a71f4ee5e2108d84550555fbc0f1edb9384c..9aacba8d02ec2322f1b776b1d914964a811080fc 100644 (file)
@@ -371,40 +371,12 @@ static void fluid_free_settings(SPHFluidSettings *fluid)
                MEM_freeN(fluid); 
 }
 
-/**
- * Free (or release) any data used by this particle settings (does not free the partsett itself).
- *
- * \param part The particle settings to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this partsett are 'released'
- *                   (their user count is decreased).
- */
-void BKE_particlesettings_free(ParticleSettings *part, const bool do_id_user)
+void BKE_particlesettings_free(ParticleSettings *part)
 {
+       MTex *mtex;
        int a;
-
-       if (do_id_user) {
-               MTex *mtex;
-
-               for (a = 0; a < MAX_MTEX; a++) {
-                       mtex = part->mtex[a];
-                       if (mtex && mtex->tex) {
-                               id_us_min(&mtex->tex->id);
-                               mtex->tex = NULL;
-                       }
-               }
-
-               /* No ID refcount here... */
-               part->dup_group = NULL;
-               part->dup_ob = NULL;
-               part->bb_ob = NULL;
-       }
-
        BKE_animdata_free(&part->id);
        
-       for (a = 0; a < MAX_MTEX; a++) {
-               MEM_SAFE_FREE(part->mtex[a]);
-       }
-
        if (part->clumpcurve)
                curvemapping_free(part->clumpcurve);
        if (part->roughcurve)
@@ -413,13 +385,19 @@ void BKE_particlesettings_free(ParticleSettings *part, const bool do_id_user)
        free_partdeflect(part->pd);
        free_partdeflect(part->pd2);
 
-       MEM_SAFE_FREE(part->effector_weights);
+       if (part->effector_weights)
+               MEM_freeN(part->effector_weights);
 
        BLI_freelistN(&part->dupliweights);
 
        boid_free_settings(part->boids);
        fluid_free_settings(part->fluid);
 
+       for (a = 0; a < MAX_MTEX; a++) {
+               mtex = part->mtex[a];
+               if (mtex && mtex->tex) mtex->tex->id.us--;
+               if (mtex) MEM_freeN(mtex);
+       }
 }
 
 void free_hair(Object *UNUSED(ob), ParticleSystem *psys, int dynamics)
index 8f0437109a5c35ee0150c33ed1f04df52cb236de..1ccc213006ad74b4dc106badbce7f72a21392f6c 100644 (file)
@@ -360,73 +360,41 @@ void BKE_scene_groups_relink(Scene *sce)
                BKE_rigidbody_world_groups_relink(sce->rigidbody_world);
 }
 
-/**
- * Free (or release) any data used by this scene (does not free the scene itself).
- *
- * \param sce The scene to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this scene are 'released'
- *                   (their user count is decreased).
- */
-void BKE_scene_free(Scene *sce, const bool do_id_user)
+/* do not free scene itself */
+void BKE_scene_free(Scene *sce)
 {
+       Base *base;
        SceneRenderLayer *srl;
 
-       if (do_id_user) {
-               Base *base;
-
-               for (base = sce->base.first; base; base = base->next) {
-                       id_us_min(&base->object->id);
-                       base->object = NULL;
-               }
-               /* do not free objects! */
-
-               if (sce->world) {
-                       id_us_min(&sce->world->id);
-                       sce->world = NULL;
-               }
-
-               BLI_assert(sce->obedit == NULL);
+       /* check all sequences */
+       BKE_sequencer_clear_scene_in_allseqs(G.main, sce);
 
-               if (sce->gpd) {
-                       /* XXX TODO Fix This! */
-#if 0     /* removed since this can be invalid memory when freeing everything */
-                       /* since the grease pencil data is freed before the scene.
-                        * since grease pencil data is not (yet?), shared between objects
-                        * its probably safe not to do this, some save and reload will free this. */
-                       id_us_min(&sce->gpd->id);
+       base = sce->base.first;
+       while (base) {
+               base->object->id.us--;
+               base = base->next;
+       }
+       /* do not free objects! */
+       
+       if (sce->gpd) {
+#if 0   /* removed since this can be invalid memory when freeing everything */
+               /* since the grease pencil data is freed before the scene.
+                * since grease pencil data is not (yet?), shared between objects
+                * its probably safe not to do this, some save and reload will free this. */
+               sce->gpd->id.us--;
 #endif
-                       sce->gpd = NULL;
-               }
-
-               /* No ID refcount here... */
-               sce->camera = NULL;
-               sce->set = NULL;
-               sce->clip = NULL;
+               sce->gpd = NULL;
        }
 
-       BKE_animdata_free((ID *)sce);
-
-       /* check all sequences */
-       BKE_sequencer_clear_scene_in_allseqs(G.main, sce);
-
-       sce->basact = NULL;
        BLI_freelistN(&sce->base);
        BKE_sequencer_editing_free(sce);
 
+       BKE_animdata_free((ID *)sce);
        BKE_keyingsets_free(&sce->keyingsets);
-
-       /* is no lib link block, but scene extension */
-       if (sce->nodetree) {
-               ntreeFreeTree(sce->nodetree, do_id_user);
-               MEM_freeN(sce->nodetree);
-               sce->nodetree = NULL;
-       }
-
-       if (sce->rigidbody_world) {
+       
+       if (sce->rigidbody_world)
                BKE_rigidbody_free_world(sce->rigidbody_world);
-               sce->rigidbody_world = NULL;
-       }
-
+       
        if (sce->r.avicodecdata) {
                free_avicodecdata(sce->r.avicodecdata);
                MEM_freeN(sce->r.avicodecdata);
@@ -479,8 +447,15 @@ void BKE_scene_free(Scene *sce, const bool do_id_user)
        if (sce->depsgraph)
                DEG_graph_free(sce->depsgraph);
        
-       MEM_SAFE_FREE(sce->stats);
-       MEM_SAFE_FREE(sce->fps_info);
+       if (sce->nodetree) {
+               ntreeFreeTree(sce->nodetree);
+               MEM_freeN(sce->nodetree);
+       }
+
+       if (sce->stats)
+               MEM_freeN(sce->stats);
+       if (sce->fps_info)
+               MEM_freeN(sce->fps_info);
 
        BKE_sound_destroy_scene(sce);
 
index 4dd67f5ecff2bd6fcd0b97372e66dcb23687cf2d..7401ef28f62808afcc3d70bda624304be61daf63 100644 (file)
@@ -357,19 +357,11 @@ void BKE_screen_area_free(ScrArea *sa)
        BLI_freelistN(&sa->actionzones);
 }
 
-/**
- * Free (or release) any data used by this screen (does not free the screen itself).
- *
- * \param sc The screen to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this screen are 'released'
- *                   (their user count is decreased).
- */
-void BKE_screen_free(bScreen *sc, const bool UNUSED(do_id_user))
+/* don't free screen itself */
+void BKE_screen_free(bScreen *sc)
 {
        ScrArea *sa, *san;
        ARegion *ar;
-
-       /* No animdata here. */
        
        for (ar = sc->regionbase.first; ar; ar = ar->next)
                BKE_area_region_free(NULL, ar);
index fe197fb4122291e78d50588a7b0e0ef961c128bb..fc8fa616d208be5bd11a3d3d48c3e01ff8fb1b86 100644 (file)
@@ -3036,7 +3036,7 @@ static ImBuf *seq_render_mask(const SeqRenderData *context, Mask *mask, float nr
 
                BKE_maskrasterize_handle_init(mr_handle, mask_temp, context->rectx, context->recty, true, true, true);
 
-               BKE_mask_free(mask_temp, false);
+               BKE_mask_free_nolib(mask_temp);
                MEM_freeN(mask_temp);
 
                BKE_maskrasterize_buffer(mr_handle, context->rectx, context->recty, maskbuf);
@@ -5026,7 +5026,7 @@ Sequence *BKE_sequencer_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoad
        info = AUD_getInfo(sound->playback_handle);
 
        if (info.specs.channels == AUD_CHANNELS_INVALID) {
-               BKE_libblock_free(bmain, sound);
+               BKE_sound_delete(bmain, sound);
 #if 0
                if (op)
                        BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
index 53d6d8b5d10407eae77c8512c4276813a554861f..7e7cc8745fde1a7465a1d3ebf0e64ef2eeab9b8e 100644 (file)
@@ -123,17 +123,8 @@ bSound *BKE_sound_new_file_exists(struct Main *bmain, const char *filepath)
        return BKE_sound_new_file_exists_ex(bmain, filepath, NULL);
 }
 
-/**
- * Free (or release) any data used by this sound (does not free the sound itself).
- *
- * \param sound The sound to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this sound are 'released'
- *                   (their user count is decreased).
- */
-void BKE_sound_free(bSound *sound, const bool UNUSED(do_id_user))
+void BKE_sound_free(bSound *sound)
 {
-       /* No animdata here. */
-
        if (sound->packedfile) {
                freePackedFile(sound->packedfile);
                sound->packedfile = NULL;
@@ -157,7 +148,8 @@ void BKE_sound_free(bSound *sound, const bool UNUSED(do_id_user))
                BLI_spin_end(sound->spinlock);
                MEM_freeN(sound->spinlock);
                sound->spinlock = NULL;
-       }       
+       }
+       
 #endif  /* WITH_AUDASPACE */
 }
 
@@ -323,6 +315,15 @@ bSound *BKE_sound_new_limiter(struct Main *bmain, bSound *source, float start, f
 }
 #endif
 
+void BKE_sound_delete(struct Main *bmain, bSound *sound)
+{
+       if (sound) {
+               BKE_sound_free(sound);
+
+               BKE_libblock_free(bmain, sound);
+       }
+}
+
 void BKE_sound_cache(bSound *sound)
 {
        sound->flags |= SOUND_FLAGS_CACHING;
index 96a6dc35a1afdefaf265c558b4d79869a6708490..7a800555144294300828dfadbd457e7d4484fec8 100644 (file)
@@ -125,21 +125,10 @@ void BKE_speaker_make_local(Speaker *spk)
        }
 }
 
-/**
- * Free (or release) any data used by this speaker (does not free the speaker itself).
- *
- * \param spk The speaker to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this speaker are 'released'
- *                   (their user count is decreased).
- */
-void BKE_speaker_free(Speaker *spk, const bool do_id_user)
+void BKE_speaker_free(Speaker *spk)
 {
-       if (do_id_user) {
-               if (spk->sound) {
-                       id_us_min(&spk->sound->id);
-                       spk->sound = NULL;
-               }
-       }
+       if (spk->sound)
+               spk->sound->id.us--;
 
        BKE_animdata_free((ID *)spk);
 }
index d5d2e169aa3eb366cea84e3269829d213fae3be4..77d6043d6f35015c064a60c528262621e71d36bf 100644 (file)
@@ -152,19 +152,10 @@ static void init_undo_text(Text *text)
        text->undo_buf = MEM_mallocN(text->undo_len, "undo buf");
 }
 
-/**
- * Free (or release) any data used by this text (does not free the text itself).
- *
- * \param text The text to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this text are 'released'
- *                   (their user count is decreased).
- */
-void BKE_text_free(Text *text, const bool UNUSED(do_id_user))
+void BKE_text_free(Text *text)
 {
        TextLine *tmp;
 
-       /* No animdata here. */
-
        for (tmp = text->lines.first; tmp; tmp = tmp->next) {
                MEM_freeN(tmp->line);
                if (tmp->format)
@@ -173,10 +164,10 @@ void BKE_text_free(Text *text, const bool UNUSED(do_id_user))
        
        BLI_freelistN(&text->lines);
 
-       MEM_SAFE_FREE(text->name);
-       MEM_SAFE_FREE(text->undo_buf);
+       if (text->name) MEM_freeN(text->name);
+       MEM_freeN(text->undo_buf);
 #ifdef WITH_PYTHON
-       BPY_text_free_code(text);
+       if (text->compiled) BPY_text_free_code(text);
 #endif
 }
 
index ef1863e555be7f89637e7c0b126277beea565a0b..88a412d5e95d8f40bb4588f1bc2b64eeafc5c8ec 100644 (file)
@@ -557,51 +557,23 @@ int colorband_element_remove(struct ColorBand *coba, int index)
 
 /* ******************* TEX ************************ */
 
-/**
- * Free (or release) any data used by this texture (does not free the texure itself).
- *
- * \param te The texure to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this texture are 'released'
- *                   (their user count is decreased).
- */
-void BKE_texture_free(Tex *tex, const bool do_id_user)
+void BKE_texture_free(Tex *tex)
 {
-       if (do_id_user) {
-               if (tex->ima) {
-                       id_us_min(&tex->ima->id);
-                       tex->ima = NULL;
-               }
-       }
-
-       BKE_animdata_free((ID *)tex);
-
-       /* is no lib link block, but texture extension */
+       if (tex->coba) MEM_freeN(tex->coba);
+       if (tex->env) BKE_texture_envmap_free(tex->env);
+       if (tex->pd) BKE_texture_pointdensity_free(tex->pd);
+       if (tex->vd) BKE_texture_voxeldata_free(tex->vd);
+       if (tex->ot) BKE_texture_ocean_free(tex->ot);
+       BKE_animdata_free((struct ID *)tex);
+       
+       BKE_previewimg_free(&tex->preview);
+       BKE_icon_id_delete((struct ID *)tex);
+       tex->id.icon_id = 0;
+       
        if (tex->nodetree) {
-               ntreeFreeTree(tex->nodetree, do_id_user);
+               ntreeFreeTree(tex->nodetree);
                MEM_freeN(tex->nodetree);
-               tex->nodetree = NULL;
        }
-
-       MEM_SAFE_FREE(tex->coba);
-       if (tex->env) {
-               BKE_texture_envmap_free(tex->env);
-               tex->env = NULL;
-       }
-       if (tex->pd) {
-               BKE_texture_pointdensity_free(tex->pd);
-               tex->pd = NULL;
-       }
-       if (tex->vd) {
-               BKE_texture_voxeldata_free(tex->vd);
-               tex->vd = NULL;
-       }
-       if (tex->ot) {
-               BKE_texture_ocean_free(tex->ot);
-               tex->ot = NULL;
-       }
-       
-       BKE_icon_id_delete((ID *)tex);
-       BKE_previewimg_free(&tex->preview);
 }
 
 /* ------------------------------------------------------------------------- */
index 95fa0679a99ee6e38f3a8e7eb74ca479bacf1705..e4736b1f54c5fe1bc09a43502fff943df12ba142 100644 (file)
 
 #include "GPU_material.h"
 
-/**
- * Free (or release) any data used by this world (does not free the world itself).
- *
- * \param wrld The world to free.
- * \param do_id_user When \a true, ID datablocks used (referenced) by this world are 'released'
- *                   (their user count is decreased).
- */
-void BKE_world_free(World *wrld, const bool do_id_user)
+void BKE_world_free_ex(World *wrld, bool do_id_user)
 {
+       MTex *mtex;
        int a;
-
-       if (do_id_user) {
-               MTex *mtex;
-
-               for (a = 0; a < MAX_MTEX; a++) {
-                       mtex = wrld->mtex[a];
-                       if (mtex && mtex->tex) {
-                               id_us_min(&mtex->tex->id);
-                               mtex->tex = NULL;
-                       }
-               }
+       
+       for (a = 0; a < MAX_MTEX; a++) {
+               mtex = wrld->mtex[a];
+               if (do_id_user && mtex && mtex->tex) mtex->tex->id.us--;
+               if (mtex) MEM_freeN(mtex);
        }
+       BKE_previewimg_free(&wrld->preview);
 
        BKE_animdata_free((ID *)wrld);
 
-       for (a = 0; a < MAX_MTEX; a++) {
-               MEM_SAFE_FREE(wrld->mtex[a]);
-       }
-
        /* is no lib link block, but world extension */
        if (wrld->nodetree) {
-               ntreeFreeTree(wrld->nodetree, do_id_user);
+               ntreeFreeTree_ex(wrld->nodetree, do_id_user);
                MEM_freeN(wrld->nodetree);
-               wrld->nodetree = NULL;
        }
 
-       GPU_material_free(&wrld->gpumaterial);
+       if (wrld->gpumaterial.first)
+               GPU_material_free(&wrld->gpumaterial);
        
        BKE_icon_id_delete((struct ID *)wrld);
-       BKE_previewimg_free(&wrld->preview);
+       wrld->id.icon_id = 0;
+}
+
+void BKE_world_free(World *wrld)
+{
+       BKE_world_free_ex(wrld, true);
 }
 
 World *add_world(Main *bmain, const char *name)
index 5202134833e17a7d80a12fdce57aaca1a3aac6cd..220b4e908a613cf6bfae17a70087e055345a53fe 100644 (file)
@@ -94,7 +94,7 @@ void MaskOperation::initExecution()
                                frame_iter += frame_step;
                        }
 
-                       BKE_mask_free(mask_temp, false);
+                       BKE_mask_free_nolib(mask_temp);
                        MEM_freeN(mask_temp);
                }
        }
index eaa0cd5563c0e76a283769b0eef2249e6de6b567..34e640a4b7baf1ea81c66c6dbedd3ac4cfc3cd66 100644 (file)
@@ -140,7 +140,7 @@ void gpencil_undo_push(bGPdata *gpd)
                         */
                        undo_node->gpd->adt = NULL;
                        
-                       BKE_gpencil_free(undo_node->gpd, false);
+                       BKE_gpencil_free(undo_node->gpd);
                        MEM_freeN(undo_node->gpd);
                        
                        BLI_freelinkN(&undo_nodes, undo_node);
@@ -168,7 +168,7 @@ void gpencil_undo_finish(void)
                 */
                undo_node->gpd->adt = NULL;
                
-               BKE_gpencil_free(undo_node->gpd, false);
+               BKE_gpencil_free(undo_node->gpd);
                MEM_freeN(undo_node->gpd);
                
                undo_node = undo_node->next;
index 736fef58a096fe343e593d5a2ca34153db4e5937..c101b416169a12a15b1d07e9aa81f1b65b937a60 100644 (file)
@@ -591,7 +591,7 @@ static void free_undo(void *me_v)
 {
        Mesh *me = me_v;
        if (me->key) {
-               BKE_key_free(me->key, false);
+               BKE_key_free(me->key);
                MEM_freeN(me->key);
        }
 
index 9525e88bd6ffc4815def814436413c240438b3fa..2491685161c0e2f6fd29fe935fa63b784990e54f 100644 (file)
@@ -552,7 +552,7 @@ int join_mesh_exec(bContext *C, wmOperator *op)
                }
 #endif
                
-               BKE_key_free(nkey, true);
+               BKE_key_free(nkey);
                BLI_remlink(&bmain->key, nkey);
                MEM_freeN(nkey);
        }
index 575faa5703367f858e7f8316cf960f09e19098a2..6dfd2b31d3043113c333963ac21e2bbbe9178e09 100644 (file)
@@ -828,7 +828,7 @@ static void shader_preview_free(void *customdata)
                /* get rid of copied material */
                BLI_remlink(&pr_main->mat, sp->matcopy);
                
-               BKE_material_free(sp->matcopy, false);
+               BKE_material_free_ex(sp->matcopy, false);
 
                properties = IDP_GetProperties((ID *)sp->matcopy, false);
                if (properties) {
@@ -844,7 +844,7 @@ static void shader_preview_free(void *customdata)
                
                /* get rid of copied texture */
                BLI_remlink(&pr_main->tex, sp->texcopy);
-               BKE_texture_free(sp->texcopy, false);
+               BKE_texture_free(sp->texcopy);
                
                properties = IDP_GetProperties((ID *)sp->texcopy, false);
                if (properties) {
@@ -860,7 +860,7 @@ static void shader_preview_free(void *customdata)
                
                /* get rid of copied world */
                BLI_remlink(&pr_main->world, sp->worldcopy);
-               BKE_world_free(sp->worldcopy, true); /* [#32865] - we need to unlink the texture copies, unlike for materials */
+               BKE_world_free_ex(sp->worldcopy, true); /* [#32865] - we need to unlink the texture copies, unlike for materials */
                
                properties = IDP_GetProperties((ID *)sp->worldcopy, false);
                if (properties) {
@@ -876,7 +876,7 @@ static void shader_preview_free(void *customdata)
                
                /* get rid of copied lamp */
                BLI_remlink(&pr_main->lamp, sp->lampcopy);
-               BKE_lamp_free(sp->lampcopy, true);
+               BKE_lamp_free(sp->lampcopy);
                
                properties = IDP_GetProperties((ID *)sp->lampcopy, false);
                if (properties) {
index f368f786a464ed786b736106cfb582c5227aca44..1a1cc8894e631aad7fb7a345a1f8b0a808379646 100644 (file)
@@ -494,7 +494,7 @@ static void screen_copy(bScreen *to, bScreen *from)
        ScrArea *sa, *saf;
        
        /* free contents of 'to', is from blenkernel screen.c */
-       BKE_screen_free(to, false);
+       BKE_screen_free(to);
        
        BLI_duplicatelist(&to->vertbase, &from->vertbase);
        BLI_duplicatelist(&to->edgebase, &from->edgebase);
@@ -1903,7 +1903,7 @@ ScrArea *ED_screen_state_toggle(bContext *C, wmWindow *win, ScrArea *sa, const s
 
                ED_screen_set(C, sc);
 
-               BKE_screen_free(oldscreen, false);
+               BKE_screen_free(oldscreen);
                BKE_libblock_free(CTX_data_main(C), oldscreen);
 
                /* After we've restored back to SCREENNORMAL, we have to wait with
index d34f57577be50de65c92fb9de584fb8cbc36bb6f..f8d84cc0276c1ac4fd9800642202b951fa509db2 100644 (file)
@@ -116,7 +116,7 @@ static int sound_open_exec(bContext *C, wmOperator *op)
        info = AUD_getInfo(sound->playback_handle);
 
        if (info.specs.channels == AUD_CHANNELS_INVALID) {
-               BKE_libblock_free(bmain, sound);
+               BKE_sound_delete(bmain, sound);
                if (op->customdata) MEM_freeN(op->customdata);
                BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
                return OPERATOR_CANCELLED;
index cdbdf48f1ba25ba00a27e7c9ea66012444559725..b57f95db4e6af11930e82be624a5609b350a5b0a 100644 (file)
@@ -623,7 +623,7 @@ static bool node_group_make_test_selected(bNodeTree *ntree, bNode *gnode, const
        }
        
        /* free local pseudo node tree again */
-       ntreeFreeTree(ngroup, true);
+       ntreeFreeTree(ngroup);
        MEM_freeN(ngroup);
        if (!ok)
                return false;
index fdb5d952e30282b21e5832d375d3650249c706c8..5a0da0b76517fa9c2ac9f010d1c27c908703fabb 100644 (file)
@@ -733,7 +733,7 @@ static Mask *rna_Main_mask_new(Main *bmain, const char *name)
 static void rna_Main_masks_remove(Main *bmain, PointerRNA *mask_ptr)
 {
        Mask *mask = mask_ptr->data;
-       BKE_mask_unlink(bmain, mask);
+       BKE_mask_free(bmain, mask);
        BKE_libblock_free(bmain, mask);
        RNA_POINTER_INVALIDATE(mask_ptr);
 }
@@ -742,6 +742,7 @@ static void rna_Main_grease_pencil_remove(Main *bmain, ReportList *reports, Poin
 {
        bGPdata *gpd = gpd_ptr->data;
        if (ID_REAL_USERS(gpd) <= 0) {
+               BKE_gpencil_free(gpd);
                BKE_libblock_free(bmain, gpd);
                RNA_POINTER_INVALIDATE(gpd_ptr);
        }
index c3dbe2b5fe383e6af7f223acd6804f0e9729c327..c4ec55c8d06f543f0a54a64e36acac0f9f469349 100644 (file)
@@ -209,7 +209,7 @@ void ntreeGPUMaterialNodes(bNodeTree *ntree, GPUMaterial *mat, short compatibili
        ntreeExecGPUNodes(exec, mat, 1, compatibility);
        ntreeShaderEndExecTree(exec);
 
-       ntreeFreeTree(localtree, false);
+       ntreeFreeTree_ex(localtree, false);
        MEM_freeN(localtree);
 }
 
index 2f3f69a7245fa3cf044dabab2af3d0211e22f443..b282ec0593e12e4ab9f95f1e0762e6e683112056 100644 (file)
@@ -3655,8 +3655,7 @@ void RE_free_sample_material(Material *mat)
                        MTex *mtex= mat->mtex[tex_nr];
        
                        if (mtex->tex) {
-                               /* don't update user counts as we are freeing a duplicate */
-                               BKE_texture_free(mtex->tex, false);
+                               BKE_texture_free(mtex->tex);
                                MEM_freeN(mtex->tex);
                                mtex->tex = NULL;
                        }
@@ -3664,7 +3663,7 @@ void RE_free_sample_material(Material *mat)
        }
 
        /* don't update user counts as we are freeing a duplicate */
-       BKE_material_free(mat, false);
+       BKE_material_free_ex(mat, false);
        MEM_freeN(mat);
 }