misc/mediasource/netradiant-src/libs/math/expression.cpp

   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 #include "expression.h"
  23
  24 Vector3 testAdded1(const Vector3& a, const Vector3& b)
  25 {
  26   return vector3_added(a, vector3_added(a, b));
  27 }
  28
  29 Vector3 testAdded2(const Vector3& a, const Vector3& b)
  30 {
  31   return vector3_for_expression( vector_added( vector3_identity(a), vector_added( vector3_identity(a), vector3_identity(b) ) ) );
  32 }
  33
  34 Vector3 testMultiplied1(const Vector3& a, const Vector3& b)
  35 {
  36   return vector3_scaled(a, b);
  37 }
  38
  39 Vector3 testMultiplied2(const Vector3& a, const Vector3& b)
  40 {
  41   return vector3_for_expression( vector_multiplied( vector3_identity(a), vector3_identity(b) ) );
  42 }
  43
  44 Vector3 testCross1(const Vector3& a, const Vector3& b)
  45 {
  46   return vector3_cross(a, b);
  47 }
  48
  49 Vector3 testCross2(const Vector3& a, const Vector3& b)
  50 {
  51   return vector3_for_expression( vector_cross( vector3_identity(a), vector3_identity(b) ) );
  52 }
  53
  54 double testDot1(const Vector3& a, const Vector3& b)
  55 {
  56   return vector3_dot(a, b);
  57 }
  58
  59 double testDot2(const Vector3& a, const Vector3& b)
  60 {
  61   return float_for_expression( vector_dot( vector3_identity(a), vector3_identity(b) ) );
  62 }
  63
  64 double testLength1(const Vector3& a)
  65 {
  66   return vector3_length(a);
  67 }
  68
  69 double testLength2(const Vector3& a)
  70 {
  71   return float_for_expression( vector_length( vector3_identity(a) ) );
  72 }
  73
  74 Vector3 testNormalised1(const Vector3& a)
  75 {
  76   return vector3_normalised(a);
  77 }
  78
  79 Vector3 testNormalised2(const Vector3& a)
  80 {
  81   return vector3_for_expression( vector_normalised( vector3_identity(a) ) );
  82 }
  83
  84 Vector3 testNegated1(const Vector3& a)
  85 {
  86   return vector3_negated(a);
  87 }
  88
  89 Vector3 testNegated2(const Vector3& a)
  90 {
  91   return vector3_for_expression( vector_negated( vector3_identity(a) ) );
  92 }
  93
  94 Vector3 testScaled1(const Vector3& a, const double& b)
  95 {
  96   return vector3_scaled(a, b);
  97 }
  98
  99 Vector3 testScaled2(const Vector3& a, const double& b)
 100 {
 101   return vector3_for_expression( vector_scaled( vector3_identity(a), float_literal(b) ) );
 102 }
 103
 104 Vector3 testMatrixMultiplied1(const Vector3& a, const Matrix4& b)
 105 {
 106   return matrix4_transformed_point(b, vector3_added(a, Vector3(1, 0, 0)));
 107 }
 108
 109 Vector3 testMatrixMultiplied2(const Vector3& a, const Matrix4& b)
 110 {
 111   return vector3_for_expression(
 112     point_multiplied(
 113       vector_added(
 114         vector3_identity(a),
 115         vector3_literal(Vector3(1, 0, 0))
 116       ),
 117       matrix4_identity(b)
 118     )
 119   );
 120 }
 121
 122 Matrix4 testMatrix4Multiplied1(const Matrix4& a, const Matrix4& b)
 123 {
 124   return matrix4_multiplied_by_matrix4(a, matrix4_multiplied_by_matrix4(a, b));
 125 }
 126
 127 Matrix4 testMatrix4Multiplied2(const Matrix4& a, const Matrix4& b)
 128 {
 129   return matrix4_for_expression(
 130     matrix4_multiplied(
 131       matrix4_identity(a),
 132       matrix4_identity(b)
 133     )
 134   );
 135 }
 136
 137 Matrix4 testMatrix4AffineMultiplied1(const Matrix4& a, const Matrix4& b)
 138 {
 139   return matrix4_affine_multiplied_by_matrix4(a, b);
 140 }
 141
 142 Matrix4 testMatrix4AffineMultiplied2(const Matrix4& a, const Matrix4& b)
 143 {
 144   return matrix4_affine_for_expression(
 145     matrix4_multiplied(
 146       matrix4_identity(a),
 147       matrix4_identity(b)
 148     )
 149   );
 150 }
 151
 152 Matrix4 testMatrix4MultipliedConstant1(const Matrix4& a)
 153 {
 154   return matrix4_multiplied_by_matrix4(a, g_matrix4_identity);
 155 }
 156
 157 Matrix4 testMatrix4MultipliedConstant2(const Matrix4& a)
 158 {
 159   return matrix4_for_expression(
 160     matrix4_multiplied(
 161       matrix4_identity(a),
 162       matrix4_identity(g_matrix4_identity)
 163     )
 164   );
 165 }
 166 Matrix4 testMatrix4Transposed1(const Matrix4& a)
 167 {
 168   return matrix4_transposed(a);
 169 }
 170
 171 Matrix4 testMatrix4Transposed2(const Matrix4& a)
 172 {
 173   return matrix4_for_expression( matrix_transposed( matrix4_identity(a) ) );
 174 }
 175
 176 Vector3 testMulti1(const Matrix4& a, const Vector3& b, const Vector3& c)
 177 {
 178   return vector3_added(matrix4_transformed_point(matrix4_transposed(a), b), c);
 179 }
 180
 181 Vector3 testMulti2(const Matrix4& a, const Vector3& b, const Vector3& c)
 182 {
 183   return vector3_for_expression(
 184     vector_added(
 185       point_multiplied(
 186         vector3_identity(b),
 187         matrix_transposed(matrix4_identity(a))
 188       ),
 189       vector3_identity(c)
 190     )
 191   );
 192 }
 193
 194 template<typename Value, typename First, typename Second>
 195 class TestBinaryFunction
 196 {
 197   typedef Value(*Function)(const First&, const Second&);
 198   Function m_function;
 199 public:
 200
 201   TestBinaryFunction(Function function) : m_function(function)
 202   {
 203   }
 204   Value run(const First& first, const Second& second) const
 205   {
 206     return m_function(first, second);
 207   }
 208 };
 209
 210 template<typename Value, typename First>
 211 class TestUnaryFunction
 212 {
 213   typedef Value(*Function)(const First&);
 214   Function m_function;
 215 public:
 216
 217   TestUnaryFunction(Function function) : m_function(function)
 218   {
 219   }
 220   Value run(const First& first) const
 221   {
 222     return m_function(first);
 223   }
 224 };
 225
 226 class TestAll
 227 {
 228 public:
 229   TestAll()
 230   {
 231     Vector3 result1 = TestBinaryFunction<Vector3, Vector3, Vector3>(testAdded1).run(Vector3(0, 0, 0), Vector3(1, 1, 1));
 232     Vector3 result2 = TestBinaryFunction<Vector3, Vector3, Vector3>(testAdded2).run(Vector3(0, 0, 0), Vector3(1, 1, 1));
 233     Vector3 result3 = TestBinaryFunction<Vector3, Vector3, Vector3>(testMultiplied1).run(Vector3(1, 2, 3), Vector3(2, 1, 0.5f));
 234     Vector3 result4 = TestBinaryFunction<Vector3, Vector3, Vector3>(testMultiplied2).run(Vector3(1, 2, 3), Vector3(2, 1, 0.5f));
 235     Vector3 result5 = TestBinaryFunction<Vector3, Vector3, double>(testScaled1).run(Vector3(1, 2, 3), 2.0);
 236     Vector3 result6 = TestBinaryFunction<Vector3, Vector3, double>(testScaled2).run(Vector3(1, 2, 3), 2.0);
 237     Vector3 result7 = TestBinaryFunction<Vector3, Vector3, Matrix4>(testMatrixMultiplied1).run(Vector3(1, 2, 3), matrix4_rotation_for_x_degrees(90));
 238     Vector3 result8 = TestBinaryFunction<Vector3, Vector3, Matrix4>(testMatrixMultiplied2).run(Vector3(1, 2, 3), matrix4_rotation_for_x_degrees(90));
 239     Vector3 result9 = TestUnaryFunction<Vector3, Vector3>(testNormalised1).run(Vector3(1, 2, 3));
 240     Vector3 result10 = TestUnaryFunction<Vector3, Vector3>(testNormalised2).run(Vector3(1, 2, 3));
 241   }
 242 } g_testAll;
 243