2012-12-11 23:00:22 +01:00
|
|
|
/*
|
2010-06-26 00:45:42 +02:00
|
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*
|
|
|
|
* The Original Code is Copyright (C) 2010 Blender Foundation.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* The Original Code is: all of this file.
|
|
|
|
*
|
|
|
|
* Contributor(s): none yet.
|
|
|
|
*
|
|
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
|
|
*/
|
|
|
|
|
2012-12-11 23:00:22 +01:00
|
|
|
/** \file blender/blenkernel/intern/linestyle.c
|
|
|
|
* \ingroup bke
|
|
|
|
*/
|
|
|
|
|
2010-06-26 00:45:42 +02:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2010-10-24 18:10:45 +02:00
|
|
|
#include <string.h>
|
2010-06-26 00:45:42 +02:00
|
|
|
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
#include "DNA_object_types.h"
|
2010-07-20 19:57:33 +02:00
|
|
|
#include "DNA_material_types.h" /* for ramp blend */
|
2010-09-18 02:31:22 +02:00
|
|
|
#include "DNA_texture_types.h"
|
2010-07-20 19:57:33 +02:00
|
|
|
|
2013-03-18 01:48:59 +01:00
|
|
|
#include "BLI_blenlib.h"
|
|
|
|
#include "BLI_math.h"
|
|
|
|
#include "BLI_utildefines.h"
|
|
|
|
|
2010-06-26 00:45:42 +02:00
|
|
|
#include "BKE_global.h"
|
|
|
|
#include "BKE_library.h"
|
|
|
|
#include "BKE_linestyle.h"
|
|
|
|
#include "BKE_main.h"
|
2010-07-20 19:57:33 +02:00
|
|
|
#include "BKE_texture.h"
|
|
|
|
#include "BKE_colortools.h"
|
2010-09-18 02:31:22 +02:00
|
|
|
#include "BKE_animsys.h"
|
2010-07-20 19:57:33 +02:00
|
|
|
|
2012-12-08 23:24:41 +01:00
|
|
|
static const char *modifier_name[LS_MODIFIER_NUM] = {
|
2010-07-20 19:57:33 +02:00
|
|
|
NULL,
|
|
|
|
"Along Stroke",
|
|
|
|
"Distance from Camera",
|
2011-07-25 01:29:19 +02:00
|
|
|
"Distance from Object",
|
2011-08-19 16:05:11 +02:00
|
|
|
"Material",
|
|
|
|
"Sampling",
|
|
|
|
"Bezier Curve",
|
|
|
|
"Sinus Displacement",
|
|
|
|
"Spatial Noise",
|
|
|
|
"Perlin Noise 1D",
|
|
|
|
"Perlin Noise 2D",
|
|
|
|
"Backbone Stretcher",
|
2011-09-11 21:57:38 +02:00
|
|
|
"Tip Remover",
|
2011-11-01 10:47:41 +01:00
|
|
|
"Calligraphy",
|
|
|
|
"Polygonalization",
|
2011-11-11 21:35:03 +01:00
|
|
|
"Guiding Lines",
|
2012-01-04 01:23:34 +01:00
|
|
|
"Blueprint",
|
|
|
|
"2D Offset",
|
2012-12-11 23:00:22 +01:00
|
|
|
"2D Transform",
|
|
|
|
};
|
2010-06-26 00:45:42 +02:00
|
|
|
|
2010-06-27 02:03:34 +02:00
|
|
|
static void default_linestyle_settings(FreestyleLineStyle *linestyle)
|
|
|
|
{
|
2011-08-19 16:05:11 +02:00
|
|
|
linestyle->panel = LS_PANEL_STROKES;
|
2013-03-30 17:42:59 +01:00
|
|
|
linestyle->r = linestyle->g = linestyle->b = 0.0f;
|
2012-12-11 23:00:22 +01:00
|
|
|
linestyle->alpha = 1.0f;
|
2013-03-30 17:42:59 +01:00
|
|
|
linestyle->thickness = 3.0f;
|
2012-04-07 19:28:09 +02:00
|
|
|
linestyle->thickness_position = LS_THICKNESS_CENTER;
|
|
|
|
linestyle->thickness_ratio = 0.5f;
|
2011-09-20 01:24:14 +02:00
|
|
|
linestyle->chaining = LS_CHAINING_PLAIN;
|
2011-09-20 00:40:44 +02:00
|
|
|
linestyle->rounds = 3;
|
2012-12-11 23:00:22 +01:00
|
|
|
linestyle->min_angle = DEG2RADF(0.0f);
|
|
|
|
linestyle->max_angle = DEG2RADF(0.0f);
|
2011-09-19 00:59:51 +02:00
|
|
|
linestyle->min_length = 0.0f;
|
|
|
|
linestyle->max_length = 10000.0f;
|
2011-12-12 00:41:15 +01:00
|
|
|
linestyle->split_length = 100;
|
2010-06-27 02:03:34 +02:00
|
|
|
|
2010-07-20 19:57:33 +02:00
|
|
|
linestyle->color_modifiers.first = linestyle->color_modifiers.last = NULL;
|
|
|
|
linestyle->alpha_modifiers.first = linestyle->alpha_modifiers.last = NULL;
|
|
|
|
linestyle->thickness_modifiers.first = linestyle->thickness_modifiers.last = NULL;
|
2011-08-19 16:05:11 +02:00
|
|
|
linestyle->geometry_modifiers.first = linestyle->geometry_modifiers.last = NULL;
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_add_linestyle_geometry_modifier(linestyle, LS_MODIFIER_SAMPLING);
|
2010-10-11 00:50:32 +02:00
|
|
|
|
|
|
|
linestyle->caps = LS_CAPS_BUTT;
|
2010-06-27 02:03:34 +02:00
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
FreestyleLineStyle *BKE_new_linestyle(const char *name, struct Main *main)
|
2010-06-26 00:45:42 +02:00
|
|
|
{
|
|
|
|
FreestyleLineStyle *linestyle;
|
|
|
|
|
|
|
|
if (!main)
|
|
|
|
main = G.main;
|
|
|
|
|
2012-05-12 00:48:41 +02:00
|
|
|
linestyle = (FreestyleLineStyle *)BKE_libblock_alloc(&main->linestyle, ID_LS, name);
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2010-06-27 02:03:34 +02:00
|
|
|
default_linestyle_settings(linestyle);
|
2010-06-26 00:45:42 +02:00
|
|
|
|
|
|
|
return linestyle;
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_free_linestyle(FreestyleLineStyle *linestyle)
|
2010-06-26 00:45:42 +02:00
|
|
|
{
|
2010-07-20 19:57:33 +02:00
|
|
|
LineStyleModifier *m;
|
|
|
|
|
2010-09-18 02:31:22 +02:00
|
|
|
BKE_free_animdata(&linestyle->id);
|
2010-07-20 19:57:33 +02:00
|
|
|
while ((m = (LineStyleModifier *)linestyle->color_modifiers.first))
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_remove_linestyle_color_modifier(linestyle, m);
|
2010-07-20 19:57:33 +02:00
|
|
|
while ((m = (LineStyleModifier *)linestyle->alpha_modifiers.first))
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_remove_linestyle_alpha_modifier(linestyle, m);
|
2010-07-20 19:57:33 +02:00
|
|
|
while ((m = (LineStyleModifier *)linestyle->thickness_modifiers.first))
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_remove_linestyle_thickness_modifier(linestyle, m);
|
2011-08-19 16:05:11 +02:00
|
|
|
while ((m = (LineStyleModifier *)linestyle->geometry_modifiers.first))
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_remove_linestyle_geometry_modifier(linestyle, m);
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
FreestyleLineStyle *BKE_copy_linestyle(FreestyleLineStyle *linestyle)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
FreestyleLineStyle *new_linestyle;
|
|
|
|
LineStyleModifier *m;
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
new_linestyle = BKE_new_linestyle(linestyle->id.name + 2, NULL);
|
|
|
|
BKE_free_linestyle(new_linestyle);
|
2011-11-14 01:43:37 +01:00
|
|
|
|
|
|
|
new_linestyle->r = linestyle->r;
|
|
|
|
new_linestyle->g = linestyle->g;
|
|
|
|
new_linestyle->b = linestyle->b;
|
|
|
|
new_linestyle->alpha = linestyle->alpha;
|
|
|
|
new_linestyle->thickness = linestyle->thickness;
|
2012-04-07 19:28:09 +02:00
|
|
|
new_linestyle->thickness_position = linestyle->thickness_position;
|
|
|
|
new_linestyle->thickness_ratio = linestyle->thickness_ratio;
|
2011-11-14 01:43:37 +01:00
|
|
|
new_linestyle->flag = linestyle->flag;
|
|
|
|
new_linestyle->caps = linestyle->caps;
|
|
|
|
new_linestyle->chaining = linestyle->chaining;
|
|
|
|
new_linestyle->rounds = linestyle->rounds;
|
2013-04-25 18:23:23 +02:00
|
|
|
new_linestyle->split_length = linestyle->split_length;
|
2011-11-14 01:43:37 +01:00
|
|
|
new_linestyle->min_angle = linestyle->min_angle;
|
|
|
|
new_linestyle->max_angle = linestyle->max_angle;
|
|
|
|
new_linestyle->min_length = linestyle->min_length;
|
|
|
|
new_linestyle->max_length = linestyle->max_length;
|
2013-04-25 18:23:23 +02:00
|
|
|
new_linestyle->split_dash1 = linestyle->split_dash1;
|
|
|
|
new_linestyle->split_gap1 = linestyle->split_gap1;
|
|
|
|
new_linestyle->split_dash2 = linestyle->split_dash2;
|
|
|
|
new_linestyle->split_gap2 = linestyle->split_gap2;
|
|
|
|
new_linestyle->split_dash3 = linestyle->split_dash3;
|
|
|
|
new_linestyle->split_gap3 = linestyle->split_gap3;
|
2011-11-14 01:43:37 +01:00
|
|
|
new_linestyle->dash1 = linestyle->dash1;
|
|
|
|
new_linestyle->gap1 = linestyle->gap1;
|
|
|
|
new_linestyle->dash2 = linestyle->dash2;
|
|
|
|
new_linestyle->gap2 = linestyle->gap2;
|
|
|
|
new_linestyle->dash3 = linestyle->dash3;
|
|
|
|
new_linestyle->gap3 = linestyle->gap3;
|
|
|
|
new_linestyle->panel = linestyle->panel;
|
|
|
|
for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next)
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_copy_linestyle_color_modifier(new_linestyle, m);
|
2011-11-14 01:43:37 +01:00
|
|
|
for (m = (LineStyleModifier *)linestyle->alpha_modifiers.first; m; m = m->next)
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_copy_linestyle_alpha_modifier(new_linestyle, m);
|
2011-11-14 01:43:37 +01:00
|
|
|
for (m = (LineStyleModifier *)linestyle->thickness_modifiers.first; m; m = m->next)
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_copy_linestyle_thickness_modifier(new_linestyle, m);
|
2011-11-14 01:43:37 +01:00
|
|
|
for (m = (LineStyleModifier *)linestyle->geometry_modifiers.first; m; m = m->next)
|
2013-03-23 04:00:37 +01:00
|
|
|
BKE_copy_linestyle_geometry_modifier(new_linestyle, m);
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
return new_linestyle;
|
|
|
|
}
|
|
|
|
|
2010-07-20 19:57:33 +02:00
|
|
|
static LineStyleModifier *new_modifier(int type, size_t size)
|
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
|
|
|
|
|
|
|
m = (LineStyleModifier *)MEM_callocN(size, "line style modifier");
|
2013-03-20 00:54:14 +01:00
|
|
|
m->type = type;
|
2013-07-13 07:50:35 +02:00
|
|
|
BLI_strncpy(m->name, modifier_name[type], sizeof(m->name));
|
2013-03-20 00:54:14 +01:00
|
|
|
m->influence = 1.0f;
|
|
|
|
m->flags = LS_MODIFIER_ENABLED | LS_MODIFIER_EXPANDED;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2010-07-20 19:57:33 +02:00
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_to_modifier_list(ListBase *lb, LineStyleModifier *m)
|
|
|
|
{
|
|
|
|
BLI_addtail(lb, (void *)m);
|
2011-10-29 17:46:14 +02:00
|
|
|
BLI_uniquename(lb, m, modifier_name[m->type], '.', offsetof(LineStyleModifier, name), sizeof(m->name));
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
static LineStyleModifier *alloc_color_modifier(int type)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
2011-08-19 16:05:11 +02:00
|
|
|
size_t size;
|
2010-07-20 19:57:33 +02:00
|
|
|
|
2011-08-19 16:05:11 +02:00
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
size = sizeof(LineStyleColorModifier_AlongStroke);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
size = sizeof(LineStyleColorModifier_DistanceFromCamera);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
size = sizeof(LineStyleColorModifier_DistanceFromObject);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
size = sizeof(LineStyleColorModifier_Material);
|
|
|
|
break;
|
|
|
|
default:
|
2011-11-14 01:43:37 +01:00
|
|
|
return NULL; /* unknown modifier type */
|
2011-08-19 16:05:11 +02:00
|
|
|
}
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
return new_modifier(type, size);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_add_linestyle_color_modifier(FreestyleLineStyle *linestyle, int type)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
m = alloc_color_modifier(type);
|
2011-08-19 16:05:11 +02:00
|
|
|
m->blend = MA_RAMP_BLEND;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2010-07-20 19:57:33 +02:00
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
((LineStyleColorModifier_AlongStroke *)m)->color_ramp = add_colorband(1);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp = add_colorband(1);
|
|
|
|
((LineStyleColorModifier_DistanceFromCamera *)m)->range_min = 0.0f;
|
|
|
|
((LineStyleColorModifier_DistanceFromCamera *)m)->range_max = 10000.0f;
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
((LineStyleColorModifier_DistanceFromObject *)m)->target = NULL;
|
|
|
|
((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp = add_colorband(1);
|
|
|
|
((LineStyleColorModifier_DistanceFromObject *)m)->range_min = 0.0f;
|
|
|
|
((LineStyleColorModifier_DistanceFromObject *)m)->range_max = 10000.0f;
|
|
|
|
break;
|
2011-07-25 01:29:19 +02:00
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
((LineStyleColorModifier_Material *)m)->color_ramp = add_colorband(1);
|
|
|
|
((LineStyleColorModifier_Material *)m)->mat_attr = LS_MODIFIER_MATERIAL_DIFF;
|
|
|
|
break;
|
2010-07-20 19:57:33 +02:00
|
|
|
default:
|
2011-11-14 01:43:37 +01:00
|
|
|
return NULL; /* unknown modifier type */
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->color_modifiers, m);
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_copy_linestyle_color_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *new_m;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
new_m = alloc_color_modifier(m->type);
|
|
|
|
new_m->influence = m->influence;
|
|
|
|
new_m->flags = m->flags;
|
|
|
|
new_m->blend = m->blend;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
{
|
|
|
|
LineStyleColorModifier_AlongStroke *p = (LineStyleColorModifier_AlongStroke *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleColorModifier_AlongStroke *q = (LineStyleColorModifier_AlongStroke *)new_m;
|
|
|
|
q->color_ramp = MEM_dupallocN(p->color_ramp);
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
{
|
|
|
|
LineStyleColorModifier_DistanceFromCamera *p = (LineStyleColorModifier_DistanceFromCamera *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleColorModifier_DistanceFromCamera *q = (LineStyleColorModifier_DistanceFromCamera *)new_m;
|
|
|
|
q->color_ramp = MEM_dupallocN(p->color_ramp);
|
|
|
|
q->range_min = p->range_min;
|
|
|
|
q->range_max = p->range_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
{
|
|
|
|
LineStyleColorModifier_DistanceFromObject *p = (LineStyleColorModifier_DistanceFromObject *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleColorModifier_DistanceFromObject *q = (LineStyleColorModifier_DistanceFromObject *)new_m;
|
2011-11-14 01:43:37 +01:00
|
|
|
if (p->target)
|
|
|
|
p->target->id.us++;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->target = p->target;
|
|
|
|
q->color_ramp = MEM_dupallocN(p->color_ramp);
|
|
|
|
q->range_min = p->range_min;
|
|
|
|
q->range_max = p->range_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
{
|
|
|
|
LineStyleColorModifier_Material *p = (LineStyleColorModifier_Material *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleColorModifier_Material *q = (LineStyleColorModifier_Material *)new_m;
|
|
|
|
q->color_ramp = MEM_dupallocN(p->color_ramp);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->mat_attr = p->mat_attr;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL; /* unknown modifier type */
|
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->color_modifiers, new_m);
|
|
|
|
|
|
|
|
return new_m;
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_remove_linestyle_color_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
MEM_freeN(((LineStyleColorModifier_AlongStroke *)m)->color_ramp);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
MEM_freeN(((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
MEM_freeN(((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
|
|
|
|
break;
|
2011-07-25 01:29:19 +02:00
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);
|
|
|
|
break;
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
BLI_freelinkN(&linestyle->color_modifiers, m);
|
|
|
|
}
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
static LineStyleModifier *alloc_alpha_modifier(int type)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
2011-08-19 16:05:11 +02:00
|
|
|
size_t size;
|
2010-07-20 19:57:33 +02:00
|
|
|
|
2011-08-19 16:05:11 +02:00
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
size = sizeof(LineStyleAlphaModifier_AlongStroke);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
size = sizeof(LineStyleAlphaModifier_DistanceFromCamera);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
size = sizeof(LineStyleAlphaModifier_DistanceFromObject);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
size = sizeof(LineStyleAlphaModifier_Material);
|
|
|
|
break;
|
|
|
|
default:
|
2011-11-14 01:43:37 +01:00
|
|
|
return NULL; /* unknown modifier type */
|
2011-08-19 16:05:11 +02:00
|
|
|
}
|
2011-11-14 01:43:37 +01:00
|
|
|
return new_modifier(type, size);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_add_linestyle_alpha_modifier(FreestyleLineStyle *linestyle, int type)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
m = alloc_alpha_modifier(type);
|
2011-08-19 16:05:11 +02:00
|
|
|
m->blend = LS_VALUE_BLEND;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2010-07-20 19:57:33 +02:00
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
}
|
2010-07-20 19:57:33 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)m;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
p->range_min = 0.0f;
|
|
|
|
p->range_max = 10000.0f;
|
|
|
|
}
|
2010-07-20 19:57:33 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)m;
|
|
|
|
p->target = NULL;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
p->range_min = 0.0f;
|
|
|
|
p->range_max = 10000.0f;
|
|
|
|
}
|
2010-07-20 19:57:33 +02:00
|
|
|
break;
|
2011-07-25 01:29:19 +02:00
|
|
|
case LS_MODIFIER_MATERIAL:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
p->mat_attr = LS_MODIFIER_MATERIAL_DIFF;
|
|
|
|
}
|
2011-07-25 01:29:19 +02:00
|
|
|
break;
|
2011-11-14 01:43:37 +01:00
|
|
|
default:
|
|
|
|
return NULL; /* unknown modifier type */
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->alpha_modifiers, m);
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_copy_linestyle_alpha_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *new_m;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
new_m = alloc_alpha_modifier(m->type);
|
|
|
|
new_m->influence = m->influence;
|
|
|
|
new_m->flags = m->flags;
|
|
|
|
new_m->blend = m->blend;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleAlphaModifier_AlongStroke *q = (LineStyleAlphaModifier_AlongStroke *)new_m;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleAlphaModifier_DistanceFromCamera *q = (LineStyleAlphaModifier_DistanceFromCamera *)new_m;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->range_min = p->range_min;
|
|
|
|
q->range_max = p->range_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleAlphaModifier_DistanceFromObject *q = (LineStyleAlphaModifier_DistanceFromObject *)new_m;
|
2011-11-14 01:43:37 +01:00
|
|
|
if (p->target)
|
|
|
|
p->target->id.us++;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->target = p->target;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->range_min = p->range_min;
|
|
|
|
q->range_max = p->range_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
{
|
|
|
|
LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleAlphaModifier_Material *q = (LineStyleAlphaModifier_Material *)new_m;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->mat_attr = p->mat_attr;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL; /* unknown modifier type */
|
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->alpha_modifiers, new_m);
|
|
|
|
|
|
|
|
return new_m;
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_remove_linestyle_alpha_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
curvemapping_free(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
curvemapping_free(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
curvemapping_free(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
|
|
|
|
break;
|
2011-07-25 01:29:19 +02:00
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
curvemapping_free(((LineStyleAlphaModifier_Material *)m)->curve);
|
|
|
|
break;
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
BLI_freelinkN(&linestyle->alpha_modifiers, m);
|
|
|
|
}
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
static LineStyleModifier *alloc_thickness_modifier(int type)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
2011-08-19 16:05:11 +02:00
|
|
|
size_t size;
|
2010-07-20 19:57:33 +02:00
|
|
|
|
2011-08-19 16:05:11 +02:00
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
size = sizeof(LineStyleThicknessModifier_AlongStroke);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
size = sizeof(LineStyleThicknessModifier_DistanceFromCamera);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
size = sizeof(LineStyleThicknessModifier_DistanceFromObject);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
size = sizeof(LineStyleThicknessModifier_Material);
|
|
|
|
break;
|
2011-09-11 21:57:38 +02:00
|
|
|
case LS_MODIFIER_CALLIGRAPHY:
|
|
|
|
size = sizeof(LineStyleThicknessModifier_Calligraphy);
|
|
|
|
break;
|
2011-08-19 16:05:11 +02:00
|
|
|
default:
|
2011-11-14 01:43:37 +01:00
|
|
|
return NULL; /* unknown modifier type */
|
2011-08-19 16:05:11 +02:00
|
|
|
}
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
return new_modifier(type, size);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_add_linestyle_thickness_modifier(FreestyleLineStyle *linestyle, int type)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
|
|
|
|
|
|
|
m = alloc_thickness_modifier(type);
|
2011-08-19 16:05:11 +02:00
|
|
|
m->blend = LS_VALUE_BLEND;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2010-07-20 19:57:33 +02:00
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
p->value_min = 0.0f;
|
|
|
|
p->value_max = 1.0f;
|
|
|
|
}
|
2010-07-20 19:57:33 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_DistanceFromCamera *p = (LineStyleThicknessModifier_DistanceFromCamera *)m;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
p->range_min = 0.0f;
|
|
|
|
p->range_max = 1000.0f;
|
|
|
|
p->value_min = 0.0f;
|
|
|
|
p->value_max = 1.0f;
|
|
|
|
}
|
2010-07-20 19:57:33 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_DistanceFromObject *p = (LineStyleThicknessModifier_DistanceFromObject *)m;
|
|
|
|
p->target = NULL;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
p->range_min = 0.0f;
|
|
|
|
p->range_max = 1000.0f;
|
|
|
|
p->value_min = 0.0f;
|
|
|
|
p->value_max = 1.0f;
|
|
|
|
}
|
2010-07-20 19:57:33 +02:00
|
|
|
break;
|
2011-07-25 01:29:19 +02:00
|
|
|
case LS_MODIFIER_MATERIAL:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
|
|
|
|
p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
p->mat_attr = LS_MODIFIER_MATERIAL_DIFF;
|
|
|
|
p->value_min = 0.0f;
|
|
|
|
p->value_max = 1.0f;
|
|
|
|
}
|
2011-07-25 01:29:19 +02:00
|
|
|
break;
|
2011-09-11 21:57:38 +02:00
|
|
|
case LS_MODIFIER_CALLIGRAPHY:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
|
|
|
|
p->min_thickness = 1.0f;
|
|
|
|
p->max_thickness = 10.0f;
|
|
|
|
p->orientation = DEG2RADF(60.0f);
|
|
|
|
}
|
2011-09-11 21:57:38 +02:00
|
|
|
break;
|
2011-11-14 01:43:37 +01:00
|
|
|
default:
|
|
|
|
return NULL; /* unknown modifier type */
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->thickness_modifiers, m);
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_copy_linestyle_thickness_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *new_m;
|
|
|
|
|
|
|
|
new_m = alloc_thickness_modifier(m->type);
|
|
|
|
if (!new_m)
|
|
|
|
return NULL;
|
|
|
|
new_m->influence = m->influence;
|
|
|
|
new_m->flags = m->flags;
|
|
|
|
new_m->blend = m->blend;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleThicknessModifier_AlongStroke *q = (LineStyleThicknessModifier_AlongStroke *)new_m;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->value_min = p->value_min;
|
|
|
|
q->value_max = p->value_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_DistanceFromCamera *p = (LineStyleThicknessModifier_DistanceFromCamera *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleThicknessModifier_DistanceFromCamera *q = (LineStyleThicknessModifier_DistanceFromCamera *)new_m;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->range_min = p->range_min;
|
|
|
|
q->range_max = p->range_max;
|
|
|
|
q->value_min = p->value_min;
|
|
|
|
q->value_max = p->value_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_DistanceFromObject *p = (LineStyleThicknessModifier_DistanceFromObject *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleThicknessModifier_DistanceFromObject *q = (LineStyleThicknessModifier_DistanceFromObject *)new_m;
|
2011-11-14 01:43:37 +01:00
|
|
|
if (p->target)
|
|
|
|
p->target->id.us++;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->target = p->target;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->range_min = p->range_min;
|
|
|
|
q->range_max = p->range_max;
|
|
|
|
q->value_min = p->value_min;
|
|
|
|
q->value_max = p->value_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleThicknessModifier_Material *q = (LineStyleThicknessModifier_Material *)new_m;
|
|
|
|
q->curve = curvemapping_copy(p->curve);
|
2013-04-25 18:23:23 +02:00
|
|
|
q->flags = p->flags;
|
2013-03-20 00:54:14 +01:00
|
|
|
q->mat_attr = p->mat_attr;
|
|
|
|
q->value_min = p->value_min;
|
|
|
|
q->value_max = p->value_max;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_CALLIGRAPHY:
|
|
|
|
{
|
|
|
|
LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleThicknessModifier_Calligraphy *q = (LineStyleThicknessModifier_Calligraphy *)new_m;
|
|
|
|
q->min_thickness = p->min_thickness;
|
|
|
|
q->max_thickness = p->max_thickness;
|
|
|
|
q->orientation = p->orientation;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL; /* unknown modifier type */
|
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->thickness_modifiers, new_m);
|
|
|
|
|
|
|
|
return new_m;
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
2010-06-26 00:45:42 +02:00
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_remove_linestyle_thickness_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
|
|
|
|
break;
|
2011-07-25 01:29:19 +02:00
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);
|
|
|
|
break;
|
2011-09-11 21:57:38 +02:00
|
|
|
case LS_MODIFIER_CALLIGRAPHY:
|
|
|
|
break;
|
2010-07-20 19:57:33 +02:00
|
|
|
}
|
|
|
|
BLI_freelinkN(&linestyle->thickness_modifiers, m);
|
|
|
|
}
|
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
static LineStyleModifier *alloc_geometry_modifier(int type)
|
2011-08-19 16:05:11 +02:00
|
|
|
{
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_SAMPLING:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_Sampling);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_BEZIER_CURVE:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_BezierCurve);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_SINUS_DISPLACEMENT:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_SinusDisplacement);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_SPATIAL_NOISE:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_SpatialNoise);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_PERLIN_NOISE_1D:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_PerlinNoise1D);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_PERLIN_NOISE_2D:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_PerlinNoise2D);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_BACKBONE_STRETCHER:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_BackboneStretcher);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_TIP_REMOVER:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_TipRemover);
|
|
|
|
break;
|
2011-11-01 10:47:41 +01:00
|
|
|
case LS_MODIFIER_POLYGONIZATION:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_Polygonalization);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_GUIDING_LINES:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_GuidingLines);
|
|
|
|
break;
|
2011-11-11 21:35:03 +01:00
|
|
|
case LS_MODIFIER_BLUEPRINT:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_Blueprint);
|
|
|
|
break;
|
2012-01-04 01:23:34 +01:00
|
|
|
case LS_MODIFIER_2D_OFFSET:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_2DOffset);
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_2D_TRANSFORM:
|
|
|
|
size = sizeof(LineStyleGeometryModifier_2DTransform);
|
|
|
|
break;
|
2011-08-19 16:05:11 +02:00
|
|
|
default:
|
2011-11-14 01:43:37 +01:00
|
|
|
return NULL; /* unknown modifier type */
|
2011-08-19 16:05:11 +02:00
|
|
|
}
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
return new_modifier(type, size);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_add_linestyle_geometry_modifier(FreestyleLineStyle *linestyle, int type)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
|
|
|
|
|
|
|
m = alloc_geometry_modifier(type);
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-08-19 16:05:11 +02:00
|
|
|
switch (type) {
|
|
|
|
case LS_MODIFIER_SAMPLING:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
|
|
|
|
p->sampling = 10.0f;
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_BEZIER_CURVE:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
|
|
|
|
p->error = 10.0f;
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_SINUS_DISPLACEMENT:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_SinusDisplacement *p = (LineStyleGeometryModifier_SinusDisplacement *)m;
|
|
|
|
p->wavelength = 20.0f;
|
|
|
|
p->amplitude = 5.0f;
|
|
|
|
p->phase = 0.0f;
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_SPATIAL_NOISE:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
|
|
|
|
p->amplitude = 5.0f;
|
|
|
|
p->scale = 20.0f;
|
|
|
|
p->octaves = 4;
|
|
|
|
p->flags = LS_MODIFIER_SPATIAL_NOISE_SMOOTH | LS_MODIFIER_SPATIAL_NOISE_PURERANDOM;
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_PERLIN_NOISE_1D:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
|
|
|
|
p->frequency = 10.0f;
|
|
|
|
p->amplitude = 10.0f;
|
|
|
|
p->octaves = 4;
|
|
|
|
p->angle = DEG2RADF(45.0f);
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_PERLIN_NOISE_2D:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
|
|
|
|
p->frequency = 10.0f;
|
|
|
|
p->amplitude = 10.0f;
|
|
|
|
p->octaves = 4;
|
|
|
|
p->angle = DEG2RADF(45.0f);
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_BACKBONE_STRETCHER:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_BackboneStretcher *p = (LineStyleGeometryModifier_BackboneStretcher *)m;
|
|
|
|
p->backbone_length = 10.0f;
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_TIP_REMOVER:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
|
|
|
|
p->tip_length = 10.0f;
|
|
|
|
}
|
2011-08-19 16:05:11 +02:00
|
|
|
break;
|
2011-11-01 10:47:41 +01:00
|
|
|
case LS_MODIFIER_POLYGONIZATION:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_Polygonalization *p = (LineStyleGeometryModifier_Polygonalization *)m;
|
|
|
|
p->error = 10.0f;
|
|
|
|
}
|
2011-11-01 10:47:41 +01:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_GUIDING_LINES:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
|
|
|
|
p->offset = 0.0f;
|
|
|
|
}
|
2011-11-01 10:47:41 +01:00
|
|
|
break;
|
2011-11-11 21:35:03 +01:00
|
|
|
case LS_MODIFIER_BLUEPRINT:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
|
|
|
|
p->flags = LS_MODIFIER_BLUEPRINT_CIRCLES;
|
|
|
|
p->rounds = 1;
|
|
|
|
p->backbone_length = 10.0f;
|
|
|
|
p->random_radius = 3;
|
|
|
|
p->random_center = 5;
|
|
|
|
p->random_backbone = 5;
|
|
|
|
}
|
2011-11-11 21:35:03 +01:00
|
|
|
break;
|
2012-01-04 01:23:34 +01:00
|
|
|
case LS_MODIFIER_2D_OFFSET:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
|
|
|
|
p->start = 0.0f;
|
|
|
|
p->end = 0.0f;
|
|
|
|
p->x = 0.0f;
|
|
|
|
p->y = 0.0f;
|
|
|
|
}
|
2012-01-04 01:23:34 +01:00
|
|
|
break;
|
|
|
|
case LS_MODIFIER_2D_TRANSFORM:
|
2013-03-20 00:54:14 +01:00
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
|
|
|
|
p->pivot = LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER;
|
|
|
|
p->scale_x = 1.0f;
|
|
|
|
p->scale_y = 1.0f;
|
|
|
|
p->angle = DEG2RADF(0.0f);
|
|
|
|
p->pivot_u = 0.5f;
|
|
|
|
p->pivot_x = 0.0f;
|
|
|
|
p->pivot_y = 0.0f;
|
|
|
|
}
|
2012-01-04 01:23:34 +01:00
|
|
|
break;
|
2011-11-14 01:43:37 +01:00
|
|
|
default:
|
|
|
|
return NULL; /* unknown modifier type */
|
2011-08-19 16:05:11 +02:00
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->geometry_modifiers, m);
|
2011-11-14 01:43:37 +01:00
|
|
|
|
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
LineStyleModifier *BKE_copy_linestyle_geometry_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2011-11-14 01:43:37 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *new_m;
|
|
|
|
|
|
|
|
new_m = alloc_geometry_modifier(m->type);
|
|
|
|
new_m->flags = m->flags;
|
2012-12-11 23:00:22 +01:00
|
|
|
|
2011-11-14 01:43:37 +01:00
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_SAMPLING:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_Sampling *q = (LineStyleGeometryModifier_Sampling *)new_m;
|
|
|
|
q->sampling = p->sampling;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_BEZIER_CURVE:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_BezierCurve *q = (LineStyleGeometryModifier_BezierCurve *)new_m;
|
|
|
|
q->error = p->error;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_SINUS_DISPLACEMENT:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_SinusDisplacement *p = (LineStyleGeometryModifier_SinusDisplacement *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_SinusDisplacement *q = (LineStyleGeometryModifier_SinusDisplacement *)new_m;
|
|
|
|
q->wavelength = p->wavelength;
|
|
|
|
q->amplitude = p->amplitude;
|
|
|
|
q->phase = p->phase;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_SPATIAL_NOISE:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_SpatialNoise *q = (LineStyleGeometryModifier_SpatialNoise *)new_m;
|
|
|
|
q->amplitude = p->amplitude;
|
|
|
|
q->scale = p->scale;
|
|
|
|
q->octaves = p->octaves;
|
|
|
|
q->flags = p->flags;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_PERLIN_NOISE_1D:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_PerlinNoise1D *q = (LineStyleGeometryModifier_PerlinNoise1D *)new_m;
|
|
|
|
q->frequency = p->frequency;
|
|
|
|
q->amplitude = p->amplitude;
|
|
|
|
q->angle = p->angle;
|
2013-04-25 18:23:23 +02:00
|
|
|
q->octaves = p->octaves;
|
|
|
|
q->seed = p->seed;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_PERLIN_NOISE_2D:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_PerlinNoise2D *q = (LineStyleGeometryModifier_PerlinNoise2D *)new_m;
|
|
|
|
q->frequency = p->frequency;
|
|
|
|
q->amplitude = p->amplitude;
|
|
|
|
q->angle = p->angle;
|
2013-04-25 18:23:23 +02:00
|
|
|
q->octaves = p->octaves;
|
|
|
|
q->seed = p->seed;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_BACKBONE_STRETCHER:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_BackboneStretcher *p = (LineStyleGeometryModifier_BackboneStretcher *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_BackboneStretcher *q = (LineStyleGeometryModifier_BackboneStretcher *)new_m;
|
|
|
|
q->backbone_length = p->backbone_length;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_TIP_REMOVER:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_TipRemover *q = (LineStyleGeometryModifier_TipRemover *)new_m;
|
|
|
|
q->tip_length = p->tip_length;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_POLYGONIZATION:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_Polygonalization *p = (LineStyleGeometryModifier_Polygonalization *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_Polygonalization *q = (LineStyleGeometryModifier_Polygonalization *)new_m;
|
|
|
|
q->error = p->error;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_GUIDING_LINES:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_GuidingLines *q = (LineStyleGeometryModifier_GuidingLines *)new_m;
|
|
|
|
q->offset = p->offset;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_BLUEPRINT:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_Blueprint *q = (LineStyleGeometryModifier_Blueprint *)new_m;
|
|
|
|
q->flags = p->flags;
|
|
|
|
q->rounds = p->rounds;
|
|
|
|
q->backbone_length = p->backbone_length;
|
|
|
|
q->random_radius = p->random_radius;
|
|
|
|
q->random_center = p->random_center;
|
|
|
|
q->random_backbone = p->random_backbone;
|
2011-11-14 01:43:37 +01:00
|
|
|
}
|
|
|
|
break;
|
2012-01-04 01:23:34 +01:00
|
|
|
case LS_MODIFIER_2D_OFFSET:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_2DOffset *q = (LineStyleGeometryModifier_2DOffset *)new_m;
|
|
|
|
q->start = p->start;
|
|
|
|
q->end = p->end;
|
|
|
|
q->x = p->x;
|
|
|
|
q->y = p->y;
|
2012-01-04 01:23:34 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_2D_TRANSFORM:
|
|
|
|
{
|
|
|
|
LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
|
2013-03-20 00:54:14 +01:00
|
|
|
LineStyleGeometryModifier_2DTransform *q = (LineStyleGeometryModifier_2DTransform *)new_m;
|
|
|
|
q->pivot = p->pivot;
|
|
|
|
q->scale_x = p->scale_x;
|
|
|
|
q->scale_y = p->scale_y;
|
|
|
|
q->angle = p->angle;
|
|
|
|
q->pivot_u = p->pivot_u;
|
|
|
|
q->pivot_x = p->pivot_x;
|
|
|
|
q->pivot_y = p->pivot_y;
|
2012-01-04 01:23:34 +01:00
|
|
|
}
|
|
|
|
break;
|
2011-11-14 01:43:37 +01:00
|
|
|
default:
|
|
|
|
return NULL; /* unknown modifier type */
|
|
|
|
}
|
|
|
|
add_to_modifier_list(&linestyle->geometry_modifiers, new_m);
|
|
|
|
|
|
|
|
return new_m;
|
2011-08-19 16:05:11 +02:00
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_remove_linestyle_geometry_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *m)
|
2011-08-19 16:05:11 +02:00
|
|
|
{
|
|
|
|
BLI_freelinkN(&linestyle->geometry_modifiers, m);
|
|
|
|
}
|
|
|
|
|
2010-07-20 19:57:33 +02:00
|
|
|
static void move_modifier(ListBase *lb, LineStyleModifier *modifier, int direction)
|
|
|
|
{
|
|
|
|
BLI_remlink(lb, modifier);
|
|
|
|
if (direction > 0)
|
|
|
|
BLI_insertlinkbefore(lb, modifier->prev, modifier);
|
|
|
|
else
|
|
|
|
BLI_insertlinkafter(lb, modifier->next, modifier);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_move_linestyle_color_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
|
|
|
move_modifier(&linestyle->color_modifiers, modifier, direction);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_move_linestyle_alpha_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
|
|
|
move_modifier(&linestyle->alpha_modifiers, modifier, direction);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_move_linestyle_thickness_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
|
2010-07-20 19:57:33 +02:00
|
|
|
{
|
|
|
|
move_modifier(&linestyle->thickness_modifiers, modifier, direction);
|
2010-06-26 00:45:42 +02:00
|
|
|
}
|
2010-09-18 02:31:22 +02:00
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_move_linestyle_geometry_modifier(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
|
2011-08-19 16:05:11 +02:00
|
|
|
{
|
|
|
|
move_modifier(&linestyle->geometry_modifiers, modifier, direction);
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_list_modifier_color_ramps(FreestyleLineStyle *linestyle, ListBase *listbase)
|
2010-09-18 02:31:22 +02:00
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
|
|
|
ColorBand *color_ramp;
|
|
|
|
LinkData *link;
|
|
|
|
|
|
|
|
listbase->first = listbase->last = NULL;
|
|
|
|
for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
|
|
|
|
switch (m->type) {
|
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;
|
|
|
|
break;
|
2011-07-25 01:29:19 +02:00
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;
|
|
|
|
break;
|
2010-09-18 02:31:22 +02:00
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
link = (LinkData *) MEM_callocN( sizeof(LinkData), "link to color ramp");
|
|
|
|
link->data = color_ramp;
|
|
|
|
BLI_addtail(listbase, link);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
char *BKE_path_from_ID_to_color_ramp(FreestyleLineStyle *linestyle, ColorBand *color_ramp)
|
2010-09-18 02:31:22 +02:00
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
2013-03-20 01:08:42 +01:00
|
|
|
bool found = false;
|
2010-09-18 02:31:22 +02:00
|
|
|
|
|
|
|
for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
|
|
|
|
switch (m->type) {
|
2013-04-23 22:10:22 +02:00
|
|
|
case LS_MODIFIER_ALONG_STROKE:
|
|
|
|
if (color_ramp == ((LineStyleColorModifier_AlongStroke *)m)->color_ramp)
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_CAMERA:
|
|
|
|
if (color_ramp == ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp)
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_DISTANCE_FROM_OBJECT:
|
|
|
|
if (color_ramp == ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp)
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
case LS_MODIFIER_MATERIAL:
|
|
|
|
if (color_ramp == ((LineStyleColorModifier_Material *)m)->color_ramp)
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found) {
|
|
|
|
char name_esc[sizeof(m->name) * 2];
|
|
|
|
BLI_strescape(name_esc, m->name, sizeof(name_esc));
|
|
|
|
return BLI_sprintfN("color_modifiers[\"%s\"].color_ramp", name_esc);
|
2010-09-18 02:31:22 +02:00
|
|
|
}
|
|
|
|
}
|
2013-03-23 04:00:37 +01:00
|
|
|
printf("BKE_path_from_ID_to_color_ramp: No color ramps correspond to the given pointer.\n");
|
2010-09-18 02:31:22 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-11-29 22:24:55 +01:00
|
|
|
|
2013-03-23 04:00:37 +01:00
|
|
|
void BKE_unlink_linestyle_target_object(FreestyleLineStyle *linestyle, struct Object *ob)
|
2010-11-29 22:24:55 +01:00
|
|
|
{
|
|
|
|
LineStyleModifier *m;
|
|
|
|
|
|
|
|
for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
|
|
|
|
if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
|
|
|
|
if (((LineStyleColorModifier_DistanceFromObject *)m)->target == ob) {
|
|
|
|
((LineStyleColorModifier_DistanceFromObject *)m)->target = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (m = (LineStyleModifier *)linestyle->alpha_modifiers.first; m; m = m->next) {
|
|
|
|
if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
|
|
|
|
if (((LineStyleAlphaModifier_DistanceFromObject *)m)->target == ob) {
|
|
|
|
((LineStyleAlphaModifier_DistanceFromObject *)m)->target = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (m = (LineStyleModifier *)linestyle->thickness_modifiers.first; m; m = m->next) {
|
|
|
|
if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
|
|
|
|
if (((LineStyleThicknessModifier_DistanceFromObject *)m)->target == ob) {
|
|
|
|
((LineStyleThicknessModifier_DistanceFromObject *)m)->target = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|