use 'bool' for BLI_/BKE_ functions.
This commit is contained in:
Campbell Barton
parent
ddddb7bab1
commit
221a383366
|
|
@ -66,9 +66,9 @@ void BKE_curve_type_test(struct Object *ob);
|
|||
void BKE_curve_curve_dimension_update(struct Curve *cu);
|
||||
void BKE_curve_texspace_calc(struct Curve *cu);
|
||||
|
||||
int BKE_curve_minmax(struct Curve *cu, float min[3], float max[3]);
|
||||
int BKE_curve_center_median(struct Curve *cu, float cent[3]);
|
||||
int BKE_curve_center_bounds(struct Curve *cu, float cent[3]);
|
||||
bool BKE_curve_minmax(struct Curve *cu, float min[3], float max[3]);
|
||||
bool BKE_curve_center_median(struct Curve *cu, float cent[3]);
|
||||
bool BKE_curve_center_bounds(struct Curve *cu, float cent[3]);
|
||||
void BKE_curve_translate(struct Curve *cu, float offset[3], int do_keys);
|
||||
void BKE_curve_delete_material_index(struct Curve *cu, int index);
|
||||
|
||||
|
|
@ -118,11 +118,11 @@ void BKE_nurb_knot_calc_u(struct Nurb *nu);
|
|||
void BKE_nurb_knot_calc_v(struct Nurb *nu);
|
||||
|
||||
/* nurb checks if they can be drawn, also clamp order func */
|
||||
int BKE_nurb_check_valid_u(struct Nurb *nu);
|
||||
int BKE_nurb_check_valid_v(struct Nurb *nu);
|
||||
bool BKE_nurb_check_valid_u(struct Nurb *nu);
|
||||
bool BKE_nurb_check_valid_v(struct Nurb *nu);
|
||||
|
||||
int BKE_nurb_order_clamp_u(struct Nurb *nu);
|
||||
int BKE_nurb_order_clamp_v(struct Nurb *nu);
|
||||
bool BKE_nurb_order_clamp_u(struct Nurb *nu);
|
||||
bool BKE_nurb_order_clamp_v(struct Nurb *nu);
|
||||
|
||||
void BKE_nurb_direction_switch(struct Nurb *nu);
|
||||
|
||||
|
|
@ -135,4 +135,4 @@ void BKE_nurb_handles_calc(struct Nurb *nu);
|
|||
void BKE_nurb_handles_autocalc(struct Nurb *nu, int flag);
|
||||
void BKE_nurb_handles_test(struct Nurb *nu);
|
||||
|
||||
#endif
|
||||
#endif /* __BKE_CURVE_H__ */
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ typedef struct EditFont {
|
|||
} EditFont;
|
||||
|
||||
|
||||
int BKE_vfont_is_builtin(struct VFont *vfont);
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ int BKE_idcode_from_name(const char *name);
|
|||
* \param code The code to check.
|
||||
* \return Boolean, 0 when non linkable.
|
||||
*/
|
||||
int BKE_idcode_is_linkable(int code);
|
||||
bool BKE_idcode_is_linkable(int code);
|
||||
|
||||
/**
|
||||
* Return if the ID code is a valid ID code.
|
||||
|
|
@ -72,7 +72,7 @@ int BKE_idcode_is_linkable(int code);
|
|||
* \param code The code to check.
|
||||
* \return Boolean, 0 when invalid.
|
||||
*/
|
||||
int BKE_idcode_is_valid(int code);
|
||||
bool BKE_idcode_is_valid(int code);
|
||||
|
||||
/**
|
||||
* Return an ID code and steps the index forward 1.
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ int BKE_add_image_extension_from_type(char *string, const char imtype);
|
|||
char BKE_ftype_to_imtype(const int ftype);
|
||||
int BKE_imtype_to_ftype(const char imtype);
|
||||
|
||||
int BKE_imtype_is_movie(const char imtype);
|
||||
bool BKE_imtype_is_movie(const char imtype);
|
||||
int BKE_imtype_supports_zbuf(const char imtype);
|
||||
int BKE_imtype_supports_compress(const char imtype);
|
||||
int BKE_imtype_supports_quality(const char imtype);
|
||||
|
|
|
|||
|
|
@ -48,8 +48,8 @@ void BKE_mball_make_local(struct MetaBall *mb);
|
|||
void BKE_mball_cubeTable_free(void);
|
||||
|
||||
void BKE_mball_polygonize(struct Scene *scene, struct Object *ob, struct ListBase *dispbase);
|
||||
int BKE_mball_is_basis_for(struct Object *ob1, struct Object *ob2);
|
||||
int BKE_mball_is_basis(struct Object *ob);
|
||||
bool BKE_mball_is_basis_for(struct Object *ob1, struct Object *ob2);
|
||||
bool BKE_mball_is_basis(struct Object *ob);
|
||||
struct Object *BKE_mball_basis_find(struct Scene *scene, struct Object *ob);
|
||||
|
||||
void BKE_mball_texspace_calc(struct Object *ob);
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ void BKE_object_update_base_layer(struct Scene *scene, struct Object *ob);
|
|||
void BKE_object_free(struct Object *ob);
|
||||
void BKE_object_free_display(struct Object *ob);
|
||||
|
||||
int BKE_object_support_modifier_type_check(struct Object *ob, int modifier_type);
|
||||
bool BKE_object_support_modifier_type_check(struct Object *ob, int modifier_type);
|
||||
|
||||
void BKE_object_link_modifiers(struct Object *ob, struct Object *from);
|
||||
void BKE_object_free_modifiers(struct Object *ob);
|
||||
|
|
@ -77,8 +77,8 @@ void BKE_object_make_proxy(struct Object *ob, struct Object *target, struct Obje
|
|||
void BKE_object_copy_proxy_drivers(struct Object *ob, struct Object *target);
|
||||
|
||||
void BKE_object_unlink(struct Object *ob);
|
||||
int BKE_object_exists_check(struct Object *obtest);
|
||||
int BKE_object_is_in_editmode(struct Object *ob);
|
||||
bool BKE_object_exists_check(struct Object *obtest);
|
||||
bool BKE_object_is_in_editmode(struct Object *ob);
|
||||
|
||||
struct Object *BKE_object_add_only_object(struct Main *bmain, int type, const char *name);
|
||||
struct Object *BKE_object_add(struct Scene *scene, int type);
|
||||
|
|
@ -87,8 +87,8 @@ void *BKE_object_obdata_add_from_type(int type);
|
|||
struct Object *BKE_object_copy_ex(struct Main *bmain, struct Object *ob, int copy_caches);
|
||||
struct Object *BKE_object_copy(struct Object *ob);
|
||||
void BKE_object_make_local(struct Object *ob);
|
||||
int BKE_object_is_libdata(struct Object *ob);
|
||||
int BKE_object_obdata_is_libdata(struct Object *ob);
|
||||
bool BKE_object_is_libdata(struct Object *ob);
|
||||
bool BKE_object_obdata_is_libdata(struct Object *ob);
|
||||
|
||||
void BKE_object_scale_to_mat3(struct Object *ob, float mat[3][3]);
|
||||
void BKE_object_rot_to_mat3(struct Object *ob, float mat[3][3], short use_drot);
|
||||
|
|
@ -128,7 +128,7 @@ void BKE_scene_foreach_display_point(struct Scene *scene,
|
|||
const short flag,
|
||||
void (*func_cb)(const float[3], void *), void *user_data);
|
||||
|
||||
int BKE_object_parent_loop_check(const struct Object *parent, const struct Object *ob);
|
||||
bool BKE_object_parent_loop_check(const struct Object *parent, const struct Object *ob);
|
||||
|
||||
void *BKE_object_tfm_backup(struct Object *ob);
|
||||
void BKE_object_tfm_restore(struct Object *ob, void *obtfm_pt);
|
||||
|
|
@ -161,9 +161,11 @@ int BKE_object_insert_ptcache(struct Object *ob);
|
|||
struct KeyBlock *BKE_object_insert_shape_key(struct Scene *scene, struct Object *ob, const char *name, int from_mix);
|
||||
|
||||
bool BKE_object_is_child_recursive(struct Object *ob_parent, struct Object *ob_child);
|
||||
bool BKE_object_is_animated(struct Scene *scene, struct Object *ob);
|
||||
|
||||
/* return ModifierMode flag */
|
||||
int BKE_object_is_modified(struct Scene *scene, struct Object *ob);
|
||||
int BKE_object_is_deform_modified(struct Scene *scene, struct Object *ob);
|
||||
int BKE_object_is_animated(struct Scene *scene, struct Object *ob);
|
||||
|
||||
void BKE_object_relink(struct Object *ob);
|
||||
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ void rewindPackedFile(struct PackedFile *pf);
|
|||
int readPackedFile(struct PackedFile *pf, void *data, int size);
|
||||
|
||||
/* ID should be not NULL, return 1 if there's a packed file */
|
||||
int BKE_pack_check(struct ID *id);
|
||||
bool BKE_pack_check(struct ID *id);
|
||||
/* ID should be not NULL, throws error when ID is Library */
|
||||
void BKE_unpack_id(struct Main *bmain, struct ID *id, struct ReportList *reports, int how);
|
||||
|
||||
|
|
|
|||
|
|
@ -289,10 +289,10 @@ int BKE_sequence_tx_get_final_right(struct Sequence *seq, int metaclip);
|
|||
void BKE_sequence_tx_set_final_left(struct Sequence *seq, int val);
|
||||
void BKE_sequence_tx_set_final_right(struct Sequence *seq, int val);
|
||||
void BKE_sequence_tx_handle_xlimits(struct Sequence *seq, int leftflag, int rightflag);
|
||||
int BKE_sequence_tx_test(struct Sequence *seq);
|
||||
int BKE_sequence_single_check(struct Sequence *seq);
|
||||
bool BKE_sequence_tx_test(struct Sequence *seq);
|
||||
bool BKE_sequence_single_check(struct Sequence *seq);
|
||||
void BKE_sequence_single_fix(struct Sequence *seq);
|
||||
int BKE_sequence_test_overlap(struct ListBase *seqbasep, struct Sequence *test);
|
||||
bool BKE_sequence_test_overlap(struct ListBase *seqbasep, struct Sequence *test);
|
||||
void BKE_sequence_translate(struct Scene *scene, struct Sequence *seq, int delta);
|
||||
void BKE_sequence_sound_init(struct Scene *scene, struct Sequence *seq);
|
||||
struct Sequence *BKE_sequencer_foreground_frame_get(struct Scene *scene, int frame);
|
||||
|
|
@ -301,14 +301,14 @@ struct Sequence *BKE_sequence_metastrip(ListBase *seqbase /* = ed->seqbase */, s
|
|||
|
||||
void BKE_sequencer_offset_animdata(struct Scene *scene, struct Sequence *seq, int ofs);
|
||||
void BKE_sequencer_dupe_animdata(struct Scene *scene, const char *name_src, const char *name_dst);
|
||||
int BKE_sequence_base_shuffle(struct ListBase *seqbasep, struct Sequence *test, struct Scene *evil_scene);
|
||||
int BKE_sequence_base_shuffle_time(ListBase *seqbasep, struct Scene *evil_scene);
|
||||
int BKE_sequence_base_isolated_sel_check(struct ListBase *seqbase);
|
||||
bool BKE_sequence_base_shuffle(struct ListBase *seqbasep, struct Sequence *test, struct Scene *evil_scene);
|
||||
bool BKE_sequence_base_shuffle_time(ListBase *seqbasep, struct Scene *evil_scene);
|
||||
bool BKE_sequence_base_isolated_sel_check(struct ListBase *seqbase);
|
||||
void BKE_sequencer_free_imbuf(struct Scene *scene, struct ListBase *seqbasep, int for_render);
|
||||
struct Sequence *BKE_sequence_dupli_recursive(struct Scene *scene, struct Scene *scene_to, struct Sequence *seq, int dupe_flag);
|
||||
int BKE_sequence_swap(struct Sequence *seq_a, struct Sequence *seq_b, const char **error_str);
|
||||
|
||||
int BKE_sequence_check_depend(struct Sequence *seq, struct Sequence *cur);
|
||||
bool BKE_sequence_check_depend(struct Sequence *seq, struct Sequence *cur);
|
||||
void BKE_sequence_invalidate_cache(struct Scene *scene, struct Sequence *seq);
|
||||
void BKE_sequence_invalidate_dependent(struct Scene *scene, struct Sequence *seq);
|
||||
void BKE_sequence_invalidate_cache_for_modifier(struct Scene *scene, struct Sequence *seq);
|
||||
|
|
@ -320,7 +320,7 @@ void BKE_sequencer_update_sound(struct Scene *scene, struct bSound *sound);
|
|||
|
||||
void BKE_sequence_base_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq);
|
||||
void BKE_sequence_base_dupli_recursive(struct Scene *scene, struct Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag);
|
||||
int BKE_sequence_is_valid_check(struct Sequence *seq);
|
||||
bool BKE_sequence_is_valid_check(struct Sequence *seq);
|
||||
|
||||
void BKE_sequencer_clear_scene_in_allseqs(struct Main *bmain, struct Scene *sce);
|
||||
void BKE_sequencer_clear_movieclip_in_clipboard(struct MovieClip *clip);
|
||||
|
|
@ -419,4 +419,4 @@ int BKE_sequence_supports_modifiers(struct Sequence *seq);
|
|||
struct ImBuf *BKE_sequencer_render_mask_input(SeqRenderData context, int mask_input_type, struct Sequence *mask_sequence, struct Mask *mask_id, int cfra, int make_float);
|
||||
void BKE_sequencer_color_balance_apply(struct StripColorBalance *cb, struct ImBuf *ibuf, float mul, short make_float, struct ImBuf *mask_input);
|
||||
|
||||
#endif /* __BKE_SEQUENCER_H__ */
|
||||
#endif /* __BKE_SEQUENCER_H__ */
|
||||
|
|
|
|||
|
|
@ -3319,76 +3319,76 @@ void BKE_curve_keyVertexTilts_apply(Curve *UNUSED(cu), ListBase *lb, float *key)
|
|||
}
|
||||
}
|
||||
|
||||
int BKE_nurb_check_valid_u(struct Nurb *nu)
|
||||
bool BKE_nurb_check_valid_u(struct Nurb *nu)
|
||||
{
|
||||
if (nu == NULL)
|
||||
return 0;
|
||||
return false;
|
||||
if (nu->pntsu <= 1)
|
||||
return 0;
|
||||
return false;
|
||||
if (nu->type != CU_NURBS)
|
||||
return 1; /* not a nurb, lets assume its valid */
|
||||
return true; /* not a nurb, lets assume its valid */
|
||||
|
||||
if (nu->pntsu < nu->orderu) return 0;
|
||||
if (nu->pntsu < nu->orderu) return false;
|
||||
if (((nu->flag & CU_NURB_CYCLIC) == 0) && (nu->flagu & CU_NURB_BEZIER)) { /* Bezier U Endpoints */
|
||||
if (nu->orderu == 4) {
|
||||
if (nu->pntsu < 5)
|
||||
return 0; /* bezier with 4 orderu needs 5 points */
|
||||
return false; /* bezier with 4 orderu needs 5 points */
|
||||
}
|
||||
else {
|
||||
if (nu->orderu != 3)
|
||||
return 0; /* order must be 3 or 4 */
|
||||
return false; /* order must be 3 or 4 */
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
int BKE_nurb_check_valid_v(struct Nurb *nu)
|
||||
bool BKE_nurb_check_valid_v(struct Nurb *nu)
|
||||
{
|
||||
if (nu == NULL)
|
||||
return 0;
|
||||
return false;
|
||||
if (nu->pntsv <= 1)
|
||||
return 0;
|
||||
return false;
|
||||
if (nu->type != CU_NURBS)
|
||||
return 1; /* not a nurb, lets assume its valid */
|
||||
return true; /* not a nurb, lets assume its valid */
|
||||
|
||||
if (nu->pntsv < nu->orderv)
|
||||
return 0;
|
||||
return false;
|
||||
if (((nu->flag & CU_NURB_CYCLIC) == 0) && (nu->flagv & CU_NURB_BEZIER)) { /* Bezier V Endpoints */
|
||||
if (nu->orderv == 4) {
|
||||
if (nu->pntsv < 5)
|
||||
return 0; /* bezier with 4 orderu needs 5 points */
|
||||
return false; /* bezier with 4 orderu needs 5 points */
|
||||
}
|
||||
else {
|
||||
if (nu->orderv != 3)
|
||||
return 0; /* order must be 3 or 4 */
|
||||
return false; /* order must be 3 or 4 */
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
int BKE_nurb_order_clamp_u(struct Nurb *nu)
|
||||
bool BKE_nurb_order_clamp_u(struct Nurb *nu)
|
||||
{
|
||||
int change = 0;
|
||||
bool change = false;
|
||||
if (nu->pntsu < nu->orderu) {
|
||||
nu->orderu = nu->pntsu;
|
||||
change = 1;
|
||||
change = true;
|
||||
}
|
||||
if (((nu->flagu & CU_NURB_CYCLIC) == 0) && (nu->flagu & CU_NURB_BEZIER)) {
|
||||
CLAMP(nu->orderu, 3, 4);
|
||||
change = 1;
|
||||
change = true;
|
||||
}
|
||||
return change;
|
||||
}
|
||||
|
||||
int BKE_nurb_order_clamp_v(struct Nurb *nu)
|
||||
bool BKE_nurb_order_clamp_v(struct Nurb *nu)
|
||||
{
|
||||
int change = 0;
|
||||
bool change = false;
|
||||
if (nu->pntsv < nu->orderv) {
|
||||
nu->orderv = nu->pntsv;
|
||||
change = 1;
|
||||
change = true;
|
||||
}
|
||||
if (((nu->flagv & CU_NURB_CYCLIC) == 0) && (nu->flagv & CU_NURB_BEZIER)) {
|
||||
CLAMP(nu->orderv, 3, 4);
|
||||
change = 1;
|
||||
change = true;
|
||||
}
|
||||
return change;
|
||||
}
|
||||
|
|
@ -3405,7 +3405,7 @@ ListBase *BKE_curve_nurbs_get(Curve *cu)
|
|||
|
||||
|
||||
/* basic vertex data functions */
|
||||
int BKE_curve_minmax(Curve *cu, float min[3], float max[3])
|
||||
bool BKE_curve_minmax(Curve *cu, float min[3], float max[3])
|
||||
{
|
||||
ListBase *nurb_lb = BKE_curve_nurbs_get(cu);
|
||||
Nurb *nu;
|
||||
|
|
@ -3416,7 +3416,7 @@ int BKE_curve_minmax(Curve *cu, float min[3], float max[3])
|
|||
return (nurb_lb->first != NULL);
|
||||
}
|
||||
|
||||
int BKE_curve_center_median(Curve *cu, float cent[3])
|
||||
bool BKE_curve_center_median(Curve *cu, float cent[3])
|
||||
{
|
||||
ListBase *nurb_lb = BKE_curve_nurbs_get(cu);
|
||||
Nurb *nu;
|
||||
|
|
@ -3454,16 +3454,16 @@ int BKE_curve_center_median(Curve *cu, float cent[3])
|
|||
return (total != 0);
|
||||
}
|
||||
|
||||
int BKE_curve_center_bounds(Curve *cu, float cent[3])
|
||||
bool BKE_curve_center_bounds(Curve *cu, float cent[3])
|
||||
{
|
||||
float min[3], max[3];
|
||||
INIT_MINMAX(min, max);
|
||||
if (BKE_curve_minmax(cu, min, max)) {
|
||||
mid_v3_v3v3(cent, min, max);
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
void BKE_curve_translate(Curve *cu, float offset[3], int do_keys)
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ void BKE_vfont_free(struct VFont *vf)
|
|||
static void *builtin_font_data = NULL;
|
||||
static int builtin_font_size = 0;
|
||||
|
||||
int BKE_vfont_is_builtin(struct VFont *vfont)
|
||||
bool BKE_vfont_is_builtin(struct VFont *vfont)
|
||||
{
|
||||
return (strcmp(vfont->name, FO_BUILTIN_NAME) == 0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,12 +30,13 @@
|
|||
* \ingroup bke
|
||||
*/
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "DNA_ID.h"
|
||||
|
||||
#include "BLI_utildefines.h"
|
||||
|
||||
#include "BKE_idcode.h"
|
||||
|
||||
typedef struct {
|
||||
|
|
@ -105,15 +106,15 @@ static IDType *idtype_from_code(int code)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
int BKE_idcode_is_valid(int code)
|
||||
bool BKE_idcode_is_valid(int code)
|
||||
{
|
||||
return idtype_from_code(code) ? 1 : 0;
|
||||
return idtype_from_code(code) ? true : false;
|
||||
}
|
||||
|
||||
int BKE_idcode_is_linkable(int code)
|
||||
bool BKE_idcode_is_linkable(int code)
|
||||
{
|
||||
IDType *idt = idtype_from_code(code);
|
||||
return idt ? (idt->flags & IDTYPE_FLAGS_ISLINKABLE) : 0;
|
||||
return idt ? ((idt->flags & IDTYPE_FLAGS_ISLINKABLE) != 0) : false;
|
||||
}
|
||||
|
||||
const char *BKE_idcode_to_name(int code)
|
||||
|
|
|
|||
|
|
@ -1042,7 +1042,7 @@ char BKE_ftype_to_imtype(const int ftype)
|
|||
}
|
||||
|
||||
|
||||
int BKE_imtype_is_movie(const char imtype)
|
||||
bool BKE_imtype_is_movie(const char imtype)
|
||||
{
|
||||
switch (imtype) {
|
||||
case R_IMF_IMTYPE_AVIRAW:
|
||||
|
|
@ -1053,9 +1053,9 @@ int BKE_imtype_is_movie(const char imtype)
|
|||
case R_IMF_IMTYPE_THEORA:
|
||||
case R_IMF_IMTYPE_XVID:
|
||||
case R_IMF_IMTYPE_FRAMESERVER:
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
int BKE_imtype_supports_zbuf(const char imtype)
|
||||
|
|
|
|||
|
|
@ -24,13 +24,14 @@
|
|||
* \ingroup bke
|
||||
*/
|
||||
|
||||
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BLI_math_color.h"
|
||||
#include "BLI_math_base.h"
|
||||
|
||||
#include "BKE_image.h"
|
||||
|
||||
#include "BLF_api.h"
|
||||
|
||||
void BKE_image_buf_fill_color(unsigned char *rect, float *rect_float, int width, int height, const float color[4])
|
||||
|
|
|
|||
|
|
@ -439,18 +439,15 @@ float *BKE_mball_make_orco(Object *ob, ListBase *dispbase)
|
|||
* It test last character of Object ID name. If last character
|
||||
* is digit it return 0, else it return 1.
|
||||
*/
|
||||
int BKE_mball_is_basis(Object *ob)
|
||||
bool BKE_mball_is_basis(Object *ob)
|
||||
{
|
||||
int len;
|
||||
|
||||
/* just a quick test */
|
||||
len = strlen(ob->id.name);
|
||||
if (isdigit(ob->id.name[len - 1]) ) return 0;
|
||||
return 1;
|
||||
const int len = strlen(ob->id.name);
|
||||
return (!isdigit(ob->id.name[len - 1]));
|
||||
}
|
||||
|
||||
/* return nonzero if ob1 is a basis mball for ob */
|
||||
int BKE_mball_is_basis_for(Object *ob1, Object *ob2)
|
||||
bool BKE_mball_is_basis_for(Object *ob1, Object *ob2)
|
||||
{
|
||||
int basis1nr, basis2nr;
|
||||
char basis1name[MAX_ID_NAME], basis2name[MAX_ID_NAME];
|
||||
|
|
@ -458,8 +455,12 @@ int BKE_mball_is_basis_for(Object *ob1, Object *ob2)
|
|||
BLI_split_name_num(basis1name, &basis1nr, ob1->id.name + 2, '.');
|
||||
BLI_split_name_num(basis2name, &basis2nr, ob2->id.name + 2, '.');
|
||||
|
||||
if (!strcmp(basis1name, basis2name)) return BKE_mball_is_basis(ob1);
|
||||
else return 0;
|
||||
if (!strcmp(basis1name, basis2name)) {
|
||||
return BKE_mball_is_basis(ob1);
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/* \brief copy some properties from object to other metaball object with same base name
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ void BKE_object_free_modifiers(Object *ob)
|
|||
BKE_object_free_softbody(ob);
|
||||
}
|
||||
|
||||
int BKE_object_support_modifier_type_check(Object *ob, int modifier_type)
|
||||
bool BKE_object_support_modifier_type_check(Object *ob, int modifier_type)
|
||||
{
|
||||
ModifierTypeInfo *mti;
|
||||
|
||||
|
|
@ -194,10 +194,10 @@ int BKE_object_support_modifier_type_check(Object *ob, int modifier_type)
|
|||
if (!((mti->flags & eModifierTypeFlag_AcceptsCVs) ||
|
||||
(ob->type == OB_MESH && (mti->flags & eModifierTypeFlag_AcceptsMesh))))
|
||||
{
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
void BKE_object_link_modifiers(struct Object *ob_dst, struct Object *ob_src)
|
||||
|
|
@ -773,61 +773,61 @@ void BKE_object_unlink(Object *ob)
|
|||
}
|
||||
|
||||
/* actual check for internal data, not context or flags */
|
||||
int BKE_object_is_in_editmode(Object *ob)
|
||||
bool BKE_object_is_in_editmode(Object *ob)
|
||||
{
|
||||
if (ob->data == NULL)
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
if (ob->type == OB_MESH) {
|
||||
Mesh *me = ob->data;
|
||||
if (me->edit_btmesh)
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else if (ob->type == OB_ARMATURE) {
|
||||
bArmature *arm = ob->data;
|
||||
|
||||
if (arm->edbo)
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else if (ob->type == OB_FONT) {
|
||||
Curve *cu = ob->data;
|
||||
|
||||
if (cu->editfont)
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else if (ob->type == OB_MBALL) {
|
||||
MetaBall *mb = ob->data;
|
||||
|
||||
if (mb->editelems)
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else if (ob->type == OB_LATTICE) {
|
||||
Lattice *lt = ob->data;
|
||||
|
||||
if (lt->editlatt)
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else if (ob->type == OB_SURF || ob->type == OB_CURVE) {
|
||||
Curve *cu = ob->data;
|
||||
|
||||
if (cu->editnurb)
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
int BKE_object_exists_check(Object *obtest)
|
||||
bool BKE_object_exists_check(Object *obtest)
|
||||
{
|
||||
Object *ob;
|
||||
|
||||
if (obtest == NULL) return 0;
|
||||
if (obtest == NULL) return false;
|
||||
|
||||
ob = G.main->object.first;
|
||||
while (ob) {
|
||||
if (ob == obtest) return 1;
|
||||
if (ob == obtest) return true;
|
||||
ob = ob->id.next;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* *************************************************** */
|
||||
|
|
@ -1394,24 +1394,24 @@ void BKE_object_make_local(Object *ob)
|
|||
/*
|
||||
* Returns true if the Object is a from an external blend file (libdata)
|
||||
*/
|
||||
int BKE_object_is_libdata(Object *ob)
|
||||
bool BKE_object_is_libdata(Object *ob)
|
||||
{
|
||||
if (!ob) return 0;
|
||||
if (ob->proxy) return 0;
|
||||
if (ob->id.lib) return 1;
|
||||
return 0;
|
||||
if (!ob) return false;
|
||||
if (ob->proxy) return false;
|
||||
if (ob->id.lib) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Returns true if the Object data is a from an external blend file (libdata) */
|
||||
int BKE_object_obdata_is_libdata(Object *ob)
|
||||
bool BKE_object_obdata_is_libdata(Object *ob)
|
||||
{
|
||||
if (!ob) return 0;
|
||||
if (ob->proxy && (ob->data == NULL || ((ID *)ob->data)->lib == NULL)) return 0;
|
||||
if (ob->id.lib) return 1;
|
||||
if (ob->data == NULL) return 0;
|
||||
if (((ID *)ob->data)->lib) return 1;
|
||||
if (!ob) return false;
|
||||
if (ob->proxy && (ob->data == NULL || ((ID *)ob->data)->lib == NULL)) return false;
|
||||
if (ob->id.lib) return true;
|
||||
if (ob->data == NULL) return false;
|
||||
if (((ID *)ob->data)->lib) return true;
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* *************** PROXY **************** */
|
||||
|
|
@ -2623,11 +2623,11 @@ void BKE_object_tfm_restore(Object *ob, void *obtfm_pt)
|
|||
copy_m4_m4(ob->imat, obtfm->imat);
|
||||
}
|
||||
|
||||
int BKE_object_parent_loop_check(const Object *par, const Object *ob)
|
||||
bool BKE_object_parent_loop_check(const Object *par, const Object *ob)
|
||||
{
|
||||
/* test if 'ob' is a parent somewhere in par's parents */
|
||||
if (par == NULL) return 0;
|
||||
if (ob == par) return 1;
|
||||
if (par == NULL) return false;
|
||||
if (ob == par) return true;
|
||||
return BKE_object_parent_loop_check(par->parent, ob);
|
||||
}
|
||||
|
||||
|
|
@ -3192,7 +3192,7 @@ int BKE_object_is_deform_modified(Scene *scene, Object *ob)
|
|||
}
|
||||
|
||||
/* See if an object is using an animated modifier */
|
||||
int BKE_object_is_animated(Scene *scene, Object *ob)
|
||||
bool BKE_object_is_animated(Scene *scene, Object *ob)
|
||||
{
|
||||
ModifierData *md;
|
||||
|
||||
|
|
@ -3201,9 +3201,9 @@ int BKE_object_is_animated(Scene *scene, Object *ob)
|
|||
(modifier_isEnabled(scene, md, eModifierMode_Realtime) ||
|
||||
modifier_isEnabled(scene, md, eModifierMode_Render)))
|
||||
{
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
static void copy_object__forwardModifierLinks(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin)
|
||||
|
|
|
|||
|
|
@ -617,7 +617,7 @@ void unpackAll(Main *bmain, ReportList *reports, int how)
|
|||
}
|
||||
|
||||
/* ID should be not NULL, return 1 if there's a packed file */
|
||||
int BKE_pack_check(ID *id)
|
||||
bool BKE_pack_check(ID *id)
|
||||
{
|
||||
if (GS(id->name) == ID_IM) {
|
||||
Image *ima = (Image *)id;
|
||||
|
|
@ -635,7 +635,7 @@ int BKE_pack_check(ID *id)
|
|||
Library *li = (Library *)id;
|
||||
return li->packedfile != NULL;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* ID should be not NULL */
|
||||
|
|
|
|||
|
|
@ -3062,30 +3062,30 @@ static void free_anim_seq(Sequence *seq)
|
|||
}
|
||||
|
||||
/* check whether sequence cur depends on seq */
|
||||
int BKE_sequence_check_depend(Sequence *seq, Sequence *cur)
|
||||
bool BKE_sequence_check_depend(Sequence *seq, Sequence *cur)
|
||||
{
|
||||
if (cur->seq1 == seq || cur->seq2 == seq || cur->seq3 == seq)
|
||||
return TRUE;
|
||||
return true;
|
||||
|
||||
/* sequences are not intersecting in time, assume no dependency exists between them */
|
||||
if (cur->enddisp < seq->startdisp || cur->startdisp > seq->enddisp)
|
||||
return FALSE;
|
||||
return false;
|
||||
|
||||
/* checking sequence is below reference one, not dependent on it */
|
||||
if (cur->machine < seq->machine)
|
||||
return FALSE;
|
||||
return false;
|
||||
|
||||
/* sequence is not blending with lower machines, no dependency here occurs
|
||||
* check for non-effects only since effect could use lower machines as input
|
||||
*/
|
||||
if ((cur->type & SEQ_TYPE_EFFECT) == 0 &&
|
||||
((cur->blend_mode == SEQ_BLEND_REPLACE) ||
|
||||
(cur->blend_mode == SEQ_TYPE_CROSS && cur->blend_opacity == 100.0f)))
|
||||
((cur->blend_mode == SEQ_BLEND_REPLACE) ||
|
||||
(cur->blend_mode == SEQ_TYPE_CROSS && cur->blend_opacity == 100.0f)))
|
||||
{
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
static void sequence_do_invalidate_dependent(Sequence *seq, ListBase *seqbase)
|
||||
|
|
@ -3291,7 +3291,7 @@ void BKE_sequence_tx_set_final_right(Sequence *seq, int val)
|
|||
|
||||
/* used so we can do a quick check for single image seq
|
||||
* since they work a bit differently to normal image seq's (during transform) */
|
||||
int BKE_sequence_single_check(Sequence *seq)
|
||||
bool BKE_sequence_single_check(Sequence *seq)
|
||||
{
|
||||
return ((seq->len == 1) &&
|
||||
(seq->type == SEQ_TYPE_IMAGE ||
|
||||
|
|
@ -3300,21 +3300,21 @@ int BKE_sequence_single_check(Sequence *seq)
|
|||
}
|
||||
|
||||
/* check if the selected seq's reference unselected seq's */
|
||||
int BKE_sequence_base_isolated_sel_check(ListBase *seqbase)
|
||||
bool BKE_sequence_base_isolated_sel_check(ListBase *seqbase)
|
||||
{
|
||||
Sequence *seq;
|
||||
/* is there more than 1 select */
|
||||
int ok = FALSE;
|
||||
bool ok = false;
|
||||
|
||||
for (seq = seqbase->first; seq; seq = seq->next) {
|
||||
if (seq->flag & SELECT) {
|
||||
ok = TRUE;
|
||||
ok = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (ok == FALSE)
|
||||
return FALSE;
|
||||
if (ok == false)
|
||||
return false;
|
||||
|
||||
/* test relationships */
|
||||
for (seq = seqbase->first; seq; seq = seq->next) {
|
||||
|
|
@ -3322,24 +3322,24 @@ int BKE_sequence_base_isolated_sel_check(ListBase *seqbase)
|
|||
continue;
|
||||
|
||||
if (seq->flag & SELECT) {
|
||||
if ( (seq->seq1 && (seq->seq1->flag & SELECT) == 0) ||
|
||||
(seq->seq2 && (seq->seq2->flag & SELECT) == 0) ||
|
||||
(seq->seq3 && (seq->seq3->flag & SELECT) == 0) )
|
||||
if ((seq->seq1 && (seq->seq1->flag & SELECT) == 0) ||
|
||||
(seq->seq2 && (seq->seq2->flag & SELECT) == 0) ||
|
||||
(seq->seq3 && (seq->seq3->flag & SELECT) == 0) )
|
||||
{
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if ( (seq->seq1 && (seq->seq1->flag & SELECT)) ||
|
||||
(seq->seq2 && (seq->seq2->flag & SELECT)) ||
|
||||
(seq->seq3 && (seq->seq3->flag & SELECT)) )
|
||||
if ((seq->seq1 && (seq->seq1->flag & SELECT)) ||
|
||||
(seq->seq2 && (seq->seq2->flag & SELECT)) ||
|
||||
(seq->seq3 && (seq->seq3->flag & SELECT)) )
|
||||
{
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* use to impose limits when dragging/extending - so impossible situations don't happen
|
||||
|
|
@ -3405,29 +3405,29 @@ void BKE_sequence_single_fix(Sequence *seq)
|
|||
}
|
||||
}
|
||||
|
||||
int BKE_sequence_tx_test(Sequence *seq)
|
||||
bool BKE_sequence_tx_test(Sequence *seq)
|
||||
{
|
||||
return (seq->type < SEQ_TYPE_EFFECT) || (BKE_sequence_effect_get_num_inputs(seq->type) == 0);
|
||||
}
|
||||
|
||||
static int seq_overlap(Sequence *seq1, Sequence *seq2)
|
||||
static bool seq_overlap(Sequence *seq1, Sequence *seq2)
|
||||
{
|
||||
return (seq1 != seq2 && seq1->machine == seq2->machine &&
|
||||
((seq1->enddisp <= seq2->startdisp) || (seq1->startdisp >= seq2->enddisp)) == 0);
|
||||
}
|
||||
|
||||
int BKE_sequence_test_overlap(ListBase *seqbasep, Sequence *test)
|
||||
bool BKE_sequence_test_overlap(ListBase *seqbasep, Sequence *test)
|
||||
{
|
||||
Sequence *seq;
|
||||
|
||||
seq = seqbasep->first;
|
||||
while (seq) {
|
||||
if (seq_overlap(test, seq))
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
seq = seq->next;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -3487,7 +3487,7 @@ Sequence *BKE_sequencer_foreground_frame_get(Scene *scene, int frame)
|
|||
}
|
||||
|
||||
/* return 0 if there werent enough space */
|
||||
int BKE_sequence_base_shuffle(ListBase *seqbasep, Sequence *test, Scene *evil_scene)
|
||||
bool BKE_sequence_base_shuffle(ListBase *seqbasep, Sequence *test, Scene *evil_scene)
|
||||
{
|
||||
int orig_machine = test->machine;
|
||||
test->machine++;
|
||||
|
|
@ -3518,10 +3518,10 @@ int BKE_sequence_base_shuffle(ListBase *seqbasep, Sequence *test, Scene *evil_sc
|
|||
BKE_sequence_translate(evil_scene, test, new_frame - test->start);
|
||||
|
||||
BKE_sequence_calc(evil_scene, test);
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3572,7 +3572,7 @@ static int shuffle_seq_time_offset(Scene *scene, ListBase *seqbasep, char dir)
|
|||
return tot_ofs;
|
||||
}
|
||||
|
||||
int BKE_sequence_base_shuffle_time(ListBase *seqbasep, Scene *evil_scene)
|
||||
bool BKE_sequence_base_shuffle_time(ListBase *seqbasep, Scene *evil_scene)
|
||||
{
|
||||
/* note: seq->tmp is used to tag strips to move */
|
||||
|
||||
|
|
@ -3591,7 +3591,7 @@ int BKE_sequence_base_shuffle_time(ListBase *seqbasep, Scene *evil_scene)
|
|||
}
|
||||
}
|
||||
|
||||
return offset ? 0 : 1;
|
||||
return offset ? false : true;
|
||||
}
|
||||
|
||||
void BKE_sequencer_update_sound_bounds_all(Scene *scene)
|
||||
|
|
@ -4324,7 +4324,7 @@ void BKE_sequence_base_dupli_recursive(Scene *scene, Scene *scene_to, ListBase *
|
|||
|
||||
/* called on draw, needs to be fast,
|
||||
* we could cache and use a flag if we want to make checks for file paths resolving for eg. */
|
||||
int BKE_sequence_is_valid_check(Sequence *seq)
|
||||
bool BKE_sequence_is_valid_check(Sequence *seq)
|
||||
{
|
||||
switch (seq->type) {
|
||||
case SEQ_TYPE_MASK:
|
||||
|
|
@ -4337,6 +4337,6 @@ int BKE_sequence_is_valid_check(Sequence *seq)
|
|||
return (seq->sound != NULL);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ void BLI_ghashIterator_step(GHashIterator *ghi);
|
|||
* \param ghi The iterator.
|
||||
* \return True if done, False otherwise.
|
||||
*/
|
||||
int BLI_ghashIterator_notDone(GHashIterator *ghi);
|
||||
bool BLI_ghashIterator_notDone(GHashIterator *ghi);
|
||||
|
||||
#define GHASH_ITER(gh_iter_, ghash_) \
|
||||
for (BLI_ghashIterator_init(&gh_iter_, ghash_); \
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ GSQueue *BLI_gsqueue_new(int elem_size);
|
|||
/**
|
||||
* Query if the queue is empty
|
||||
*/
|
||||
int BLI_gsqueue_is_empty(GSQueue *gq);
|
||||
bool BLI_gsqueue_is_empty(GSQueue *gq);
|
||||
|
||||
/**
|
||||
* Query number elements in the queue
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ HeapNode *BLI_heap_insert(Heap *heap, float value, void *ptr);
|
|||
void BLI_heap_remove(Heap *heap, HeapNode *node);
|
||||
|
||||
/* Return 0 if the heap is empty, 1 otherwise. */
|
||||
int BLI_heap_is_empty(Heap *heap);
|
||||
bool BLI_heap_is_empty(Heap *heap);
|
||||
|
||||
/* Return the size of the heap. */
|
||||
unsigned int BLI_heap_size(Heap *heap);
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@
|
|||
struct rcti;
|
||||
|
||||
void BLI_lasso_boundbox(struct rcti *rect, const int mcords[][2], const short moves);
|
||||
int BLI_lasso_is_point_inside(const int mcords[][2], const short moves, const int sx, const int sy, const int error_value);
|
||||
int BLI_lasso_is_edge_inside(const int mcords[][2], const short moves, int x0, int y0, int x1, int y1, const int error_value);
|
||||
bool BLI_lasso_is_point_inside(const int mcords[][2], const short moves, const int sx, const int sy, const int error_value);
|
||||
bool BLI_lasso_is_edge_inside(const int mcords[][2], const short moves, int x0, int y0, int x1, int y1, const int error_value);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -43,8 +43,8 @@ struct rcti;
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
int BLI_rcti_is_empty(const struct rcti *rect);
|
||||
int BLI_rctf_is_empty(const struct rctf *rect);
|
||||
bool BLI_rcti_is_empty(const struct rcti *rect);
|
||||
bool BLI_rctf_is_empty(const struct rctf *rect);
|
||||
void BLI_rctf_init(struct rctf *rect, float xmin, float xmax, float ymin, float ymax);
|
||||
void BLI_rcti_init(struct rcti *rect, int xmin, int xmax, int ymin, int ymax);
|
||||
void BLI_rcti_init_minmax(struct rcti *rect);
|
||||
|
|
@ -60,18 +60,18 @@ void BLI_rcti_scale(rcti *rect, const float scale);
|
|||
void BLI_rctf_scale(rctf *rect, const float scale);
|
||||
void BLI_rctf_interp(struct rctf *rect, const struct rctf *rect_a, const struct rctf *rect_b, const float fac);
|
||||
//void BLI_rcti_interp(struct rctf *rect, struct rctf *rect_a, struct rctf *rect_b, float fac);
|
||||
int BLI_rctf_clamp_pt_v(const struct rctf *rect, float xy[2]);
|
||||
int BLI_rcti_clamp_pt_v(const struct rcti *rect, int xy[2]);
|
||||
int BLI_rctf_compare(const struct rctf *rect_a, const struct rctf *rect_b, const float limit);
|
||||
int BLI_rcti_compare(const struct rcti *rect_a, const struct rcti *rect_b);
|
||||
int BLI_rctf_isect(const struct rctf *src1, const struct rctf *src2, struct rctf *dest);
|
||||
int BLI_rcti_isect(const struct rcti *src1, const struct rcti *src2, struct rcti *dest);
|
||||
int BLI_rcti_isect_pt(const struct rcti *rect, const int x, const int y);
|
||||
int BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2]);
|
||||
int BLI_rctf_isect_pt(const struct rctf *rect, const float x, const float y);
|
||||
int BLI_rctf_isect_pt_v(const struct rctf *rect, const float xy[2]);
|
||||
int BLI_rcti_isect_segment(const struct rcti *rect, const int s1[2], const int s2[2]);
|
||||
int BLI_rctf_isect_segment(const struct rctf *rect, const float s1[2], const float s2[2]);
|
||||
bool BLI_rctf_clamp_pt_v(const struct rctf *rect, float xy[2]);
|
||||
bool BLI_rcti_clamp_pt_v(const struct rcti *rect, int xy[2]);
|
||||
bool BLI_rctf_compare(const struct rctf *rect_a, const struct rctf *rect_b, const float limit);
|
||||
bool BLI_rcti_compare(const struct rcti *rect_a, const struct rcti *rect_b);
|
||||
bool BLI_rctf_isect(const struct rctf *src1, const struct rctf *src2, struct rctf *dest);
|
||||
bool BLI_rcti_isect(const struct rcti *src1, const struct rcti *src2, struct rcti *dest);
|
||||
bool BLI_rcti_isect_pt(const struct rcti *rect, const int x, const int y);
|
||||
bool BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2]);
|
||||
bool BLI_rctf_isect_pt(const struct rctf *rect, const float x, const float y);
|
||||
bool BLI_rctf_isect_pt_v(const struct rctf *rect, const float xy[2]);
|
||||
bool BLI_rcti_isect_segment(const struct rcti *rect, const int s1[2], const int s2[2]);
|
||||
bool BLI_rctf_isect_segment(const struct rctf *rect, const float s1[2], const float s2[2]);
|
||||
void BLI_rctf_union(struct rctf *rctf1, const struct rctf *rctf2);
|
||||
void BLI_rcti_union(struct rcti *rcti1, const struct rcti *rcti2);
|
||||
void BLI_rcti_rctf_copy(struct rcti *dst, const struct rctf *src);
|
||||
|
|
|
|||
|
|
@ -271,7 +271,7 @@ void BLI_ghashIterator_step(GHashIterator *ghi)
|
|||
}
|
||||
}
|
||||
}
|
||||
int BLI_ghashIterator_notDone(GHashIterator *ghi)
|
||||
bool BLI_ghashIterator_notDone(GHashIterator *ghi)
|
||||
{
|
||||
return ghi->curEntry != NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,9 +33,10 @@
|
|||
#include <string.h>
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "BLI_utildefines.h"
|
||||
#include "BLI_memarena.h"
|
||||
#include "BLI_heap.h"
|
||||
#include "BLI_utildefines.h"
|
||||
|
||||
/***/
|
||||
|
||||
|
|
@ -183,7 +184,7 @@ HeapNode *BLI_heap_insert(Heap *heap, float value, void *ptr)
|
|||
return node;
|
||||
}
|
||||
|
||||
int BLI_heap_is_empty(Heap *heap)
|
||||
bool BLI_heap_is_empty(Heap *heap)
|
||||
{
|
||||
return (heap->size == 0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,6 +32,8 @@
|
|||
#include <string.h>
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "BLI_utildefines.h"
|
||||
#include "BLI_gsqueue.h"
|
||||
|
||||
typedef struct _GSQueueElem GSQueueElem;
|
||||
|
|
@ -54,7 +56,7 @@ GSQueue *BLI_gsqueue_new(int elem_size)
|
|||
return gq;
|
||||
}
|
||||
|
||||
int BLI_gsqueue_is_empty(GSQueue *gq)
|
||||
bool BLI_gsqueue_is_empty(GSQueue *gq)
|
||||
{
|
||||
return (gq->head == NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,9 +53,9 @@ void BLI_lasso_boundbox(rcti *rect, const int mcords[][2], const short moves)
|
|||
}
|
||||
|
||||
|
||||
int BLI_lasso_is_point_inside(const int mcords[][2], const short moves,
|
||||
const int sx, const int sy,
|
||||
const int error_value)
|
||||
bool BLI_lasso_is_point_inside(const int mcords[][2], const short moves,
|
||||
const int sx, const int sy,
|
||||
const int error_value)
|
||||
{
|
||||
/* we do the angle rule, define that all added angles should be about zero or (2 * PI) */
|
||||
float angletot = 0.0, dot, ang, cross, fp1[2], fp2[2];
|
||||
|
|
@ -63,7 +63,7 @@ int BLI_lasso_is_point_inside(const int mcords[][2], const short moves,
|
|||
const int *p1, *p2;
|
||||
|
||||
if (sx == error_value) {
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
p1 = mcords[moves - 1];
|
||||
|
|
@ -95,35 +95,35 @@ int BLI_lasso_is_point_inside(const int mcords[][2], const short moves,
|
|||
p2 = mcords[a + 1];
|
||||
}
|
||||
|
||||
if (fabsf(angletot) > 4.0f) return 1;
|
||||
return 0;
|
||||
if (fabsf(angletot) > 4.0f) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* edge version for lasso select. we assume boundbox check was done */
|
||||
int BLI_lasso_is_edge_inside(const int mcords[][2], const short moves,
|
||||
int x0, int y0, int x1, int y1,
|
||||
const int error_value)
|
||||
bool BLI_lasso_is_edge_inside(const int mcords[][2], const short moves,
|
||||
int x0, int y0, int x1, int y1,
|
||||
const int error_value)
|
||||
{
|
||||
int v1[2], v2[2];
|
||||
int a;
|
||||
|
||||
if (x0 == error_value || x1 == error_value) {
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
v1[0] = x0, v1[1] = y0;
|
||||
v2[0] = x1, v2[1] = y1;
|
||||
|
||||
/* check points in lasso */
|
||||
if (BLI_lasso_is_point_inside(mcords, moves, v1[0], v1[1], error_value)) return 1;
|
||||
if (BLI_lasso_is_point_inside(mcords, moves, v2[0], v2[1], error_value)) return 1;
|
||||
if (BLI_lasso_is_point_inside(mcords, moves, v1[0], v1[1], error_value)) return true;
|
||||
if (BLI_lasso_is_point_inside(mcords, moves, v2[0], v2[1], error_value)) return true;
|
||||
|
||||
/* no points in lasso, so we have to intersect with lasso edge */
|
||||
|
||||
if (isect_line_line_v2_int(mcords[0], mcords[moves - 1], v1, v2) > 0) return 1;
|
||||
if (isect_line_line_v2_int(mcords[0], mcords[moves - 1], v1, v2) > 0) return true;
|
||||
for (a = 0; a < moves - 1; a++) {
|
||||
if (isect_line_line_v2_int(mcords[a], mcords[a + 1], v1, v2) > 0) return 1;
|
||||
if (isect_line_line_v2_int(mcords[a], mcords[a + 1], v1, v2) > 0) return true;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,23 +48,23 @@
|
|||
*
|
||||
* \return True if \a rect is empty.
|
||||
*/
|
||||
int BLI_rcti_is_empty(const rcti *rect)
|
||||
bool BLI_rcti_is_empty(const rcti *rect)
|
||||
{
|
||||
return ((rect->xmax <= rect->xmin) || (rect->ymax <= rect->ymin));
|
||||
}
|
||||
|
||||
int BLI_rctf_is_empty(const rctf *rect)
|
||||
bool BLI_rctf_is_empty(const rctf *rect)
|
||||
{
|
||||
return ((rect->xmax <= rect->xmin) || (rect->ymax <= rect->ymin));
|
||||
}
|
||||
|
||||
int BLI_rcti_isect_pt(const rcti *rect, const int x, const int y)
|
||||
bool BLI_rcti_isect_pt(const rcti *rect, const int x, const int y)
|
||||
{
|
||||
if (x < rect->xmin) return 0;
|
||||
if (x > rect->xmax) return 0;
|
||||
if (y < rect->ymin) return 0;
|
||||
if (y > rect->ymax) return 0;
|
||||
return 1;
|
||||
if (x < rect->xmin) return false;
|
||||
if (x > rect->xmax) return false;
|
||||
if (y < rect->ymin) return false;
|
||||
if (y > rect->ymax) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -74,31 +74,31 @@ int BLI_rcti_isect_pt(const rcti *rect, const int x, const int y)
|
|||
*
|
||||
* \return True if \a rect is empty.
|
||||
*/
|
||||
int BLI_rcti_isect_pt_v(const rcti *rect, const int xy[2])
|
||||
bool BLI_rcti_isect_pt_v(const rcti *rect, const int xy[2])
|
||||
{
|
||||
if (xy[0] < rect->xmin) return 0;
|
||||
if (xy[0] > rect->xmax) return 0;
|
||||
if (xy[1] < rect->ymin) return 0;
|
||||
if (xy[1] > rect->ymax) return 0;
|
||||
return 1;
|
||||
if (xy[0] < rect->xmin) return false;
|
||||
if (xy[0] > rect->xmax) return false;
|
||||
if (xy[1] < rect->ymin) return false;
|
||||
if (xy[1] > rect->ymax) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
int BLI_rctf_isect_pt(const rctf *rect, const float x, const float y)
|
||||
bool BLI_rctf_isect_pt(const rctf *rect, const float x, const float y)
|
||||
{
|
||||
if (x < rect->xmin) return 0;
|
||||
if (x > rect->xmax) return 0;
|
||||
if (y < rect->ymin) return 0;
|
||||
if (y > rect->ymax) return 0;
|
||||
return 1;
|
||||
if (x < rect->xmin) return false;
|
||||
if (x > rect->xmax) return false;
|
||||
if (y < rect->ymin) return false;
|
||||
if (y > rect->ymax) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
int BLI_rctf_isect_pt_v(const rctf *rect, const float xy[2])
|
||||
bool BLI_rctf_isect_pt_v(const rctf *rect, const float xy[2])
|
||||
{
|
||||
if (xy[0] < rect->xmin) return 0;
|
||||
if (xy[0] > rect->xmax) return 0;
|
||||
if (xy[1] < rect->ymin) return 0;
|
||||
if (xy[1] > rect->ymax) return 0;
|
||||
return 1;
|
||||
if (xy[0] < rect->xmin) return false;
|
||||
if (xy[0] > rect->xmax) return false;
|
||||
if (xy[1] < rect->ymin) return false;
|
||||
if (xy[1] > rect->ymax) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* based closely on 'isect_line_line_v2_int', but in modified so corner cases are treated as intersections */
|
||||
|
|
@ -127,17 +127,17 @@ static int isect_segments_fl(const float v1[2], const float v2[2], const float v
|
|||
}
|
||||
}
|
||||
|
||||
int BLI_rcti_isect_segment(const rcti *rect, const int s1[2], const int s2[2])
|
||||
bool BLI_rcti_isect_segment(const rcti *rect, const int s1[2], const int s2[2])
|
||||
{
|
||||
/* first do outside-bounds check for both points of the segment */
|
||||
if (s1[0] < rect->xmin && s2[0] < rect->xmin) return 0;
|
||||
if (s1[0] > rect->xmax && s2[0] > rect->xmax) return 0;
|
||||
if (s1[1] < rect->ymin && s2[1] < rect->ymin) return 0;
|
||||
if (s1[1] > rect->ymax && s2[1] > rect->ymax) return 0;
|
||||
if (s1[0] < rect->xmin && s2[0] < rect->xmin) return false;
|
||||
if (s1[0] > rect->xmax && s2[0] > rect->xmax) return false;
|
||||
if (s1[1] < rect->ymin && s2[1] < rect->ymin) return false;
|
||||
if (s1[1] > rect->ymax && s2[1] > rect->ymax) return false;
|
||||
|
||||
/* if either points intersect then we definetly intersect */
|
||||
if (BLI_rcti_isect_pt_v(rect, s1) || BLI_rcti_isect_pt_v(rect, s2)) {
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
/* both points are outside but may insersect the rect */
|
||||
|
|
@ -147,32 +147,32 @@ int BLI_rcti_isect_segment(const rcti *rect, const int s1[2], const int s2[2])
|
|||
tvec1[0] = rect->xmin; tvec1[1] = rect->ymin;
|
||||
tvec2[0] = rect->xmin; tvec2[1] = rect->ymax;
|
||||
if (isect_segments_i(s1, s2, tvec1, tvec2)) {
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* diagonal: [\] */
|
||||
tvec1[0] = rect->xmin; tvec1[1] = rect->ymax;
|
||||
tvec2[0] = rect->xmax; tvec2[1] = rect->ymin;
|
||||
if (isect_segments_i(s1, s2, tvec1, tvec2)) {
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* no intersection */
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
int BLI_rctf_isect_segment(const rctf *rect, const float s1[2], const float s2[2])
|
||||
bool BLI_rctf_isect_segment(const rctf *rect, const float s1[2], const float s2[2])
|
||||
{
|
||||
/* first do outside-bounds check for both points of the segment */
|
||||
if (s1[0] < rect->xmin && s2[0] < rect->xmin) return 0;
|
||||
if (s1[0] > rect->xmax && s2[0] > rect->xmax) return 0;
|
||||
if (s1[1] < rect->ymin && s2[1] < rect->ymin) return 0;
|
||||
if (s1[1] > rect->ymax && s2[1] > rect->ymax) return 0;
|
||||
if (s1[0] < rect->xmin && s2[0] < rect->xmin) return false;
|
||||
if (s1[0] > rect->xmax && s2[0] > rect->xmax) return false;
|
||||
if (s1[1] < rect->ymin && s2[1] < rect->ymin) return false;
|
||||
if (s1[1] > rect->ymax && s2[1] > rect->ymax) return false;
|
||||
|
||||
/* if either points intersect then we definetly intersect */
|
||||
if (BLI_rctf_isect_pt_v(rect, s1) || BLI_rctf_isect_pt_v(rect, s2)) {
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
/* both points are outside but may insersect the rect */
|
||||
|
|
@ -182,18 +182,18 @@ int BLI_rctf_isect_segment(const rctf *rect, const float s1[2], const float s2[2
|
|||
tvec1[0] = rect->xmin; tvec1[1] = rect->ymin;
|
||||
tvec2[0] = rect->xmin; tvec2[1] = rect->ymax;
|
||||
if (isect_segments_fl(s1, s2, tvec1, tvec2)) {
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* diagonal: [\] */
|
||||
tvec1[0] = rect->xmin; tvec1[1] = rect->ymax;
|
||||
tvec2[0] = rect->xmax; tvec2[1] = rect->ymin;
|
||||
if (isect_segments_fl(s1, s2, tvec1, tvec2)) {
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* no intersection */
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -353,49 +353,49 @@ void BLI_rctf_interp(rctf *rect, const rctf *rect_a, const rctf *rect_b, const f
|
|||
/* BLI_rcti_interp() not needed yet */
|
||||
|
||||
|
||||
int BLI_rctf_clamp_pt_v(const struct rctf *rect, float xy[2])
|
||||
bool BLI_rctf_clamp_pt_v(const struct rctf *rect, float xy[2])
|
||||
{
|
||||
int change = 0;
|
||||
if (xy[0] < rect->xmin) { xy[0] = rect->xmin; change = 1; }
|
||||
if (xy[0] > rect->xmax) { xy[0] = rect->xmax; change = 1; }
|
||||
if (xy[1] < rect->ymin) { xy[1] = rect->ymin; change = 1; }
|
||||
if (xy[1] > rect->ymax) { xy[1] = rect->ymax; change = 1; }
|
||||
bool change = false;
|
||||
if (xy[0] < rect->xmin) { xy[0] = rect->xmin; change = true; }
|
||||
if (xy[0] > rect->xmax) { xy[0] = rect->xmax; change = true; }
|
||||
if (xy[1] < rect->ymin) { xy[1] = rect->ymin; change = true; }
|
||||
if (xy[1] > rect->ymax) { xy[1] = rect->ymax; change = true; }
|
||||
return change;
|
||||
}
|
||||
|
||||
int BLI_rcti_clamp_pt_v(const struct rcti *rect, int xy[2])
|
||||
bool BLI_rcti_clamp_pt_v(const struct rcti *rect, int xy[2])
|
||||
{
|
||||
int change = 0;
|
||||
if (xy[0] < rect->xmin) { xy[0] = rect->xmin; change = 1; }
|
||||
if (xy[0] > rect->xmax) { xy[0] = rect->xmax; change = 1; }
|
||||
if (xy[1] < rect->ymin) { xy[1] = rect->ymin; change = 1; }
|
||||
if (xy[1] > rect->ymax) { xy[1] = rect->ymax; change = 1; }
|
||||
bool change = false;
|
||||
if (xy[0] < rect->xmin) { xy[0] = rect->xmin; change = true; }
|
||||
if (xy[0] > rect->xmax) { xy[0] = rect->xmax; change = true; }
|
||||
if (xy[1] < rect->ymin) { xy[1] = rect->ymin; change = true; }
|
||||
if (xy[1] > rect->ymax) { xy[1] = rect->ymax; change = true; }
|
||||
return change;
|
||||
}
|
||||
|
||||
int BLI_rctf_compare(const struct rctf *rect_a, const struct rctf *rect_b, const float limit)
|
||||
bool BLI_rctf_compare(const struct rctf *rect_a, const struct rctf *rect_b, const float limit)
|
||||
{
|
||||
if (fabsf(rect_a->xmin - rect_b->xmin) < limit)
|
||||
if (fabsf(rect_a->xmax - rect_b->xmax) < limit)
|
||||
if (fabsf(rect_a->ymin - rect_b->ymin) < limit)
|
||||
if (fabsf(rect_a->ymax - rect_b->ymax) < limit)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
int BLI_rcti_compare(const struct rcti *rect_a, const struct rcti *rect_b)
|
||||
bool BLI_rcti_compare(const struct rcti *rect_a, const struct rcti *rect_b)
|
||||
{
|
||||
if (rect_a->xmin == rect_b->xmin)
|
||||
if (rect_a->xmax == rect_b->xmax)
|
||||
if (rect_a->ymin == rect_b->ymin)
|
||||
if (rect_a->ymax == rect_b->ymax)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
int BLI_rctf_isect(const rctf *src1, const rctf *src2, rctf *dest)
|
||||
bool BLI_rctf_isect(const rctf *src1, const rctf *src2, rctf *dest)
|
||||
{
|
||||
float xmin, xmax;
|
||||
float ymin, ymax;
|
||||
|
|
@ -412,7 +412,7 @@ int BLI_rctf_isect(const rctf *src1, const rctf *src2, rctf *dest)
|
|||
dest->ymin = ymin;
|
||||
dest->ymax = ymax;
|
||||
}
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
if (dest) {
|
||||
|
|
@ -421,11 +421,11 @@ int BLI_rctf_isect(const rctf *src1, const rctf *src2, rctf *dest)
|
|||
dest->ymin = 0;
|
||||
dest->ymax = 0;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
int BLI_rcti_isect(const rcti *src1, const rcti *src2, rcti *dest)
|
||||
bool BLI_rcti_isect(const rcti *src1, const rcti *src2, rcti *dest)
|
||||
{
|
||||
int xmin, xmax;
|
||||
int ymin, ymax;
|
||||
|
|
@ -442,7 +442,7 @@ int BLI_rcti_isect(const rcti *src1, const rcti *src2, rcti *dest)
|
|||
dest->ymin = ymin;
|
||||
dest->ymax = ymax;
|
||||
}
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
if (dest) {
|
||||
|
|
@ -451,7 +451,7 @@ int BLI_rcti_isect(const rcti *src1, const rcti *src2, rcti *dest)
|
|||
dest->ymin = 0;
|
||||
dest->ymax = 0;
|
||||
}
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,12 +26,12 @@
|
|||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "BLI_heap.h"
|
||||
#include "BLI_listbase.h"
|
||||
#include "BLI_math.h"
|
||||
#include "BLI_array.h"
|
||||
#include "BLI_smallhash.h"
|
||||
#include "BLI_rand.h"
|
||||
#include "BLI_heap.h"
|
||||
|
||||
#include "bmesh.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -29,10 +29,10 @@
|
|||
#include "DNA_meshdata_types.h"
|
||||
|
||||
#include "BLI_array.h"
|
||||
#include "BLI_heap.h"
|
||||
#include "BLI_math.h"
|
||||
#include "BLI_math_geom.h"
|
||||
#include "BLI_smallhash.h"
|
||||
#include "BLI_heap.h"
|
||||
|
||||
#include "BKE_customdata.h"
|
||||
#include "BKE_mesh.h"
|
||||
|
|
|
|||
|
|
@ -38,6 +38,8 @@
|
|||
#include "DNA_space_types.h"
|
||||
#include "DNA_object_types.h"
|
||||
|
||||
#include "BLI_math.h"
|
||||
|
||||
#include "BKE_context.h"
|
||||
#include "BKE_brush.h"
|
||||
#include "BKE_main.h"
|
||||
|
|
@ -47,8 +49,6 @@
|
|||
|
||||
#include "ED_screen.h"
|
||||
|
||||
#include "BLI_math.h"
|
||||
|
||||
#include "IMB_imbuf.h"
|
||||
#include "IMB_imbuf_types.h"
|
||||
#include "IMB_colormanagement.h"
|
||||
|
|
|
|||
|
|
@ -1700,7 +1700,7 @@ ImBuf *IMB_colormanagement_imbuf_for_write(ImBuf *ibuf, int save_as_render, int
|
|||
{
|
||||
ImBuf *colormanaged_ibuf = ibuf;
|
||||
int do_colormanagement;
|
||||
int is_movie = BKE_imtype_is_movie(image_format_data->imtype);
|
||||
bool is_movie = BKE_imtype_is_movie(image_format_data->imtype);
|
||||
int requires_linear_float = BKE_imtype_requires_linear_float(image_format_data->imtype);
|
||||
int do_alpha_under = image_format_data->planes != R_IMF_PLANES_RGBA;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue