Listbox / Picker: Implement item fading in a different way so that it gets influenced...
[xonotic/xonotic-data.pk3dir.git] / qcsrc / warpzonelib / anglestransform.qc
1 #if defined(CSQC)
2         #include "../dpdefs/csprogsdefs.qh"
3         #include "anglestransform.qh"
4 #elif defined(MENUQC)
5 #elif defined(SVQC)
6         #include "../dpdefs/progsdefs.qh"
7     #include "../dpdefs/dpextensions.qh"
8     #include "anglestransform.qh"
9 #endif
10
11 #ifdef POSITIVE_PITCH_IS_DOWN
12 vector fixedvectoangles(vector a)
13 {
14         vector ang;
15         ang = vectoangles(a);
16         ang.x = -ang.x;
17         return ang;
18 }
19 vector fixedvectoangles2(vector a, vector b)
20 {
21         vector ang;
22         ang = vectoangles2(a, b);
23         ang.x = -ang.x;
24         return ang;
25 }
26 #else
27 void fixedmakevectors(vector a)
28 {
29         // a makevectors that actually inverts vectoangles
30         a.x = -a.x;
31         makevectors(a);
32 }
33 #endif
34
35 // angles transforms
36 // angles in fixedmakevectors/fixedvectoangles space
37 vector AnglesTransform_Apply(vector transform, vector v)
38 {
39         fixedmakevectors(transform);
40         return v_forward * v.x
41                 + v_right   * (-v.y)
42                 + v_up      * v.z;
43 }
44
45 vector AnglesTransform_Multiply(vector t1, vector t2)
46 {
47         vector m_forward, m_up;
48         fixedmakevectors(t2); m_forward = v_forward; m_up = v_up;
49         m_forward = AnglesTransform_Apply(t1, m_forward); m_up = AnglesTransform_Apply(t1, m_up);
50         return fixedvectoangles2(m_forward, m_up);
51 }
52
53 vector AnglesTransform_Invert(vector transform)
54 {
55         vector i_forward, i_up;
56         fixedmakevectors(transform);
57         // we want angles that turn v_forward into '1 0 0', v_right into '0 1 0' and v_up into '0 0 1'
58         // but these are orthogonal unit vectors!
59         // so to invert, we can simply fixedvectoangles the TRANSPOSED matrix
60         // TODO is this always -transform?
61         i_forward.x = v_forward.x;
62         i_forward.y = -v_right.x;
63         i_forward.z = v_up.x;
64         i_up.x = v_forward.z;
65         i_up.y = -v_right.z;
66         i_up.z = v_up.z;
67         return fixedvectoangles2(i_forward, i_up);
68 }
69
70 vector AnglesTransform_TurnDirectionFR(vector transform)
71 {
72         // turn 180 degrees around v_up
73         // changes in-direction to out-direction
74         //fixedmakevectors(transform);
75         //return fixedvectoangles2(-1 * v_forward, 1 * v_up);
76         transform.x = -transform.x;
77         transform.y = 180 + transform.y;
78         transform.z = -transform.z;
79         // pitch: -s +c
80         // yaw:   -s -c
81         // roll:  -s +c
82         return transform;
83 }
84
85 vector AnglesTransform_TurnDirectionFU(vector transform)
86 {
87         // turn 180 degrees around v_up
88         // changes in-direction to out-direction
89         //fixedmakevectors(transform);
90         //return fixedvectoangles2(-1 * v_forward, 1 * v_up);
91         transform.x = -transform.x;
92         transform.y = 180 + transform.y;
93         transform.z = 180 - transform.z;
94         return transform;
95 }
96
97 vector AnglesTransform_RightDivide(vector to_transform, vector from_transform)
98 {
99         return AnglesTransform_Multiply(to_transform, AnglesTransform_Invert(from_transform));
100 }
101
102 vector AnglesTransform_LeftDivide(vector from_transform, vector to_transform)
103 {
104         return AnglesTransform_Multiply(AnglesTransform_Invert(from_transform), to_transform);
105 }
106
107 vector AnglesTransform_Normalize(vector t, float minimize_roll)
108 {
109         float need_flip;
110         // first, bring all angles in their range...
111         t.x = t.x - 360 * rint(t.x / 360);
112         t.y = t.y - 360 * rint(t.y / 360);
113         t.z = t.z - 360 * rint(t.z / 360);
114         if(minimize_roll)
115                 need_flip = (t.z > 90 || t.z <= -90);
116         else
117                 need_flip = (t.x > 90 || t.x < -90); // for pitch we prefer to allow exactly -90 degrees for looking straight down
118         if(need_flip)
119         {
120                 if(t.x >= 0) t.x = 180 - t.x; else t.x = -180 - t.x;
121                 if(t.y > 0) t.y -= 180; else t.y += 180;
122                 if(t.z > 0) t.z -= 180; else t.z += 180;
123         }
124         return t;
125 }
126
127 vector AnglesTransform_CancelRoll(vector t)
128 {
129         const float epsilon = 30;
130         float f;
131
132         // constraints:
133         // forward vector (NOT SO important)
134         // right vector, up vector: screen rotation (MORE important)
135         // choose best match among all pitch-yaw only rotations
136
137         // FIXME find a better method
138
139         f = fabs(t.x - (-90)) / epsilon;
140         if(f < 1)
141         {
142                 //t_x = -90;
143                 t.y += t.z;
144                 t.z = 0;
145         }
146         else
147         {
148                 f = fabs(t.x - 90) / epsilon;
149                 if(f < 1)
150                 {
151                         //t_x = 90;
152                         t.y -= t.z;
153                         t.z = 0;
154                 }
155         }
156         return t;
157 }
158
159 #ifdef POSITIVE_PITCH_IS_DOWN
160 vector AnglesTransform_ApplyToAngles(vector transform, vector v)
161 {
162         v.x = -v.x;
163         v = AnglesTransform_Multiply(transform, v);
164         v.x = -v.x;
165         return v;
166 }
167 vector AnglesTransform_ApplyToVAngles(vector transform, vector v)
168 {
169         v = AnglesTransform_Multiply(transform, v);
170         return v;
171 }
172 vector AnglesTransform_FromAngles(vector v)
173 {
174         v.x = -v.x;
175         return v;
176 }
177 vector AnglesTransform_ToAngles(vector v)
178 {
179         v.x = -v.x;
180         return v;
181 }
182 vector AnglesTransform_FromVAngles(vector v)
183 {
184         return v;
185 }
186 vector AnglesTransform_ToVAngles(vector v)
187 {
188         return v;
189 }
190 #else
191 vector AnglesTransform_ApplyToAngles(vector transform, vector v)
192 {
193         v = AnglesTransform_Multiply(transform, v);
194         return v;
195 }
196 vector AnglesTransform_ApplyToVAngles(vector transform, vector v)
197 {
198         v.x = -v.x;
199         v = AnglesTransform_Multiply(transform, v);
200         v.x = -v.x;
201         return v;
202 }
203 vector AnglesTransform_FromAngles(vector v)
204 {
205         return v;
206 }
207 vector AnglesTransform_ToAngles(vector v)
208 {
209         return v;
210 }
211 vector AnglesTransform_FromVAngles(vector v)
212 {
213         v.x = -v.x;
214         return v;
215 }
216 vector AnglesTransform_ToVAngles(vector v)
217 {
218         v.x = -v.x;
219         return v;
220 }
221 #endif
222
223 vector AnglesTransform_Multiply_GetPostShift(vector t0, vector st0, vector t1, vector st1)
224 {
225         // we want the result of:
226         //   t0 * (t1 * p + st1) + st0
227         //   t0 * t1 * p + t0 * st1 + st0
228         return st0 + AnglesTransform_Apply(t0, st1);
229 }
230 vector AnglesTransform_PrePostShift_GetPostShift(vector sf, vector t, vector st)
231 {
232         return st - AnglesTransform_Apply(t, sf);
233 }