#3706 (patch tracker)
[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         "SizeX", "SizeY", "SizeZ", "dSizeX", "dSizeY", "dSizeZ",
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", "SizeX", "SizeY",
94         "SizeZ", "QuatW", "QuatX", "QuatY", "QuatZ"};
95 char *ic_name_empty[1] ={ "" };
96
97 char *getname_ac_ei(int nr) 
98 {
99         switch(nr) {
100                 case AC_LOC_X:
101                 case AC_LOC_Y:
102                 case AC_LOC_Z:
103                         return ac_ic_names[nr-1];
104                 case AC_SIZE_X:
105                 case AC_SIZE_Y:
106                 case AC_SIZE_Z:
107                         return ac_ic_names[nr-10];
108                 case AC_QUAT_X:
109                 case AC_QUAT_Y:
110                 case AC_QUAT_Z:
111                 case AC_QUAT_W:
112                         return ac_ic_names[nr-19];
113                 default:
114                         return ic_name_empty[0]; /* empty */
115         }
116 }
117
118 char *getname_co_ei(int nr)
119 {
120         switch(nr){
121                 case CO_ENFORCE:
122                         return co_ic_names[nr-1];
123         }
124         return ic_name_empty[0];
125 }
126
127 char *getname_ob_ei(int nr, int colipo)
128 {
129         if(nr>=OB_LOC_X && nr <= OB_PD_PERM) return ob_ic_names[nr-1];
130         
131         return ic_name_empty[0];
132 }
133
134 char *getname_tex_ei(int nr)
135 {
136         if(nr>=TE_NSIZE && nr<=TE_CONTRA) return tex_ic_names[nr-1];
137         
138         return ic_name_empty[0];
139 }
140
141 char *getname_mtex_ei(int nr)
142 {
143         if(nr>=MAP_OFS_X && nr<=MAP_DISP) return mtex_ic_names[nr-1];
144         
145         return ic_name_empty[0];
146 }
147
148 char *getname_mat_ei(int nr)
149 {
150         if(nr>=MA_MAP1) return getname_mtex_ei((nr & (MA_MAP1-1)));
151         else {
152                 if(nr>=MA_COL_R && nr<=MA_ADD) return ma_ic_names[nr-1];
153         }
154         return ic_name_empty[0];
155 }
156
157 char *getname_world_ei(int nr)
158 {
159         if(nr>=MA_MAP1) return getname_mtex_ei((nr & (MA_MAP1-1)));
160         else {
161                 if(nr>=WO_HOR_R && nr<=WO_STARSIZE) return wo_ic_names[nr-1];
162         }
163         return ic_name_empty[0];
164 }
165
166 char *getname_seq_ei(int nr)
167 {
168         if(nr == SEQ_FAC1) return seq_ic_names[nr-1];
169         return ic_name_empty[0];
170 }
171
172 char *getname_cu_ei(int nr)
173 {
174         if(nr==CU_SPEED) return cu_ic_names[nr-1];
175         return ic_name_empty[0];
176 }
177
178 char *getname_la_ei(int nr)
179 {
180         if(nr>=MA_MAP1) return getname_mtex_ei((nr & (MA_MAP1-1)));
181         else {
182                 if(nr>=LA_ENERGY && nr<=LA_HALOINT) return la_ic_names[nr-1];
183         }
184         return ic_name_empty[0];
185 }
186
187 char *getname_cam_ei(int nr)
188 {
189         /* yafray: curves extended to CAM_YF_FDIST */
190         //if(nr>=CAM_LENS && nr<=CAM_END) return cam_ic_names[nr-1];
191         if(nr>=CAM_LENS && nr<=CAM_YF_FDIST) return cam_ic_names[nr-1];
192         return ic_name_empty[0];
193 }
194
195 char *getname_snd_ei(int nr)
196 {
197         if(nr>=SND_VOLUME && nr<=SND_ATTEN) return snd_ic_names[nr-1];
198         return ic_name_empty[0];
199 }
200
201
202 void boundbox_ipocurve(IpoCurve *icu)
203 {
204         BezTriple *bezt;
205         float vec[3]={0.0,0.0,0.0};
206         float min[3], max[3];
207         int a;
208         
209         if(icu->totvert) {
210                 INIT_MINMAX(min, max);
211                 
212                 if(icu->bezt ) {
213                         a= icu->totvert;
214                         bezt= icu->bezt;
215                         while(a--) {
216                                 if(icu->vartype & IPO_BITS) {
217                                         vec[0]= bezt->vec[1][0];
218                                         vec[1]= 0.0;
219                                         DO_MINMAX(vec, min, max);
220                                         
221                                         vec[1]= 16.0;
222                                         DO_MINMAX(vec, min, max);
223                                 }
224                                 else {
225                                         if(icu->ipo==IPO_BEZ && a!=icu->totvert-1) {
226                                                 DO_MINMAX(bezt->vec[0], min, max);
227                                         }
228                                         DO_MINMAX(bezt->vec[1], min, max);
229                                         if(icu->ipo==IPO_BEZ && a!=0) {
230                                                 DO_MINMAX(bezt->vec[2], min, max);
231                                         }
232                                 }
233                                 
234                                 bezt++;
235                         }
236                 }
237                 if(min[0]==max[0]) max[0]= (float)(min[0]+1.0);
238                 if(min[1]==max[1]) max[1]= (float)(min[1]+0.1);
239                 
240                 icu->totrct.xmin= min[0];
241                 icu->totrct.ymin= min[1];
242                 icu->totrct.xmax= max[0];
243                 icu->totrct.ymax= max[1];
244         }
245         else {
246                 icu->totrct.xmin= icu->totrct.ymin= 0.0;
247                 icu->totrct.xmax= EFRA;
248                 icu->totrct.ymax= 1.0;
249         }
250 }
251
252 void boundbox_ipo(Ipo *ipo, rctf *bb)
253 {
254         IpoCurve *icu;
255         int first= 1;
256         
257         icu= ipo->curve.first;
258         while(icu) {
259                 
260                 boundbox_ipocurve(icu);
261                 
262                 if(first) {
263                         *bb= icu->totrct;
264                         first= 0;
265                 }
266                 else BLI_union_rctf(bb, &(icu->totrct));
267                 
268                 icu= icu->next;
269         }
270 }
271
272
273 unsigned int ipo_rainbow(int cur, int tot)
274 {
275         float dfac, fac, sat;
276         
277         dfac= (float)(1.0/( (float)tot+1.0));
278         
279         /* this calculation makes 2 or 4 different cycles of rainbow colors */
280         if(cur< tot/2) fac= (float)(cur*2.0f*dfac);
281         else fac= (float)((cur-tot/2)*2.0f*dfac +dfac);
282         if(tot > 32) fac= fac*1.95f;
283         if(fac>1.0f) fac-= 1.0f;
284         
285         if(fac>0.5f && fac<0.8f) sat= 0.4f;
286         else sat= 0.5f;
287         
288         return hsv_to_cpack(fac, sat, 1.0f);
289 }               
290
291 /* exported to python, hrms... (ton) */
292 int texchannel_to_adrcode(int channel)
293 {
294         switch(channel) {
295                 case 0: return MA_MAP1;
296                 case 1: return MA_MAP2; 
297                 case 2: return MA_MAP3; 
298                 case 3: return MA_MAP4; 
299                 case 4: return MA_MAP5; 
300                 case 5: return MA_MAP6; 
301                 case 6: return MA_MAP7; 
302                 case 7: return MA_MAP8; 
303                 case 8: return MA_MAP9; 
304                 case 9: return MA_MAP10; 
305                 default: return 0;
306         }
307 }
308
309