← Back to branch summary

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

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/intern/freestyle.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-08-14 10:43:49 UTC
  • mfrom: (14.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20130814104349-t1d5mtwkphp12dyj
Tags: 2.68a-3
* Upload to unstable
* debian/: python3.3 Depends simplified
  - debian/control: python3.3 Depends dropped
    for blender-data package
  - 0001-blender_thumbnailer.patch refreshed
* debian/control: libavcodec b-dep versioning dropped

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/blenkernel/intern/freestyle.c
 
1
/*
 
2
 * ***** BEGIN GPL LICENSE BLOCK *****
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU General Public License
 
6
 * as published by the Free Software Foundation; either version 2
 
7
 * of the License, or (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software Foundation,
 
16
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
17
 *
 
18
 * The Original Code is Copyright (C) 2013 Blender Foundation
 
19
 * All rights reserved.
 
20
 *
 
21
 * The Original Code is: all of this file.
 
22
 *
 
23
 * Contributor(s): none yet.
 
24
 *
 
25
 * ***** END GPL LICENSE BLOCK *****
 
26
 */
 
27
 
 
28
/** \file blender/blenkernel/intern/freestyle.c
 
29
 *  \ingroup bke
 
30
 */
 
31
 
 
32
#include "MEM_guardedalloc.h"
 
33
 
 
34
#include "DNA_freestyle_types.h"
 
35
#include "DNA_group_types.h"
 
36
 
 
37
#include "BKE_freestyle.h"
 
38
#include "BKE_linestyle.h"
 
39
 
 
40
#include "BLI_blenlib.h"
 
41
#include "BLI_math.h"
 
42
 
 
43
// function declarations
 
44
static FreestyleLineSet *alloc_lineset(void);
 
45
static void copy_lineset(FreestyleLineSet *new_lineset, FreestyleLineSet *lineset);
 
46
static FreestyleModuleConfig *alloc_module(void);
 
47
static void copy_module(FreestyleModuleConfig *new_module, FreestyleModuleConfig *module);
 
48
 
 
49
void BKE_freestyle_config_init(FreestyleConfig *config)
 
50
{
 
51
        config->mode = FREESTYLE_CONTROL_EDITOR_MODE;
 
52
 
 
53
        config->modules.first = config->modules.last = NULL;
 
54
        config->flags = 0;
 
55
        config->sphere_radius = 1.0f;
 
56
        config->dkr_epsilon = 0.0f;
 
57
        config->crease_angle = DEG2RADF(134.43f);
 
58
 
 
59
        config->linesets.first = config->linesets.last = NULL;
 
60
}
 
61
 
 
62
void BKE_freestyle_config_free(FreestyleConfig *config)
 
63
{
 
64
        FreestyleLineSet *lineset;
 
65
 
 
66
        for (lineset = (FreestyleLineSet *)config->linesets.first; lineset; lineset = lineset->next) {
 
67
                if (lineset->group) {
 
68
                        lineset->group->id.us--;
 
69
                        lineset->group = NULL;
 
70
                }
 
71
                if (lineset->linestyle) {
 
72
                        lineset->linestyle->id.us--;
 
73
                        lineset->linestyle = NULL;
 
74
                }
 
75
        }
 
76
        BLI_freelistN(&config->linesets);
 
77
        BLI_freelistN(&config->modules);
 
78
}
 
79
 
 
80
void BKE_freestyle_config_copy(FreestyleConfig *new_config, FreestyleConfig *config)
 
81
{
 
82
        FreestyleLineSet *lineset, *new_lineset;
 
83
        FreestyleModuleConfig *module, *new_module;
 
84
 
 
85
        new_config->mode = config->mode;
 
86
        new_config->raycasting_algorithm = config->raycasting_algorithm; /* deprecated */
 
87
        new_config->flags = config->flags;
 
88
        new_config->sphere_radius = config->sphere_radius;
 
89
        new_config->dkr_epsilon = config->dkr_epsilon;
 
90
        new_config->crease_angle = config->crease_angle;
 
91
 
 
92
        new_config->linesets.first = new_config->linesets.last = NULL;
 
93
        for (lineset = (FreestyleLineSet *)config->linesets.first; lineset; lineset = lineset->next) {
 
94
                new_lineset = alloc_lineset();
 
95
                copy_lineset(new_lineset, lineset);
 
96
                BLI_addtail(&new_config->linesets, (void *)new_lineset);
 
97
        }
 
98
 
 
99
        new_config->modules.first = new_config->modules.last = NULL;
 
100
        for (module = (FreestyleModuleConfig *)config->modules.first; module; module = module->next) {
 
101
                new_module = alloc_module();
 
102
                copy_module(new_module, module);
 
103
                BLI_addtail(&new_config->modules, (void *)new_module);
 
104
        }
 
105
}
 
106
 
 
107
static void copy_lineset(FreestyleLineSet *new_lineset, FreestyleLineSet *lineset)
 
108
{
 
109
        new_lineset->linestyle = lineset->linestyle;
 
110
        new_lineset->linestyle->id.us++;
 
111
        new_lineset->flags = lineset->flags;
 
112
        new_lineset->selection = lineset->selection;
 
113
        new_lineset->qi = lineset->qi;
 
114
        new_lineset->qi_start = lineset->qi_start;
 
115
        new_lineset->qi_end = lineset->qi_end;
 
116
        new_lineset->edge_types = lineset->edge_types;
 
117
        new_lineset->exclude_edge_types = lineset->exclude_edge_types;
 
118
        new_lineset->group = lineset->group;
 
119
        if (new_lineset->group) {
 
120
                new_lineset->group->id.us++;
 
121
        }
 
122
        strcpy(new_lineset->name, lineset->name);
 
123
}
 
124
 
 
125
static FreestyleModuleConfig *alloc_module(void)
 
126
{
 
127
        return (FreestyleModuleConfig *)MEM_callocN(sizeof(FreestyleModuleConfig), "style module configuration");
 
128
}
 
129
 
 
130
void BKE_freestyle_module_add(FreestyleConfig *config)
 
131
{
 
132
        FreestyleModuleConfig *module_conf = alloc_module();
 
133
        BLI_addtail(&config->modules, (void *)module_conf);
 
134
        module_conf->script = NULL;
 
135
        module_conf->is_displayed = 1;
 
136
}
 
137
 
 
138
static void copy_module(FreestyleModuleConfig *new_module, FreestyleModuleConfig *module)
 
139
{
 
140
        new_module->script = module->script;
 
141
        new_module->is_displayed = module->is_displayed;
 
142
}
 
143
 
 
144
void BKE_freestyle_module_delete(FreestyleConfig *config, FreestyleModuleConfig *module_conf)
 
145
{
 
146
        BLI_freelinkN(&config->modules, module_conf);
 
147
}
 
148
 
 
149
void BKE_freestyle_module_move_up(FreestyleConfig *config, FreestyleModuleConfig *module_conf)
 
150
{
 
151
        BLI_remlink(&config->modules, module_conf);
 
152
        BLI_insertlinkbefore(&config->modules, module_conf->prev, module_conf);
 
153
}
 
154
 
 
155
void BKE_freestyle_module_move_down(FreestyleConfig *config, FreestyleModuleConfig *module_conf)
 
156
{
 
157
        BLI_remlink(&config->modules, module_conf);
 
158
        BLI_insertlinkafter(&config->modules, module_conf->next, module_conf);
 
159
}
 
160
 
 
161
void BKE_freestyle_lineset_unique_name(FreestyleConfig *config, FreestyleLineSet *lineset)
 
162
{
 
163
        BLI_uniquename(&config->linesets, lineset, "FreestyleLineSet", '.', offsetof(FreestyleLineSet, name),
 
164
                       sizeof(lineset->name));
 
165
}
 
166
 
 
167
static FreestyleLineSet *alloc_lineset(void)
 
168
{
 
169
        return (FreestyleLineSet *)MEM_callocN(sizeof(FreestyleLineSet), "Freestyle line set");
 
170
}
 
171
 
 
172
FreestyleLineSet *BKE_freestyle_lineset_add(FreestyleConfig *config)
 
173
{
 
174
        int lineset_index = BLI_countlist(&config->linesets);
 
175
 
 
176
        FreestyleLineSet *lineset = alloc_lineset();
 
177
        BLI_addtail(&config->linesets, (void *)lineset);
 
178
        BKE_freestyle_lineset_set_active_index(config, lineset_index);
 
179
 
 
180
        lineset->linestyle = BKE_new_linestyle("LineStyle", NULL);
 
181
        lineset->flags |= FREESTYLE_LINESET_ENABLED;
 
182
        lineset->selection = FREESTYLE_SEL_VISIBILITY | FREESTYLE_SEL_EDGE_TYPES | FREESTYLE_SEL_IMAGE_BORDER;
 
183
        lineset->qi = FREESTYLE_QI_VISIBLE;
 
184
        lineset->qi_start = 0;
 
185
        lineset->qi_end = 100;
 
186
        lineset->edge_types = FREESTYLE_FE_SILHOUETTE | FREESTYLE_FE_BORDER | FREESTYLE_FE_CREASE;
 
187
        lineset->exclude_edge_types = 0;
 
188
        lineset->group = NULL;
 
189
        if (lineset_index > 0)
 
190
                sprintf(lineset->name, "LineSet %i", lineset_index + 1);
 
191
        else
 
192
                strcpy(lineset->name, "LineSet");
 
193
        BKE_freestyle_lineset_unique_name(config, lineset);
 
194
 
 
195
        return lineset;
 
196
}
 
197
 
 
198
FreestyleLineSet *BKE_freestyle_lineset_get_active(FreestyleConfig *config)
 
199
{
 
200
        FreestyleLineSet *lineset;
 
201
 
 
202
        for (lineset = (FreestyleLineSet *)config->linesets.first; lineset; lineset = lineset->next) {
 
203
                if (lineset->flags & FREESTYLE_LINESET_CURRENT)
 
204
                        return lineset;
 
205
        }
 
206
        return NULL;
 
207
}
 
208
 
 
209
short BKE_freestyle_lineset_get_active_index(FreestyleConfig *config)
 
210
{
 
211
        FreestyleLineSet *lineset;
 
212
        short i;
 
213
 
 
214
        for (lineset = (FreestyleLineSet *)config->linesets.first, i = 0; lineset; lineset = lineset->next, i++) {
 
215
                if (lineset->flags & FREESTYLE_LINESET_CURRENT)
 
216
                        return i;
 
217
        }
 
218
        return 0;
 
219
}
 
220
 
 
221
void BKE_freestyle_lineset_set_active_index(FreestyleConfig *config, short index)
 
222
{
 
223
        FreestyleLineSet *lineset;
 
224
        short i;
 
225
 
 
226
        for (lineset = (FreestyleLineSet *)config->linesets.first, i = 0; lineset; lineset = lineset->next, i++) {
 
227
                if (i == index)
 
228
                        lineset->flags |= FREESTYLE_LINESET_CURRENT;
 
229
                else
 
230
                        lineset->flags &= ~FREESTYLE_LINESET_CURRENT;
 
231
        }
 
232
}