← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/modifiers/intern/MOD_cast.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/modifiers/intern/MOD_cast.c
52
52
 
53
53
static void initData(ModifierData *md)
54
54
{
55
 
        CastModifierData *cmd = (CastModifierData*) md;
 
55
        CastModifierData *cmd = (CastModifierData *) md;
56
56
 
57
57
        cmd->fac = 0.5f;
58
58
        cmd->radius = 0.0f;
59
59
        cmd->size = 0.0f;
60
 
        cmd->flag = MOD_CAST_X | MOD_CAST_Y | MOD_CAST_Z
61
 
                        | MOD_CAST_SIZE_FROM_RADIUS;
 
60
        cmd->flag = MOD_CAST_X | MOD_CAST_Y | MOD_CAST_Z | MOD_CAST_SIZE_FROM_RADIUS;
62
61
        cmd->type = MOD_CAST_TYPE_SPHERE;
63
62
        cmd->defgrp_name[0] = '\0';
64
63
        cmd->object = NULL;
67
66
 
68
67
static void copyData(ModifierData *md, ModifierData *target)
69
68
{
70
 
        CastModifierData *cmd = (CastModifierData*) md;
71
 
        CastModifierData *tcmd = (CastModifierData*) target;
 
69
        CastModifierData *cmd = (CastModifierData *) md;
 
70
        CastModifierData *tcmd = (CastModifierData *) target;
72
71
 
73
72
        tcmd->fac = cmd->fac;
74
73
        tcmd->radius = cmd->radius;
81
80
 
82
81
static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
83
82
{
84
 
        CastModifierData *cmd = (CastModifierData*) md;
 
83
        CastModifierData *cmd = (CastModifierData *) md;
85
84
        short flag;
86
85
        
87
 
        flag = cmd->flag & (MOD_CAST_X|MOD_CAST_Y|MOD_CAST_Z);
 
86
        flag = cmd->flag & (MOD_CAST_X | MOD_CAST_Y | MOD_CAST_Z);
88
87
 
89
88
        if ((cmd->fac == 0.0f) || flag == 0) return 1;
90
89
 
103
102
}
104
103
 
105
104
static void foreachObjectLink(
106
 
                                           ModifierData *md, Object *ob,
107
 
        void (*walk)(void *userData, Object *ob, Object **obpoin),
108
 
                   void *userData)
 
105
        ModifierData *md, Object *ob,
 
106
        void (*walk)(void *userData, Object *ob, Object **obpoin),
 
107
        void *userData)
109
108
{
110
 
        CastModifierData *cmd = (CastModifierData*) md;
 
109
        CastModifierData *cmd = (CastModifierData *) md;
111
110
 
112
 
        walk (userData, ob, &cmd->object);
 
111
        walk(userData, ob, &cmd->object);
113
112
}
114
113
 
115
114
static void updateDepgraph(ModifierData *md, DagForest *forest,
116
 
                                                struct Scene *UNUSED(scene),
117
 
                                                Object *UNUSED(ob),
118
 
                                                DagNode *obNode)
 
115
                           struct Scene *UNUSED(scene),
 
116
                           Object *UNUSED(ob),
 
117
                           DagNode *obNode)
119
118
{
120
 
        CastModifierData *cmd = (CastModifierData*) md;
 
119
        CastModifierData *cmd = (CastModifierData *) md;
121
120
 
122
121
        if (cmd->object) {
123
122
                DagNode *curNode = dag_get_node(forest, cmd->object);
124
123
 
125
124
                dag_add_relation(forest, curNode, obNode, DAG_RL_OB_DATA,
126
 
                        "Cast Modifier");
 
125
                                 "Cast Modifier");
127
126
        }
128
127
}
129
128
 
130
129
static void sphere_do(
131
 
                                   CastModifierData *cmd, Object *ob, DerivedMesh *dm,
132
 
           float (*vertexCos)[3], int numVerts)
 
130
        CastModifierData *cmd, Object *ob, DerivedMesh *dm,
 
131
        float (*vertexCos)[3], int numVerts)
133
132
{
134
133
        MDeformVert *dvert = NULL;
135
134
 
200
199
         * with or w/o a vgroup. With lots of if's in the code below,
201
200
         * further optimization's are possible, if needed */
202
201
        if (dvert) { /* with a vgroup */
203
 
                MDeformVert *dv= dvert;
 
202
                MDeformVert *dv = dvert;
204
203
                float fac_orig = fac;
205
204
                for (i = 0; i < numVerts; i++, dv++) {
206
205
                        float tmp_co[3];
225
224
                                if (len_v3(vec) > cmd->radius) continue;
226
225
                        }
227
226
 
228
 
                        weight= defvert_find_weight(dv, defgrp_index);
 
227
                        weight = defvert_find_weight(dv, defgrp_index);
229
228
                        if (weight <= 0.0f) continue;
230
229
 
231
230
                        fac = fac_orig * weight;
234
233
                        normalize_v3(vec);
235
234
 
236
235
                        if (flag & MOD_CAST_X)
237
 
                                tmp_co[0] = fac*vec[0]*len + facm*tmp_co[0];
 
236
                                tmp_co[0] = fac * vec[0] * len + facm * tmp_co[0];
238
237
                        if (flag & MOD_CAST_Y)
239
 
                                tmp_co[1] = fac*vec[1]*len + facm*tmp_co[1];
 
238
                                tmp_co[1] = fac * vec[1] * len + facm * tmp_co[1];
240
239
                        if (flag & MOD_CAST_Z)
241
 
                                tmp_co[2] = fac*vec[2]*len + facm*tmp_co[2];
 
240
                                tmp_co[2] = fac * vec[2] * len + facm * tmp_co[2];
242
241
 
243
242
                        if (ctrl_ob) {
244
243
                                if (flag & MOD_CAST_USE_OB_TRANSFORM) {
280
279
                normalize_v3(vec);
281
280
 
282
281
                if (flag & MOD_CAST_X)
283
 
                        tmp_co[0] = fac*vec[0]*len + facm*tmp_co[0];
 
282
                        tmp_co[0] = fac * vec[0] * len + facm * tmp_co[0];
284
283
                if (flag & MOD_CAST_Y)
285
 
                        tmp_co[1] = fac*vec[1]*len + facm*tmp_co[1];
 
284
                        tmp_co[1] = fac * vec[1] * len + facm * tmp_co[1];
286
285
                if (flag & MOD_CAST_Z)
287
 
                        tmp_co[2] = fac*vec[2]*len + facm*tmp_co[2];
 
286
                        tmp_co[2] = fac * vec[2] * len + facm * tmp_co[2];
288
287
 
289
288
                if (ctrl_ob) {
290
289
                        if (flag & MOD_CAST_USE_OB_TRANSFORM) {
300
299
}
301
300
 
302
301
static void cuboid_do(
303
 
                                   CastModifierData *cmd, Object *ob, DerivedMesh *dm,
304
 
           float (*vertexCos)[3], int numVerts)
 
302
        CastModifierData *cmd, Object *ob, DerivedMesh *dm,
 
303
        float (*vertexCos)[3], int numVerts)
305
304
{
306
305
        MDeformVert *dvert = NULL;
307
306
        Object *ctrl_ob = NULL;
368
367
                        float vec[3];
369
368
 
370
369
                        /* let the center of the ctrl_ob be part of the bound box: */
371
 
                        DO_MINMAX(center, min, max);
 
370
                        minmax_v3v3_v3(min, max, center);
372
371
 
373
372
                        for (i = 0; i < numVerts; i++) {
374
373
                                sub_v3_v3v3(vec, vertexCos[i], center);
375
 
                                DO_MINMAX(vec, min, max);
 
374
                                minmax_v3v3_v3(min, max, vec);
376
375
                        }
377
376
                }
378
377
                else {
379
378
                        for (i = 0; i < numVerts; i++) {
380
 
                                DO_MINMAX(vertexCos[i], min, max);
 
379
                                minmax_v3v3_v3(min, max, vertexCos[i]);
381
380
                        }
382
381
                }
383
382
 
384
383
                /* we want a symmetric bound box around the origin */
385
 
                if (fabs(min[0]) > fabs(max[0])) max[0] = fabs(min[0]); 
386
 
                if (fabs(min[1]) > fabs(max[1])) max[1] = fabs(min[1]); 
387
 
                if (fabs(min[2]) > fabs(max[2])) max[2] = fabs(min[2]);
 
384
                if (fabsf(min[0]) > fabsf(max[0])) max[0] = fabsf(min[0]);
 
385
                if (fabsf(min[1]) > fabsf(max[1])) max[1] = fabsf(min[1]);
 
386
                if (fabsf(min[2]) > fabsf(max[2])) max[2] = fabsf(min[2]);
388
387
                min[0] = -max[0];
389
388
                min[1] = -max[1];
390
389
                min[2] = -max[2];
423
422
 
424
423
                        if (has_radius) {
425
424
                                if (fabsf(tmp_co[0]) > cmd->radius ||
426
 
                                                                fabsf(tmp_co[1]) > cmd->radius ||
427
 
                                                                fabsf(tmp_co[2]) > cmd->radius) continue;
 
425
                                    fabsf(tmp_co[1]) > cmd->radius ||
 
426
                                    fabsf(tmp_co[2]) > cmd->radius)
 
427
                                {
 
428
                                        continue;
 
429
                                }
428
430
                        }
429
431
 
430
432
                        for (j = 0; j < dvert[i].totweight; ++j) {
521
523
 
522
524
                if (has_radius) {
523
525
                        if (fabsf(tmp_co[0]) > cmd->radius ||
524
 
                                                 fabsf(tmp_co[1]) > cmd->radius ||
525
 
                                                 fabsf(tmp_co[2]) > cmd->radius) continue;
 
526
                            fabsf(tmp_co[1]) > cmd->radius ||
 
527
                            fabsf(tmp_co[2]) > cmd->radius)
 
528
                        {
 
529
                                continue;
 
530
                        }
526
531
                }
527
532
 
528
533
                octant = 0;
573
578
}
574
579
 
575
580
static void deformVerts(ModifierData *md, Object *ob,
576
 
                                                DerivedMesh *derivedData,
577
 
                                                float (*vertexCos)[3],
578
 
                                                int numVerts,
579
 
                                                int UNUSED(useRenderParams),
580
 
                                                int UNUSED(isFinalCalc))
 
581
                        DerivedMesh *derivedData,
 
582
                        float (*vertexCos)[3],
 
583
                        int numVerts,
 
584
                        ModifierApplyFlag UNUSED(flag))
581
585
{
582
586
        DerivedMesh *dm = NULL;
583
587
        CastModifierData *cmd = (CastModifierData *)md;
596
600
}
597
601
 
598
602
static void deformVertsEM(
599
 
                                           ModifierData *md, Object *ob, struct BMEditMesh *editData,
600
 
           DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
 
603
        ModifierData *md, Object *ob, struct BMEditMesh *editData,
 
604
        DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
601
605
{
602
606
        DerivedMesh *dm = get_dm(ob, editData, derivedData, NULL, 0);
603
607
        CastModifierData *cmd = (CastModifierData *)md;
619
623
        /* structName */        "CastModifierData",
620
624
        /* structSize */        sizeof(CastModifierData),
621
625
        /* type */              eModifierTypeType_OnlyDeform,
622
 
        /* flags */             eModifierTypeFlag_AcceptsCVs
623
 
                                                        | eModifierTypeFlag_SupportsEditmode,
 
626
        /* flags */             eModifierTypeFlag_AcceptsCVs |
 
627
                                eModifierTypeFlag_SupportsEditmode,
624
628
 
625
629
        /* copyData */          copyData,
626
630
        /* deformVerts */       deformVerts,