6f8d9911d89fa2530d77a299274f3fa0e99eeafc
[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.
31  * CustomData is a structure which stores custom element data associated
32  * with mesh elements (vertices, edges or faces). The custom data is
33  * organised into a series of layers, each with a data type (e.g. TFace,
34  * MDeformVert, etc.).
35  */
36
37 #ifndef BKE_CUSTOMDATA_H
38 #define BKE_CUSTOMDATA_H
39
40 typedef struct CustomData {
41         struct LayerDesc *layers; /* data layer descriptors, ordered by type */
42         int numLayers;            /* current number of layers */
43         int maxLayers;            /* maximum number of layers */
44         int numElems;             /* current number of elements */
45         int maxElems;             /* maximum number of elements */
46         int subElems;             /* number of sub-elements layers can have */
47 } CustomData;
48
49 /* custom data types */
50 enum {
51         LAYERTYPE_MVERT = 0,
52         LAYERTYPE_MSTICKY,
53         LAYERTYPE_MDEFORMVERT,
54         LAYERTYPE_MEDGE,
55         LAYERTYPE_MFACE,
56         LAYERTYPE_TFACE,
57         LAYERTYPE_MCOL,
58         LAYERTYPE_ORIGINDEX,
59         LAYERTYPE_NORMAL,
60         LAYERTYPE_FLAGS,
61         LAYERTYPE_NUMTYPES
62 };
63
64 #define ORIGINDEX_NONE -1 /* indicates no original index for this element */
65
66 /* layer flags - to be used with CustomData_add_layer */
67
68 /* indicates layer should not be copied by CustomData_from_template or
69  * CustomData_copy_data (for temporary utility layers)
70  */
71 #define LAYERFLAG_NOCOPY 1<<0
72
73 /* indicates layer should not be freed (for layers backed by external data)
74  */
75 #define LAYERFLAG_NOFREE 1<<1
76
77 /* initialises a CustomData object with space for the given number
78  * of data layers and the given number of elements per layer
79  */
80 void CustomData_init(CustomData *data,
81                      int maxLayers, int maxElems, int subElems);
82
83 /* initialises a CustomData object with the same layer setup as source
84  * and memory space for maxElems elements
85  */
86 void CustomData_from_template(const CustomData *source, CustomData *dest,
87                               int maxElems);
88
89 /* frees data associated with a CustomData object (doesn't free the object
90  * itself, though)
91  */
92 void CustomData_free(CustomData *data);
93
94 /* adds a data layer of the given type to the CustomData object, optionally
95  * backed by an external data array
96  * if layer != NULL, it is used as the layer data array, otherwise new memory
97  * is allocated
98  * the layer data will be freed by CustomData_free unless
99  * (flag & LAYERFLAG_NOFREE) is true
100  * grows the number of layers in data if data->maxLayers has been reached
101  * returns 1 on success, 0 on failure
102  */
103 int CustomData_add_layer(CustomData *data, int type, int flag, void *layer);
104
105 /* returns 1 if the two objects are compatible (same layer types and
106  * flags in the same order), 0 if not
107  */
108 int CustomData_compat(const CustomData *data1, const CustomData *data2);
109
110 /* copies data from one CustomData object to another
111  * objects need not be compatible, each source layer is copied to the
112  * first dest layer of correct type (if there is none, the layer is skipped)
113  * return 1 on success, 0 on failure
114  */
115 int CustomData_copy_data(const CustomData *source, CustomData *dest,
116                          int source_index, int dest_index, int count);
117
118 /* frees data in a CustomData object
119  * return 1 on success, 0 on failure
120  */
121 int CustomData_free_elem(CustomData *data, int index, int count);
122
123 /* interpolates data from one CustomData object to another
124  * objects need not be compatible, each source layer is interpolated to the
125  * first dest layer of correct type (if there is none, the layer is skipped)
126  * if weights == NULL or sub_weights == NULL, they default to all 1's
127  *
128  * src_indices gives the source elements to interpolate from
129  * weights gives the weight for each source element
130  * sub_weights is an array of matrices of weights for sub-elements (matrices
131  *     should be source->subElems * source->subElems in size)
132  * count gives the number of source elements to interpolate from
133  * dest_index gives the dest element to write the interpolated value to
134  *
135  * returns 1 on success, 0 on failure
136  */
137 int CustomData_interp(const CustomData *source, CustomData *dest,
138                       int *src_indices, float *weights, float *sub_weights,
139                       int count, int dest_index);
140
141 /* gets a pointer to the data element at index from the first layer of type
142  * returns NULL if there is no layer of type
143  */
144 void *CustomData_get(const CustomData *data, int index, int type);
145
146 /* gets a pointer to the first layer of type
147  * returns NULL if there is no layer of type
148  */
149 void *CustomData_get_layer(const CustomData *data, int type);
150
151 /* copies the data from source to the data element at index in the first
152  * layer of type
153  * no effect if there is no layer of type
154  */
155 void CustomData_set(const CustomData *data, int index, int type, void *source);
156
157 /* sets the number of elements in a CustomData object
158  * if the value given is more than the maximum, the maximum is used
159  */
160 void CustomData_set_num_elems(CustomData *data, int numElems);
161 #endif