← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/bmesh/intern/bmesh_structure.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-02-19 11:24:23 UTC
  • mfrom: (14.2.23 sid)
  • Revision ID: package-import@ubuntu.com-20140219112423-rkmaz2m7ha06d4tk
Tags: 2.69-3ubuntu1
* Merge with Debian; remaining changes:
  - Configure without OpenImageIO on armhf, as it is not available on
    Ubuntu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/bmesh/intern/bmesh_structure.c
45
45
        if (e->v1 == v || e->v2 == v) return true;
46
46
        return false;
47
47
}
48
 
bool bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
 
48
bool bmesh_verts_in_edge(const BMVert *v1, const BMVert *v2, const BMEdge *e)
49
49
{
50
50
        if (e->v1 == v1 && e->v2 == v2) return true;
51
51
        else if (e->v1 == v2 && e->v2 == v1) return true;
130
130
 * Functions relating to this cycle:
131
131
 * - #bmesh_radial_append
132
132
 * - #bmesh_radial_loop_remove
133
 
 * - #bmesh_radial_face_find
134
133
 * - #bmesh_radial_facevert_count
135
134
 * - #bmesh_radial_faceloop_find_first
136
135
 * - #bmesh_radial_faceloop_find_next
217
216
 *
218
217
 * \return Pointer to the next edge in the disk cycle for the vertex v.
219
218
 */
220
 
BMEdge *bmesh_disk_edge_next(BMEdge *e, BMVert *v)
 
219
BMEdge *bmesh_disk_edge_next(const BMEdge *e, const BMVert *v)
221
220
{
222
221
        if (v == e->v1)
223
222
                return e->v1_disk_link.next;
226
225
        return NULL;
227
226
}
228
227
 
229
 
BMEdge *bmesh_disk_edge_prev(BMEdge *e, BMVert *v)
 
228
BMEdge *bmesh_disk_edge_prev(const BMEdge *e, const BMVert *v)
230
229
{
231
230
        if (v == e->v1)
232
231
                return e->v1_disk_link.prev;
235
234
        return NULL;
236
235
}
237
236
 
238
 
BMEdge *bmesh_disk_edge_exists(BMVert *v1, BMVert *v2)
 
237
BMEdge *bmesh_disk_edge_exists(const BMVert *v1, const BMVert *v2)
239
238
{
240
239
        BMEdge *e_iter, *e_first;
241
240
        
252
251
        return NULL;
253
252
}
254
253
 
255
 
int bmesh_disk_count(BMVert *v)
 
254
int bmesh_disk_count(const BMVert *v)
256
255
{
257
256
        if (v->e) {
258
257
                BMEdge *e_first, *e_iter;
305
304
 * equivalent to counting the number of
306
305
 * faces incident upon this vertex
307
306
 */
308
 
int bmesh_disk_facevert_count(BMVert *v)
 
307
int bmesh_disk_facevert_count(const BMVert *v)
309
308
{
310
309
        /* is there an edge on this vert at all */
311
310
        if (v->e) {
334
333
 * vert's loops attached
335
334
 * to it.
336
335
 */
337
 
BMEdge *bmesh_disk_faceedge_find_first(BMEdge *e, BMVert *v)
 
336
BMEdge *bmesh_disk_faceedge_find_first(const BMEdge *e, const BMVert *v)
338
337
{
339
 
        BMEdge *searchedge = NULL;
340
 
        searchedge = e;
 
338
        const BMEdge *e_find = e;
341
339
        do {
342
 
                if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
343
 
                        return searchedge;
 
340
                if (e_find->l && bmesh_radial_facevert_count(e_find->l, v)) {
 
341
                        return (BMEdge *)e_find;
344
342
                }
345
 
        } while ((searchedge = bmesh_disk_edge_next(searchedge, v)) != e);
 
343
        } while ((e_find = bmesh_disk_edge_next(e_find, v)) != e);
346
344
 
347
345
        return NULL;
348
346
}
349
347
 
350
 
BMEdge *bmesh_disk_faceedge_find_next(BMEdge *e, BMVert *v)
 
348
BMEdge *bmesh_disk_faceedge_find_next(const BMEdge *e, const BMVert *v)
351
349
{
352
 
        BMEdge *searchedge = NULL;
353
 
        searchedge = bmesh_disk_edge_next(e, v);
 
350
        BMEdge *e_find = NULL;
 
351
        e_find = bmesh_disk_edge_next(e, v);
354
352
        do {
355
 
                if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
356
 
                        return searchedge;
 
353
                if (e_find->l && bmesh_radial_facevert_count(e_find->l, v)) {
 
354
                        return e_find;
357
355
                }
358
 
        } while ((searchedge = bmesh_disk_edge_next(searchedge, v)) != e);
359
 
        return e;
 
356
        } while ((e_find = bmesh_disk_edge_next(e_find, v)) != e);
 
357
        return (BMEdge *)e;
360
358
}
361
359
 
362
360
/*****radial cycle functions, e.g. loops surrounding edges**** */
436
434
 * Finds the first loop of v around radial
437
435
 * cycle
438
436
 */
439
 
BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v)
 
437
BMLoop *bmesh_radial_faceloop_find_first(const BMLoop *l, const BMVert *v)
440
438
{
441
 
        BMLoop *l_iter;
 
439
        const BMLoop *l_iter;
442
440
        l_iter = l;
443
441
        do {
444
442
                if (l_iter->v == v) {
445
 
                        return l_iter;
 
443
                        return (BMLoop *)l_iter;
446
444
                }
447
445
        } while ((l_iter = l_iter->radial_next) != l);
448
446
        return NULL;
449
447
}
450
448
 
451
 
BMLoop *bmesh_radial_faceloop_find_next(BMLoop *l, BMVert *v)
 
449
BMLoop *bmesh_radial_faceloop_find_next(const BMLoop *l, const BMVert *v)
452
450
{
453
451
        BMLoop *l_iter;
454
452
        l_iter = l->radial_next;
457
455
                        return l_iter;
458
456
                }
459
457
        } while ((l_iter = l_iter->radial_next) != l);
460
 
        return l;
 
458
        return (BMLoop *)l;
461
459
}
462
460
 
463
 
int bmesh_radial_length(BMLoop *l)
 
461
int bmesh_radial_length(const BMLoop *l)
464
462
{
465
 
        BMLoop *l_iter = l;
 
463
        const BMLoop *l_iter = l;
466
464
        int i = 0;
467
465
 
468
466
        if (!l)
509
507
        l->e = e;
510
508
}
511
509
 
512
 
bool bmesh_radial_face_find(BMEdge *e, BMFace *f)
513
 
{
514
 
        BMLoop *l_iter;
515
 
        int i, len;
516
 
 
517
 
        len = bmesh_radial_length(e->l);
518
 
        for (i = 0, l_iter = e->l; i < len; i++, l_iter = l_iter->radial_next) {
519
 
                if (l_iter->f == f)
520
 
                        return true;
521
 
        }
522
 
        return false;
523
 
}
524
 
 
525
510
/**
526
511
 * \brief RADIAL COUNT FACE VERT
527
512
 *
528
513
 * Returns the number of times a vertex appears
529
514
 * in a radial cycle
530
515
 */
531
 
int bmesh_radial_facevert_count(BMLoop *l, BMVert *v)
 
516
int bmesh_radial_facevert_count(const BMLoop *l, const BMVert *v)
532
517
{
533
 
        BMLoop *l_iter;
 
518
        const BMLoop *l_iter;
534
519
        int count = 0;
535
520
        l_iter = l;
536
521
        do {