4c6bb24a3da50e716c158986bdfbcab87620025f
[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" };
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         /* yafray: curves extended to CAM_YF_FDIST */
191         //if(nr>=CAM_LENS && nr<=CAM_END) return cam_ic_names[nr-1];
192         if(nr>=CAM_LENS && nr<=CAM_YF_FDIST) return cam_ic_names[nr-1];
193         return ic_name_empty[0];
194 }
195
196 char *getname_snd_ei(int nr)
197 {
198         if(nr>=SND_VOLUME && nr<=SND_ATTEN) return snd_ic_names[nr-1];
199         return ic_name_empty[0];
200 }
201
202 char *getname_fluidsim_ei(int nr)
203 {
204         if(nr <= FLUIDSIM_TOTIPO) return fluidsim_ic_names[nr-1];
205         return ic_name_empty[0];
206 }
207
208
209 void boundbox_ipocurve(IpoCurve *icu)
210 {
211         BezTriple *bezt;
212         float vec[3]={0.0,0.0,0.0};
213         float min[3], max[3];
214         int a;
215         
216         if(icu->totvert) {
217                 INIT_MINMAX(min, max);
218                 
219                 if(icu->bezt ) {
220                         a= icu->totvert;
221                         bezt= icu->bezt;
222                         while(a--) {
223                                 if(icu->vartype & IPO_BITS) {
224                                         vec[0]= bezt->vec[1][0];
225                                         vec[1]= 0.0;
226                                         DO_MINMAX(vec, min, max);
227                                         
228                                         vec[1]= 16.0;
229                                         DO_MINMAX(vec, min, max);
230                                 }
231                                 else {
232                                         if(icu->ipo==IPO_BEZ && a!=icu->totvert-1) {
233                                                 DO_MINMAX(bezt->vec[0], min, max);
234                                         }
235                                         DO_MINMAX(bezt->vec[1], min, max);
236                                         if(icu->ipo==IPO_BEZ && a!=0) {
237                                                 DO_MINMAX(bezt->vec[2], min, max);
238                                         }
239                                 }
240                                 
241                                 bezt++;
242                         }
243                 }
244                 if(min[0]==max[0]) max[0]= (float)(min[0]+1.0);
245                 if(min[1]==max[1]) max[1]= (float)(min[1]+0.1);
246                 
247                 icu->totrct.xmin= min[0];
248                 icu->totrct.ymin= min[1];
249                 icu->totrct.xmax= max[0];
250                 icu->totrct.ymax= max[1];
251         }
252         else {
253                 icu->totrct.xmin= icu->totrct.ymin= 0.0;
254                 icu->totrct.xmax= EFRA;
255                 icu->totrct.ymax= 1.0;
256         }
257 }
258
259 void boundbox_ipo(Ipo *ipo, rctf *bb)
260 {
261         IpoCurve *icu;
262         int first= 1;
263         
264         icu= ipo->curve.first;
265         while(icu) {
266                 
267                 boundbox_ipocurve(icu);
268                 
269                 if(first) {
270                         *bb= icu->totrct;
271                         first= 0;
272                 }
273                 else BLI_union_rctf(bb, &(icu->totrct));
274                 
275                 icu= icu->next;
276         }
277 }
278
279
280 unsigned int ipo_rainbow(int cur, int tot)
281 {
282         float dfac, fac, sat;
283         
284         dfac= (float)(1.0/( (float)tot+1.0));
285         
286         /* this calculation makes 2 or 4 different cycles of rainbow colors */
287         if(cur< tot/2) fac= (float)(cur*2.0f*dfac);
288         else fac= (float)((cur-tot/2)*2.0f*dfac +dfac);
289         if(tot > 32) fac= fac*1.95f;
290         if(fac>1.0f) fac-= 1.0f;
291         
292         if(fac>0.5f && fac<0.8f) sat= 0.4f;
293         else sat= 0.5f;
294         
295         return hsv_to_cpack(fac, sat, 1.0f);
296 }               
297
298 /* exported to python, hrms... (ton) */
299 int texchannel_to_adrcode(int channel)
300 {
301         switch(channel) {
302                 case 0: return MA_MAP1;
303                 case 1: return MA_MAP2; 
304                 case 2: return MA_MAP3; 
305                 case 3: return MA_MAP4; 
306                 case 4: return MA_MAP5; 
307                 case 5: return MA_MAP6; 
308                 case 6: return MA_MAP7; 
309                 case 7: return MA_MAP8; 
310                 case 8: return MA_MAP9; 
311                 case 9: return MA_MAP10; 
312                 default: return 0;
313         }
314 }
315
316