remove RSA's md4.c, replace by DP's
[xonotic/netradiant.git] / libs / math / expression.h
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #if !defined (INCLUDED_EXPRESSION_H)
23 #define INCLUDED_EXPRESSION_H
24
25 #include <math/matrix.h>
26
27 template<typename Value>
28 class Literal
29 {
30   Value m_value;
31 public:
32   typedef Value value_type;
33
34   Literal(const Value& value)
35     : m_value(value)
36   {
37   }
38   const value_type& eval() const
39   {
40     return m_value;
41   }
42 };
43
44 template<typename Value>
45 inline Literal<Value> float_literal(const Value& value)
46 {
47   return Literal<Value>(value);
48 }
49
50 template<typename Expression>
51 inline float float_for_expression(const Expression& expression)
52 {
53   return expression.eval();
54 }
55
56
57 template<typename First, typename Second>
58 class ScalarDivided
59 {
60   First first;
61   Second second;
62 public:
63   typedef typename First::value_type value_type;
64
65   ScalarDivided(const First& first_, const Second& second_) : first(first_), second(second_)
66   {
67   }
68   value_type eval() const
69   {
70     return static_cast<value_type>(first.eval() / second.eval());
71   }
72 };
73
74 template<typename First, typename Second>
75 inline ScalarDivided<First, Second> float_divided(const First& first, const Second& second)
76 {
77   return ScalarDivided<First, Second>(first, second);
78 }
79
80 template<typename First>
81 inline ScalarDivided<Literal<typename First::value_type>, First> float_reciprocal(const First& first)
82 {
83   typedef typename First::value_type first_value_type;
84   return ScalarDivided<Literal<first_value_type>, First>(float_literal(first_value_type(1.0)), first);
85 }
86
87 template<typename First>
88 class SquareRoot
89 {
90   First first;
91 public:
92   typedef typename First::value_type value_type;
93
94   SquareRoot(const First& first_) : first(first_)
95   {
96   }
97   value_type eval() const
98   {
99     return static_cast<value_type>(sqrt(first.eval()));
100   }
101 };
102
103 template<typename First>
104 inline SquareRoot<First> float_square_root(const First& first)
105 {
106   return SquareRoot<First>(first);
107 }
108
109
110 template<typename Element>
111 class BasicVector3Literal
112 {
113   const BasicVector3<Element> m_value;
114 public:
115   typedef Element value_type;
116   typedef IntegralConstant<3> dimension;
117
118   BasicVector3Literal(const BasicVector3<Element>& value)
119     : m_value(value)
120   {
121   }
122   const value_type& eval(unsigned int i) const
123   {
124     return m_value[i];
125   }
126 };
127
128 template<typename Element>
129 inline BasicVector3Literal<Element> vector3_literal(const BasicVector3<Element>& value)
130 {
131   return BasicVector3Literal<Element>(value);
132 }
133
134 typedef BasicVector3Literal<float> Vector3Literal;
135
136 template<typename Element>
137 class BasicVector3Identity
138 {
139   const BasicVector3<Element>& m_value;
140 public:
141   typedef Element value_type;
142   typedef IntegralConstant<3> dimension;
143
144   BasicVector3Identity(const BasicVector3<Element>& value)
145     : m_value(value)
146   {
147   }
148   const value_type& eval(unsigned int i) const
149   {
150     return m_value[i];
151   }
152 };
153
154 template<typename Element>
155 inline BasicVector3Identity<Element> vector3_identity(const BasicVector3<Element>& value)
156 {
157   return BasicVector3Identity<Element>(value);
158 }
159
160 typedef BasicVector3Identity<float> Vector3Identity;
161
162 template<typename Expression>
163 inline BasicVector3<typename Expression::value_type> vector3_for_expression(const Expression& expression)
164 {
165   return Vector3(expression.eval(0), expression.eval(1), expression.eval(2));
166 }
167
168
169 template<typename Operation, typename First, typename Second>
170 class VectorScalar
171 {
172   First first;
173   Literal<typename Second::value_type> second;
174 public:
175   typedef typename First::value_type value_type;
176   typedef typename First::dimension dimension;
177
178   VectorScalar(const First& first_, const Second& second_)
179     : first(first_), second(second_.eval())
180   {
181   }
182   value_type eval(unsigned int i) const
183   {
184     return Operation::apply( first.eval(i), second.eval() );
185   }
186 };
187
188
189
190 template<typename Operation, typename First, typename Second>
191 class VectorVector
192 {
193   First first;
194   Second second;
195 public:
196   typedef typename First::value_type value_type;
197   typedef typename First::dimension dimension;
198
199   VectorVector(const First& first_, const Second& second_)
200     : first(first_), second(second_)
201   {
202   }
203   value_type eval(unsigned int i) const
204   {
205     return Operation::apply(first.eval(i), second.eval(i));
206   }
207 };
208
209 template<typename First, typename Second>
210 class Added
211 {
212 public:
213   typedef First value_type;
214
215   static value_type apply(const First& first, const Second& second)
216   {
217     return static_cast<value_type>(first + second);
218   }
219 };
220
221 template<typename First, typename Second>
222 inline VectorVector<Added<typename First::value_type, typename Second::value_type>, First, Second>
223 vector_added(const First& first, const Second& second)
224 {
225   typedef typename First::value_type first_value_type;
226   typedef typename Second::value_type second_value_type;
227   return VectorVector<Added<first_value_type, second_value_type>, First, Second>(first, second);
228 }
229
230 template<typename First, typename Second>
231 class Multiplied
232 {
233 public:
234   typedef First value_type;
235
236   static value_type apply(const First& first, const Second& second)
237   {
238     return static_cast<value_type>(first * second);
239   }
240 };
241
242 template<typename First, typename Second>
243 inline VectorVector<Multiplied<typename First::value_type, typename Second::value_type>, First, Second>
244 vector_multiplied(const First& first, const Second& second)
245 {
246   typedef typename First::value_type first_value_type;
247   typedef typename Second::value_type second_value_type;
248   return VectorVector<Multiplied<first_value_type, second_value_type>, First, Second>(first, second);
249 }
250
251 template<typename First, typename Second>
252 inline VectorScalar<Multiplied<typename First::value_type, typename Second::value_type>, First, Second>
253 vector_scaled(const First& first, const Second& second)
254 {
255   typedef typename First::value_type first_value_type;
256   typedef typename Second::value_type second_value_type;
257   return VectorScalar<Multiplied<first_value_type, second_value_type>, First, Second>(first, second);
258 }
259
260 template<typename First>
261 class Negated
262 {
263 public:
264   typedef First value_type;
265
266   static value_type apply(const First& first)
267   {
268     return -first;
269   }
270 };
271
272 template<typename First, typename Operation>
273 class VectorUnary
274 {
275   First first;
276 public:
277   typedef typename First::value_type value_type;
278   typedef typename First::dimension dimension;
279
280   VectorUnary(const First& first_) : first(first_)
281   {
282   }
283   value_type eval(unsigned int i) const
284   {
285     return Operation::apply(first.eval(i));
286   }
287 };
288
289 template<typename First>
290 inline VectorUnary<First, Negated<typename First::value_type> >
291 vector_negated(const First& first)
292 {
293   typedef typename First::value_type first_value_type;
294   return VectorUnary<First, Negated<first_value_type> >(first);
295 }
296
297 template<typename First, typename Second>
298 class VectorCross
299 {
300   First first;
301   Second second;
302 public:
303   typedef typename First::value_type value_type;
304   typedef typename First::dimension dimension;
305
306   VectorCross(const First& first_, const Second& second_)
307     : first(first_), second(second_)
308   {
309   }
310   value_type eval(unsigned int i) const
311   {
312     return first.eval((i+1)%3) * second.eval((i+2)%3) - first.eval((i+2)%3) * second.eval((i+1)%3);
313   }
314 };
315
316 template<typename First, typename Second>
317 inline VectorCross<First, Second>
318 vector_cross(const First& first, const Second& second)
319 {
320   return VectorCross<First, Second>(first, second);
321 }
322
323
324 template<typename First, typename Second>
325 class VectorDot
326 {
327   First first;
328   Second second;
329 public:
330   typedef typename First::value_type value_type;
331   typedef typename First::dimension dimension;
332
333   VectorDot(const First& first_, const Second& second_)
334     : first(first_), second(second_)
335   {
336   }
337
338   template<typename Index>
339   struct eval_dot
340   {
341     static value_type apply(const First& first, const Second& second)
342     {
343       return static_cast<value_type>(
344         first.eval(Index::VALUE) * second.eval(Index::VALUE)
345         + eval_dot< IntegralConstant<Index::VALUE-1> >::apply(first, second)
346       );
347     }
348   };
349
350   template<>
351   struct eval_dot< IntegralConstant<0> >
352   {
353     static value_type apply(const First& first, const Second& second)
354     {
355       return first.eval(0) * second.eval(0);
356     }
357   };
358
359   value_type eval() const
360   {
361     return eval_dot< IntegralConstant<dimension::VALUE - 1> >::apply(first, second);
362   }
363 };
364
365
366 template<typename First, typename Second>
367 inline VectorDot<First, Second> vector_dot(const First& first, const Second& second)
368 {
369   return VectorDot<First, Second>(first, second);
370 }
371
372 template<typename First>
373 class VectorLengthSquared
374 {
375   First first;
376 public:
377   typedef typename First::value_type value_type;
378   typedef typename First::dimension dimension;
379
380   VectorLengthSquared(const First& first_)
381     : first(first_)
382   {
383   }
384
385   static value_type squared(const value_type& value)
386   {
387     return value * value;
388   }
389
390   template<typename Index>
391   struct eval_squared
392   {
393     static value_type apply(const First& first)
394     {
395       return static_cast<value_type>(
396         squared(first.eval(Index::VALUE))
397         + eval_squared< IntegralConstant<Index::VALUE - 1> >::apply(first)
398       );
399     }
400   };
401
402   template<>
403   struct eval_squared< IntegralConstant<0> >
404   {
405     static value_type apply(const First& first)
406     {
407       return squared(first.eval(0));
408     }
409   };
410
411   value_type eval() const
412   {
413     return eval_squared< IntegralConstant<dimension::VALUE - 1> >::apply(first);
414   }
415 };
416
417 template<typename First>
418 inline VectorLengthSquared<First> vector_length_squared(const First& first)
419 {
420   return VectorLengthSquared<First>(first);
421 }
422
423 template<typename First>
424 inline SquareRoot< VectorLengthSquared<First> > vector_length(const First& first)
425 {
426   return float_square_root(vector_length_squared(first));
427 }
428
429 #if 1
430 template<typename First>
431 inline VectorScalar<
432   Multiplied<typename First::value_type, typename First::value_type>,
433   First,
434   // multiple evaulations of subexpression
435   ScalarDivided<
436     Literal<typename First::value_type>,
437     SquareRoot<
438       VectorLengthSquared<First>
439     >
440   >
441 > vector_normalised(const First& first)
442 {
443   typedef typename First::value_type first_value_type;
444   return vector_scaled(first, float_reciprocal(vector_length(first)));
445 }
446 #else
447 template<typename First>
448 inline VectorScalar<
449   Multiplied<typename First::value_type, typename First::value_type>,
450   First,
451   // single evaluation of subexpression
452   Literal<typename First::value_type>
453 >
454 vector_normalised(const First& first)
455 {
456   typedef typename First::value_type first_value_type;
457   return vector_scaled(first, float_literal(static_cast<first_value_type>(first_value_type(1.0) / vector_length(first).eval())));
458 }
459 #endif
460
461
462 class Matrix4Literal
463 {
464   const Matrix4 m_value;
465 public:
466   typedef float value_type;
467   typedef IntegralConstant<4> dimension0;
468   typedef IntegralConstant<4> dimension1;
469
470   Matrix4Literal(const Matrix4& value)
471     : m_value(value)
472   {
473   }
474   const value_type& eval(unsigned int r, unsigned int c) const
475   {
476     return m_value[r*4+c];
477   }
478 };
479
480 inline Matrix4Literal matrix4_literal(const Matrix4& value)
481 {
482   return Matrix4Literal(value);
483 }
484
485 class Matrix4Identity
486 {
487   const Matrix4& m_value;
488 public:
489   typedef float value_type;
490   typedef IntegralConstant<4> dimension0;
491   typedef IntegralConstant<4> dimension1;
492
493   Matrix4Identity(const Matrix4& value)
494     : m_value(value)
495   {
496   }
497   const value_type& eval(unsigned int r, unsigned int c) const
498   {
499     return m_value[r*4+c];
500   }
501 };
502
503 inline Matrix4Identity matrix4_identity(const Matrix4& value)
504 {
505   return Matrix4Identity(value);
506 }
507
508 template<typename Expression>
509 inline Matrix4 matrix4_for_expression(const Expression& expression)
510 {
511   return Matrix4(
512     expression.eval(0, 0), expression.eval(0, 1), expression.eval(0, 2), expression.eval(0, 3),
513     expression.eval(1, 0), expression.eval(1, 1), expression.eval(1, 2), expression.eval(1, 3),
514     expression.eval(2, 0), expression.eval(2, 1), expression.eval(2, 2), expression.eval(2, 3),
515     expression.eval(3, 0), expression.eval(3, 1), expression.eval(3, 2), expression.eval(3, 3)
516   );
517 }
518
519 template<typename Expression>
520 inline Matrix4 matrix4_affine_for_expression(const Expression& expression)
521 {
522   return Matrix4(
523     expression.eval(0, 0), expression.eval(0, 1), expression.eval(0, 2), 0,
524     expression.eval(1, 0), expression.eval(1, 1), expression.eval(1, 2), 0,
525     expression.eval(2, 0), expression.eval(2, 1), expression.eval(2, 2), 0,
526     expression.eval(3, 0), expression.eval(3, 1), expression.eval(3, 2), 1
527   );
528 }
529
530
531 template<typename First, typename Second>
532 class PointMultiplied
533 {
534   const First& first;
535   const Second& second;
536 public:
537   typedef typename First::value_type value_type;
538   typedef typename First::dimension dimension;
539
540   PointMultiplied(const First& first_, const Second& second_)
541     : first(first_), second(second_)
542   {
543   }
544   value_type eval(unsigned int i) const
545   {
546     return static_cast<value_type>(second.eval(0, i) * first.eval(0)
547       + second.eval(1, i) * first.eval(1)
548       + second.eval(2, i) * first.eval(2)
549       + second.eval(3, i));
550   }
551 };
552
553 template<typename First, typename Second>
554 inline PointMultiplied<First, Second> point_multiplied(const First& point, const Second& matrix)
555 {
556   return PointMultiplied<First, Second>(point, matrix);
557 }
558
559 template<typename First, typename Second>
560 class Matrix4Multiplied
561 {
562   const First& first;
563   const Second& second;
564 public:
565   typedef typename First::value_type value_type;
566   typedef typename First::dimension0 dimension0;
567   typedef typename First::dimension1 dimension1;
568
569   Matrix4Multiplied(const First& first_, const Second& second_)
570     : first(first_), second(second_)
571   {
572   }
573
574   value_type eval(unsigned int r, unsigned int c) const
575   {
576     return static_cast<value_type>(
577       second.eval(r, 0) * first.eval(0, c)
578       + second.eval(r, 1) * first.eval(1, c)
579       + second.eval(r, 2) * first.eval(2, c)
580       + second.eval(r, 3) * first.eval(3, c)
581     );
582   }
583 };
584
585 template<typename First, typename Second>
586 inline Matrix4Multiplied<First, Second> matrix4_multiplied(const First& first, const Second& second)
587 {
588   return Matrix4Multiplied<First, Second>(first, second);
589 }
590
591 template<typename First>
592 class MatrixTransposed
593 {
594   const First& first;
595 public:
596   typedef typename First::value_type value_type;
597   typedef typename First::dimension0 dimension0;
598   typedef typename First::dimension1 dimension1;
599
600   MatrixTransposed(const First& first_)
601     : first(first_)
602   {
603   }
604
605   value_type eval(unsigned int r, unsigned int c) const
606   {
607     return first.eval(c, r);
608   }
609 };
610
611 template<typename First>
612 inline MatrixTransposed<First> matrix_transposed(const First& first)
613 {
614   return MatrixTransposed<First>(first);
615 }
616
617 #endif