resolve some compiler warnings with intel c/c++ compiler
[blender.git] / source / blender / blenkernel / intern / deform.c
1 /*  deform.c   June 2001
2  *  
3  *  support for deformation groups
4  * 
5  *      Reevan McKay
6  *
7  * $Id$
8  *
9  * ***** BEGIN GPL LICENSE BLOCK *****
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
26  * All rights reserved.
27  *
28  * The Original Code is: all of this file.
29  *
30  * Contributor(s): none yet.
31  *
32  * ***** END GPL LICENSE BLOCK *****
33  */
34
35 #include <string.h>
36 #include <math.h>
37
38 #include "MEM_guardedalloc.h"
39
40 #include "DNA_curve_types.h"
41 #include "DNA_effect_types.h"
42 #include "DNA_lattice_types.h"
43 #include "DNA_mesh_types.h"
44 #include "DNA_meshdata_types.h"
45 #include "DNA_object_types.h"
46 #include "DNA_object_force.h"
47 #include "DNA_scene_types.h"
48
49 #include "BKE_curve.h"
50 #include "BKE_deform.h"
51 #include "BKE_displist.h"
52 #include "BKE_effect.h"
53 #include "BKE_global.h"
54 #include "BKE_key.h"
55 #include "BKE_lattice.h"
56 #include "BKE_object.h"
57 #include "BKE_softbody.h"
58 #include "BKE_utildefines.h"
59 #include "BKE_mesh.h"
60
61 #include "BLI_blenlib.h"
62 #include "BLI_arithb.h"
63
64 #ifdef HAVE_CONFIG_H
65 #include <config.h>
66 #endif
67
68
69 void copy_defgroups (ListBase *outbase, ListBase *inbase)
70 {
71         bDeformGroup *defgroup, *defgroupn;
72
73         outbase->first= outbase->last= 0;
74
75         for (defgroup = inbase->first; defgroup; defgroup=defgroup->next){
76                 defgroupn= copy_defgroup(defgroup);
77                 BLI_addtail(outbase, defgroupn);
78         }
79 }
80
81 bDeformGroup *copy_defgroup (bDeformGroup *ingroup)
82 {
83         bDeformGroup *outgroup;
84
85         if (!ingroup)
86                 return NULL;
87
88         outgroup=MEM_callocN(sizeof(bDeformGroup), "copy deformGroup");
89         
90         /* For now, just copy everything over. */
91         memcpy (outgroup, ingroup, sizeof(bDeformGroup));
92
93         outgroup->next=outgroup->prev=NULL;
94
95         return outgroup;
96 }
97
98 bDeformGroup *get_named_vertexgroup (Object *ob, char *name)
99 {
100         /* return a pointer to the deform group with this name
101          * or return NULL otherwise.
102          */
103         bDeformGroup *curdef;
104
105         for (curdef = ob->defbase.first; curdef; curdef=curdef->next) {
106                 if (!strcmp(curdef->name, name)) {
107                         return curdef;
108                 }
109         }
110         return NULL;
111 }
112
113 int get_named_vertexgroup_num (Object *ob, char *name)
114 {
115         /* Return the location of the named deform group within the list of
116          * deform groups. This function is a combination of get_defgroup_num and
117          * get_named_vertexgroup. The other two could be called instead, but that
118          * require looping over the vertexgroups twice.
119          */
120         bDeformGroup *curdef;
121         int def_nr;
122         
123         for (curdef=ob->defbase.first, def_nr=0; curdef; curdef=curdef->next, def_nr++) {
124                 if (!strcmp(curdef->name, name))
125                         return def_nr;
126         }
127         
128         return -1;
129 }
130
131 int get_defgroup_num (Object *ob, bDeformGroup *dg)
132 {
133         /* Fetch the location of this deform group
134          * within the linked list of deform groups.
135          * (this number is stored in the deform
136          * weights of the deform verts to link them
137          * to this deform group).
138          */
139
140         bDeformGroup *eg;
141         int def_nr;
142
143         eg = ob->defbase.first;
144         def_nr = 0;
145
146         /* loop through all deform groups */
147         while (eg != NULL) {
148
149                 /* if the current deform group is
150                  * the one we are after, return
151                  * def_nr
152                  */
153                 if (eg == dg) {
154                         break;
155                 }
156                 ++def_nr;
157                 eg = eg->next;
158         }
159
160         /* if there was no deform group found then
161          * return -1 (should set up a nice symbolic
162          * constant for this)
163          */
164         if (eg == NULL) return -1;
165         
166         return def_nr;
167     
168 }
169
170 void unique_vertexgroup_name (bDeformGroup *dg, Object *ob)
171 {
172         bDeformGroup *curdef;
173         int number;
174         int exists = 0;
175         char tempname[64];
176         char *dot;
177         
178         if (!ob)
179                 return;
180                 
181         /* See if we are given an empty string */
182         if (dg->name[0] == '\0') {
183                 /* give it default name first */
184                 strcpy (dg->name, "Group");
185         }       
186                 
187         /* See if we even need to do this */
188         for (curdef = ob->defbase.first; curdef; curdef=curdef->next) {
189                 if (dg!=curdef) {
190                         if (!strcmp(curdef->name, dg->name)) {
191                                 exists = 1;
192                                 break;
193                         }
194                 }
195         }
196         
197         if (!exists)
198                 return;
199
200         /*      Strip off the suffix */
201         dot=strchr(dg->name, '.');
202         if (dot)
203                 *dot=0;
204         
205         for (number = 1; number <=999; number++) {
206                 sprintf (tempname, "%s.%03d", dg->name, number);
207                 
208                 exists = 0;
209                 for (curdef=ob->defbase.first; curdef; curdef=curdef->next) {
210                         if (dg!=curdef) {
211                                 if (!strcmp (curdef->name, tempname)) {
212                                         exists = 1;
213                                         break;
214                                 }
215                         }
216                 }
217                 if (!exists) {
218                         BLI_strncpy (dg->name, tempname, 32);
219                         return;
220                 }
221         }       
222 }
223
224 float deformvert_get_weight(const struct MDeformVert *dvert, int group_num)
225 {
226         if(dvert)
227         {
228                 const MDeformWeight *dw = dvert->dw;
229                 int i;
230
231                 for(i=dvert->totweight; i>0; i--, dw++)
232                         if(dw->def_nr == group_num)
233                                 return dw->weight;
234         }
235
236         /* Not found */
237         return 0.0;
238 }
239
240 float vertexgroup_get_vertex_weight(const struct MDeformVert *dvert, int index, int group_num)
241 {
242         if(group_num == -1)
243                 return 1.0;
244
245         if(dvert == 0)
246                 return 0.0;
247
248         return deformvert_get_weight(dvert+index, group_num);
249 }
250