CustomData: const correctness
authorCampbell Barton <ideasman42@gmail.com>
Mon, 23 Feb 2015 04:55:48 +0000 (15:55 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 23 Feb 2015 05:17:16 +0000 (16:17 +1100)
source/blender/blenkernel/BKE_customdata.h
source/blender/blenkernel/intern/customdata.c
source/blender/bmesh/intern/bmesh_interp.c
source/blender/bmesh/intern/bmesh_interp.h

index e2e4a7a08ecb6ef8247b661b1c3815bb34319a8e..9028ad0926595ae5af692dc9ab6b38af43263830 100644 (file)
@@ -130,8 +130,9 @@ bool CustomData_merge(const struct CustomData *source, struct CustomData *dest,
 /* bmesh version of CustomData_merge; merges the layouts of source and dest,
  * then goes through the mesh and makes sure all the customdata blocks are
  * consistent with the new layout.*/
-bool CustomData_bmesh_merge(struct CustomData *source, struct CustomData *dest,
-                            CustomDataMask mask, int alloctype, struct BMesh *bm, const char htype);
+bool CustomData_bmesh_merge(
+        const struct CustomData *source, struct CustomData *dest,
+        CustomDataMask mask, int alloctype, struct BMesh *bm, const char htype);
 
 /** NULL's all members and resets the typemap. */
 void CustomData_reset(struct CustomData *data);
@@ -285,19 +286,23 @@ int CustomData_get_stencil_layer(const struct CustomData *data, int type);
  * layer of type
  * no effect if there is no layer of type
  */
-void CustomData_set(const struct CustomData *data, int index, int type,
-                    void *source);
+void CustomData_set(
+        const struct CustomData *data, int index, int type,
+        const void *source);
 
-void CustomData_bmesh_set(const struct CustomData *data, void *block, int type, 
-                          void *source);
+void CustomData_bmesh_set(
+        const struct CustomData *data, void *block, int type,
+        const void *source);
 
-void CustomData_bmesh_set_n(struct CustomData *data, void *block, int type, int n, 
-                            void *source);
+void CustomData_bmesh_set_n(
+        struct CustomData *data, void *block, int type, int n,
+        const void *source);
 /* sets the data of the block at physical layer n.  no real type checking
  * is performed.
  */
-void CustomData_bmesh_set_layer_n(struct CustomData *data, void *block, int n,
-                                  void *source);
+void CustomData_bmesh_set_layer_n(
+        struct CustomData *data, void *block, int n,
+        const void *source);
 
 /* set the pointer of to the first layer of type. the old data is not freed.
  * returns the value of ptr if the layer is found, NULL otherwise
index 1362c55f49c4a3edda918c79956af25a8dfa64fe..483a4b979b943a8726ac3e16476f0ca3c5e57d4e 100644 (file)
@@ -2408,7 +2408,7 @@ void *CustomData_set_layer_n(const struct CustomData *data, int type, int n, voi
        return ptr;
 }
 
-void CustomData_set(const CustomData *data, int index, int type, void *source)
+void CustomData_set(const CustomData *data, int index, int type, const void *source)
 {
        void *dest = CustomData_get(data, index, type);
        const LayerTypeInfo *typeInfo = layerType_getInfo(type);
@@ -2573,8 +2573,9 @@ void CustomData_bmesh_init_pool(CustomData *data, int totelem, const char htype)
        }
 }
 
-bool CustomData_bmesh_merge(CustomData *source, CustomData *dest,
-                            CustomDataMask mask, int alloctype, BMesh *bm, const char htype)
+bool CustomData_bmesh_merge(
+        const CustomData *source, CustomData *dest,
+        CustomDataMask mask, int alloctype, BMesh *bm, const char htype)
 {
        BMHeader *h;
        BMIter iter;
@@ -2944,7 +2945,7 @@ void CustomData_data_add(int type, void *data1, const void *data2)
                typeInfo->add(data1, data2);
 }
 
-void CustomData_bmesh_set(const CustomData *data, void *block, int type, void *source)
+void CustomData_bmesh_set(const CustomData *data, void *block, int type, const void *source)
 {
        void *dest = CustomData_bmesh_get(data, block, type);
        const LayerTypeInfo *typeInfo = layerType_getInfo(type);
@@ -2957,7 +2958,7 @@ void CustomData_bmesh_set(const CustomData *data, void *block, int type, void *s
                memcpy(dest, source, typeInfo->size);
 }
 
-void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, void *source)
+void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, const void *source)
 {
        void *dest = CustomData_bmesh_get_n(data, block, type, n);
        const LayerTypeInfo *typeInfo = layerType_getInfo(type);
@@ -2970,7 +2971,7 @@ void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, void
                memcpy(dest, source, typeInfo->size);
 }
 
-void CustomData_bmesh_set_layer_n(CustomData *data, void *block, int n, void *source)
+void CustomData_bmesh_set_layer_n(CustomData *data, void *block, int n, const void *source)
 {
        void *dest = CustomData_bmesh_get_layer_n(data, block, n);
        const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[n].type);
index b7a72e2e2ae626afcf43d23600d2dbcb8e2e161d..c0add425fa2336d526f1aa0bc4caf89d7c8db0d5 100644 (file)
 #include "intern/bmesh_private.h"
 
 /* edge and vertex share, currently theres no need to have different logic */
-static void bm_data_interp_from_elem(CustomData *data_layer, BMElem *ele1, BMElem *ele2, BMElem *ele_dst, const float fac)
+static void bm_data_interp_from_elem(
+        CustomData *data_layer, const BMElem *ele_src_1, const BMElem *ele_src_2,
+        BMElem *ele_dst, const float fac)
 {
-       if (ele1->head.data && ele2->head.data) {
+       if (ele_src_1->head.data && ele_src_2->head.data) {
                /* first see if we can avoid interpolation */
                if (fac <= 0.0f) {
-                       if (ele1 == ele_dst) {
+                       if (ele_src_1 == ele_dst) {
                                /* do nothing */
                        }
                        else {
                                CustomData_bmesh_free_block_data(data_layer, ele_dst->head.data);
-                               CustomData_bmesh_copy_data(data_layer, data_layer, ele1->head.data, &ele_dst->head.data);
+                               CustomData_bmesh_copy_data(data_layer, data_layer, ele_src_1->head.data, &ele_dst->head.data);
                        }
                }
                else if (fac >= 1.0f) {
-                       if (ele2 == ele_dst) {
+                       if (ele_src_2 == ele_dst) {
                                /* do nothing */
                        }
                        else {
                                CustomData_bmesh_free_block_data(data_layer, ele_dst->head.data);
-                               CustomData_bmesh_copy_data(data_layer, data_layer, ele2->head.data, &ele_dst->head.data);
+                               CustomData_bmesh_copy_data(data_layer, data_layer, ele_src_2->head.data, &ele_dst->head.data);
                        }
                }
                else {
                        const void *src[2];
                        float w[2];
 
-                       src[0] = ele1->head.data;
-                       src[1] = ele2->head.data;
+                       src[0] = ele_src_1->head.data;
+                       src[1] = ele_src_2->head.data;
                        w[0] = 1.0f - fac;
                        w[1] = fac;
                        CustomData_bmesh_interp(data_layer, src, w, NULL, 2, ele_dst->head.data);
@@ -85,25 +87,25 @@ static void bm_data_interp_from_elem(CustomData *data_layer, BMElem *ele1, BMEle
 /**
  * \brief Data, Interp From Verts
  *
- * Interpolates per-vertex data from two sources to a target.
+ * Interpolates per-vertex data from two sources to \a v_dst
  *
  * \note This is an exact match to #BM_data_interp_from_edges
  */
-void BM_data_interp_from_verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, const float fac)
+void BM_data_interp_from_verts(BMesh *bm, const BMVert *v_src_1, const BMVert *v_src_2, BMVert *v_dst, const float fac)
 {
-       bm_data_interp_from_elem(&bm->vdata, (BMElem *)v1, (BMElem *)v2, (BMElem *)v, fac);
+       bm_data_interp_from_elem(&bm->vdata, (const BMElem *)v_src_1, (const BMElem *)v_src_2, (BMElem *)v_dst, fac);
 }
 
 /**
  * \brief Data, Interp From Edges
  *
- * Interpolates per-edge data from two sources to a target.
+ * Interpolates per-edge data from two sources to \a e_dst.
  *
  * \note This is an exact match to #BM_data_interp_from_verts
  */
-void BM_data_interp_from_edges(BMesh *bm, BMEdge *e1, BMEdge *e2, BMEdge *e, const float fac)
+void BM_data_interp_from_edges(BMesh *bm, const BMEdge *e_src_1, const BMEdge *e_src_2, BMEdge *e_dst, const float fac)
 {
-       bm_data_interp_from_elem(&bm->edata, (BMElem *)e1, (BMElem *)e2, (BMElem *)e, fac);
+       bm_data_interp_from_elem(&bm->edata, (const BMElem *)e_src_1, (const BMElem *)e_src_2, (BMElem *)e_dst, fac);
 }
 
 /**
@@ -120,25 +122,26 @@ static void UNUSED_FUNCTION(BM_Data_Vert_Average)(BMesh *UNUSED(bm), BMFace *UNU
 /**
  * \brief Data Face-Vert Edge Interp
  *
- * Walks around the faces of an edge and interpolates the per-face-edge
- * data between two sources to a target.
+ * Walks around the faces of \a e and interpolates
+ * the loop data between two sources.
  */
-void BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BMVert *v, BMEdge *e1, const float fac)
+void BM_data_interp_face_vert_edge(
+        BMesh *bm, const BMVert *v_src_1, const BMVert *UNUSED(v_src_2), BMVert *v, BMEdge *e, const float fac)
 {
        float w[2];
        BMLoop *l_v1 = NULL, *l_v = NULL, *l_v2 = NULL;
        BMLoop *l_iter = NULL;
 
-       if (!e1->l) {
+       if (!e->l) {
                return;
        }
 
        w[1] = 1.0f - fac;
        w[0] = fac;
 
-       l_iter = e1->l;
+       l_iter = e->l;
        do {
-               if (l_iter->v == v1) {
+               if (l_iter->v == v_src_1) {
                        l_v1 = l_iter;
                        l_v = l_v1->next;
                        l_v2 = l_v->next;
@@ -159,7 +162,7 @@ void BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BM
 
                        CustomData_bmesh_interp(&bm->ldata, src, w, NULL, 2, l_v->head.data);
                }
-       } while ((l_iter = l_iter->radial_next) != e1->l);
+       } while ((l_iter = l_iter->radial_next) != e->l);
 }
 
 /**
@@ -171,56 +174,56 @@ void BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BM
  * \note Only handles loop customdata. multires is handled.
  */
 void BM_face_interp_from_face_ex(
-        BMesh *bm, BMFace *target, BMFace *source, const bool do_vertex,
+        BMesh *bm, BMFace *f_dst, const BMFace *f_src, const bool do_vertex,
         const void **blocks_l, const void **blocks_v, float (*cos_2d)[2], float axis_mat[3][3])
 {
        BMLoop *l_iter;
        BMLoop *l_first;
 
-       float *w = BLI_array_alloca(w, source->len);
+       float *w = BLI_array_alloca(w, f_src->len);
        float co[2];
        int i;
 
-       if (source != target)
-               BM_elem_attrs_copy(bm, bm, source, target);
+       if (f_src != f_dst)
+               BM_elem_attrs_copy(bm, bm, f_src, f_dst);
 
        /* interpolate */
        i = 0;
-       l_iter = l_first = BM_FACE_FIRST_LOOP(target);
+       l_iter = l_first = BM_FACE_FIRST_LOOP(f_dst);
        do {
                mul_v2_m3v3(co, axis_mat, l_iter->v->co);
-               interp_weights_poly_v2(w, cos_2d, source->len, co);
-               CustomData_bmesh_interp(&bm->ldata, blocks_l, w, NULL, source->len, l_iter->head.data);
+               interp_weights_poly_v2(w, cos_2d, f_src->len, co);
+               CustomData_bmesh_interp(&bm->ldata, blocks_l, w, NULL, f_src->len, l_iter->head.data);
                if (do_vertex) {
-                       CustomData_bmesh_interp(&bm->vdata, blocks_v, w, NULL, source->len, l_iter->v->head.data);
+                       CustomData_bmesh_interp(&bm->vdata, blocks_v, w, NULL, f_src->len, l_iter->v->head.data);
                }
        } while (i++, (l_iter = l_iter->next) != l_first);
 }
 
-void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source, const bool do_vertex)
+void BM_face_interp_from_face(BMesh *bm, BMFace *f_dst, const BMFace *f_src, const bool do_vertex)
 {
        BMLoop *l_iter;
        BMLoop *l_first;
 
-       const void **blocks_l    = BLI_array_alloca(blocks_l, source->len);
-       const void **blocks_v    = do_vertex ? BLI_array_alloca(blocks_v, source->len) : NULL;
-       float (*cos_2d)[2] = BLI_array_alloca(cos_2d, source->len);
+       const void **blocks_l    = BLI_array_alloca(blocks_l, f_src->len);
+       const void **blocks_v    = do_vertex ? BLI_array_alloca(blocks_v, f_src->len) : NULL;
+       float (*cos_2d)[2] = BLI_array_alloca(cos_2d, f_src->len);
        float axis_mat[3][3];  /* use normal to transform into 2d xy coords */
        int i;
 
        /* convert the 3d coords into 2d for projection */
-       BLI_assert(BM_face_is_normal_valid(source));
-       axis_dominant_v3_to_m3(axis_mat, source->no);
+       BLI_assert(BM_face_is_normal_valid(f_src));
+       axis_dominant_v3_to_m3(axis_mat, f_src->no);
 
        i = 0;
-       l_iter = l_first = BM_FACE_FIRST_LOOP(source);
+       l_iter = l_first = BM_FACE_FIRST_LOOP(f_src);
        do {
                mul_v2_m3v3(cos_2d[i], axis_mat, l_iter->v->co);
                blocks_l[i] = l_iter->head.data;
                if (do_vertex) blocks_v[i] = l_iter->v->head.data;
        } while (i++, (l_iter = l_iter->next) != l_first);
 
-       BM_face_interp_from_face_ex(bm, target, source, do_vertex,
+       BM_face_interp_from_face_ex(bm, f_dst, f_src, do_vertex,
                                    blocks_l, blocks_v, cos_2d, axis_mat);
 }
 
@@ -430,7 +433,7 @@ static void bm_loop_flip_disp(const float source_axis_x[3], const float source_a
        disp[1] = (mat[0][0] * b[1] - b[0] * mat[1][0]) / d;
 }
 
-static void bm_loop_interp_mdisps(BMesh *bm, BMLoop *l_dst, BMFace *f_src)
+static void bm_loop_interp_mdisps(BMesh *bm, BMLoop *l_dst, const BMFace *f_src)
 {
        const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
        MDisps *md_dst;
@@ -614,36 +617,37 @@ void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
 }
 
 /**
- * project the multires grid in target onto source's set of multires grids
+ * project the multires grid in target onto f_src's set of multires grids
  */
-void BM_loop_interp_multires(BMesh *bm, BMLoop *target, BMFace *source)
+void BM_loop_interp_multires(BMesh *bm, BMLoop *l_dst, const BMFace *f_src)
 {
-       bm_loop_interp_mdisps(bm, target, source);
+       bm_loop_interp_mdisps(bm, l_dst, f_src);
 }
 
 /**
- * projects a single loop, target, onto source for customdata interpolation. multires is handled.
+ * projects a single loop, target, onto f_src for customdata interpolation. multires is handled.
  * if do_vertex is true, target's vert data will also get interpolated.
  */
-void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
-                              const bool do_vertex, const bool do_multires)
+void BM_loop_interp_from_face(
+        BMesh *bm, BMLoop *l_dst, const BMFace *f_src,
+        const bool do_vertex, const bool do_multires)
 {
        BMLoop *l_iter;
        BMLoop *l_first;
-       const void **vblocks  = do_vertex ? BLI_array_alloca(vblocks, source->len) : NULL;
-       const void **blocks   = BLI_array_alloca(blocks, source->len);
-       float (*cos_2d)[2] = BLI_array_alloca(cos_2d, source->len);
-       float *w        = BLI_array_alloca(w, source->len);
+       const void **vblocks  = do_vertex ? BLI_array_alloca(vblocks, f_src->len) : NULL;
+       const void **blocks   = BLI_array_alloca(blocks, f_src->len);
+       float (*cos_2d)[2] = BLI_array_alloca(cos_2d, f_src->len);
+       float *w        = BLI_array_alloca(w, f_src->len);
        float axis_mat[3][3];  /* use normal to transform into 2d xy coords */
        float co[2];
        int i;
 
        /* convert the 3d coords into 2d for projection */
-       BLI_assert(BM_face_is_normal_valid(source));
-       axis_dominant_v3_to_m3(axis_mat, source->no);
+       BLI_assert(BM_face_is_normal_valid(f_src));
+       axis_dominant_v3_to_m3(axis_mat, f_src->no);
 
        i = 0;
-       l_iter = l_first = BM_FACE_FIRST_LOOP(source);
+       l_iter = l_first = BM_FACE_FIRST_LOOP(f_src);
        do {
                mul_v2_m3v3(cos_2d[i], axis_mat, l_iter->v->co);
                blocks[i] = l_iter->head.data;
@@ -653,48 +657,48 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
                }
        } while (i++, (l_iter = l_iter->next) != l_first);
 
-       mul_v2_m3v3(co, axis_mat, target->v->co);
+       mul_v2_m3v3(co, axis_mat, l_dst->v->co);
 
        /* interpolate */
-       interp_weights_poly_v2(w, cos_2d, source->len, co);
-       CustomData_bmesh_interp(&bm->ldata, blocks, w, NULL, source->len, target->head.data);
+       interp_weights_poly_v2(w, cos_2d, f_src->len, co);
+       CustomData_bmesh_interp(&bm->ldata, blocks, w, NULL, f_src->len, l_dst->head.data);
        if (do_vertex) {
-               CustomData_bmesh_interp(&bm->vdata, vblocks, w, NULL, source->len, target->v->head.data);
+               CustomData_bmesh_interp(&bm->vdata, vblocks, w, NULL, f_src->len, l_dst->v->head.data);
        }
 
        if (do_multires) {
-               bm_loop_interp_mdisps(bm, target, source);
+               bm_loop_interp_mdisps(bm, l_dst, f_src);
        }
 }
 
 
-void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source)
+void BM_vert_interp_from_face(BMesh *bm, BMVert *v_dst, const BMFace *f_src)
 {
        BMLoop *l_iter;
        BMLoop *l_first;
-       const void **blocks   = BLI_array_alloca(blocks, source->len);
-       float (*cos_2d)[2] = BLI_array_alloca(cos_2d, source->len);
-       float *w        = BLI_array_alloca(w,      source->len);
+       const void **blocks   = BLI_array_alloca(blocks, f_src->len);
+       float (*cos_2d)[2] = BLI_array_alloca(cos_2d, f_src->len);
+       float *w        = BLI_array_alloca(w,      f_src->len);
        float axis_mat[3][3];  /* use normal to transform into 2d xy coords */
        float co[2];
        int i;
 
        /* convert the 3d coords into 2d for projection */
-       BLI_assert(BM_face_is_normal_valid(source));
-       axis_dominant_v3_to_m3(axis_mat, source->no);
+       BLI_assert(BM_face_is_normal_valid(f_src));
+       axis_dominant_v3_to_m3(axis_mat, f_src->no);
 
        i = 0;
-       l_iter = l_first = BM_FACE_FIRST_LOOP(source);
+       l_iter = l_first = BM_FACE_FIRST_LOOP(f_src);
        do {
                mul_v2_m3v3(cos_2d[i], axis_mat, l_iter->v->co);
                blocks[i] = l_iter->v->head.data;
        } while (i++, (l_iter = l_iter->next) != l_first);
 
-       mul_v2_m3v3(co, axis_mat, v->co);
+       mul_v2_m3v3(co, axis_mat, v_dst->co);
 
        /* interpolate */
-       interp_weights_poly_v2(w, cos_2d, source->len, co);
-       CustomData_bmesh_interp(&bm->vdata, blocks, w, NULL, source->len, v->head.data);
+       interp_weights_poly_v2(w, cos_2d, f_src->len, co);
+       CustomData_bmesh_interp(&bm->vdata, blocks, w, NULL, f_src->len, v_dst->head.data);
 }
 
 static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
index 8493d401a32f5f7875e4ed2eb353b7b5f2d04c91..969e92f37db288b7aff4b0981be84755d8cc7034 100644 (file)
 struct LinkNode;
 struct MemArena;
 
-void  BM_loop_interp_multires(BMesh *bm, BMLoop *target, BMFace *source);
-void  BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source);
+void  BM_loop_interp_multires(BMesh *bm, BMLoop *l_dst, const BMFace *f_src);
+void  BM_vert_interp_from_face(BMesh *bm, BMVert *v_dst, const BMFace *f_src);
 
-void  BM_data_interp_from_verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, const float fac);
-void  BM_data_interp_from_edges(BMesh *bm, BMEdge *e1, BMEdge *e2, BMEdge *e, const float fac);
-void  BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, BMEdge *e1, const float fac);
+void  BM_data_interp_from_verts(BMesh *bm, const BMVert *v_src_1, const BMVert *v_src_2, BMVert *v_dst, const float fac);
+void  BM_data_interp_from_edges(BMesh *bm, const BMEdge *e_src_1, const BMEdge *e_src_2, BMEdge *e_dst, const float fac);
+void  BM_data_interp_face_vert_edge(BMesh *bm, const BMVert *v_src_1, const BMVert *v_src_2, BMVert *v, BMEdge *e, const float fac);
 void  BM_data_layer_add(BMesh *bm, CustomData *data, int type);
 void  BM_data_layer_add_named(BMesh *bm, CustomData *data, int type, const char *name);
 void  BM_data_layer_free(BMesh *bm, CustomData *data, int type);
@@ -46,12 +46,15 @@ float BM_elem_float_data_get(CustomData *cd, void *element, int type);
 void  BM_elem_float_data_set(CustomData *cd, void *element, int type, const float val);
 
 void BM_face_interp_from_face_ex(
-        BMesh *bm, BMFace *target, BMFace *source, const bool do_vertex,
+        BMesh *bm, BMFace *f_dst, const BMFace *f_src, const bool do_vertex,
         const void **blocks, const void **blocks_v,
         float (*cos_2d)[2], float axis_mat[3][3]);
-void  BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source, const bool do_vertex);
-void  BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
-                               const bool do_vertex, const bool do_multires);
+void  BM_face_interp_from_face(
+        BMesh *bm, BMFace *f_dst, const BMFace *f_src,
+        const bool do_vertex);
+void  BM_loop_interp_from_face(
+        BMesh *bm, BMLoop *l_dst, const BMFace *f_src,
+        const bool do_vertex, const bool do_multires);
 
 void  BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f);