Fix for bug #4393: initial vertex colors were not created from shaded
[blender.git] / source / blender / blenkernel / BKE_modifier.h
1 /**
2  *      
3  * $Id$ 
4  *
5  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version. The Blender
11  * Foundation also sells licenses for use in proprietary software under
12  * the Blender License.  See http://www.blender.org/BL/ for information
13  * about this.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
25  * All rights reserved.
26  *
27  * The Original Code is: all of this file.
28  *
29  * Contributor(s): none yet.
30  *
31  * ***** END GPL/BL DUAL LICENSE BLOCK *****
32  */
33 #ifndef BKE_MODIFIER_H
34 #define BKE_MODIFIER_H
35
36 struct DerivedMesh;
37 struct DagForest;
38 struct DagNode;
39 struct Object;
40 struct ListBase;
41 struct bArmature;
42
43 typedef enum {
44                 /* Should not be used, only for None modifier type */
45         eModifierTypeType_None,
46
47                 /* Modifier only does deformation, implies that modifier
48                  * type should have a valid deformVerts function. OnlyDeform
49                  * style modifiers implicitly accept either mesh or CV
50                  * input but should still declare flags appropriately.
51                  */
52         eModifierTypeType_OnlyDeform,
53
54         eModifierTypeType_Constructive,
55         eModifierTypeType_Nonconstructive,
56 } ModifierTypeType;
57
58 typedef enum {
59         eModifierTypeFlag_AcceptsMesh = (1<<0),
60         eModifierTypeFlag_AcceptsCVs = (1<<1),
61         eModifierTypeFlag_SupportsMapping = (1<<2),
62         eModifierTypeFlag_SupportsEditmode = (1<<3),
63         
64                 /* For modifiers that support editmode this determines if the
65                  * modifier should be enabled by default in editmode. This should
66                  * only be used by modifiers that are relatively speedy and
67                  * also generally used in editmode, otherwise let the user enable
68                  * it by hand.
69                  */
70         eModifierTypeFlag_EnableInEditmode = (1<<4),
71
72                 /* For modifiers that require original data and so cannot
73                  * be placed after any non-deformative modifier.
74                  */
75         eModifierTypeFlag_RequiresOriginalData = (1<<5),
76 } ModifierTypeFlag;
77
78 typedef struct ModifierTypeInfo {
79                 /* The user visible name for this modifier */
80         char name[32];
81
82                 /* The DNA struct name for the modifier data type, used to
83                  * write the DNA data out.
84                  */
85         char structName[32];
86
87                 /* The size of the modifier data type, used by allocation. */
88         int structSize;
89
90         ModifierTypeType type;
91         ModifierTypeFlag flags;
92
93                 /* Initialize new instance data for this modifier type, this function
94                  * should set modifier variables to their default values.
95                  * 
96                  * This function is optional.
97                  */
98         void (*initData)(ModifierData *md);
99
100                 /* Copy instance data for this modifier type. Should copy all user
101                  * level settings to the target modifier.
102                  */
103         void (*copyData)(ModifierData *md, ModifierData *target);
104
105                 /* Free internal modifier data variables, this function should
106                  * not free the _md_ variable itself.
107                  *
108                  * This function is optional.
109                  */
110         void (*freeData)(ModifierData *md);
111
112                 /* Return a boolean value indicating if this modifier is able to be calculated
113                  * based on the modifier data. This is *not* regarding the md->flag, that is
114                  * tested by the system, this is just if the data validates (for example, a
115                  * lattice will return false if the lattice object is not defined).
116                  *
117                  * This function is optional (assumes never disabled if not present).
118                  */
119         int (*isDisabled)(ModifierData *md);
120
121                 /* Add the appropriate relations to the DEP graph depending on the modifier
122                  * data. 
123                  *
124                  * This function is optional.
125                  */
126         void (*updateDepgraph)(ModifierData *md, struct DagForest *forest, struct Object *ob, struct DagNode *obNode);
127
128                 /* Should return true if the modifier needs to be recalculated on time changes.
129                  *
130                  * This function is optional (assumes false if not present).
131                  */
132         int (*dependsOnTime)(ModifierData *md);
133
134                 /* Should call the given _walk_ function on with a pointer to each Object pointer
135                  * that the modifier data stores. This is used for linking on file load and for
136                  * unlinking objects or forwarding object references.
137                  *
138                  * This function is optional.
139                  */
140         void (*foreachObjectLink)(ModifierData *md, struct Object *ob, void (*walk)(void *userData, Object *ob, Object **obpoin), void *userData);
141
142                 /* Only for deform types, should apply the deformation
143                  * to the given vertex array. If the deformer requires information from
144                  * the object it can obtain it from the _derivedData_ argument if non-NULL,
145                  * and otherwise the _ob_ argument.
146                  */
147         void (*deformVerts)(ModifierData *md, struct Object *ob, void *derivedData, float (*vertexCos)[3], int numVerts);
148
149                 /* Like deformVerts but called during editmode (for supporting modifiers) */
150         void (*deformVertsEM)(ModifierData *md, struct Object *ob, void *editData, void *derivedData, float (*vertexCos)[3], int numVerts);
151
152                 /* For non-deform types: apply the modifier and return a new derived
153                  * data object (type is dependent on object type). If the _derivedData_
154                  * argument is non-NULL then the modifier should read the object data 
155                  * from the derived object instead of the actual object data. 
156                  *
157                  * If the _vertexCos_ argument is non-NULL then the modifier should read 
158                  * the vertex coordinates from that (even if _derivedData_ is non-NULL).
159                  * The length of the _vertexCos_ array is either the number of verts in
160                  * the derived object (if non-NULL) or otherwise the number of verts in
161                  * the original object.
162                  *
163                  * The _useRenderParams_ indicates if the modifier is being applied in
164                  * the service of the renderer which may alter quality settings.
165                  *
166                  * The _isFinalCalc_ parameter indicates if the modifier is being calculated
167                  * for a final result or for something temporary (like orcos). This is a hack
168                  * at the moment, it is meant so subsurf can know if it is safe to reuse its
169                  * internal cache.
170                  *
171                  * The modifier *MAY NOT* reuse or release the _derivedData_ argument
172                  * if non-NULL. The modifier *MAY NOT* share the _vertexCos_ argument.
173                  */
174         void *(*applyModifier)(ModifierData *md, struct Object *ob, void *derivedData, float (*vertexCos)[3], int useRenderParams, int isFinalCalc);
175
176                 /* Like applyModifier but called during editmode (for supporting modifiers).
177                  * 
178                  * The derived object that is returned must support the operations that are expected
179                  * from editmode objects. The same qualifications regarding _derivedData_ and _vertexCos_
180                  * apply as for applyModifier.
181                  */
182         void *(*applyModifierEM)(ModifierData *md, struct Object *ob, void *editData, void *derivedData, float (*vertexCos)[3]);
183 } ModifierTypeInfo;
184
185 ModifierTypeInfo*               modifierType_getInfo    (ModifierType type);
186
187         /* Modifier utility calls, do call through type pointer and return
188          * default values if pointer is optional.
189          */
190 ModifierData*   modifier_new                            (int type);
191 void                    modifier_free                           (ModifierData *md);
192
193 void                    modifier_copyData                       (ModifierData *md, ModifierData *target);
194 int                             modifier_dependsOnTime          (ModifierData *md);
195 int                             modifier_supportsMapping        (ModifierData *md);
196 int                             modifier_couldBeCage            (ModifierData *md);
197 void                    modifier_setError                       (ModifierData *md, char *format, ...);
198
199 void                    modifiers_foreachObjectLink     (struct Object *ob, void (*walk)(void *userData, struct Object *ob, struct Object **obpoin), void *userData);
200 ModifierData*   modifiers_findByType            (struct Object *ob, ModifierType type);
201 void                    modifiers_clearErrors           (struct Object *ob);
202 int                             modifiers_getCageIndex          (struct Object *ob, int *lastPossibleCageIndex_r);
203
204 int                             modifiers_isSoftbodyEnabled     (struct Object *ob);
205 struct Object*  modifiers_isDeformedByArmature(struct Object *ob);
206 int                             modifiers_usesArmature(struct Object *ob, struct bArmature *arm);
207 int                             modifiers_isDeformed            (struct Object *ob);
208
209 ModifierData*   modifiers_getVirtualModifierList        (struct Object *ob);
210
211         /* Modifier utility calls, do call through type pointer and return
212          * default values if pointer is optional.
213          */
214 struct ModifierData*    modifier_new                    (int type);
215 void                                    modifier_free                   (struct ModifierData *md);
216
217 int                                             modifier_dependsOnTime  (struct ModifierData *md);
218
219 #endif
220