doxygen: blender/editors tagged.
[blender.git] / source / blender / editors / transform / transform_ndofinput.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is: all of this file.
21  *
22  * Contributor(s): Martin Poirier
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/transform/transform_ndofinput.c
28  *  \ingroup edtransform
29  */
30
31  
32  #include <math.h>                      /* fabs */
33 #include <stdio.h>                      /* for sprintf          */
34
35 #include "BLI_utildefines.h"
36
37 #include "BKE_global.h"         /* for G                        */
38         /* ABS */
39
40 #include "WM_types.h"
41
42 #include "transform.h"
43
44 #if 0
45 static int updateNDofMotion(NDofInput *n); // return 0 when motion is null
46 #endif
47 static void resetNDofInput(NDofInput *n);
48
49 void initNDofInput(NDofInput *n)
50 {
51         int i;
52
53         n->flag = 0;
54         n->axis = 0;
55         
56         resetNDofInput(n);
57         
58         for(i = 0; i < 3; i++)
59         {
60                 n->factor[i] = 1.0f;
61         }
62 }
63
64 static void resetNDofInput(NDofInput *n)
65 {       
66         int i;
67         for(i = 0; i < 6; i++)
68         {
69                 n->fval[i] = 0.0f;
70         }
71 }
72
73  
74 int handleNDofInput(NDofInput *UNUSED(n), wmEvent *UNUSED(event))
75 {
76         int retval = 0;
77         // TRANSFORM_FIX_ME
78 #if 0
79         switch(event)
80         {
81                 case NDOFMOTION:
82                         if (updateNDofMotion(n) == 0)
83                         {
84                                 retval = NDOF_NOMOVE;
85                         }
86                         else
87                         {
88                                 retval = NDOF_REFRESH;
89                         }
90                         break;
91                 case NDOFBUTTON:
92                         if (val == 1) 
93                         {
94                                 retval = NDOF_CONFIRM;
95                         }
96                         else if (val == 2) 
97                         {
98                                 retval = NDOF_CANCEL;
99                                 resetNDofInput(n);
100                                 n->flag &= ~NDOF_INIT;
101                         }
102                         break;
103         }
104 #endif  
105         return retval;
106 }
107
108 int hasNDofInput(NDofInput *n)
109 {
110         return (n->flag & NDOF_INIT) == NDOF_INIT;
111 }
112
113 void applyNDofInput(NDofInput *n, float *vec)
114 {
115         if (hasNDofInput(n))
116         {
117                 int i, j;
118                 
119                 for (i = 0, j = 0; i < 6; i++)
120                 {
121                         if (n->axis & (1 << i))
122                         {
123                                 vec[j] = n->fval[i] * n->factor[j];
124                                 j++;
125                         }
126                 }
127         }
128 }
129
130 // TRANSFORM_FIX_ME
131 #if 0
132
133 static int updateNDofMotion(NDofInput *n)
134 {
135         float fval[7];
136         int i;
137         int retval = 0;
138
139         getndof(fval);
140
141         if (G.vd->ndoffilter)
142                 filterNDOFvalues(fval);
143
144         for(i = 0; i < 6; i++)
145         {
146                 if (!retval && fval[i] != 0.0f)
147                 {
148                         retval = 1;
149                 }
150                 
151                 n->fval[i] += fval[i] / 1024.0f;
152         }
153         
154         n->flag |= NDOF_INIT;
155         
156         return retval;
157 }
158 #endif
159
160
161
162