Two in one:
[blender.git] / source / blender / src / editipo_lib.c
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) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Blender Foundation, 2005. Full recode
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /* ********** General calls (minimal dependencies) for editing Ipos in Blender ************* */
29
30 #include "BLI_blenlib.h"
31 #include "BLI_arithb.h"
32
33 #include "DNA_curve_types.h"
34 #include "DNA_ipo_types.h"
35 #include "DNA_space_types.h"
36 #include "DNA_scene_types.h"
37 #include "DNA_view3d_types.h"
38
39 #include "BKE_global.h"
40 #include "BKE_ipo.h"
41 #include "BKE_utildefines.h"
42
43 #include "BSE_edit.h"
44 #include "BSE_editipo_types.h"
45 #include "BSE_editipo.h"
46 #include "BSE_drawipo.h"
47
48 #include "blendef.h"
49 #include "mydevice.h"
50
51 char *ob_ic_names[OB_TOTNAM] = { "LocX", "LocY", "LocZ", "dLocX", "dLocY", "dLocZ",
52         "RotX", "RotY", "RotZ", "dRotX", "dRotY", "dRotZ",
53         "ScaleX", "ScaleY", "ScaleZ", "dScaleX", "dScaleY", "dScaleZ",
54         "Layer", "Time", "ColR", "ColG", "ColB", "ColA",
55         "FStreng", "FFall", "RDamp", "Damping", "Perm" };
56
57 char *co_ic_names[CO_TOTNAM] = { "Inf" };
58 char *mtex_ic_names[TEX_TOTNAM] = { "OfsX", "OfsY", "OfsZ", "SizeX", "SizeY", "SizeZ",
59         "texR", "texG", "texB", "DefVar", "Col", "Nor", "Var",
60         "Disp" };
61 char *tex_ic_names[TE_TOTNAM] = { "NSize", "NDepth", "NType", "Turb", "Vnw1", "Vnw2",
62         "Vnw3", "Vnw4", "MinkMExp", "DistM", "ColT", "iScale",
63         "DistA", "MgType", "MgH", "Lacu", "Oct", "MgOff",
64         "MgGain", "NBase1", "NBase2", "ColR", "ColG", "ColB", "Bright", "Contras"};
65 char *ma_ic_names[MA_TOTNAM] = { "R", "G", "B", "SpecR", "SpecG", "SpecB", "MirR",
66         "MirG", "MirB", "Ref", "Alpha", "Emit", "Amb", "Spec",
67         "Hard", "SpTra", "Ior", "Mode", "HaSize", "Translu",
68         "RayMir", "FresMir", "FresMirI", "FresTra", "FresTraI",
69         "TraGlow" };
70 char *seq_ic_names[SEQ_TOTNAM] = { "Fac" };
71 char *cu_ic_names[CU_TOTNAM] = { "Speed" };
72 char *key_ic_names[KEY_TOTNAM] = { "Speed", "Key 1", "Key 2", "Key 3", "Key 4", "Key 5",
73         "Key 6", "Key 7", "Key 8", "Key 9", "Key 10",
74         "Key 11", "Key 12", "Key 13", "Key 14", "Key 15",
75         "Key 16", "Key 17", "Key 18", "Key 19", "Key 20",
76         "Key 21", "Key 22", "Key 23", "Key 24", "Key 25",
77         "Key 26", "Key 27", "Key 28", "Key 29", "Key 30",
78         "Key 31", "Key 32", "Key 33", "Key 34", "Key 35",
79         "Key 36", "Key 37", "Key 38", "Key 39", "Key 40",
80         "Key 41", "Key 42", "Key 43", "Key 44", "Key 45",
81         "Key 46", "Key 47", "Key 48", "Key 49", "Key 50",
82         "Key 51", "Key 52", "Key 53", "Key 54", "Key 55",
83         "Key 56", "Key 57", "Key 58", "Key 59", "Key 60",
84         "Key 61", "Key 62", "Key 63"};
85 char *wo_ic_names[WO_TOTNAM] = { "HorR", "HorG", "HorB", "ZenR", "ZenG", "ZenB", "Expos",
86         "Misi", "MisDi", "MisSta", "MisHi", "StarR", "StarB",
87         "StarG", "StarDi", "StarSi" };
88 char *la_ic_names[LA_TOTNAM] = { "Energ", "R", "G", "B", "Dist", "SpoSi", "SpoBl",
89         "Quad1", "Quad2", "HaInt" };
90 /* yafray: two curve names added, 'Apert' for aperture, and 'FDist' for focal distance */
91 char *cam_ic_names[CAM_TOTNAM] = { "Lens", "ClSta", "ClEnd", "Apert", "FDist", "ShiftX", "ShiftY" };
92 char *snd_ic_names[SND_TOTNAM] = { "Vol", "Pitch", "Pan", "Atten" };
93 char *ac_ic_names[AC_TOTNAM] = {"LocX", "LocY", "LocZ", "ScaleX", "ScaleY",
94         "ScaleZ", "QuatW", "QuatX", "QuatY", "QuatZ"};
95 char *ic_name_empty[1] ={ "" };
96 char *fluidsim_ic_names[FLUIDSIM_TOTNAM] = { "Fac-Visc", "Fac-Time",  "GravX","GravY","GravZ",  "VelX","VelY","VelZ", "Active"  };
97
98 char *getname_ac_ei(int nr) 
99 {
100         switch(nr) {
101                 case AC_LOC_X:
102                 case AC_LOC_Y:
103                 case AC_LOC_Z:
104                         return ac_ic_names[nr-1];
105                 case AC_SIZE_X:
106                 case AC_SIZE_Y:
107                 case AC_SIZE_Z:
108                         return ac_ic_names[nr-10];
109                 case AC_QUAT_X:
110                 case AC_QUAT_Y:
111                 case AC_QUAT_Z:
112                 case AC_QUAT_W:
113                         return ac_ic_names[nr-19];
114                 default:
115                         return ic_name_empty[0]; /* empty */
116         }
117 }
118
119 char *getname_co_ei(int nr)
120 {
121         switch(nr){
122                 case CO_ENFORCE:
123                         return co_ic_names[nr-1];
124         }
125         return ic_name_empty[0];
126 }
127
128 char *getname_ob_ei(int nr, int colipo)
129 {
130         if(nr>=OB_LOC_X && nr <= OB_PD_PERM) return ob_ic_names[nr-1];
131         
132         return ic_name_empty[0];
133 }
134
135 char *getname_tex_ei(int nr)
136 {
137         if(nr>=TE_NSIZE && nr<=TE_CONTRA) return tex_ic_names[nr-1];
138         
139         return ic_name_empty[0];
140 }
141
142 char *getname_mtex_ei(int nr)
143 {
144         if(nr>=MAP_OFS_X && nr<=MAP_DISP) return mtex_ic_names[nr-1];
145         
146         return ic_name_empty[0];
147 }
148
149 char *getname_mat_ei(int nr)
150 {
151         if(nr>=MA_MAP1) return getname_mtex_ei((nr & (MA_MAP1-1)));
152         else {
153                 if(nr>=MA_COL_R && nr<=MA_ADD) return ma_ic_names[nr-1];
154         }
155         return ic_name_empty[0];
156 }
157
158 char *getname_world_ei(int nr)
159 {
160         if(nr>=MA_MAP1) return getname_mtex_ei((nr & (MA_MAP1-1)));
161         else {
162                 if(nr>=WO_HOR_R && nr<=WO_STARSIZE) return wo_ic_names[nr-1];
163         }
164         return ic_name_empty[0];
165 }
166
167 char *getname_seq_ei(int nr)
168 {
169         if(nr == SEQ_FAC1) return seq_ic_names[nr-1];
170         return ic_name_empty[0];
171 }
172
173 char *getname_cu_ei(int nr)
174 {
175         if(nr==CU_SPEED) return cu_ic_names[nr-1];
176         return ic_name_empty[0];
177 }
178
179 char *getname_la_ei(int nr)
180 {
181         if(nr>=MA_MAP1) return getname_mtex_ei((nr & (MA_MAP1-1)));
182         else {
183                 if(nr>=LA_ENERGY && nr<=LA_HALOINT) return la_ic_names[nr-1];
184         }
185         return ic_name_empty[0];
186 }
187
188 char *getname_cam_ei(int nr)
189 {
190         if(nr>=CAM_LENS && nr<=CAM_SHIFT_Y) return cam_ic_names[nr-1];
191         return ic_name_empty[0];
192 }
193
194 char *getname_snd_ei(int nr)
195 {
196         if(nr>=SND_VOLUME && nr<=SND_ATTEN) return snd_ic_names[nr-1];
197         return ic_name_empty[0];
198 }
199
200 char *getname_fluidsim_ei(int nr)
201 {
202         if(nr <= FLUIDSIM_TOTIPO) return fluidsim_ic_names[nr-1];
203         return ic_name_empty[0];
204 }
205
206
207 void boundbox_ipocurve(IpoCurve *icu)
208 {
209         BezTriple *bezt;
210         float vec[3]={0.0,0.0,0.0};
211         float min[3], max[3];
212         int a;
213         
214         if(icu->totvert) {
215                 INIT_MINMAX(min, max);
216                 
217                 if(icu->bezt ) {
218                         a= icu->totvert;
219                         bezt= icu->bezt;
220                         while(a--) {
221                                 if(icu->vartype & IPO_BITS) {
222                                         vec[0]= bezt->vec[1][0];
223                                         vec[1]= 0.0;
224                                         DO_MINMAX(vec, min, max);
225                                         
226                                         vec[1]= 16.0;
227                                         DO_MINMAX(vec, min, max);
228                                 }
229                                 else {
230                                         if(icu->ipo==IPO_BEZ && a!=icu->totvert-1) {
231                                                 DO_MINMAX(bezt->vec[0], min, max);
232                                         }
233                                         DO_MINMAX(bezt->vec[1], min, max);
234                                         if(icu->ipo==IPO_BEZ && a!=0) {
235                                                 DO_MINMAX(bezt->vec[2], min, max);
236                                         }
237                                 }
238                                 
239                                 bezt++;
240                         }
241                 }
242                 if(min[0]==max[0]) max[0]= (float)(min[0]+1.0);
243                 if(min[1]==max[1]) max[1]= (float)(min[1]+0.1);
244                 
245                 icu->totrct.xmin= min[0];
246                 icu->totrct.ymin= min[1];
247                 icu->totrct.xmax= max[0];
248                 icu->totrct.ymax= max[1];
249         }
250         else {
251                 icu->totrct.xmin= icu->totrct.ymin= 0.0;
252                 icu->totrct.xmax= EFRA;
253                 icu->totrct.ymax= 1.0;
254         }
255 }
256
257 void boundbox_ipo(Ipo *ipo, rctf *bb)
258 {
259         IpoCurve *icu;
260         int first= 1;
261         
262         icu= ipo->curve.first;
263         while(icu) {
264                 
265                 boundbox_ipocurve(icu);
266                 
267                 if(first) {
268                         *bb= icu->totrct;
269                         first= 0;
270                 }
271                 else BLI_union_rctf(bb, &(icu->totrct));
272                 
273                 icu= icu->next;
274         }
275 }
276
277
278 unsigned int ipo_rainbow(int cur, int tot)
279 {
280         float dfac, fac, sat;
281         
282         dfac= (float)(1.0/( (float)tot+1.0));
283         
284         /* this calculation makes 2 or 4 different cycles of rainbow colors */
285         if(cur< tot/2) fac= (float)(cur*2.0f*dfac);
286         else fac= (float)((cur-tot/2)*2.0f*dfac +dfac);
287         if(tot > 32) fac= fac*1.95f;
288         if(fac>1.0f) fac-= 1.0f;
289         
290         if(fac>0.5f && fac<0.8f) sat= 0.4f;
291         else sat= 0.5f;
292         
293         return hsv_to_cpack(fac, sat, 1.0f);
294 }               
295
296 /* exported to python, hrms... (ton) */
297 int texchannel_to_adrcode(int channel)
298 {
299         switch(channel) {
300                 case 0: return MA_MAP1;
301                 case 1: return MA_MAP2; 
302                 case 2: return MA_MAP3; 
303                 case 3: return MA_MAP4; 
304                 case 4: return MA_MAP5; 
305                 case 5: return MA_MAP6; 
306                 case 6: return MA_MAP7; 
307                 case 7: return MA_MAP8; 
308                 case 8: return MA_MAP9; 
309                 case 9: return MA_MAP10; 
310                 default: return 0;
311         }
312 }
313
314