Added custom face data support in edit mode. The code used to do this is
[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
37 #define ORIGINDEX_NONE -1 /* indicates no original index for this element */
38
39 /* layer flags - to be used with CustomData_add_layer */
40
41 /* indicates layer should not be copied by CustomData_from_template or
42  * CustomData_copy_data (for temporary utility layers)
43  */
44 #define LAYERFLAG_NOCOPY 1<<0
45
46 /* indicates layer should not be freed (for layers backed by external data)
47  */
48 #define LAYERFLAG_NOFREE 1<<1
49
50 /* initialises a CustomData object with space for the given number
51  * of data layers and the given number of elements per layer
52  */
53 void CustomData_init(struct CustomData *data,
54                      int maxLayers, int maxElems, int subElems);
55
56 /* initialises a CustomData object with the same layer setup as source
57  * and memory space for maxElems elements. flag is added to all layer flags
58  */
59 void CustomData_from_template(const struct CustomData *source,
60                               struct CustomData *dest, int flag, int maxElems);
61
62 /* frees data associated with a CustomData object (doesn't free the object
63  * itself, though)
64  */
65 void CustomData_free(struct CustomData *data);
66
67 /* adds a data layer of the given type to the CustomData object, optionally
68  * backed by an external data array
69  * if layer != NULL, it is used as the layer data array, otherwise new memory
70  * is allocated
71  * the layer data will be freed by CustomData_free unless
72  * (flag & LAYERFLAG_NOFREE) is true
73  * grows the number of layers in data if data->maxLayers has been reached
74  * returns 1 on success, 0 on failure
75  */
76 int CustomData_add_layer(struct CustomData *data, int type, int flag,
77                          void *layer);
78
79 /* frees the first data layer with the give type.
80  * returns 1 on succes, 0 if no layer with the given type is found
81  */
82 int CustomData_free_layer(struct CustomData *data, int type);
83
84 /* returns 1 if the two objects are compatible (same layer types and
85  * flags in the same order), 0 if not
86  */
87 int CustomData_compat(const struct CustomData *data1,
88                       const struct CustomData *data2);
89
90 /* returns 1 if a layer with the specified type exists */
91 int CustomData_has_layer(const struct CustomData *data, int type);
92
93 /* copies data from one CustomData object to another
94  * objects need not be compatible, each source layer is copied to the
95  * first dest layer of correct type (if there is none, the layer is skipped)
96  * return 1 on success, 0 on failure
97  */
98 int CustomData_copy_data(const struct CustomData *source,
99                          struct CustomData *dest, int source_index,
100                          int dest_index, int count);
101 int CustomData_em_copy_data(struct CustomData *data, void *src_block,
102                             void **dest_block);
103
104 /* frees data in a CustomData object
105  * return 1 on success, 0 on failure
106  */
107 int CustomData_free_elem(struct CustomData *data, int index, int count);
108
109 /* interpolates data from one CustomData object to another
110  * objects need not be compatible, each source layer is interpolated to the
111  * first dest layer of correct type (if there is none, the layer is skipped)
112  * if weights == NULL or sub_weights == NULL, they default to all 1's
113  *
114  * src_indices gives the source elements to interpolate from
115  * weights gives the weight for each source element
116  * sub_weights is an array of matrices of weights for sub-elements (matrices
117  *     should be source->subElems * source->subElems in size)
118  * count gives the number of source elements to interpolate from
119  * dest_index gives the dest element to write the interpolated value to
120  *
121  * returns 1 on success, 0 on failure
122  */
123 int CustomData_interp(const struct CustomData *source, struct CustomData *dest,
124                       int *src_indices, float *weights, float *sub_weights,
125                       int count, int dest_index);
126 int CustomData_em_interp(struct CustomData *data,  void **src_blocks,
127                          float *weights, float *sub_weights, int count,
128                          void *dest_block);
129
130 /* gets a pointer to the data element at index from the first layer of type
131  * returns NULL if there is no layer of type
132  */
133 void *CustomData_get(const struct CustomData *data, int index, int type);
134 void *CustomData_em_get(const struct CustomData *data, void *block, int type);
135
136 /* gets a pointer to the first layer of type
137  * returns NULL if there is no layer of type
138  */
139 void *CustomData_get_layer(const struct CustomData *data, int type);
140
141 /* copies the data from source to the data element at index in the first
142  * layer of type
143  * no effect if there is no layer of type
144  */
145 void CustomData_set(const struct CustomData *data, int index, int type,
146                     void *source);
147 void CustomData_em_set(struct CustomData *data, void *block, int type,
148                        void *source);
149
150 /* sets the number of elements in a CustomData object
151  * if the value given is more than the maximum, the maximum is used
152  */
153 void CustomData_set_num_elems(struct CustomData *data, int numElems);
154
155 /* alloc/free a block of custom data attached to one element in editmode */
156 void CustomData_em_set_default(struct CustomData *data, void **block);
157 void CustomData_em_free_block(struct CustomData *data, void **block);
158
159 /* copy custom data to/from layers as in mesh/derivedmesh, to editmesh
160    blocks of data. the CustomData's must be compatible  */
161 void CustomData_to_em_block(const struct CustomData *source,
162                             struct CustomData *dest, int index, void **block);
163 void CustomData_from_em_block(const struct CustomData *source,
164                               struct CustomData *dest, void *block, int index);
165
166 #endif