Merged 15170:15635 from trunk (no conflicts or even merges)
[blender.git] / source / blender / blenkernel / BKE_customdata.h
1 /*
2 * $Id$
3 *
4 * ***** BEGIN GPL LICENSE BLOCK *****
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software  Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19 *
20 * The Original Code is Copyright (C) 2006 Blender Foundation.
21 * All rights reserved.
22 *
23 * The Original Code is: all of this file.
24 *
25 * Contributor(s): Ben Batt <benbatt@gmail.com>
26 *
27 * ***** END GPL LICENSE BLOCK *****
28 */ 
29
30 /* CustomData interface, see also DNA_customdata_types.h. */
31
32 #ifndef BKE_CUSTOMDATA_H
33 #define BKE_CUSTOMDATA_H
34
35 struct CustomData;
36 struct CustomDataLayer;
37 typedef long CustomDataMask;
38
39 extern const CustomDataMask CD_MASK_BAREMESH;
40 extern const CustomDataMask CD_MASK_MESH;
41 extern const CustomDataMask CD_MASK_EDITMESH;
42 extern const CustomDataMask CD_MASK_DERIVEDMESH;
43 extern const CustomDataMask CD_MASK_BMESH;
44 extern const CustomDataMask CD_MASK_FACECORNERS;
45
46 /* for ORIGINDEX layer type, indicates no original index for this element */
47 #define ORIGINDEX_NONE -1
48
49 /* initialises a CustomData object with the same layer setup as source and
50  * memory space for totelem elements. mask must be an array of length
51  * CD_NUMTYPES elements, that indicate if a layer can be copied. */
52
53 /* add/copy/merge allocation types */
54 #define CD_ASSIGN    0  /* use the data pointer */
55 #define CD_CALLOC    1  /* allocate blank memory */
56 #define CD_DEFAULT   2  /* allocate and set to default */
57 #define CD_REFERENCE 3  /* use data pointers, set layer flag NOFREE */
58 #define CD_DUPLICATE 4  /* do a full copy of all layers, only allowed if source
59                            has same number of elements */
60
61 /* initialises a CustomData object with the same layer setup as source.
62  * mask is a bitfield where (mask & (1 << (layer type))) indicates
63  * if a layer should be copied or not. alloctype must be one of the above. */
64 void CustomData_copy(const struct CustomData *source, struct CustomData *dest,
65                      CustomDataMask mask, int alloctype, int totelem);
66
67 /* same as the above, except that this will preserve existing layers, and only
68  * add the layers that were not there yet */
69 void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
70                       CustomDataMask mask, int alloctype, int totelem);
71
72 /* frees data associated with a CustomData object (doesn't free the object
73  * itself, though)
74  */
75 void CustomData_free(struct CustomData *data, int totelem);
76
77 /* frees all layers with CD_FLAG_TEMPORARY */
78 void CustomData_free_temporary(struct CustomData *data, int totelem);
79
80 /* adds a data layer of the given type to the CustomData object, optionally
81  * backed by an external data array. the different allocation types are
82  * defined above. returns the data of the layer.
83  *
84  * in editmode, use EM_add_data_layer instead of this function
85  */
86 void *CustomData_add_layer(struct CustomData *data, int type, int alloctype,
87                            void *layer, int totelem);
88 /*same as above but accepts a name */
89 void *CustomData_add_layer_named(struct CustomData *data, int type, int alloctype,
90                            void *layer, int totelem, char *name);
91
92 /* frees the active or first data layer with the give type.
93  * returns 1 on succes, 0 if no layer with the given type is found
94  *
95  * in editmode, use EM_free_data_layer instead of this function
96  */
97 int CustomData_free_layer(struct CustomData *data, int type, int totelem, int index);
98
99 /* frees the layer index with the give type.
100  * returns 1 on succes, 0 if no layer with the given type is found
101  *
102  * in editmode, use EM_free_data_layer instead of this function
103  */
104 int CustomData_free_layer_active(struct CustomData *data, int type, int totelem);
105
106 /* same as above, but free all layers with type */
107 void CustomData_free_layers(struct CustomData *data, int type, int totelem);
108
109 /* returns 1 if a layer with the specified type exists */
110 int CustomData_has_layer(const struct CustomData *data, int type);
111
112 /* returns the number of layers with this type */
113 int CustomData_number_of_layers(const struct CustomData *data, int type);
114
115 /* duplicate data of a layer with flag NOFREE, and remove that flag.
116  * returns the layer data */
117 void *CustomData_duplicate_referenced_layer(struct CustomData *data, int type);
118 void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
119                                                   int type, char *name);
120
121 /* set the CD_FLAG_NOCOPY flag in custom data layers where the mask is
122  * zero for the layer type, so only layer types specified by the mask
123  * will be copied
124  */
125 void CustomData_set_only_copy(const struct CustomData *data,
126                               CustomDataMask mask);
127
128 /* copies data from one CustomData object to another
129  * objects need not be compatible, each source layer is copied to the
130  * first dest layer of correct type (if there is none, the layer is skipped)
131  * return 1 on success, 0 on failure
132  */
133 void CustomData_copy_data(const struct CustomData *source,
134                           struct CustomData *dest, int source_index,
135                           int dest_index, int count);
136 void CustomData_em_copy_data(const struct CustomData *source,
137                             struct CustomData *dest, void *src_block,
138                             void **dest_block);
139 void CustomData_bmesh_copy_data(const struct CustomData *source, 
140                                                         struct CustomData *dest,void *src_block, 
141                                                         void **dest_block);
142
143 /* frees data in a CustomData object
144  * return 1 on success, 0 on failure
145  */
146 void CustomData_free_elem(struct CustomData *data, int index, int count);
147
148 /* interpolates data from one CustomData object to another
149  * objects need not be compatible, each source layer is interpolated to the
150  * first dest layer of correct type (if there is none, the layer is skipped)
151  * if weights == NULL or sub_weights == NULL, they default to all 1's
152  *
153  * src_indices gives the source elements to interpolate from
154  * weights gives the weight for each source element
155  * sub_weights is an array of matrices of weights for sub-elements (matrices
156  *     should be source->subElems * source->subElems in size)
157  * count gives the number of source elements to interpolate from
158  * dest_index gives the dest element to write the interpolated value to
159  *
160  * returns 1 on success, 0 on failure
161  */
162 void CustomData_interp(const struct CustomData *source, struct CustomData *dest,
163                        int *src_indices, float *weights, float *sub_weights,
164                        int count, int dest_index);
165 void CustomData_em_interp(struct CustomData *data,  void **src_blocks,
166                           float *weights, float *sub_weights, int count,
167                           void *dest_block);
168 void CustomData_bmesh_interp(struct CustomData *data, void **src_blocks, 
169                                                          float *weights, float *sub_weights, int count, 
170                                                          void *dest_block);
171
172
173 /* swaps the data in the element corners, to new corners with indices as
174    specified in corner_indices. for edges this is an array of length 2, for
175    faces an array of length 4 */
176 void CustomData_swap(struct CustomData *data, int index, int *corner_indices);
177
178 /* gets a pointer to the data element at index from the first layer of type
179  * returns NULL if there is no layer of type
180  */
181 void *CustomData_get(const struct CustomData *data, int index, int type);
182 void *CustomData_em_get(const struct CustomData *data, void *block, int type);
183 void *CustomData_em_get_n(const struct CustomData *data, void *block, int type, int n);
184 void *CustomData_bmesh_get(const struct CustomData *data, void *block, int type);
185 void *CustomData_bmesh_get_n(const struct CustomData *data, void *block, int type, int n);
186
187 /* gets a pointer to the active or first layer of type
188  * returns NULL if there is no layer of type
189  */
190 void *CustomData_get_layer(const struct CustomData *data, int type);
191 void *CustomData_get_layer_n(const struct CustomData *data, int type, int n);
192 void *CustomData_get_layer_named(const struct CustomData *data, int type,
193                                  char *name);
194
195 int CustomData_get_layer_index(const struct CustomData *data, int type);
196 int CustomData_get_named_layer_index(const struct CustomData *data, int type, char *name);
197 int CustomData_get_active_layer_index(const struct CustomData *data, int type);
198 int CustomData_get_render_layer_index(const struct CustomData *data, int type);
199 int CustomData_get_active_layer(const struct CustomData *data, int type);
200 int CustomData_get_render_layer(const struct CustomData *data, int type);
201
202 /* copies the data from source to the data element at index in the first
203  * layer of type
204  * no effect if there is no layer of type
205  */
206 void CustomData_set(const struct CustomData *data, int index, int type,
207                     void *source);
208 void CustomData_em_set(struct CustomData *data, void *block, int type,
209                        void *source);
210 void CustomData_em_set_n(struct CustomData *data, void *block, int type, int n,
211                          void *source);
212
213 void CustomData_bmesh_set(const struct CustomData *data, void *block, int type, 
214                                                   void *source);
215
216 void CustomData_bmesh_set_n(struct CustomData *data, void *block, int type, int n, 
217                                                         void *source);
218
219 /* set the pointer of to the first layer of type. the old data is not freed.
220  * returns the value of ptr if the layer is found, NULL otherwise
221  */
222 void *CustomData_set_layer(const struct CustomData *data, int type, void *ptr);
223 void *CustomData_set_layer_n(const struct CustomData *data, int type, int n, void *ptr);
224
225 /* sets the nth layer of type as active */
226 void CustomData_set_layer_active(struct CustomData *data, int type, int n);
227 void CustomData_set_layer_render(struct CustomData *data, int type, int n);
228
229 /* same as above but works with an index from CustomData_get_layer_index */
230 void CustomData_set_layer_active_index(struct CustomData *data, int type, int n);
231 void CustomData_set_layer_render_index(struct CustomData *data, int type, int n);
232
233 /* adds flag to the layer flags */
234 void CustomData_set_layer_flag(struct CustomData *data, int type, int flag);
235
236 /* alloc/free a block of custom data attached to one element in editmode */
237 void CustomData_em_set_default(struct CustomData *data, void **block);
238 void CustomData_em_free_block(struct CustomData *data, void **block);
239
240 void CustomData_bmesh_set_default(struct CustomData *data, void **block);
241 void CustomData_bmesh_free_block(struct CustomData *data, void **block);
242
243 /* copy custom data to/from layers as in mesh/derivedmesh, to editmesh
244    blocks of data. the CustomData's must not be compatible  */
245 void CustomData_to_em_block(const struct CustomData *source,
246                             struct CustomData *dest, int index, void **block);
247 void CustomData_from_em_block(const struct CustomData *source,
248                               struct CustomData *dest, void *block, int index);
249 void CustomData_to_bmesh_block(const struct CustomData *source, 
250                                                         struct CustomData *dest, int src_index, void **dest_block);
251 void CustomData_from_bmesh_block(const struct CustomData *source, 
252                                                         struct CustomData *dest, void *src_block, int dest_index);
253
254
255 /* query info over types */
256 void CustomData_file_write_info(int type, char **structname, int *structnum);
257 int CustomData_sizeof(int type);
258
259 /* get the name of a layer type */
260 const char *CustomData_layertype_name(int type);
261
262 /* make sure the name of layer at index is unique */
263 void CustomData_set_layer_unique_name(struct CustomData *data, int index);
264
265 /* for file reading compatibility, returns false if the layer was freed,
266    only after this test passes, layer->data should be assigned */
267 int CustomData_verify_versions(struct CustomData *data, int index);
268
269 /*BMesh specific customdata stuff*/
270 void CustomData_to_bmeshpoly(struct CustomData *fdata, struct CustomData *pdata, struct CustomData *ldata);
271 void CustomData_from_bmeshpoly(struct CustomData *fdata, struct CustomData *pdata, struct CustomData *ldata, int total);
272 void CustomData_bmesh_init_pool(struct CustomData *data, int allocsize);
273 #endif