1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
/*
* $Id$
*
* ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2006 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Ben Batt <benbatt@gmail.com>
*
* ***** END GPL LICENSE BLOCK *****
*/
/* CustomData interface, see also DNA_customdata_types.h. */
#ifndef BKE_CUSTOMDATA_H
#define BKE_CUSTOMDATA_H
struct CustomData;
#define ORIGINDEX_NONE -1 /* indicates no original index for this element */
/* layer flags - to be used with CustomData_add_layer */
/* indicates layer should not be copied by CustomData_from_template or
* CustomData_copy_data (for temporary utility layers)
*/
#define LAYERFLAG_NOCOPY 1<<0
/* indicates layer should not be freed (for layers backed by external data)
*/
#define LAYERFLAG_NOFREE 1<<1
/* initialises a CustomData object with space for the given number
* of data layers and the given number of elements per layer
*/
void CustomData_init(struct CustomData *data,
int maxLayers, int maxElems, int subElems);
/* initialises a CustomData object with the same layer setup as source
* and memory space for maxElems elements. flag is added to all layer flags
*/
void CustomData_from_template(const struct CustomData *source,
struct CustomData *dest, int flag, int maxElems);
/* frees data associated with a CustomData object (doesn't free the object
* itself, though)
*/
void CustomData_free(struct CustomData *data);
/* adds a data layer of the given type to the CustomData object, optionally
* backed by an external data array
* if layer != NULL, it is used as the layer data array, otherwise new memory
* is allocated
* the layer data will be freed by CustomData_free unless
* (flag & LAYERFLAG_NOFREE) is true
* grows the number of layers in data if data->maxLayers has been reached
* returns 1 on success, 0 on failure
*
* in editmode, use EM_add_data_layer instead of this function
*/
int CustomData_add_layer(struct CustomData *data, int type, int flag,
void *layer);
/* frees the first data layer with the give type.
* returns 1 on succes, 0 if no layer with the given type is found
*
* in editmode, use EM_free_data_layer instead of this function
*/
int CustomData_free_layer(struct CustomData *data, int type);
/* returns 1 if the two objects are compatible (same layer types and
* flags in the same order), 0 if not
*/
int CustomData_compat(const struct CustomData *data1,
const struct CustomData *data2);
/* returns 1 if a layer with the specified type exists */
int CustomData_has_layer(const struct CustomData *data, int type);
/* copies data from one CustomData object to another
* objects need not be compatible, each source layer is copied to the
* first dest layer of correct type (if there is none, the layer is skipped)
* return 1 on success, 0 on failure
*/
int CustomData_copy_data(const struct CustomData *source,
struct CustomData *dest, int source_index,
int dest_index, int count);
int CustomData_em_copy_data(const struct CustomData *source,
struct CustomData *dest, void *src_block,
void **dest_block);
/* frees data in a CustomData object
* return 1 on success, 0 on failure
*/
int CustomData_free_elem(struct CustomData *data, int index, int count);
/* interpolates data from one CustomData object to another
* objects need not be compatible, each source layer is interpolated to the
* first dest layer of correct type (if there is none, the layer is skipped)
* if weights == NULL or sub_weights == NULL, they default to all 1's
*
* src_indices gives the source elements to interpolate from
* weights gives the weight for each source element
* sub_weights is an array of matrices of weights for sub-elements (matrices
* should be source->subElems * source->subElems in size)
* count gives the number of source elements to interpolate from
* dest_index gives the dest element to write the interpolated value to
*
* returns 1 on success, 0 on failure
*/
int CustomData_interp(const struct CustomData *source, struct CustomData *dest,
int *src_indices, float *weights, float *sub_weights,
int count, int dest_index);
int CustomData_em_interp(struct CustomData *data, void **src_blocks,
float *weights, float *sub_weights, int count,
void *dest_block);
/* gets a pointer to the data element at index from the first layer of type
* returns NULL if there is no layer of type
*/
void *CustomData_get(const struct CustomData *data, int index, int type);
void *CustomData_em_get(const struct CustomData *data, void *block, int type);
/* gets a pointer to the first layer of type
* returns NULL if there is no layer of type
*/
void *CustomData_get_layer(const struct CustomData *data, int type);
/* copies the data from source to the data element at index in the first
* layer of type
* no effect if there is no layer of type
*/
void CustomData_set(const struct CustomData *data, int index, int type,
void *source);
void CustomData_em_set(struct CustomData *data, void *block, int type,
void *source);
/* sets the number of elements in a CustomData object
* if the value given is more than the maximum, the maximum is used
*/
void CustomData_set_num_elems(struct CustomData *data, int numElems);
/* alloc/free a block of custom data attached to one element in editmode */
void CustomData_em_set_default(struct CustomData *data, void **block);
void CustomData_em_free_block(struct CustomData *data, void **block);
/* copy custom data to/from layers as in mesh/derivedmesh, to editmesh
blocks of data. the CustomData's must be compatible */
void CustomData_to_em_block(const struct CustomData *source,
struct CustomData *dest, int index, void **block);
void CustomData_from_em_block(const struct CustomData *source,
struct CustomData *dest, void *block, int index);
#endif
|
