rename define BM_INLINE -> BLI_INLINE to avoid confusion with bmesh defines.
authorCampbell Barton <ideasman42@gmail.com>
Tue, 20 Mar 2012 08:42:26 +0000 (08:42 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 20 Mar 2012 08:42:26 +0000 (08:42 +0000)
16 files changed:
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/deform.c
source/blender/blenkernel/intern/navmesh_conversion.c
source/blender/blenlib/BLI_utildefines.h
source/blender/blenlib/intern/voxel.c
source/blender/bmesh/bmesh.h
source/blender/bmesh/bmesh_operator_api.h
source/blender/bmesh/intern/bmesh_core.c
source/blender/bmesh/intern/bmesh_inline.c
source/blender/bmesh/intern/bmesh_iterators_inline.c
source/blender/bmesh/intern/bmesh_mesh_conv.c
source/blender/bmesh/intern/bmesh_operator_api_inline.c
source/blender/bmesh/operators/bmo_create.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/space_text/text_ops.c
source/blender/render/intern/source/volumetric.c

index bf3f461d3f533f95de45879932dd30d218d852e8..68264ddd200825dc14ec6fb9b6802a5548a1f966 100644 (file)
@@ -2854,12 +2854,12 @@ void DM_set_object_boundbox(Object *ob, DerivedMesh *dm)
  */
 
 
-BM_INLINE int navmesh_bit(int a, int b)
+BLI_INLINE int navmesh_bit(int a, int b)
 {
        return (a & (1 << b)) >> b;
 }
 
-BM_INLINE void navmesh_intToCol(int i, float col[3])
+BLI_INLINE void navmesh_intToCol(int i, float col[3])
 {
        int     r = navmesh_bit(i, 0) + navmesh_bit(i, 3) * 2 + 1;
        int     g = navmesh_bit(i, 1) + navmesh_bit(i, 4) * 2 + 1;
index 6de24856ce890654a5557b484ee31ad7d0514132..186a4d41403f37e80ce999d8fb25c5ee79d4ca16 100644 (file)
@@ -437,7 +437,7 @@ void defgroup_unique_name(bDeformGroup *dg, Object *ob)
        BLI_uniquename_cb(defgroup_unique_check, &data, "Group", '.', dg->name, sizeof(dg->name));
 }
 
-BM_INLINE int is_char_sep(const char c)
+BLI_INLINE int is_char_sep(const char c)
 {
        return ELEM4(c, '.', ' ', '-', '_');
 }
index cdba036a6aed742ab3cc2cd47c2b05928ea392e4..f14482c4cb32e89e7db9178add93c09fcf5bbae0 100644 (file)
 
 #include "recast-capi.h"
 
-BM_INLINE float area2(const float* a, const float* b, const float* c)
+BLI_INLINE float area2(const float* a, const float* b, const float* c)
 {
        return (b[0] - a[0]) * (c[2] - a[2]) - (c[0] - a[0]) * (b[2] - a[2]);
 }
 
-BM_INLINE int left(const float* a, const float* b, const float* c)
+BLI_INLINE int left(const float* a, const float* b, const float* c)
 {
        return area2(a, b, c) < 0;
 }
index 06de3ff05fcaec39a548f0ed625ef48dfcda5ab4..d3f1d52631797ea67659417b95ed047f86e877ef 100644 (file)
 
 /*little macro so inline keyword works*/
 #if defined(_MSC_VER)
-#  define BM_INLINE static __forceinline
+#  define BLI_INLINE static __forceinline
 #elif defined(__GNUC__)
-#  define BM_INLINE static inline __attribute((always_inline))
+#  define BLI_INLINE static inline __attribute((always_inline))
 #else
 /* #warning "MSC/GNUC defines not found, inline non-functional" */
-#  define BM_INLINE static
+#  define BLI_INLINE static
 #endif
 
 
index dd56988fd9063891281b5449a46b2362f93cf693..34862c724e12eefeb377cb108cb1316761b517fc 100644 (file)
@@ -35,7 +35,7 @@
 
 
 
-BM_INLINE float D(float *data, const int res[3], int x, int y, int z)
+BLI_INLINE float D(float *data, const int res[3], int x, int y, int z)
 {
        CLAMP(x, 0, res[0]-1);
        CLAMP(y, 0, res[1]-1);
@@ -57,7 +57,7 @@ float voxel_sample_nearest(float *data, const int res[3], const float co[3])
 }
 
 // returns highest integer <= x as integer (slightly faster than floor())
-BM_INLINE int FLOORI(float x)
+BLI_INLINE int FLOORI(float x)
 {
        const int r = (int)x;
        return ((x >= 0.f) || (float)r == x) ? r : (r - 1);
@@ -65,7 +65,7 @@ BM_INLINE int FLOORI(float x)
 
 // clamp function, cannot use the CLAMPIS macro, it sometimes returns unwanted results apparently related to gcc optimization flag -fstrict-overflow which is enabled at -O2
 // this causes the test (x + 2) < 0 with int x == 2147483647 to return false (x being an integer, x + 2 should wrap around to -2147483647 so the test < 0 should return true, which it doesn't)
-BM_INLINE int _clamp(int a, int b, int c)
+BLI_INLINE int _clamp(int a, int b, int c)
 {
        return (a < b) ? b : ((a > c) ? c : a);
 }
index 56efe88c10459d998fa25bed29d2356397ad7c5e..0cb1f5c051abd9c079c03ab5fd9066a0201bc3f2 100644 (file)
@@ -219,12 +219,12 @@ extern "C" {
 #define BM_elem_flag_toggle( ele, hflag)      _bm_elem_flag_toggle  (&(ele)->head, hflag)
 #define BM_elem_flag_merge(  ele_a, ele_b)    _bm_elem_flag_merge   (&(ele_a)->head, &(ele_b)->head)
 
-BM_INLINE char _bm_elem_flag_test(const BMHeader *head, const char hflag);
-BM_INLINE void _bm_elem_flag_enable(BMHeader *head, const char hflag);
-BM_INLINE void _bm_elem_flag_disable(BMHeader *head, const char hflag);
-BM_INLINE void _bm_elem_flag_set(BMHeader *head, const char hflag, const int val);
-BM_INLINE void _bm_elem_flag_toggle(BMHeader *head, const char hflag);
-BM_INLINE void _bm_elem_flag_merge(BMHeader *head_a, BMHeader *head_b);
+BLI_INLINE char _bm_elem_flag_test(const BMHeader *head, const char hflag);
+BLI_INLINE void _bm_elem_flag_enable(BMHeader *head, const char hflag);
+BLI_INLINE void _bm_elem_flag_disable(BMHeader *head, const char hflag);
+BLI_INLINE void _bm_elem_flag_set(BMHeader *head, const char hflag, const int val);
+BLI_INLINE void _bm_elem_flag_toggle(BMHeader *head, const char hflag);
+BLI_INLINE void _bm_elem_flag_merge(BMHeader *head_a, BMHeader *head_b);
 
 /* notes on BM_elem_index_set(...) usage,
  * Set index is sometimes abused as temp storage, other times we cant be
@@ -257,8 +257,8 @@ BM_INLINE void _bm_elem_flag_merge(BMHeader *head_a, BMHeader *head_b);
 
 #define BM_elem_index_get(ele)           _bm_elem_index_get(&(ele)->head)
 #define BM_elem_index_set(ele, index)    _bm_elem_index_set(&(ele)->head, index)
-BM_INLINE int  _bm_elem_index_get(const BMHeader *ele);
-BM_INLINE void _bm_elem_index_set(BMHeader *ele, const int index);
+BLI_INLINE int  _bm_elem_index_get(const BMHeader *ele);
+BLI_INLINE void _bm_elem_index_set(BMHeader *ele, const int index);
 
 #ifdef USE_BMESH_HOLES
 #  define BM_FACE_FIRST_LOOP(p) (((BMLoopList *)((p)->loops.first))->first)
index c53a76a59d64002b3d3579ce4ce50c4c33aa1390..84de5d57aa3bef183dc147ba8c5e655b8f7c1b61 100644 (file)
@@ -81,11 +81,11 @@ struct GHashIterator;
 #define BMO_elem_flag_set(    bm, ele, oflag, val) _bmo_elem_flag_set     (bm, (ele)->oflags, oflag, val)
 #define BMO_elem_flag_toggle( bm, ele, oflag)      _bmo_elem_flag_toggle  (bm, (ele)->oflags, oflag)
 
-BM_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag);
-BM_INLINE void  _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag);
-BM_INLINE void  _bmo_elem_flag_disable(BMesh *bm, BMFlagLayer *oflags, const short oflag);
-BM_INLINE void  _bmo_elem_flag_set(BMesh *bm, BMFlagLayer *oflags, const short oflag, int val);
-BM_INLINE void  _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE void  _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE void  _bmo_elem_flag_disable(BMesh *bm, BMFlagLayer *oflags, const short oflag);
+BLI_INLINE void  _bmo_elem_flag_set(BMesh *bm, BMFlagLayer *oflags, const short oflag, int val);
+BLI_INLINE void  _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const short oflag);
 
 /* slot type arrays are terminated by the last member
  * having a slot type of 0.*/
index c1814b0ae96c2e276244bcd4255f6c74528378c9..6aaa2911bd90c95d2a04bce7eaac1ae716cceede 100644 (file)
@@ -240,7 +240,7 @@ BMFace *BM_face_copy(BMesh *bm, BMFace *f, const short copyverts, const short co
  * only create the face, since this calloc's the length is initialized to 0,
  * leave adding loops to the caller.
  */
-BM_INLINE BMFace *bm_face_create__internal(BMesh *bm)
+BLI_INLINE BMFace *bm_face_create__internal(BMesh *bm)
 {
        BMFace *f;
 
index f7a0fb5c45c3523f7363da02b6bc5f0620a733da..085488cf7ed65c7109761c5ceba1891617ac3f39 100644 (file)
 
 #include "bmesh.h"
 
-BM_INLINE char _bm_elem_flag_test(const BMHeader *head, const char hflag)
+BLI_INLINE char _bm_elem_flag_test(const BMHeader *head, const char hflag)
 {
        return head->hflag & hflag;
 }
 
-BM_INLINE void _bm_elem_flag_enable(BMHeader *head, const char hflag)
+BLI_INLINE void _bm_elem_flag_enable(BMHeader *head, const char hflag)
 {
        head->hflag |= hflag;
 }
 
-BM_INLINE void _bm_elem_flag_disable(BMHeader *head, const char hflag)
+BLI_INLINE void _bm_elem_flag_disable(BMHeader *head, const char hflag)
 {
        head->hflag &= ~hflag;
 }
 
-BM_INLINE void _bm_elem_flag_set(BMHeader *head, const char hflag, const int val)
+BLI_INLINE void _bm_elem_flag_set(BMHeader *head, const char hflag, const int val)
 {
        if (val)  _bm_elem_flag_enable(head,  hflag);
        else      _bm_elem_flag_disable(head, hflag);
 }
 
-BM_INLINE void _bm_elem_flag_toggle(BMHeader *head, const char hflag)
+BLI_INLINE void _bm_elem_flag_toggle(BMHeader *head, const char hflag)
 {
        head->hflag ^= hflag;
 }
 
-BM_INLINE void _bm_elem_flag_merge(BMHeader *head_a, BMHeader *head_b)
+BLI_INLINE void _bm_elem_flag_merge(BMHeader *head_a, BMHeader *head_b)
 {
        head_a->hflag = head_b->hflag = head_a->hflag | head_b->hflag;
 }
 
 
-BM_INLINE void _bm_elem_index_set(BMHeader *head, const int index)
+BLI_INLINE void _bm_elem_index_set(BMHeader *head, const int index)
 {
        head->index = index;
 }
 
-BM_INLINE int _bm_elem_index_get(const BMHeader *head)
+BLI_INLINE int _bm_elem_index_get(const BMHeader *head)
 {
        return head->index;
 }
index ed65b0e7facea605860b981b10af8b14c00013df..bb16fcc439c55b548188594e3a1c3eae20f5156e 100644 (file)
@@ -39,7 +39,7 @@
  *
  * Calls an iterators step fucntion to return the next element.
  */
-BM_INLINE void *BM_iter_step(BMIter *iter)
+BLI_INLINE void *BM_iter_step(BMIter *iter)
 {
        return iter->step(iter);
 }
@@ -52,7 +52,7 @@ BM_INLINE void *BM_iter_step(BMIter *iter)
  * it with the appropriate function pointers based
  * upon its type.
  */
-BM_INLINE int BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *data)
+BLI_INLINE int BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *data)
 {
        /* int argtype; */
        iter->itype = itype;
@@ -179,7 +179,7 @@ BM_INLINE int BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *data
  * to return the first element of the iterator.
  *
  */
-BM_INLINE void *BM_iter_new(BMIter *iter, BMesh *bm, const char itype, void *data)
+BLI_INLINE void *BM_iter_new(BMIter *iter, BMesh *bm, const char itype, void *data)
 {
        if (LIKELY(BM_iter_init(iter, bm, itype, data))) {
                return BM_iter_step(iter);
index b10e25a318c74fa9b9c6229927213e59bed57e09..476c049c687d3c30a5ea2e9888b5880e7b64652a 100644 (file)
@@ -407,7 +407,7 @@ static BMVert **bm_to_mesh_vertex_map(BMesh *bm, int ototvert)
        return vertMap;
 }
 
-BM_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
+BLI_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e)
 {
        /* this is a cheap way to set the edge draw, its not precise and will
         * pick the first 2 faces an edge uses */
index 5b88d9f1b96e0e111c6c8b4bef06da9306c224b6..91fc3b1e4ca0dcd2682fa0fb2e1ff2054733ac80 100644 (file)
  * ghash or a mapping slot to do it. */
 
 /* flags 15 and 16 (1 << 14 and 1 << 15) are reserved for bmesh api use */
-BM_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag)
+BLI_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
     return oflags[bm->stackdepth - 1].f & oflag;
 }
 
-BM_INLINE void _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
+BLI_INLINE void _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
        oflags[bm->stackdepth - 1].f |= oflag;
 }
 
-BM_INLINE void _bmo_elem_flag_disable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
+BLI_INLINE void _bmo_elem_flag_disable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
        oflags[bm->stackdepth - 1].f &= ~oflag;
 }
 
-BM_INLINE void _bmo_elem_flag_set(BMesh *bm, BMFlagLayer *oflags, const short oflag, int val)
+BLI_INLINE void _bmo_elem_flag_set(BMesh *bm, BMFlagLayer *oflags, const short oflag, int val)
 {
        if (val) oflags[bm->stackdepth - 1].f |= oflag;
        else     oflags[bm->stackdepth - 1].f &= ~oflag;
 }
 
-BM_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const short oflag)
+BLI_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const short oflag)
 {
        oflags[bm->stackdepth - 1].f ^= oflag;
 }
 
-BM_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slotname,
                                        void *element, int val)
 {
        BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(int));
 }
 
-BM_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slotname,
                                          void *element, float val)
 {
        BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(float));
@@ -85,13 +85,13 @@ BM_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *
  * do NOT use these for non-operator-api-allocated memory! instead
  * use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */
 
-BM_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slotname,
                                        void *element, void *val)
 {
        BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(void *));
 }
 
-BM_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void *element)
+BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void *element)
 {
        BMOpSlot *slot = BMO_slot_get(op, slotname);
        BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING);
@@ -102,7 +102,7 @@ BM_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const cha
        return BLI_ghash_haskey(slot->data.ghash, element);
 }
 
-BM_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
+BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slotname,
                                       void *element)
 {
        BMOElemMapping *mapping;
@@ -119,7 +119,7 @@ BM_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const c
        return mapping + 1;
 }
 
-BM_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slotname,
                                        void *element)
 {
        float *val = (float *) BMO_slot_map_data_get(bm, op, slotname, element);
@@ -128,7 +128,7 @@ BM_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *sl
        return 0.0f;
 }
 
-BM_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotname,
                                    void *element)
 {
        int *val = (int *) BMO_slot_map_data_get(bm, op, slotname, element);
@@ -137,7 +137,7 @@ BM_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotna
        return 0;
 }
 
-BM_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slotname,
+BLI_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slotname,
                                      void *element)
 {
        void **val = (void **) BMO_slot_map_data_get(bm, op, slotname, element);
index 459b1cbb3a720cd8f0572fefc5cc478dcaee1b71..7db29501ed53a2cc9a1674f9248cc4df9d59f41b 100644 (file)
@@ -76,7 +76,7 @@ static int count_edge_faces(BMesh *bm, BMEdge *e);
 
 /****  rotation system code * */
 
-BM_INLINE BMDiskLink *rs_edge_link_get(BMEdge *e, BMVert *v, EdgeData *e_data)
+BLI_INLINE BMDiskLink *rs_edge_link_get(BMEdge *e, BMVert *v, EdgeData *e_data)
 {
        return  v == ((BMEdge *)e)->v1 ? &(((EdgeData *)e_data)->v1_disk_link) :
                                         &(((EdgeData *)e_data)->v2_disk_link) ;
@@ -866,7 +866,7 @@ static int count_edge_faces(BMesh *bm, BMEdge *e)
        return i;
 }
 
-BM_INLINE void vote_on_winding(BMEdge *edge, EPathNode *node, unsigned int winding[2])
+BLI_INLINE void vote_on_winding(BMEdge *edge, EPathNode *node, unsigned int winding[2])
 {
        BMVert *test_v1, *test_v2;
        /* we want to use the reverse winding to the existing order */
index 3a6a9dd654866ed1c58d414e0e49f6385ed646a1..bf3a7268e1182f0b3387b280a2b61531a3961b91 100644 (file)
@@ -589,7 +589,7 @@ void vpaint_dogamma(Scene *scene)
 }
 #endif
 
-BM_INLINE unsigned int mcol_blend(unsigned int col1, unsigned int col2, int fac)
+BLI_INLINE unsigned int mcol_blend(unsigned int col1, unsigned int col2, int fac)
 {
        unsigned char *cp1, *cp2, *cp;
        int mfac;
@@ -617,7 +617,7 @@ BM_INLINE unsigned int mcol_blend(unsigned int col1, unsigned int col2, int fac)
        return col;
 }
 
-BM_INLINE unsigned int mcol_add(unsigned int col1, unsigned int col2, int fac)
+BLI_INLINE unsigned int mcol_add(unsigned int col1, unsigned int col2, int fac)
 {
        unsigned char *cp1, *cp2, *cp;
        int temp;
@@ -642,7 +642,7 @@ BM_INLINE unsigned int mcol_add(unsigned int col1, unsigned int col2, int fac)
        return col;
 }
 
-BM_INLINE unsigned int mcol_sub(unsigned int col1, unsigned int col2, int fac)
+BLI_INLINE unsigned int mcol_sub(unsigned int col1, unsigned int col2, int fac)
 {
        unsigned char *cp1, *cp2, *cp;
        int temp;
@@ -667,7 +667,7 @@ BM_INLINE unsigned int mcol_sub(unsigned int col1, unsigned int col2, int fac)
        return col;
 }
 
-BM_INLINE unsigned int mcol_mul(unsigned int col1, unsigned int col2, int fac)
+BLI_INLINE unsigned int mcol_mul(unsigned int col1, unsigned int col2, int fac)
 {
        unsigned char *cp1, *cp2, *cp;
        int mfac;
@@ -692,7 +692,7 @@ BM_INLINE unsigned int mcol_mul(unsigned int col1, unsigned int col2, int fac)
        return col;
 }
 
-BM_INLINE unsigned int mcol_lighten(unsigned int col1, unsigned int col2, int fac)
+BLI_INLINE unsigned int mcol_lighten(unsigned int col1, unsigned int col2, int fac)
 {
        unsigned char *cp1, *cp2, *cp;
        int mfac;
@@ -725,7 +725,7 @@ BM_INLINE unsigned int mcol_lighten(unsigned int col1, unsigned int col2, int fa
        return col;
 }
 
-BM_INLINE unsigned int mcol_darken(unsigned int col1, unsigned int col2, int fac)
+BLI_INLINE unsigned int mcol_darken(unsigned int col1, unsigned int col2, int fac)
 {
        unsigned char *cp1, *cp2, *cp;
        int mfac;
@@ -904,27 +904,27 @@ static float calc_vp_alpha_dl(VPaint *vp, ViewContext *vc,
 }
 
 
-BM_INLINE float wval_blend(const float weight, const float paintval, const float alpha)
+BLI_INLINE float wval_blend(const float weight, const float paintval, const float alpha)
 {
        return (paintval * alpha) + (weight * (1.0f - alpha));
 }
-BM_INLINE float wval_add(const float weight, const float paintval, const float alpha)
+BLI_INLINE float wval_add(const float weight, const float paintval, const float alpha)
 {
        return weight + (paintval * alpha);
 }
-BM_INLINE float wval_sub(const float weight, const float paintval, const float alpha)
+BLI_INLINE float wval_sub(const float weight, const float paintval, const float alpha)
 {
        return weight - (paintval * alpha);
 }
-BM_INLINE float wval_mul(const float weight, const float paintval, const float alpha)
+BLI_INLINE float wval_mul(const float weight, const float paintval, const float alpha)
 {      /* first mul, then blend the fac */
        return ((1.0f - alpha) + (alpha * paintval)) * weight;
 }
-BM_INLINE float wval_lighten(const float weight, const float paintval, const float alpha)
+BLI_INLINE float wval_lighten(const float weight, const float paintval, const float alpha)
 {
        return (weight < paintval) ? wval_blend(weight, paintval, alpha) : weight;
 }
-BM_INLINE float wval_darken(const float weight, const float paintval, const float alpha)
+BLI_INLINE float wval_darken(const float weight, const float paintval, const float alpha)
 {
        return (weight > paintval) ? wval_blend(weight, paintval, alpha) : weight;
 }
index 4c6357f7505bce2b455f13ab74f6ad5784d27fa3..ba7c1f556b2f2450887c44040ea34a649b9ff331 100644 (file)
@@ -74,7 +74,7 @@
 /************************ poll ***************************/
 
 
-BM_INLINE int text_pixel_x_to_index(SpaceText *st, const int x)
+BLI_INLINE int text_pixel_x_to_index(SpaceText *st, const int x)
 {
        /* add half the char width so mouse cursor selection is inbetween letters */
        return (x + (st->cwidth / 2)) / st->cwidth;
index 36895f8ad53025f60845d767beed7f5c6d7447f6..17c4601264a0c6f4069745ce7f492b8605bc7be3 100644 (file)
@@ -69,7 +69,7 @@ extern struct Render R;
 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
 
 /* luminance rec. 709 */
-BM_INLINE float luminance(const float col[3])
+BLI_INLINE float luminance(const float col[3])
 {
        return (0.212671f*col[0] + 0.71516f*col[1] + 0.072169f*col[2]);
 }