← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/intern/linestyle.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/blenkernel/intern/linestyle.c
81
81
        linestyle->thickness = 3.0f;
82
82
        linestyle->thickness_position = LS_THICKNESS_CENTER;
83
83
        linestyle->thickness_ratio = 0.5f;
 
84
        linestyle->flag = LS_SAME_OBJECT;
84
85
        linestyle->chaining = LS_CHAINING_PLAIN;
85
86
        linestyle->rounds = 3;
86
87
        linestyle->min_angle = DEG2RADF(0.0f);
201
202
        size_t size;
202
203
 
203
204
        switch (type) {
204
 
        case LS_MODIFIER_ALONG_STROKE:
205
 
                size = sizeof(LineStyleColorModifier_AlongStroke);
206
 
                break;
207
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
208
 
                size = sizeof(LineStyleColorModifier_DistanceFromCamera);
209
 
                break;
210
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
211
 
                size = sizeof(LineStyleColorModifier_DistanceFromObject);
212
 
                break;
213
 
        case LS_MODIFIER_MATERIAL:
214
 
                size = sizeof(LineStyleColorModifier_Material);
215
 
                break;
216
 
        default:
217
 
                return NULL; /* unknown modifier type */
 
205
                case LS_MODIFIER_ALONG_STROKE:
 
206
                        size = sizeof(LineStyleColorModifier_AlongStroke);
 
207
                        break;
 
208
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
209
                        size = sizeof(LineStyleColorModifier_DistanceFromCamera);
 
210
                        break;
 
211
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
212
                        size = sizeof(LineStyleColorModifier_DistanceFromObject);
 
213
                        break;
 
214
                case LS_MODIFIER_MATERIAL:
 
215
                        size = sizeof(LineStyleColorModifier_Material);
 
216
                        break;
 
217
                default:
 
218
                        return NULL; /* unknown modifier type */
218
219
        }
219
220
 
220
221
        return new_modifier(type, size);
228
229
        m->blend = MA_RAMP_BLEND;
229
230
 
230
231
        switch (type) {
231
 
        case LS_MODIFIER_ALONG_STROKE:
232
 
                ((LineStyleColorModifier_AlongStroke *)m)->color_ramp = add_colorband(1);
233
 
                break;
234
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
235
 
                ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp = add_colorband(1);
236
 
                ((LineStyleColorModifier_DistanceFromCamera *)m)->range_min = 0.0f;
237
 
                ((LineStyleColorModifier_DistanceFromCamera *)m)->range_max = 10000.0f;
238
 
                break;
239
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
240
 
                ((LineStyleColorModifier_DistanceFromObject *)m)->target = NULL;
241
 
                ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp = add_colorband(1);
242
 
                ((LineStyleColorModifier_DistanceFromObject *)m)->range_min = 0.0f;
243
 
                ((LineStyleColorModifier_DistanceFromObject *)m)->range_max = 10000.0f;
244
 
                break;
245
 
        case LS_MODIFIER_MATERIAL:
246
 
                ((LineStyleColorModifier_Material *)m)->color_ramp = add_colorband(1);
247
 
                ((LineStyleColorModifier_Material *)m)->mat_attr = LS_MODIFIER_MATERIAL_DIFF;
248
 
                break;
249
 
        default:
250
 
                return NULL; /* unknown modifier type */
 
232
                case LS_MODIFIER_ALONG_STROKE:
 
233
                        ((LineStyleColorModifier_AlongStroke *)m)->color_ramp = add_colorband(1);
 
234
                        break;
 
235
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
236
                        ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp = add_colorband(1);
 
237
                        ((LineStyleColorModifier_DistanceFromCamera *)m)->range_min = 0.0f;
 
238
                        ((LineStyleColorModifier_DistanceFromCamera *)m)->range_max = 10000.0f;
 
239
                        break;
 
240
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
241
                        ((LineStyleColorModifier_DistanceFromObject *)m)->target = NULL;
 
242
                        ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp = add_colorband(1);
 
243
                        ((LineStyleColorModifier_DistanceFromObject *)m)->range_min = 0.0f;
 
244
                        ((LineStyleColorModifier_DistanceFromObject *)m)->range_max = 10000.0f;
 
245
                        break;
 
246
                case LS_MODIFIER_MATERIAL:
 
247
                        ((LineStyleColorModifier_Material *)m)->color_ramp = add_colorband(1);
 
248
                        ((LineStyleColorModifier_Material *)m)->mat_attr = LS_MODIFIER_MATERIAL_DIFF;
 
249
                        break;
 
250
                default:
 
251
                        return NULL; /* unknown modifier type */
251
252
        }
252
253
        add_to_modifier_list(&linestyle->color_modifiers, m);
253
254
 
264
265
        new_m->blend = m->blend;
265
266
 
266
267
        switch (m->type) {
267
 
        case LS_MODIFIER_ALONG_STROKE:
 
268
                case LS_MODIFIER_ALONG_STROKE:
268
269
                {
269
270
                        LineStyleColorModifier_AlongStroke *p = (LineStyleColorModifier_AlongStroke *)m;
270
271
                        LineStyleColorModifier_AlongStroke *q = (LineStyleColorModifier_AlongStroke *)new_m;
271
272
                        q->color_ramp = MEM_dupallocN(p->color_ramp);
 
273
                        break;
272
274
                }
273
 
                break;
274
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
275
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
275
276
                {
276
277
                        LineStyleColorModifier_DistanceFromCamera *p = (LineStyleColorModifier_DistanceFromCamera *)m;
277
278
                        LineStyleColorModifier_DistanceFromCamera *q = (LineStyleColorModifier_DistanceFromCamera *)new_m;
278
279
                        q->color_ramp = MEM_dupallocN(p->color_ramp);
279
280
                        q->range_min = p->range_min;
280
281
                        q->range_max = p->range_max;
 
282
                        break;
281
283
                }
282
 
                break;
283
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
284
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
284
285
                {
285
286
                        LineStyleColorModifier_DistanceFromObject *p = (LineStyleColorModifier_DistanceFromObject *)m;
286
287
                        LineStyleColorModifier_DistanceFromObject *q = (LineStyleColorModifier_DistanceFromObject *)new_m;
290
291
                        q->color_ramp = MEM_dupallocN(p->color_ramp);
291
292
                        q->range_min = p->range_min;
292
293
                        q->range_max = p->range_max;
 
294
                        break;
293
295
                }
294
 
                break;
295
 
        case LS_MODIFIER_MATERIAL:
 
296
                case LS_MODIFIER_MATERIAL:
296
297
                {
297
298
                        LineStyleColorModifier_Material *p = (LineStyleColorModifier_Material *)m;
298
299
                        LineStyleColorModifier_Material *q = (LineStyleColorModifier_Material *)new_m;
299
300
                        q->color_ramp = MEM_dupallocN(p->color_ramp);
300
301
                        q->flags = p->flags;
301
302
                        q->mat_attr = p->mat_attr;
 
303
                        break;
302
304
                }
303
 
                break;
304
 
        default:
305
 
                return NULL; /* unknown modifier type */
 
305
                default:
 
306
                        return NULL; /* unknown modifier type */
306
307
        }
307
308
        add_to_modifier_list(&linestyle->color_modifiers, new_m);
308
309
 
312
313
void BKE_remove_linestyle_color_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
313
314
{
314
315
        switch (m->type) {
315
 
        case LS_MODIFIER_ALONG_STROKE:
316
 
                MEM_freeN(((LineStyleColorModifier_AlongStroke *)m)->color_ramp);
317
 
                break;
318
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
319
 
                MEM_freeN(((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
320
 
                break;
321
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
322
 
                MEM_freeN(((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
323
 
                break;
324
 
        case LS_MODIFIER_MATERIAL:
325
 
                MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);
326
 
                break;
 
316
                case LS_MODIFIER_ALONG_STROKE:
 
317
                        MEM_freeN(((LineStyleColorModifier_AlongStroke *)m)->color_ramp);
 
318
                        break;
 
319
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
320
                        MEM_freeN(((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
 
321
                        break;
 
322
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
323
                        MEM_freeN(((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
 
324
                        break;
 
325
                case LS_MODIFIER_MATERIAL:
 
326
                        MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);
 
327
                        break;
327
328
        }
328
329
        BLI_freelinkN(&linestyle->color_modifiers, m);
329
330
}
333
334
        size_t size;
334
335
 
335
336
        switch (type) {
336
 
        case LS_MODIFIER_ALONG_STROKE:
337
 
                size = sizeof(LineStyleAlphaModifier_AlongStroke);
338
 
                break;
339
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
340
 
                size = sizeof(LineStyleAlphaModifier_DistanceFromCamera);
341
 
                break;
342
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
343
 
                size = sizeof(LineStyleAlphaModifier_DistanceFromObject);
344
 
                break;
345
 
        case LS_MODIFIER_MATERIAL:
346
 
                size = sizeof(LineStyleAlphaModifier_Material);
347
 
                break;
348
 
        default:
349
 
                return NULL; /* unknown modifier type */
 
337
                case LS_MODIFIER_ALONG_STROKE:
 
338
                        size = sizeof(LineStyleAlphaModifier_AlongStroke);
 
339
                        break;
 
340
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
341
                        size = sizeof(LineStyleAlphaModifier_DistanceFromCamera);
 
342
                        break;
 
343
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
344
                        size = sizeof(LineStyleAlphaModifier_DistanceFromObject);
 
345
                        break;
 
346
                case LS_MODIFIER_MATERIAL:
 
347
                        size = sizeof(LineStyleAlphaModifier_Material);
 
348
                        break;
 
349
                default:
 
350
                        return NULL; /* unknown modifier type */
350
351
        }
351
352
        return new_modifier(type, size);
352
353
}
359
360
        m->blend = LS_VALUE_BLEND;
360
361
 
361
362
        switch (type) {
362
 
        case LS_MODIFIER_ALONG_STROKE:
 
363
                case LS_MODIFIER_ALONG_STROKE:
363
364
                {
364
365
                        LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
365
366
                        p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
 
367
                        break;
366
368
                }
367
 
                break;
368
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
369
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
369
370
                {
370
371
                        LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)m;
371
372
                        p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
372
373
                        p->range_min = 0.0f;
373
374
                        p->range_max = 10000.0f;
 
375
                        break;
374
376
                }
375
 
                break;
376
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
377
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
377
378
                {
378
379
                        LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)m;
379
380
                        p->target = NULL;
380
381
                        p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
381
382
                        p->range_min = 0.0f;
382
383
                        p->range_max = 10000.0f;
 
384
                        break;
383
385
                }
384
 
                break;
385
 
        case LS_MODIFIER_MATERIAL:
 
386
                case LS_MODIFIER_MATERIAL:
386
387
                {
387
388
                        LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
388
389
                        p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
389
390
                        p->mat_attr = LS_MODIFIER_MATERIAL_DIFF;
 
391
                        break;
390
392
                }
391
 
                break;
392
 
        default:
393
 
                return NULL; /* unknown modifier type */
 
393
                default:
 
394
                        return NULL; /* unknown modifier type */
394
395
        }
395
396
        add_to_modifier_list(&linestyle->alpha_modifiers, m);
396
397
 
407
408
        new_m->blend = m->blend;
408
409
 
409
410
        switch (m->type) {
410
 
        case LS_MODIFIER_ALONG_STROKE:
 
411
                case LS_MODIFIER_ALONG_STROKE:
411
412
                {
412
413
                        LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
413
414
                        LineStyleAlphaModifier_AlongStroke *q = (LineStyleAlphaModifier_AlongStroke *)new_m;
414
415
                        q->curve = curvemapping_copy(p->curve);
415
416
                        q->flags = p->flags;
 
417
                        break;
416
418
                }
417
 
                break;
418
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
419
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
419
420
                {
420
421
                        LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)m;
421
422
                        LineStyleAlphaModifier_DistanceFromCamera *q = (LineStyleAlphaModifier_DistanceFromCamera *)new_m;
423
424
                        q->flags = p->flags;
424
425
                        q->range_min = p->range_min;
425
426
                        q->range_max = p->range_max;
 
427
                        break;
426
428
                }
427
 
                break;
428
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
429
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
429
430
                {
430
431
                        LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)m;
431
432
                        LineStyleAlphaModifier_DistanceFromObject *q = (LineStyleAlphaModifier_DistanceFromObject *)new_m;
436
437
                        q->flags = p->flags;
437
438
                        q->range_min = p->range_min;
438
439
                        q->range_max = p->range_max;
 
440
                        break;
439
441
                }
440
 
                break;
441
 
        case LS_MODIFIER_MATERIAL:
 
442
                case LS_MODIFIER_MATERIAL:
442
443
                {
443
444
                        LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
444
445
                        LineStyleAlphaModifier_Material *q = (LineStyleAlphaModifier_Material *)new_m;
445
446
                        q->curve = curvemapping_copy(p->curve);
446
447
                        q->flags = p->flags;
447
448
                        q->mat_attr = p->mat_attr;
 
449
                        break;
448
450
                }
449
 
                break;
450
 
        default:
451
 
                return NULL; /* unknown modifier type */
 
451
                default:
 
452
                        return NULL; /* unknown modifier type */
452
453
        }
453
454
        add_to_modifier_list(&linestyle->alpha_modifiers, new_m);
454
455
 
458
459
void BKE_remove_linestyle_alpha_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
459
460
{
460
461
        switch (m->type) {
461
 
        case LS_MODIFIER_ALONG_STROKE:
462
 
                curvemapping_free(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
463
 
                break;
464
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
465
 
                curvemapping_free(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
466
 
                break;
467
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
468
 
                curvemapping_free(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
469
 
                break;
470
 
        case LS_MODIFIER_MATERIAL:
471
 
                curvemapping_free(((LineStyleAlphaModifier_Material *)m)->curve);
472
 
                break;
 
462
                case LS_MODIFIER_ALONG_STROKE:
 
463
                        curvemapping_free(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
 
464
                        break;
 
465
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
466
                        curvemapping_free(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
 
467
                        break;
 
468
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
469
                        curvemapping_free(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
 
470
                        break;
 
471
                case LS_MODIFIER_MATERIAL:
 
472
                        curvemapping_free(((LineStyleAlphaModifier_Material *)m)->curve);
 
473
                        break;
473
474
        }
474
475
        BLI_freelinkN(&linestyle->alpha_modifiers, m);
475
476
}
479
480
        size_t size;
480
481
 
481
482
        switch (type) {
482
 
        case LS_MODIFIER_ALONG_STROKE:
483
 
                size = sizeof(LineStyleThicknessModifier_AlongStroke);
484
 
                break;
485
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
486
 
                size = sizeof(LineStyleThicknessModifier_DistanceFromCamera);
487
 
                break;
488
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
489
 
                size = sizeof(LineStyleThicknessModifier_DistanceFromObject);
490
 
                break;
491
 
        case LS_MODIFIER_MATERIAL:
492
 
                size = sizeof(LineStyleThicknessModifier_Material);
493
 
                break;
494
 
        case LS_MODIFIER_CALLIGRAPHY:
495
 
                size = sizeof(LineStyleThicknessModifier_Calligraphy);
496
 
                break;
497
 
        default:
498
 
                return NULL; /* unknown modifier type */
 
483
                case LS_MODIFIER_ALONG_STROKE:
 
484
                        size = sizeof(LineStyleThicknessModifier_AlongStroke);
 
485
                        break;
 
486
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
487
                        size = sizeof(LineStyleThicknessModifier_DistanceFromCamera);
 
488
                        break;
 
489
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
490
                        size = sizeof(LineStyleThicknessModifier_DistanceFromObject);
 
491
                        break;
 
492
                case LS_MODIFIER_MATERIAL:
 
493
                        size = sizeof(LineStyleThicknessModifier_Material);
 
494
                        break;
 
495
                case LS_MODIFIER_CALLIGRAPHY:
 
496
                        size = sizeof(LineStyleThicknessModifier_Calligraphy);
 
497
                        break;
 
498
                default:
 
499
                        return NULL; /* unknown modifier type */
499
500
        }
500
501
 
501
502
        return new_modifier(type, size);
509
510
        m->blend = LS_VALUE_BLEND;
510
511
 
511
512
        switch (type) {
512
 
        case LS_MODIFIER_ALONG_STROKE:
 
513
                case LS_MODIFIER_ALONG_STROKE:
513
514
                {
514
515
                        LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
515
516
                        p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
516
517
                        p->value_min = 0.0f;
517
518
                        p->value_max = 1.0f;
 
519
                        break;
518
520
                }
519
 
                break;
520
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
521
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
521
522
                {
522
523
                        LineStyleThicknessModifier_DistanceFromCamera *p = (LineStyleThicknessModifier_DistanceFromCamera *)m;
523
524
                        p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
525
526
                        p->range_max = 1000.0f;
526
527
                        p->value_min = 0.0f;
527
528
                        p->value_max = 1.0f;
 
529
                        break;
528
530
                }
529
 
                break;
530
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
531
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
531
532
                {
532
533
                        LineStyleThicknessModifier_DistanceFromObject *p = (LineStyleThicknessModifier_DistanceFromObject *)m;
533
534
                        p->target = NULL;
536
537
                        p->range_max = 1000.0f;
537
538
                        p->value_min = 0.0f;
538
539
                        p->value_max = 1.0f;
 
540
                        break;
539
541
                }
540
 
                break;
541
 
        case LS_MODIFIER_MATERIAL:
 
542
                case LS_MODIFIER_MATERIAL:
542
543
                {
543
544
                        LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
544
545
                        p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
545
546
                        p->mat_attr = LS_MODIFIER_MATERIAL_DIFF;
546
547
                        p->value_min = 0.0f;
547
548
                        p->value_max = 1.0f;
 
549
                        break;
548
550
                }
549
 
                break;
550
 
        case LS_MODIFIER_CALLIGRAPHY:
 
551
                case LS_MODIFIER_CALLIGRAPHY:
551
552
                {
552
553
                        LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
553
554
                        p->min_thickness = 1.0f;
554
555
                        p->max_thickness = 10.0f;
555
556
                        p->orientation = DEG2RADF(60.0f);
 
557
                        break;
556
558
                }
557
 
                break;
558
 
        default:
559
 
                return NULL; /* unknown modifier type */
 
559
                default:
 
560
                        return NULL; /* unknown modifier type */
560
561
        }
561
562
        add_to_modifier_list(&linestyle->thickness_modifiers, m);
562
563
 
575
576
        new_m->blend = m->blend;
576
577
 
577
578
        switch (m->type) {
578
 
        case LS_MODIFIER_ALONG_STROKE:
 
579
                case LS_MODIFIER_ALONG_STROKE:
579
580
                {
580
581
                        LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
581
582
                        LineStyleThicknessModifier_AlongStroke *q = (LineStyleThicknessModifier_AlongStroke *)new_m;
583
584
                        q->flags = p->flags;
584
585
                        q->value_min = p->value_min;
585
586
                        q->value_max = p->value_max;
 
587
                        break;
586
588
                }
587
 
                break;
588
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
589
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
589
590
                {
590
591
                        LineStyleThicknessModifier_DistanceFromCamera *p = (LineStyleThicknessModifier_DistanceFromCamera *)m;
591
592
                        LineStyleThicknessModifier_DistanceFromCamera *q = (LineStyleThicknessModifier_DistanceFromCamera *)new_m;
595
596
                        q->range_max = p->range_max;
596
597
                        q->value_min = p->value_min;
597
598
                        q->value_max = p->value_max;
 
599
                        break;
598
600
                }
599
 
                break;
600
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
601
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
601
602
                {
602
603
                        LineStyleThicknessModifier_DistanceFromObject *p = (LineStyleThicknessModifier_DistanceFromObject *)m;
603
604
                        LineStyleThicknessModifier_DistanceFromObject *q = (LineStyleThicknessModifier_DistanceFromObject *)new_m;
610
611
                        q->range_max = p->range_max;
611
612
                        q->value_min = p->value_min;
612
613
                        q->value_max = p->value_max;
 
614
                        break;
613
615
                }
614
 
                break;
615
 
        case LS_MODIFIER_MATERIAL:
 
616
                case LS_MODIFIER_MATERIAL:
616
617
                {
617
618
                        LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
618
619
                        LineStyleThicknessModifier_Material *q = (LineStyleThicknessModifier_Material *)new_m;
621
622
                        q->mat_attr = p->mat_attr;
622
623
                        q->value_min = p->value_min;
623
624
                        q->value_max = p->value_max;
 
625
                        break;
624
626
                }
625
 
                break;
626
 
        case LS_MODIFIER_CALLIGRAPHY:
 
627
                case LS_MODIFIER_CALLIGRAPHY:
627
628
                {
628
629
                        LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
629
630
                        LineStyleThicknessModifier_Calligraphy *q = (LineStyleThicknessModifier_Calligraphy *)new_m;
630
631
                        q->min_thickness = p->min_thickness;
631
632
                        q->max_thickness = p->max_thickness;
632
633
                        q->orientation = p->orientation;
 
634
                        break;
633
635
                }
634
 
                break;
635
 
        default:
636
 
                return NULL; /* unknown modifier type */
 
636
                default:
 
637
                        return NULL; /* unknown modifier type */
637
638
        }
638
639
        add_to_modifier_list(&linestyle->thickness_modifiers, new_m);
639
640
 
643
644
void BKE_remove_linestyle_thickness_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
644
645
{
645
646
        switch (m->type) {
646
 
        case LS_MODIFIER_ALONG_STROKE:
647
 
                curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
648
 
                break;
649
 
        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
650
 
                curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
651
 
                break;
652
 
        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
653
 
                curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
654
 
                break;
655
 
        case LS_MODIFIER_MATERIAL:
656
 
                curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);
657
 
                break;
658
 
        case LS_MODIFIER_CALLIGRAPHY:
659
 
                break;
 
647
                case LS_MODIFIER_ALONG_STROKE:
 
648
                        curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
 
649
                        break;
 
650
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
651
                        curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
 
652
                        break;
 
653
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
654
                        curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
 
655
                        break;
 
656
                case LS_MODIFIER_MATERIAL:
 
657
                        curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);
 
658
                        break;
 
659
                case LS_MODIFIER_CALLIGRAPHY:
 
660
                        break;
660
661
        }
661
662
        BLI_freelinkN(&linestyle->thickness_modifiers, m);
662
663
}
666
667
        size_t size;
667
668
 
668
669
        switch (type) {
669
 
        case LS_MODIFIER_SAMPLING:
670
 
                size = sizeof(LineStyleGeometryModifier_Sampling);
671
 
                break;
672
 
        case LS_MODIFIER_BEZIER_CURVE:
673
 
                size = sizeof(LineStyleGeometryModifier_BezierCurve);
674
 
                break;
675
 
        case LS_MODIFIER_SINUS_DISPLACEMENT:
676
 
                size = sizeof(LineStyleGeometryModifier_SinusDisplacement);
677
 
                break;
678
 
        case LS_MODIFIER_SPATIAL_NOISE:
679
 
                size = sizeof(LineStyleGeometryModifier_SpatialNoise);
680
 
                break;
681
 
        case LS_MODIFIER_PERLIN_NOISE_1D:
682
 
                size = sizeof(LineStyleGeometryModifier_PerlinNoise1D);
683
 
                break;
684
 
        case LS_MODIFIER_PERLIN_NOISE_2D:
685
 
                size = sizeof(LineStyleGeometryModifier_PerlinNoise2D);
686
 
                break;
687
 
        case LS_MODIFIER_BACKBONE_STRETCHER:
688
 
                size = sizeof(LineStyleGeometryModifier_BackboneStretcher);
689
 
                break;
690
 
        case LS_MODIFIER_TIP_REMOVER:
691
 
                size = sizeof(LineStyleGeometryModifier_TipRemover);
692
 
                break;
693
 
        case LS_MODIFIER_POLYGONIZATION:
694
 
                size = sizeof(LineStyleGeometryModifier_Polygonalization);
695
 
                break;
696
 
        case LS_MODIFIER_GUIDING_LINES:
697
 
                size = sizeof(LineStyleGeometryModifier_GuidingLines);
698
 
                break;
699
 
        case LS_MODIFIER_BLUEPRINT:
700
 
                size = sizeof(LineStyleGeometryModifier_Blueprint);
701
 
                break;
702
 
        case LS_MODIFIER_2D_OFFSET:
703
 
                size = sizeof(LineStyleGeometryModifier_2DOffset);
704
 
                break;
705
 
        case LS_MODIFIER_2D_TRANSFORM:
706
 
                size = sizeof(LineStyleGeometryModifier_2DTransform);
707
 
                break;
708
 
        default:
709
 
                return NULL; /* unknown modifier type */
 
670
                case LS_MODIFIER_SAMPLING:
 
671
                        size = sizeof(LineStyleGeometryModifier_Sampling);
 
672
                        break;
 
673
                case LS_MODIFIER_BEZIER_CURVE:
 
674
                        size = sizeof(LineStyleGeometryModifier_BezierCurve);
 
675
                        break;
 
676
                case LS_MODIFIER_SINUS_DISPLACEMENT:
 
677
                        size = sizeof(LineStyleGeometryModifier_SinusDisplacement);
 
678
                        break;
 
679
                case LS_MODIFIER_SPATIAL_NOISE:
 
680
                        size = sizeof(LineStyleGeometryModifier_SpatialNoise);
 
681
                        break;
 
682
                case LS_MODIFIER_PERLIN_NOISE_1D:
 
683
                        size = sizeof(LineStyleGeometryModifier_PerlinNoise1D);
 
684
                        break;
 
685
                case LS_MODIFIER_PERLIN_NOISE_2D:
 
686
                        size = sizeof(LineStyleGeometryModifier_PerlinNoise2D);
 
687
                        break;
 
688
                case LS_MODIFIER_BACKBONE_STRETCHER:
 
689
                        size = sizeof(LineStyleGeometryModifier_BackboneStretcher);
 
690
                        break;
 
691
                case LS_MODIFIER_TIP_REMOVER:
 
692
                        size = sizeof(LineStyleGeometryModifier_TipRemover);
 
693
                        break;
 
694
                case LS_MODIFIER_POLYGONIZATION:
 
695
                        size = sizeof(LineStyleGeometryModifier_Polygonalization);
 
696
                        break;
 
697
                case LS_MODIFIER_GUIDING_LINES:
 
698
                        size = sizeof(LineStyleGeometryModifier_GuidingLines);
 
699
                        break;
 
700
                case LS_MODIFIER_BLUEPRINT:
 
701
                        size = sizeof(LineStyleGeometryModifier_Blueprint);
 
702
                        break;
 
703
                case LS_MODIFIER_2D_OFFSET:
 
704
                        size = sizeof(LineStyleGeometryModifier_2DOffset);
 
705
                        break;
 
706
                case LS_MODIFIER_2D_TRANSFORM:
 
707
                        size = sizeof(LineStyleGeometryModifier_2DTransform);
 
708
                        break;
 
709
                default:
 
710
                        return NULL; /* unknown modifier type */
710
711
        }
711
712
 
712
713
        return new_modifier(type, size);
719
720
        m = alloc_geometry_modifier(type);
720
721
 
721
722
        switch (type) {
722
 
        case LS_MODIFIER_SAMPLING:
 
723
                case LS_MODIFIER_SAMPLING:
723
724
                {
724
725
                        LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
725
726
                        p->sampling = 10.0f;
 
727
                        break;
726
728
                }
727
 
                break;
728
 
        case LS_MODIFIER_BEZIER_CURVE:
 
729
                case LS_MODIFIER_BEZIER_CURVE:
729
730
                {
730
731
                        LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
731
732
                        p->error = 10.0f;
 
733
                        break;
732
734
                }
733
 
                break;
734
 
        case LS_MODIFIER_SINUS_DISPLACEMENT:
 
735
                case LS_MODIFIER_SINUS_DISPLACEMENT:
735
736
                {
736
737
                        LineStyleGeometryModifier_SinusDisplacement *p = (LineStyleGeometryModifier_SinusDisplacement *)m;
737
738
                        p->wavelength = 20.0f;
738
739
                        p->amplitude = 5.0f;
739
740
                        p->phase = 0.0f;
 
741
                        break;
740
742
                }
741
 
                break;
742
 
        case LS_MODIFIER_SPATIAL_NOISE:
 
743
                case LS_MODIFIER_SPATIAL_NOISE:
743
744
                {
744
745
                        LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
745
746
                        p->amplitude = 5.0f;
746
747
                        p->scale = 20.0f;
747
748
                        p->octaves = 4;
748
749
                        p->flags = LS_MODIFIER_SPATIAL_NOISE_SMOOTH | LS_MODIFIER_SPATIAL_NOISE_PURERANDOM;
 
750
                        break;
749
751
                }
750
 
                break;
751
 
        case LS_MODIFIER_PERLIN_NOISE_1D:
 
752
                case LS_MODIFIER_PERLIN_NOISE_1D:
752
753
                {
753
754
                        LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
754
755
                        p->frequency = 10.0f;
755
756
                        p->amplitude = 10.0f;
756
757
                        p->octaves = 4;
757
758
                        p->angle = DEG2RADF(45.0f);
 
759
                        break;
758
760
                }
759
 
                break;
760
 
        case LS_MODIFIER_PERLIN_NOISE_2D:
 
761
                case LS_MODIFIER_PERLIN_NOISE_2D:
761
762
                {
762
763
                        LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
763
764
                        p->frequency = 10.0f;
764
765
                        p->amplitude = 10.0f;
765
766
                        p->octaves = 4;
766
767
                        p->angle = DEG2RADF(45.0f);
 
768
                        break;
767
769
                }
768
 
                break;
769
 
        case LS_MODIFIER_BACKBONE_STRETCHER:
 
770
                case LS_MODIFIER_BACKBONE_STRETCHER:
770
771
                {
771
772
                        LineStyleGeometryModifier_BackboneStretcher *p = (LineStyleGeometryModifier_BackboneStretcher *)m;
772
773
                        p->backbone_length = 10.0f;
 
774
                        break;
773
775
                }
774
 
                break;
775
 
        case LS_MODIFIER_TIP_REMOVER:
 
776
                case LS_MODIFIER_TIP_REMOVER:
776
777
                {
777
778
                        LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
778
779
                        p->tip_length = 10.0f;
 
780
                        break;
779
781
                }
780
 
                break;
781
 
        case LS_MODIFIER_POLYGONIZATION:
 
782
                case LS_MODIFIER_POLYGONIZATION:
782
783
                {
783
784
                        LineStyleGeometryModifier_Polygonalization *p = (LineStyleGeometryModifier_Polygonalization *)m;
784
785
                        p->error = 10.0f;
 
786
                        break;
785
787
                }
786
 
                break;
787
 
        case LS_MODIFIER_GUIDING_LINES:
 
788
                case LS_MODIFIER_GUIDING_LINES:
788
789
                {
789
790
                        LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
790
791
                        p->offset = 0.0f;
 
792
                        break;
791
793
                }
792
 
                break;
793
 
        case LS_MODIFIER_BLUEPRINT:
 
794
                case LS_MODIFIER_BLUEPRINT:
794
795
                {
795
796
                        LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
796
797
                        p->flags = LS_MODIFIER_BLUEPRINT_CIRCLES;
799
800
                        p->random_radius = 3;
800
801
                        p->random_center = 5;
801
802
                        p->random_backbone = 5;
 
803
                        break;
802
804
                }
803
 
                break;
804
 
        case LS_MODIFIER_2D_OFFSET:
 
805
                case LS_MODIFIER_2D_OFFSET:
805
806
                {
806
807
                        LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
807
808
                        p->start = 0.0f;
808
809
                        p->end = 0.0f;
809
810
                        p->x = 0.0f;
810
811
                        p->y = 0.0f;
 
812
                        break;
811
813
                }
812
 
                break;
813
 
        case LS_MODIFIER_2D_TRANSFORM:
 
814
                case LS_MODIFIER_2D_TRANSFORM:
814
815
                {
815
816
                        LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
816
817
                        p->pivot = LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER;
820
821
                        p->pivot_u = 0.5f;
821
822
                        p->pivot_x = 0.0f;
822
823
                        p->pivot_y = 0.0f;
 
824
                        break;
823
825
                }
824
 
                break;
825
 
        default:
826
 
                return NULL; /* unknown modifier type */
 
826
                default:
 
827
                        return NULL; /* unknown modifier type */
827
828
        }
828
829
        add_to_modifier_list(&linestyle->geometry_modifiers, m);
829
830
 
838
839
        new_m->flags = m->flags;
839
840
 
840
841
        switch (m->type) {
841
 
        case LS_MODIFIER_SAMPLING:
 
842
                case LS_MODIFIER_SAMPLING:
842
843
                {
843
844
                        LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
844
845
                        LineStyleGeometryModifier_Sampling *q = (LineStyleGeometryModifier_Sampling *)new_m;
845
846
                        q->sampling = p->sampling;
 
847
                        break;
846
848
                }
847
 
                break;
848
 
        case LS_MODIFIER_BEZIER_CURVE:
 
849
                case LS_MODIFIER_BEZIER_CURVE:
849
850
                {
850
851
                        LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
851
852
                        LineStyleGeometryModifier_BezierCurve *q = (LineStyleGeometryModifier_BezierCurve *)new_m;
852
853
                        q->error = p->error;
 
854
                        break;
853
855
                }
854
 
                break;
855
 
        case LS_MODIFIER_SINUS_DISPLACEMENT:
 
856
                case LS_MODIFIER_SINUS_DISPLACEMENT:
856
857
                {
857
858
                        LineStyleGeometryModifier_SinusDisplacement *p = (LineStyleGeometryModifier_SinusDisplacement *)m;
858
859
                        LineStyleGeometryModifier_SinusDisplacement *q = (LineStyleGeometryModifier_SinusDisplacement *)new_m;
859
860
                        q->wavelength = p->wavelength;
860
861
                        q->amplitude = p->amplitude;
861
862
                        q->phase = p->phase;
 
863
                        break;
862
864
                }
863
 
                break;
864
 
        case LS_MODIFIER_SPATIAL_NOISE:
 
865
                case LS_MODIFIER_SPATIAL_NOISE:
865
866
                {
866
867
                        LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
867
868
                        LineStyleGeometryModifier_SpatialNoise *q = (LineStyleGeometryModifier_SpatialNoise *)new_m;
869
870
                        q->scale = p->scale;
870
871
                        q->octaves = p->octaves;
871
872
                        q->flags = p->flags;
 
873
                        break;
872
874
                }
873
 
                break;
874
 
        case LS_MODIFIER_PERLIN_NOISE_1D:
 
875
                case LS_MODIFIER_PERLIN_NOISE_1D:
875
876
                {
876
877
                        LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
877
878
                        LineStyleGeometryModifier_PerlinNoise1D *q = (LineStyleGeometryModifier_PerlinNoise1D *)new_m;
880
881
                        q->angle = p->angle;
881
882
                        q->octaves = p->octaves;
882
883
                        q->seed = p->seed;
 
884
                        break;
883
885
                }
884
 
                break;
885
 
        case LS_MODIFIER_PERLIN_NOISE_2D:
 
886
                case LS_MODIFIER_PERLIN_NOISE_2D:
886
887
                {
887
888
                        LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
888
889
                        LineStyleGeometryModifier_PerlinNoise2D *q = (LineStyleGeometryModifier_PerlinNoise2D *)new_m;
891
892
                        q->angle = p->angle;
892
893
                        q->octaves = p->octaves;
893
894
                        q->seed = p->seed;
 
895
                        break;
894
896
                }
895
 
                break;
896
 
        case LS_MODIFIER_BACKBONE_STRETCHER:
 
897
                case LS_MODIFIER_BACKBONE_STRETCHER:
897
898
                {
898
899
                        LineStyleGeometryModifier_BackboneStretcher *p = (LineStyleGeometryModifier_BackboneStretcher *)m;
899
900
                        LineStyleGeometryModifier_BackboneStretcher *q = (LineStyleGeometryModifier_BackboneStretcher *)new_m;
900
901
                        q->backbone_length = p->backbone_length;
 
902
                        break;
901
903
                }
902
 
                break;
903
 
        case LS_MODIFIER_TIP_REMOVER:
 
904
                case LS_MODIFIER_TIP_REMOVER:
904
905
                {
905
906
                        LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
906
907
                        LineStyleGeometryModifier_TipRemover *q = (LineStyleGeometryModifier_TipRemover *)new_m;
907
908
                        q->tip_length = p->tip_length;
 
909
                        break;
908
910
                }
909
 
                break;
910
 
        case LS_MODIFIER_POLYGONIZATION:
 
911
                case LS_MODIFIER_POLYGONIZATION:
911
912
                {
912
913
                        LineStyleGeometryModifier_Polygonalization *p = (LineStyleGeometryModifier_Polygonalization *)m;
913
914
                        LineStyleGeometryModifier_Polygonalization *q = (LineStyleGeometryModifier_Polygonalization *)new_m;
914
915
                        q->error = p->error;
 
916
                        break;
915
917
                }
916
 
                break;
917
 
        case LS_MODIFIER_GUIDING_LINES:
 
918
                case LS_MODIFIER_GUIDING_LINES:
918
919
                {
919
920
                        LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
920
921
                        LineStyleGeometryModifier_GuidingLines *q = (LineStyleGeometryModifier_GuidingLines *)new_m;
921
922
                        q->offset = p->offset;
 
923
                        break;
922
924
                }
923
 
                break;
924
 
        case LS_MODIFIER_BLUEPRINT:
 
925
                case LS_MODIFIER_BLUEPRINT:
925
926
                {
926
927
                        LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
927
928
                        LineStyleGeometryModifier_Blueprint *q = (LineStyleGeometryModifier_Blueprint *)new_m;
931
932
                        q->random_radius = p->random_radius;
932
933
                        q->random_center = p->random_center;
933
934
                        q->random_backbone = p->random_backbone;
 
935
                        break;
934
936
                }
935
 
                break;
936
 
        case LS_MODIFIER_2D_OFFSET:
 
937
                case LS_MODIFIER_2D_OFFSET:
937
938
                {
938
939
                        LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
939
940
                        LineStyleGeometryModifier_2DOffset *q = (LineStyleGeometryModifier_2DOffset *)new_m;
941
942
                        q->end = p->end;
942
943
                        q->x = p->x;
943
944
                        q->y = p->y;
 
945
                        break;
944
946
                }
945
 
                break;
946
 
        case LS_MODIFIER_2D_TRANSFORM:
 
947
                case LS_MODIFIER_2D_TRANSFORM:
947
948
                {
948
949
                        LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
949
950
                        LineStyleGeometryModifier_2DTransform *q = (LineStyleGeometryModifier_2DTransform *)new_m;
954
955
                        q->pivot_u = p->pivot_u;
955
956
                        q->pivot_x = p->pivot_x;
956
957
                        q->pivot_y = p->pivot_y;
 
958
                        break;
957
959
                }
958
 
                break;
959
 
        default:
960
 
                return NULL; /* unknown modifier type */
 
960
                default:
 
961
                        return NULL; /* unknown modifier type */
961
962
        }
962
963
        add_to_modifier_list(&linestyle->geometry_modifiers, new_m);
963
964
 
1007
1008
        listbase->first = listbase->last = NULL;
1008
1009
        for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
1009
1010
                switch (m->type) {
1010
 
                case LS_MODIFIER_ALONG_STROKE:
1011
 
                        color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;
1012
 
                        break;
1013
 
                case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1014
 
                        color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;
1015
 
                        break;
1016
 
                case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1017
 
                        color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;
1018
 
                        break;
1019
 
                case LS_MODIFIER_MATERIAL:
1020
 
                        color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;
1021
 
                        break;
1022
 
                default:
1023
 
                        continue;
 
1011
                        case LS_MODIFIER_ALONG_STROKE:
 
1012
                                color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;
 
1013
                                break;
 
1014
                        case LS_MODIFIER_DISTANCE_FROM_CAMERA:
 
1015
                                color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;
 
1016
                                break;
 
1017
                        case LS_MODIFIER_DISTANCE_FROM_OBJECT:
 
1018
                                color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;
 
1019
                                break;
 
1020
                        case LS_MODIFIER_MATERIAL:
 
1021
                                color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;
 
1022
                                break;
 
1023
                        default:
 
1024
                                continue;
1024
1025
                }
1025
1026
                link = (LinkData *) MEM_callocN( sizeof(LinkData), "link to color ramp");
1026
1027
                link->data = color_ramp;