/*
-Copyright (C) 2001-2006, William Joseph.
-All Rights Reserved.
+ Copyright (C) 2001-2006, William Joseph.
+ All Rights Reserved.
-This file is part of GtkRadiant.
+ This file is part of GtkRadiant.
-GtkRadiant is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ GtkRadiant is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-GtkRadiant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ GtkRadiant is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
-#if !defined (INCLUDED_EXPRESSION_H)
+#if !defined ( INCLUDED_EXPRESSION_H )
#define INCLUDED_EXPRESSION_H
#include <math/matrix.h>
template<typename Value>
class Literal
{
- Value m_value;
+Value m_value;
public:
- typedef Value value_type;
-
- Literal(const Value& value)
- : m_value(value)
- {
- }
- const value_type& eval() const
- {
- return m_value;
- }
+typedef Value value_type;
+
+Literal( const Value& value )
+ : m_value( value ){
+}
+const value_type& eval() const {
+ return m_value;
+}
};
template<typename Value>
-inline Literal<Value> float_literal(const Value& value)
-{
- return Literal<Value>(value);
+inline Literal<Value> float_literal( const Value& value ){
+ return Literal<Value>( value );
}
template<typename Expression>
-inline float float_for_expression(const Expression& expression)
-{
- return expression.eval();
+inline float float_for_expression( const Expression& expression ){
+ return expression.eval();
}
template<typename First, typename Second>
class ScalarDivided
{
- First first;
- Second second;
+First first;
+Second second;
public:
- typedef typename First::value_type value_type;
-
- ScalarDivided(const First& first_, const Second& second_) : first(first_), second(second_)
- {
- }
- value_type eval() const
- {
- return static_cast<value_type>(first.eval() / second.eval());
- }
+typedef typename First::value_type value_type;
+
+ScalarDivided( const First& first_, const Second& second_ ) : first( first_ ), second( second_ ){
+}
+value_type eval() const {
+ return static_cast<value_type>( first.eval() / second.eval() );
+}
};
template<typename First, typename Second>
-inline ScalarDivided<First, Second> float_divided(const First& first, const Second& second)
-{
- return ScalarDivided<First, Second>(first, second);
+inline ScalarDivided<First, Second> float_divided( const First& first, const Second& second ){
+ return ScalarDivided<First, Second>( first, second );
}
template<typename First>
-inline ScalarDivided<Literal<typename First::value_type>, First> float_reciprocal(const First& first)
-{
- typedef typename First::value_type first_value_type;
- return ScalarDivided<Literal<first_value_type>, First>(float_literal(first_value_type(1.0)), first);
+inline ScalarDivided<Literal<typename First::value_type>, First> float_reciprocal( const First& first ){
+ typedef typename First::value_type first_value_type;
+ return ScalarDivided<Literal<first_value_type>, First>( float_literal( first_value_type( 1.0 ) ), first );
}
template<typename First>
class SquareRoot
{
- First first;
+First first;
public:
- typedef typename First::value_type value_type;
-
- SquareRoot(const First& first_) : first(first_)
- {
- }
- value_type eval() const
- {
- return static_cast<value_type>(sqrt(first.eval()));
- }
+typedef typename First::value_type value_type;
+
+SquareRoot( const First& first_ ) : first( first_ ){
+}
+value_type eval() const {
+ return static_cast<value_type>( sqrt( first.eval() ) );
+}
};
template<typename First>
-inline SquareRoot<First> float_square_root(const First& first)
-{
- return SquareRoot<First>(first);
+inline SquareRoot<First> float_square_root( const First& first ){
+ return SquareRoot<First>( first );
}
template<typename Element>
class BasicVector3Literal
{
- const BasicVector3<Element> m_value;
+const BasicVector3<Element> m_value;
public:
- typedef Element value_type;
- typedef IntegralConstant<3> dimension;
-
- BasicVector3Literal(const BasicVector3<Element>& value)
- : m_value(value)
- {
- }
- const value_type& eval(unsigned int i) const
- {
- return m_value[i];
- }
+typedef Element value_type;
+typedef IntegralConstant<3> dimension;
+
+BasicVector3Literal( const BasicVector3<Element>& value )
+ : m_value( value ){
+}
+const value_type& eval( unsigned int i ) const {
+ return m_value[i];
+}
};
template<typename Element>
-inline BasicVector3Literal<Element> vector3_literal(const BasicVector3<Element>& value)
-{
- return BasicVector3Literal<Element>(value);
+inline BasicVector3Literal<Element> vector3_literal( const BasicVector3<Element>& value ){
+ return BasicVector3Literal<Element>( value );
}
typedef BasicVector3Literal<float> Vector3Literal;
template<typename Element>
class BasicVector3Identity
{
- const BasicVector3<Element>& m_value;
+const BasicVector3<Element>& m_value;
public:
- typedef Element value_type;
- typedef IntegralConstant<3> dimension;
-
- BasicVector3Identity(const BasicVector3<Element>& value)
- : m_value(value)
- {
- }
- const value_type& eval(unsigned int i) const
- {
- return m_value[i];
- }
+typedef Element value_type;
+typedef IntegralConstant<3> dimension;
+
+BasicVector3Identity( const BasicVector3<Element>& value )
+ : m_value( value ){
+}
+const value_type& eval( unsigned int i ) const {
+ return m_value[i];
+}
};
template<typename Element>
-inline BasicVector3Identity<Element> vector3_identity(const BasicVector3<Element>& value)
-{
- return BasicVector3Identity<Element>(value);
+inline BasicVector3Identity<Element> vector3_identity( const BasicVector3<Element>& value ){
+ return BasicVector3Identity<Element>( value );
}
typedef BasicVector3Identity<float> Vector3Identity;
template<typename Expression>
-inline BasicVector3<typename Expression::value_type> vector3_for_expression(const Expression& expression)
-{
- return Vector3(expression.eval(0), expression.eval(1), expression.eval(2));
+inline BasicVector3<typename Expression::value_type> vector3_for_expression( const Expression& expression ){
+ return Vector3( expression.eval( 0 ), expression.eval( 1 ), expression.eval( 2 ) );
}
template<typename Operation, typename First, typename Second>
class VectorScalar
{
- First first;
- Literal<typename Second::value_type> second;
+First first;
+Literal<typename Second::value_type> second;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension dimension;
-
- VectorScalar(const First& first_, const Second& second_)
- : first(first_), second(second_.eval())
- {
- }
- value_type eval(unsigned int i) const
- {
- return Operation::apply( first.eval(i), second.eval() );
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension dimension;
+
+VectorScalar( const First& first_, const Second& second_ )
+ : first( first_ ), second( second_.eval() ){
+}
+value_type eval( unsigned int i ) const {
+ return Operation::apply( first.eval( i ), second.eval() );
+}
};
template<typename Operation, typename First, typename Second>
class VectorVector
{
- First first;
- Second second;
+First first;
+Second second;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension dimension;
-
- VectorVector(const First& first_, const Second& second_)
- : first(first_), second(second_)
- {
- }
- value_type eval(unsigned int i) const
- {
- return Operation::apply(first.eval(i), second.eval(i));
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension dimension;
+
+VectorVector( const First& first_, const Second& second_ )
+ : first( first_ ), second( second_ ){
+}
+value_type eval( unsigned int i ) const {
+ return Operation::apply( first.eval( i ), second.eval( i ) );
+}
};
template<typename First, typename Second>
class Added
{
public:
- typedef First value_type;
+typedef First value_type;
- static value_type apply(const First& first, const Second& second)
- {
- return static_cast<value_type>(first + second);
- }
+static value_type apply( const First& first, const Second& second ){
+ return static_cast<value_type>( first + second );
+}
};
template<typename First, typename Second>
inline VectorVector<Added<typename First::value_type, typename Second::value_type>, First, Second>
-vector_added(const First& first, const Second& second)
-{
- typedef typename First::value_type first_value_type;
- typedef typename Second::value_type second_value_type;
- return VectorVector<Added<first_value_type, second_value_type>, First, Second>(first, second);
+vector_added( const First& first, const Second& second ){
+ typedef typename First::value_type first_value_type;
+ typedef typename Second::value_type second_value_type;
+ return VectorVector<Added<first_value_type, second_value_type>, First, Second>( first, second );
}
template<typename First, typename Second>
class Multiplied
{
public:
- typedef First value_type;
+typedef First value_type;
- static value_type apply(const First& first, const Second& second)
- {
- return static_cast<value_type>(first * second);
- }
+static value_type apply( const First& first, const Second& second ){
+ return static_cast<value_type>( first * second );
+}
};
template<typename First, typename Second>
inline VectorVector<Multiplied<typename First::value_type, typename Second::value_type>, First, Second>
-vector_multiplied(const First& first, const Second& second)
-{
- typedef typename First::value_type first_value_type;
- typedef typename Second::value_type second_value_type;
- return VectorVector<Multiplied<first_value_type, second_value_type>, First, Second>(first, second);
+vector_multiplied( const First& first, const Second& second ){
+ typedef typename First::value_type first_value_type;
+ typedef typename Second::value_type second_value_type;
+ return VectorVector<Multiplied<first_value_type, second_value_type>, First, Second>( first, second );
}
template<typename First, typename Second>
inline VectorScalar<Multiplied<typename First::value_type, typename Second::value_type>, First, Second>
-vector_scaled(const First& first, const Second& second)
-{
- typedef typename First::value_type first_value_type;
- typedef typename Second::value_type second_value_type;
- return VectorScalar<Multiplied<first_value_type, second_value_type>, First, Second>(first, second);
+vector_scaled( const First& first, const Second& second ){
+ typedef typename First::value_type first_value_type;
+ typedef typename Second::value_type second_value_type;
+ return VectorScalar<Multiplied<first_value_type, second_value_type>, First, Second>( first, second );
}
template<typename First>
class Negated
{
public:
- typedef First value_type;
+typedef First value_type;
- static value_type apply(const First& first)
- {
- return -first;
- }
+static value_type apply( const First& first ){
+ return -first;
+}
};
template<typename First, typename Operation>
class VectorUnary
{
- First first;
+First first;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension dimension;
-
- VectorUnary(const First& first_) : first(first_)
- {
- }
- value_type eval(unsigned int i) const
- {
- return Operation::apply(first.eval(i));
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension dimension;
+
+VectorUnary( const First& first_ ) : first( first_ ){
+}
+value_type eval( unsigned int i ) const {
+ return Operation::apply( first.eval( i ) );
+}
};
template<typename First>
inline VectorUnary<First, Negated<typename First::value_type> >
-vector_negated(const First& first)
-{
- typedef typename First::value_type first_value_type;
- return VectorUnary<First, Negated<first_value_type> >(first);
+vector_negated( const First& first ){
+ typedef typename First::value_type first_value_type;
+ return VectorUnary<First, Negated<first_value_type> >( first );
}
template<typename First, typename Second>
class VectorCross
{
- First first;
- Second second;
+First first;
+Second second;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension dimension;
-
- VectorCross(const First& first_, const Second& second_)
- : first(first_), second(second_)
- {
- }
- value_type eval(unsigned int i) const
- {
- return first.eval((i+1)%3) * second.eval((i+2)%3) - first.eval((i+2)%3) * second.eval((i+1)%3);
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension dimension;
+
+VectorCross( const First& first_, const Second& second_ )
+ : first( first_ ), second( second_ ){
+}
+value_type eval( unsigned int i ) const {
+ return first.eval( ( i + 1 ) % 3 ) * second.eval( ( i + 2 ) % 3 ) - first.eval( ( i + 2 ) % 3 ) * second.eval( ( i + 1 ) % 3 );
+}
};
template<typename First, typename Second>
inline VectorCross<First, Second>
-vector_cross(const First& first, const Second& second)
-{
- return VectorCross<First, Second>(first, second);
+vector_cross( const First& first, const Second& second ){
+ return VectorCross<First, Second>( first, second );
}
template<typename First, typename Second>
class VectorDot
{
- First first;
- Second second;
+First first;
+Second second;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension dimension;
-
- VectorDot(const First& first_, const Second& second_)
- : first(first_), second(second_)
- {
- }
-
- template<typename Index>
- struct eval_dot
- {
- static value_type apply(const First& first, const Second& second)
- {
- return static_cast<value_type>(
- first.eval(Index::VALUE) * second.eval(Index::VALUE)
- + eval_dot< IntegralConstant<Index::VALUE-1> >::apply(first, second)
- );
- }
- };
-
- template<>
- struct eval_dot< IntegralConstant<0> >
- {
- static value_type apply(const First& first, const Second& second)
- {
- return first.eval(0) * second.eval(0);
- }
- };
-
- value_type eval() const
- {
- return eval_dot< IntegralConstant<dimension::VALUE - 1> >::apply(first, second);
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension dimension;
+
+VectorDot( const First& first_, const Second& second_ )
+ : first( first_ ), second( second_ ){
+}
+
+template<typename Index>
+struct eval_dot
+{
+ static value_type apply( const First& first, const Second& second ){
+ return static_cast<value_type>(
+ first.eval( Index::VALUE ) * second.eval( Index::VALUE )
+ + eval_dot< IntegralConstant<Index::VALUE - 1> >::apply( first, second )
+ );
+ }
+};
+
+template<>
+struct eval_dot< IntegralConstant<0> >
+{
+ static value_type apply( const First& first, const Second& second ){
+ return first.eval( 0 ) * second.eval( 0 );
+ }
+};
+
+value_type eval() const {
+ return eval_dot< IntegralConstant<dimension::VALUE - 1> >::apply( first, second );
+}
};
template<typename First, typename Second>
-inline VectorDot<First, Second> vector_dot(const First& first, const Second& second)
-{
- return VectorDot<First, Second>(first, second);
+inline VectorDot<First, Second> vector_dot( const First& first, const Second& second ){
+ return VectorDot<First, Second>( first, second );
}
template<typename First>
class VectorLengthSquared
{
- First first;
+First first;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension dimension;
-
- VectorLengthSquared(const First& first_)
- : first(first_)
- {
- }
-
- static value_type squared(const value_type& value)
- {
- return value * value;
- }
-
- template<typename Index>
- struct eval_squared
- {
- static value_type apply(const First& first)
- {
- return static_cast<value_type>(
- squared(first.eval(Index::VALUE))
- + eval_squared< IntegralConstant<Index::VALUE - 1> >::apply(first)
- );
- }
- };
-
- template<>
- struct eval_squared< IntegralConstant<0> >
- {
- static value_type apply(const First& first)
- {
- return squared(first.eval(0));
- }
- };
-
- value_type eval() const
- {
- return eval_squared< IntegralConstant<dimension::VALUE - 1> >::apply(first);
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension dimension;
+
+VectorLengthSquared( const First& first_ )
+ : first( first_ ){
+}
+
+static value_type squared( const value_type& value ){
+ return value * value;
+}
+
+template<typename Index>
+struct eval_squared
+{
+ static value_type apply( const First& first ){
+ return static_cast<value_type>(
+ squared( first.eval( Index::VALUE ) )
+ + eval_squared< IntegralConstant<Index::VALUE - 1> >::apply( first )
+ );
+ }
};
-template<typename First>
-inline VectorLengthSquared<First> vector_length_squared(const First& first)
+template<>
+struct eval_squared< IntegralConstant<0> >
{
- return VectorLengthSquared<First>(first);
+ static value_type apply( const First& first ){
+ return squared( first.eval( 0 ) );
+ }
+};
+
+value_type eval() const {
+ return eval_squared< IntegralConstant<dimension::VALUE - 1> >::apply( first );
}
+};
template<typename First>
-inline SquareRoot< VectorLengthSquared<First> > vector_length(const First& first)
-{
- return float_square_root(vector_length_squared(first));
+inline VectorLengthSquared<First> vector_length_squared( const First& first ){
+ return VectorLengthSquared<First>( first );
+}
+
+template<typename First>
+inline SquareRoot< VectorLengthSquared<First> > vector_length( const First& first ){
+ return float_square_root( vector_length_squared( first ) );
}
#if 1
template<typename First>
inline VectorScalar<
- Multiplied<typename First::value_type, typename First::value_type>,
- First,
- // multiple evaulations of subexpression
- ScalarDivided<
- Literal<typename First::value_type>,
- SquareRoot<
- VectorLengthSquared<First>
- >
- >
-> vector_normalised(const First& first)
-{
- typedef typename First::value_type first_value_type;
- return vector_scaled(first, float_reciprocal(vector_length(first)));
+ Multiplied<typename First::value_type, typename First::value_type>,
+ First,
+ // multiple evaulations of subexpression
+ ScalarDivided<
+ Literal<typename First::value_type>,
+ SquareRoot<
+ VectorLengthSquared<First>
+ >
+ >
+ > vector_normalised( const First& first ){
+ typedef typename First::value_type first_value_type;
+ return vector_scaled( first, float_reciprocal( vector_length( first ) ) );
}
#else
template<typename First>
inline VectorScalar<
- Multiplied<typename First::value_type, typename First::value_type>,
- First,
- // single evaluation of subexpression
- Literal<typename First::value_type>
->
-vector_normalised(const First& first)
-{
- typedef typename First::value_type first_value_type;
- return vector_scaled(first, float_literal(static_cast<first_value_type>(first_value_type(1.0) / vector_length(first).eval())));
+ Multiplied<typename First::value_type, typename First::value_type>,
+ First,
+ // single evaluation of subexpression
+ Literal<typename First::value_type>
+ >
+vector_normalised( const First& first ){
+ typedef typename First::value_type first_value_type;
+ return vector_scaled( first, float_literal( static_cast<first_value_type>( first_value_type( 1.0 ) / vector_length( first ).eval() ) ) );
}
#endif
class Matrix4Literal
{
- const Matrix4 m_value;
+const Matrix4 m_value;
public:
- typedef float value_type;
- typedef IntegralConstant<4> dimension0;
- typedef IntegralConstant<4> dimension1;
-
- Matrix4Literal(const Matrix4& value)
- : m_value(value)
- {
- }
- const value_type& eval(unsigned int r, unsigned int c) const
- {
- return m_value[r*4+c];
- }
+typedef float value_type;
+typedef IntegralConstant<4> dimension0;
+typedef IntegralConstant<4> dimension1;
+
+Matrix4Literal( const Matrix4& value )
+ : m_value( value ){
+}
+const value_type& eval( unsigned int r, unsigned int c ) const {
+ return m_value[r * 4 + c];
+}
};
-inline Matrix4Literal matrix4_literal(const Matrix4& value)
-{
- return Matrix4Literal(value);
+inline Matrix4Literal matrix4_literal( const Matrix4& value ){
+ return Matrix4Literal( value );
}
class Matrix4Identity
{
- const Matrix4& m_value;
+const Matrix4& m_value;
public:
- typedef float value_type;
- typedef IntegralConstant<4> dimension0;
- typedef IntegralConstant<4> dimension1;
-
- Matrix4Identity(const Matrix4& value)
- : m_value(value)
- {
- }
- const value_type& eval(unsigned int r, unsigned int c) const
- {
- return m_value[r*4+c];
- }
+typedef float value_type;
+typedef IntegralConstant<4> dimension0;
+typedef IntegralConstant<4> dimension1;
+
+Matrix4Identity( const Matrix4& value )
+ : m_value( value ){
+}
+const value_type& eval( unsigned int r, unsigned int c ) const {
+ return m_value[r * 4 + c];
+}
};
-inline Matrix4Identity matrix4_identity(const Matrix4& value)
-{
- return Matrix4Identity(value);
+inline Matrix4Identity matrix4_identity( const Matrix4& value ){
+ return Matrix4Identity( value );
}
template<typename Expression>
-inline Matrix4 matrix4_for_expression(const Expression& expression)
-{
- return Matrix4(
- expression.eval(0, 0), expression.eval(0, 1), expression.eval(0, 2), expression.eval(0, 3),
- expression.eval(1, 0), expression.eval(1, 1), expression.eval(1, 2), expression.eval(1, 3),
- expression.eval(2, 0), expression.eval(2, 1), expression.eval(2, 2), expression.eval(2, 3),
- expression.eval(3, 0), expression.eval(3, 1), expression.eval(3, 2), expression.eval(3, 3)
- );
+inline Matrix4 matrix4_for_expression( const Expression& expression ){
+ return Matrix4(
+ expression.eval( 0, 0 ), expression.eval( 0, 1 ), expression.eval( 0, 2 ), expression.eval( 0, 3 ),
+ expression.eval( 1, 0 ), expression.eval( 1, 1 ), expression.eval( 1, 2 ), expression.eval( 1, 3 ),
+ expression.eval( 2, 0 ), expression.eval( 2, 1 ), expression.eval( 2, 2 ), expression.eval( 2, 3 ),
+ expression.eval( 3, 0 ), expression.eval( 3, 1 ), expression.eval( 3, 2 ), expression.eval( 3, 3 )
+ );
}
template<typename Expression>
-inline Matrix4 matrix4_affine_for_expression(const Expression& expression)
-{
- return Matrix4(
- expression.eval(0, 0), expression.eval(0, 1), expression.eval(0, 2), 0,
- expression.eval(1, 0), expression.eval(1, 1), expression.eval(1, 2), 0,
- expression.eval(2, 0), expression.eval(2, 1), expression.eval(2, 2), 0,
- expression.eval(3, 0), expression.eval(3, 1), expression.eval(3, 2), 1
- );
+inline Matrix4 matrix4_affine_for_expression( const Expression& expression ){
+ return Matrix4(
+ expression.eval( 0, 0 ), expression.eval( 0, 1 ), expression.eval( 0, 2 ), 0,
+ expression.eval( 1, 0 ), expression.eval( 1, 1 ), expression.eval( 1, 2 ), 0,
+ expression.eval( 2, 0 ), expression.eval( 2, 1 ), expression.eval( 2, 2 ), 0,
+ expression.eval( 3, 0 ), expression.eval( 3, 1 ), expression.eval( 3, 2 ), 1
+ );
}
template<typename First, typename Second>
class PointMultiplied
{
- const First& first;
- const Second& second;
+const First& first;
+const Second& second;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension dimension;
-
- PointMultiplied(const First& first_, const Second& second_)
- : first(first_), second(second_)
- {
- }
- value_type eval(unsigned int i) const
- {
- return static_cast<value_type>(second.eval(0, i) * first.eval(0)
- + second.eval(1, i) * first.eval(1)
- + second.eval(2, i) * first.eval(2)
- + second.eval(3, i));
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension dimension;
+
+PointMultiplied( const First& first_, const Second& second_ )
+ : first( first_ ), second( second_ ){
+}
+value_type eval( unsigned int i ) const {
+ return static_cast<value_type>( second.eval( 0, i ) * first.eval( 0 )
+ + second.eval( 1, i ) * first.eval( 1 )
+ + second.eval( 2, i ) * first.eval( 2 )
+ + second.eval( 3, i ) );
+}
};
template<typename First, typename Second>
-inline PointMultiplied<First, Second> point_multiplied(const First& point, const Second& matrix)
-{
- return PointMultiplied<First, Second>(point, matrix);
+inline PointMultiplied<First, Second> point_multiplied( const First& point, const Second& matrix ){
+ return PointMultiplied<First, Second>( point, matrix );
}
template<typename First, typename Second>
class Matrix4Multiplied
{
- const First& first;
- const Second& second;
+const First& first;
+const Second& second;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension0 dimension0;
- typedef typename First::dimension1 dimension1;
-
- Matrix4Multiplied(const First& first_, const Second& second_)
- : first(first_), second(second_)
- {
- }
-
- value_type eval(unsigned int r, unsigned int c) const
- {
- return static_cast<value_type>(
- second.eval(r, 0) * first.eval(0, c)
- + second.eval(r, 1) * first.eval(1, c)
- + second.eval(r, 2) * first.eval(2, c)
- + second.eval(r, 3) * first.eval(3, c)
- );
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension0 dimension0;
+typedef typename First::dimension1 dimension1;
+
+Matrix4Multiplied( const First& first_, const Second& second_ )
+ : first( first_ ), second( second_ ){
+}
+
+value_type eval( unsigned int r, unsigned int c ) const {
+ return static_cast<value_type>(
+ second.eval( r, 0 ) * first.eval( 0, c )
+ + second.eval( r, 1 ) * first.eval( 1, c )
+ + second.eval( r, 2 ) * first.eval( 2, c )
+ + second.eval( r, 3 ) * first.eval( 3, c )
+ );
+}
};
template<typename First, typename Second>
-inline Matrix4Multiplied<First, Second> matrix4_multiplied(const First& first, const Second& second)
-{
- return Matrix4Multiplied<First, Second>(first, second);
+inline Matrix4Multiplied<First, Second> matrix4_multiplied( const First& first, const Second& second ){
+ return Matrix4Multiplied<First, Second>( first, second );
}
template<typename First>
class MatrixTransposed
{
- const First& first;
+const First& first;
public:
- typedef typename First::value_type value_type;
- typedef typename First::dimension0 dimension0;
- typedef typename First::dimension1 dimension1;
-
- MatrixTransposed(const First& first_)
- : first(first_)
- {
- }
-
- value_type eval(unsigned int r, unsigned int c) const
- {
- return first.eval(c, r);
- }
+typedef typename First::value_type value_type;
+typedef typename First::dimension0 dimension0;
+typedef typename First::dimension1 dimension1;
+
+MatrixTransposed( const First& first_ )
+ : first( first_ ){
+}
+
+value_type eval( unsigned int r, unsigned int c ) const {
+ return first.eval( c, r );
+}
};
template<typename First>
-inline MatrixTransposed<First> matrix_transposed(const First& first)
-{
- return MatrixTransposed<First>(first);
+inline MatrixTransposed<First> matrix_transposed( const First& first ){
+ return MatrixTransposed<First>( first );
}
#endif
projects / xonotic / netradiant.git / blobdiff