X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fnetradiant.git;a=blobdiff_plain;f=radiant%2Fbrush_primit.cpp;h=a7bae5449a8dc43e8fc642c25f2e5c08dd64c17a;hp=4ea73c0356a7572e168bc12dec3381d1044f4fbe;hb=6a7dedc09f1a4b72077e0012bf0499a0005973d6;hpb=7fc621fc78d0e040dc2c12f38dc53dd9048215dc

diff --git a/radiant/brush_primit.cpp b/radiant/brush_primit.cpp
index 4ea73c03..a7bae544 100644
--- a/radiant/brush_primit.cpp
+++ b/radiant/brush_primit.cpp
@@ -20,6 +20,7 @@
  */
 
 #include "brush_primit.h"
+#include "globaldefs.h"
 
 #include "debugging/debugging.h"
 
@@ -43,51 +44,51 @@
    This will be one of three axis-aligned spaces, depending on the surface normal.
    NOTE: could also be done by swapping values.
  */
-void Normal_GetTransform( const Vector3& normal, Matrix4& transform ){
-	switch ( projectionaxis_for_normal( normal ) )
-	{
-	case eProjectionAxisZ:
-		transform[0]  =  1;
-		transform[1]  =  0;
-		transform[2]  =  0;
-
-		transform[4]  =  0;
-		transform[5]  =  1;
-		transform[6]  =  0;
-
-		transform[8]  =  0;
-		transform[9]  =  0;
-		transform[10] =  1;
-		break;
-	case eProjectionAxisY:
-		transform[0]  =  1;
-		transform[1]  =  0;
-		transform[2]  =  0;
-
-		transform[4]  =  0;
-		transform[5]  =  0;
-		transform[6]  = -1;
-
-		transform[8]  =  0;
-		transform[9]  =  1;
-		transform[10] =  0;
-		break;
-	case eProjectionAxisX:
-		transform[0]  =  0;
-		transform[1]  =  0;
-		transform[2]  =  1;
-
-		transform[4]  =  1;
-		transform[5]  =  0;
-		transform[6]  =  0;
-
-		transform[8]  =  0;
-		transform[9]  =  1;
-		transform[10] =  0;
-		break;
-	}
-	transform[3] = transform[7] = transform[11] = transform[12] = transform[13] = transform[14] = 0;
-	transform[15] = 1;
+void Normal_GetTransform(const Vector3 &normal, Matrix4 &transform)
+{
+    switch (projectionaxis_for_normal(normal)) {
+        case eProjectionAxisZ:
+            transform[0] = 1;
+            transform[1] = 0;
+            transform[2] = 0;
+
+            transform[4] = 0;
+            transform[5] = 1;
+            transform[6] = 0;
+
+            transform[8] = 0;
+            transform[9] = 0;
+            transform[10] = 1;
+            break;
+        case eProjectionAxisY:
+            transform[0] = 1;
+            transform[1] = 0;
+            transform[2] = 0;
+
+            transform[4] = 0;
+            transform[5] = 0;
+            transform[6] = -1;
+
+            transform[8] = 0;
+            transform[9] = 1;
+            transform[10] = 0;
+            break;
+        case eProjectionAxisX:
+            transform[0] = 0;
+            transform[1] = 0;
+            transform[2] = 1;
+
+            transform[4] = 1;
+            transform[5] = 0;
+            transform[6] = 0;
+
+            transform[8] = 0;
+            transform[9] = 1;
+            transform[10] = 0;
+            break;
+    }
+    transform[3] = transform[7] = transform[11] = transform[12] = transform[13] = transform[14] = 0;
+    transform[15] = 1;
 }
 
 /*!
@@ -95,313 +96,325 @@ void Normal_GetTransform( const Vector3& normal, Matrix4& transform ){
    Transforms constructed from quake's texdef format are (-shift)*(1/scale)*(-rotate) with x translation sign flipped.
    This would really make more sense if it was inverseof(shift*rotate*scale).. oh well.
  */
-inline void Texdef_toTransform( const texdef_t& texdef, float width, float height, Matrix4& transform ){
-	double inverse_scale[2];
-
-	// transform to texdef shift/scale/rotate
-	inverse_scale[0] = 1 / ( texdef.scale[0] * width );
-	inverse_scale[1] = 1 / ( texdef.scale[1] * -height );
-	transform[12] = texdef.shift[0] / width;
-	transform[13] = -texdef.shift[1] / -height;
-	double c = cos( degrees_to_radians( -texdef.rotate ) );
-	double s = sin( degrees_to_radians( -texdef.rotate ) );
-	transform[0] = static_cast<float>( c * inverse_scale[0] );
-	transform[1] = static_cast<float>( s * inverse_scale[1] );
-	transform[4] = static_cast<float>( -s * inverse_scale[0] );
-	transform[5] = static_cast<float>( c * inverse_scale[1] );
-	transform[2] = transform[3] = transform[6] = transform[7] = transform[8] = transform[9] = transform[11] = transform[14] = 0;
-	transform[10] = transform[15] = 1;
-}
-
-inline void BPTexdef_toTransform( const brushprimit_texdef_t& bp_texdef, Matrix4& transform ){
-	transform = g_matrix4_identity;
-	transform.xx() = bp_texdef.coords[0][0];
-	transform.yx() = bp_texdef.coords[0][1];
-	transform.tx() = bp_texdef.coords[0][2];
-	transform.xy() = bp_texdef.coords[1][0];
-	transform.yy() = bp_texdef.coords[1][1];
-	transform.ty() = bp_texdef.coords[1][2];
-}
-
-inline void Texdef_toTransform( const TextureProjection& projection, float width, float height, Matrix4& transform ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		BPTexdef_toTransform( projection.m_brushprimit_texdef, transform );
-	}
-	else
-	{
-		Texdef_toTransform( projection.m_texdef, width, height, transform );
-	}
+inline void Texdef_toTransform(const texdef_t &texdef, float width, float height, Matrix4 &transform)
+{
+    double inverse_scale[2];
+
+    // transform to texdef shift/scale/rotate
+    inverse_scale[0] = 1 / (texdef.scale[0] * width);
+    inverse_scale[1] = 1 / (texdef.scale[1] * -height);
+    transform[12] = texdef.shift[0] / width;
+    transform[13] = -texdef.shift[1] / -height;
+    double c = cos(degrees_to_radians(-texdef.rotate));
+    double s = sin(degrees_to_radians(-texdef.rotate));
+    transform[0] = static_cast<float>( c * inverse_scale[0] );
+    transform[1] = static_cast<float>( s * inverse_scale[1] );
+    transform[4] = static_cast<float>( -s * inverse_scale[0] );
+    transform[5] = static_cast<float>( c * inverse_scale[1] );
+    transform[2] = transform[3] = transform[6] = transform[7] = transform[8] = transform[9] = transform[11] = transform[14] = 0;
+    transform[10] = transform[15] = 1;
+}
+
+inline void BPTexdef_toTransform(const brushprimit_texdef_t &bp_texdef, Matrix4 &transform)
+{
+    transform = g_matrix4_identity;
+    transform.xx() = bp_texdef.coords[0][0];
+    transform.yx() = bp_texdef.coords[0][1];
+    transform.tx() = bp_texdef.coords[0][2];
+    transform.xy() = bp_texdef.coords[1][0];
+    transform.yy() = bp_texdef.coords[1][1];
+    transform.ty() = bp_texdef.coords[1][2];
+}
+
+inline void Texdef_toTransform(const TextureProjection &projection, float width, float height, Matrix4 &transform)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        BPTexdef_toTransform(projection.m_brushprimit_texdef, transform);
+    } else {
+        Texdef_toTransform(projection.m_texdef, width, height, transform);
+    }
 }
 
 // handles degenerate cases, just in case library atan2 doesn't
-inline double arctangent_yx( double y, double x ){
-	if ( fabs( x ) > 1.0E-6 ) {
-		return atan2( y, x );
-	}
-	else if ( y > 0 ) {
-		return c_half_pi;
-	}
-	else
-	{
-		return -c_half_pi;
-	}
-}
-
-inline void Texdef_fromTransform( texdef_t& texdef, float width, float height, const Matrix4& transform ){
-	texdef.scale[0] = static_cast<float>( ( 1.0 / vector2_length( Vector2( transform[0], transform[4] ) ) ) / width );
-	texdef.scale[1] = static_cast<float>( ( 1.0 / vector2_length( Vector2( transform[1], transform[5] ) ) ) / height );
-
-	texdef.rotate = static_cast<float>( -radians_to_degrees( arctangent_yx( -transform[4], transform[0] ) ) );
-
-	if ( texdef.rotate == -180.0f ) {
-		texdef.rotate = 180.0f;
-	}
-
-	texdef.shift[0] = transform[12] * width;
-	texdef.shift[1] = transform[13] * height;
-
-	// If the 2d cross-product of the x and y axes is positive, one of the axes has a negative scale.
-	if ( vector2_cross( Vector2( transform[0], transform[4] ), Vector2( transform[1], transform[5] ) ) > 0 ) {
-		if ( texdef.rotate >= 180.0f ) {
-			texdef.rotate -= 180.0f;
-			texdef.scale[0] = -texdef.scale[0];
-		}
-		else
-		{
-			texdef.scale[1] = -texdef.scale[1];
-		}
-	}
-	//globalOutputStream() << "fromTransform: " << texdef.shift[0] << " " << texdef.shift[1] << " " << texdef.scale[0] << " " << texdef.scale[1] << " " << texdef.rotate << "\n";
-}
-
-inline void BPTexdef_fromTransform( brushprimit_texdef_t& bp_texdef, const Matrix4& transform ){
-	bp_texdef.coords[0][0] = transform.xx();
-	bp_texdef.coords[0][1] = transform.yx();
-	bp_texdef.coords[0][2] = transform.tx();
-	bp_texdef.coords[1][0] = transform.xy();
-	bp_texdef.coords[1][1] = transform.yy();
-	bp_texdef.coords[1][2] = transform.ty();
-}
-
-inline void Texdef_fromTransform( TextureProjection& projection, float width, float height, const Matrix4& transform ){
-	ASSERT_MESSAGE( ( transform[0] != 0 || transform[4] != 0 )
-					&& ( transform[1] != 0 || transform[5] != 0 ), "invalid texture matrix" );
-
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		BPTexdef_fromTransform( projection.m_brushprimit_texdef, transform );
-	}
-	else
-	{
-		Texdef_fromTransform( projection.m_texdef, width, height, transform );
-	}
-}
-
-inline void Texdef_normalise( texdef_t& texdef, float width, float height ){
-	// it may be useful to also normalise the rotation here, if this function is used elsewhere.
-	texdef.shift[0] = float_mod( texdef.shift[0], width );
-	texdef.shift[1] = float_mod( texdef.shift[1], height );
-	//globalOutputStream() << "normalise: " << texdef.shift[0] << " " << texdef.shift[1] << " " << texdef.scale[0] << " " << texdef.scale[1] << " " << texdef.rotate << "\n";
-}
-
-inline void BPTexdef_normalise( brushprimit_texdef_t& bp_texdef, float width, float height ){
-	bp_texdef.coords[0][2] = float_mod( bp_texdef.coords[0][2], width );
-	bp_texdef.coords[1][2] = float_mod( bp_texdef.coords[1][2], height );
+inline double arctangent_yx(double y, double x)
+{
+    if (fabs(x) > 1.0E-6) {
+        return atan2(y, x);
+    } else if (y > 0) {
+        return c_half_pi;
+    } else {
+        return -c_half_pi;
+    }
+}
+
+inline void Texdef_fromTransform(texdef_t &texdef, float width, float height, const Matrix4 &transform)
+{
+    texdef.scale[0] = static_cast<float>((1.0 / vector2_length(Vector2(transform[0], transform[4]))) / width );
+    texdef.scale[1] = static_cast<float>((1.0 / vector2_length(Vector2(transform[1], transform[5]))) / height );
+
+    texdef.rotate = static_cast<float>( -radians_to_degrees(arctangent_yx(-transform[4], transform[0])));
+
+    if (texdef.rotate == -180.0f) {
+        texdef.rotate = 180.0f;
+    }
+
+    texdef.shift[0] = transform[12] * width;
+    texdef.shift[1] = transform[13] * height;
+
+    // If the 2d cross-product of the x and y axes is positive, one of the axes has a negative scale.
+    if (vector2_cross(Vector2(transform[0], transform[4]), Vector2(transform[1], transform[5])) > 0) {
+        if (texdef.rotate >= 180.0f) {
+            texdef.rotate -= 180.0f;
+            texdef.scale[0] = -texdef.scale[0];
+        } else {
+            texdef.scale[1] = -texdef.scale[1];
+        }
+    }
+    //globalOutputStream() << "fromTransform: " << texdef.shift[0] << " " << texdef.shift[1] << " " << texdef.scale[0] << " " << texdef.scale[1] << " " << texdef.rotate << "\n";
+}
+
+inline void BPTexdef_fromTransform(brushprimit_texdef_t &bp_texdef, const Matrix4 &transform)
+{
+    bp_texdef.coords[0][0] = transform.xx();
+    bp_texdef.coords[0][1] = transform.yx();
+    bp_texdef.coords[0][2] = transform.tx();
+    bp_texdef.coords[1][0] = transform.xy();
+    bp_texdef.coords[1][1] = transform.yy();
+    bp_texdef.coords[1][2] = transform.ty();
+}
+
+inline void Texdef_fromTransform(TextureProjection &projection, float width, float height, const Matrix4 &transform)
+{
+    ASSERT_MESSAGE((transform[0] != 0 || transform[4] != 0)
+                   && (transform[1] != 0 || transform[5] != 0), "invalid texture matrix");
+
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        BPTexdef_fromTransform(projection.m_brushprimit_texdef, transform);
+    } else {
+        Texdef_fromTransform(projection.m_texdef, width, height, transform);
+    }
+}
+
+inline void Texdef_normalise(texdef_t &texdef, float width, float height)
+{
+    // it may be useful to also normalise the rotation here, if this function is used elsewhere.
+    texdef.shift[0] = float_mod(texdef.shift[0], width);
+    texdef.shift[1] = float_mod(texdef.shift[1], height);
+    //globalOutputStream() << "normalise: " << texdef.shift[0] << " " << texdef.shift[1] << " " << texdef.scale[0] << " " << texdef.scale[1] << " " << texdef.rotate << "\n";
+}
+
+inline void BPTexdef_normalise(brushprimit_texdef_t &bp_texdef, float width, float height)
+{
+    bp_texdef.coords[0][2] = float_mod(bp_texdef.coords[0][2], width);
+    bp_texdef.coords[1][2] = float_mod(bp_texdef.coords[1][2], height);
 }
 
 /// \brief Normalise \p projection for a given texture \p width and \p height.
 ///
 /// All texture-projection translation (shift) values are congruent modulo the dimensions of the texture.
 /// This function normalises shift values to the smallest positive congruent values.
-void Texdef_normalise( TextureProjection& projection, float width, float height ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		BPTexdef_normalise( projection.m_brushprimit_texdef, width, height );
-	}
-	else
-	{
-		Texdef_normalise( projection.m_texdef, width, height );
-	}
-}
-
-void ComputeAxisBase( const Vector3& normal, Vector3& texS, Vector3& texT );
-
-inline void DebugAxisBase( const Vector3& normal ){
-	Vector3 x, y;
-	ComputeAxisBase( normal, x, y );
-	globalOutputStream() << "BP debug: " << x << y << normal << "\n";
-}
-
-void Texdef_basisForNormal( const TextureProjection& projection, const Vector3& normal, Matrix4& basis ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		basis = g_matrix4_identity;
-		ComputeAxisBase( normal, vector4_to_vector3( basis.x() ), vector4_to_vector3( basis.y() ) );
-		vector4_to_vector3( basis.z() ) = normal;
-		matrix4_transpose( basis );
-		//DebugAxisBase(normal);
-	}
-	else if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE ) {
-		basis = g_matrix4_identity;
-		vector4_to_vector3( basis.x() ) = projection.m_basis_s;
-		vector4_to_vector3( basis.y() ) = vector3_negated( projection.m_basis_t );
-		vector4_to_vector3( basis.z() ) = vector3_normalised( vector3_cross( vector4_to_vector3( basis.x() ), vector4_to_vector3( basis.y() ) ) );
-		matrix4_multiply_by_matrix4( basis, matrix4_rotation_for_z_degrees( -projection.m_texdef.rotate ) );
-		//globalOutputStream() << "debug: " << projection.m_basis_s << projection.m_basis_t << normal << "\n";
-		matrix4_transpose( basis );
-	}
-	else
-	{
-		Normal_GetTransform( normal, basis );
-	}
-}
-
-void Texdef_EmitTextureCoordinates( const TextureProjection& projection, std::size_t width, std::size_t height, Winding& w, const Vector3& normal, const Matrix4& localToWorld ){
-	if ( w.numpoints < 3 ) {
-		return;
-	}
-	//globalOutputStream() << "normal: " << normal << "\n";
-
-	Matrix4 local2tex;
-	Texdef_toTransform( projection, (float)width, (float)height, local2tex );
-	//globalOutputStream() << "texdef: " << static_cast<const Vector3&>(local2tex.x()) << static_cast<const Vector3&>(local2tex.y()) << "\n";
+void Texdef_normalise(TextureProjection &projection, float width, float height)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        BPTexdef_normalise(projection.m_brushprimit_texdef, width, height);
+    } else {
+        Texdef_normalise(projection.m_texdef, width, height);
+    }
+}
+
+void ComputeAxisBase(const Vector3 &normal, Vector3 &texS, Vector3 &texT);
+
+inline void DebugAxisBase(const Vector3 &normal)
+{
+    Vector3 x, y;
+    ComputeAxisBase(normal, x, y);
+    globalOutputStream() << "BP debug: " << x << y << normal << "\n";
+}
+
+void Texdef_basisForNormal(const TextureProjection &projection, const Vector3 &normal, Matrix4 &basis)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        basis = g_matrix4_identity;
+        ComputeAxisBase(normal, vector4_to_vector3(basis.x()), vector4_to_vector3(basis.y()));
+        vector4_to_vector3(basis.z()) = normal;
+        matrix4_transpose(basis);
+        //DebugAxisBase(normal);
+    } else if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE) {
+        basis = g_matrix4_identity;
+        vector4_to_vector3(basis.x()) = projection.m_basis_s;
+        vector4_to_vector3(basis.y()) = vector3_negated(projection.m_basis_t);
+        vector4_to_vector3(basis.z()) = vector3_normalised(
+                vector3_cross(vector4_to_vector3(basis.x()), vector4_to_vector3(basis.y())));
+        matrix4_multiply_by_matrix4(basis, matrix4_rotation_for_z_degrees(-projection.m_texdef.rotate));
+        //globalOutputStream() << "debug: " << projection.m_basis_s << projection.m_basis_t << normal << "\n";
+        matrix4_transpose(basis);
+    } else {
+        Normal_GetTransform(normal, basis);
+    }
+}
+
+void
+Texdef_EmitTextureCoordinates(const TextureProjection &projection, std::size_t width, std::size_t height, Winding &w,
+                              const Vector3 &normal, const Matrix4 &localToWorld)
+{
+    if (w.numpoints < 3) {
+        return;
+    }
+    //globalOutputStream() << "normal: " << normal << "\n";
+
+    Matrix4 local2tex;
+    Texdef_toTransform(projection, (float) width, (float) height, local2tex);
+    //globalOutputStream() << "texdef: " << static_cast<const Vector3&>(local2tex.x()) << static_cast<const Vector3&>(local2tex.y()) << "\n";
 
 #if 0
-	{
-		TextureProjection tmp;
-		Texdef_fromTransform( tmp, (float)width, (float)height, local2tex );
-		Matrix4 tmpTransform;
-		Texdef_toTransform( tmp, (float)width, (float)height, tmpTransform );
-		ASSERT_MESSAGE( matrix4_equal_epsilon( local2tex, tmpTransform, 0.0001f ), "bleh" );
-	}
+    {
+        TextureProjection tmp;
+        Texdef_fromTransform( tmp, (float)width, (float)height, local2tex );
+        Matrix4 tmpTransform;
+        Texdef_toTransform( tmp, (float)width, (float)height, tmpTransform );
+        ASSERT_MESSAGE( matrix4_equal_epsilon( local2tex, tmpTransform, 0.0001f ), "bleh" );
+    }
 #endif
 
-	{
-		Matrix4 xyz2st;
-		// we don't care if it's not normalised...
-		Texdef_basisForNormal( projection, matrix4_transformed_direction( localToWorld, normal ), xyz2st );
-		//globalOutputStream() << "basis: " << static_cast<const Vector3&>(xyz2st.x()) << static_cast<const Vector3&>(xyz2st.y()) << static_cast<const Vector3&>(xyz2st.z()) << "\n";
-		matrix4_multiply_by_matrix4( local2tex, xyz2st );
-	}
+    {
+        Matrix4 xyz2st;
+        // we don't care if it's not normalised...
+        Texdef_basisForNormal(projection, matrix4_transformed_direction(localToWorld, normal), xyz2st);
+        //globalOutputStream() << "basis: " << static_cast<const Vector3&>(xyz2st.x()) << static_cast<const Vector3&>(xyz2st.y()) << static_cast<const Vector3&>(xyz2st.z()) << "\n";
+        matrix4_multiply_by_matrix4(local2tex, xyz2st);
+    }
 
-	Vector3 tangent( vector3_normalised( vector4_to_vector3( matrix4_transposed( local2tex ).x() ) ) );
-	Vector3 bitangent( vector3_normalised( vector4_to_vector3( matrix4_transposed( local2tex ).y() ) ) );
+    Vector3 tangent(vector3_normalised(vector4_to_vector3(matrix4_transposed(local2tex).x())));
+    Vector3 bitangent(vector3_normalised(vector4_to_vector3(matrix4_transposed(local2tex).y())));
 
-	matrix4_multiply_by_matrix4( local2tex, localToWorld );
+    matrix4_multiply_by_matrix4(local2tex, localToWorld);
 
-	for ( Winding::iterator i = w.begin(); i != w.end(); ++i )
-	{
-		Vector3 texcoord = matrix4_transformed_point( local2tex, ( *i ).vertex );
-		( *i ).texcoord[0] = texcoord[0];
-		( *i ).texcoord[1] = texcoord[1];
+    for (Winding::iterator i = w.begin(); i != w.end(); ++i) {
+        Vector3 texcoord = matrix4_transformed_point(local2tex, (*i).vertex);
+        (*i).texcoord[0] = texcoord[0];
+        (*i).texcoord[1] = texcoord[1];
 
-		( *i ).tangent = tangent;
-		( *i ).bitangent = bitangent;
-	}
+        (*i).tangent = tangent;
+        (*i).bitangent = bitangent;
+    }
 }
 
 /*!
    \brief Provides the axis-base of the texture ST space for this normal,
    as they had been transformed to world XYZ space.
  */
-void TextureAxisFromNormal( const Vector3& normal, Vector3& s, Vector3& t ){
-	switch ( projectionaxis_for_normal( normal ) )
-	{
-	case eProjectionAxisZ:
-		s[0]  =  1;
-		s[1]  =  0;
-		s[2]  =  0;
+void TextureAxisFromNormal(const Vector3 &normal, Vector3 &s, Vector3 &t)
+{
+    switch (projectionaxis_for_normal(normal)) {
+        case eProjectionAxisZ:
+            s[0] = 1;
+            s[1] = 0;
+            s[2] = 0;
 
-		t[0]  =  0;
-		t[1]  = -1;
-		t[2]  =  0;
+            t[0] = 0;
+            t[1] = -1;
+            t[2] = 0;
 
-		break;
-	case eProjectionAxisY:
-		s[0]  =  1;
-		s[1]  =  0;
-		s[2]  =  0;
+            break;
+        case eProjectionAxisY:
+            s[0] = 1;
+            s[1] = 0;
+            s[2] = 0;
 
-		t[0]  =  0;
-		t[1]  =  0;
-		t[2]  = -1;
+            t[0] = 0;
+            t[1] = 0;
+            t[2] = -1;
 
-		break;
-	case eProjectionAxisX:
-		s[0]  =  0;
-		s[1]  =  1;
-		s[2]  =  0;
+            break;
+        case eProjectionAxisX:
+            s[0] = 0;
+            s[1] = 1;
+            s[2] = 0;
 
-		t[0]  =  0;
-		t[1]  =  0;
-		t[2]  = -1;
+            t[0] = 0;
+            t[1] = 0;
+            t[2] = -1;
 
-		break;
-	}
+            break;
+    }
 }
 
-void Texdef_Assign( texdef_t& td, const texdef_t& other ){
-	td = other;
+void Texdef_Assign(texdef_t &td, const texdef_t &other)
+{
+    td = other;
 }
 
-void Texdef_Shift( texdef_t& td, float s, float t ){
-	td.shift[0] += s;
-	td.shift[1] += t;
+void Texdef_Shift(texdef_t &td, float s, float t)
+{
+    td.shift[0] += s;
+    td.shift[1] += t;
 }
 
-void Texdef_Scale( texdef_t& td, float s, float t ){
-	td.scale[0] += s;
-	td.scale[1] += t;
+void Texdef_Scale(texdef_t &td, float s, float t)
+{
+    td.scale[0] += s;
+    td.scale[1] += t;
 }
 
-void Texdef_Rotate( texdef_t& td, float angle ){
-	td.rotate += angle;
-	td.rotate = static_cast<float>( float_to_integer( td.rotate ) % 360 );
+void Texdef_Rotate(texdef_t &td, float angle)
+{
+    td.rotate += angle;
+    td.rotate = static_cast<float>( float_to_integer(td.rotate) % 360 );
 }
 
 // NOTE: added these from Ritual's Q3Radiant
-void ClearBounds( Vector3& mins, Vector3& maxs ){
-	mins[0] = mins[1] = mins[2] = 99999;
-	maxs[0] = maxs[1] = maxs[2] = -99999;
+void ClearBounds(Vector3 &mins, Vector3 &maxs)
+{
+    mins[0] = mins[1] = mins[2] = 99999;
+    maxs[0] = maxs[1] = maxs[2] = -99999;
 }
 
-void AddPointToBounds( const Vector3& v, Vector3& mins, Vector3& maxs ){
-	int i;
-	float val;
+void AddPointToBounds(const Vector3 &v, Vector3 &mins, Vector3 &maxs)
+{
+    int i;
+    float val;
 
-	for ( i = 0 ; i < 3 ; i++ )
-	{
-		val = v[i];
-		if ( val < mins[i] ) {
-			mins[i] = val;
-		}
-		if ( val > maxs[i] ) {
-			maxs[i] = val;
-		}
-	}
+    for (i = 0; i < 3; i++) {
+        val = v[i];
+        if (val < mins[i]) {
+            mins[i] = val;
+        }
+        if (val > maxs[i]) {
+            maxs[i] = val;
+        }
+    }
 }
 
 template<typename Element>
-inline BasicVector3<Element> vector3_inverse( const BasicVector3<Element>& self ){
-	return BasicVector3<Element>(
-			   Element( 1.0 / self.x() ),
-			   Element( 1.0 / self.y() ),
-			   Element( 1.0 / self.z() )
-			   );
+inline BasicVector3<Element> vector3_inverse(const BasicVector3<Element> &self)
+{
+    return BasicVector3<Element>(
+            Element(1.0 / self.x()),
+            Element(1.0 / self.y()),
+            Element(1.0 / self.z())
+    );
 }
 
 // low level functions .. put in mathlib?
-#define BPMatCopy( a,b ) {b[0][0] = a[0][0]; b[0][1] = a[0][1]; b[0][2] = a[0][2]; b[1][0] = a[1][0]; b[1][1] = a[1][1]; b[1][2] = a[1][2]; }
+#define BPMatCopy(a, b) {b[0][0] = a[0][0]; b[0][1] = a[0][1]; b[0][2] = a[0][2]; b[1][0] = a[1][0]; b[1][1] = a[1][1]; b[1][2] = a[1][2]; }
 // apply a scale transformation to the BP matrix
-#define BPMatScale( m,sS,sT ) {m[0][0] *= sS; m[1][0] *= sS; m[0][1] *= sT; m[1][1] *= sT; }
+#define BPMatScale(m, sS, sT) {m[0][0] *= sS; m[1][0] *= sS; m[0][1] *= sT; m[1][1] *= sT; }
 // apply a translation transformation to a BP matrix
-#define BPMatTranslate( m,s,t ) {m[0][2] += m[0][0] * s + m[0][1] * t; m[1][2] += m[1][0] * s + m[1][1] * t; }
+#define BPMatTranslate(m, s, t) {m[0][2] += m[0][0] * s + m[0][1] * t; m[1][2] += m[1][0] * s + m[1][1] * t; }
+
 // 2D homogeneous matrix product C = A*B
-void BPMatMul( float A[2][3], float B[2][3], float C[2][3] );
+void BPMatMul(float A[2][3], float B[2][3], float C[2][3]);
+
 // apply a rotation (degrees)
-void BPMatRotate( float A[2][3], float theta );
-#ifdef _DEBUG
-void BPMatDump( float A[2][3] );
+void BPMatRotate(float A[2][3], float theta);
+
+#if GDEF_DEBUG
+
+void BPMatDump(float A[2][3]);
+
 #endif
 
-#ifdef _DEBUG
+#if GDEF_DEBUG
 //#define DBG_BP
 #endif
 
@@ -412,9 +425,10 @@ float g_texdef_default_scale;
 // compute a determinant using Sarrus rule
 //++timo "inline" this with a macro
 // NOTE : the three vectors are understood as columns of the matrix
-inline float SarrusDet( const Vector3& a, const Vector3& b, const Vector3& c ){
-	return a[0] * b[1] * c[2] + b[0] * c[1] * a[2] + c[0] * a[1] * b[2]
-		   - c[0] * b[1] * a[2] - a[1] * b[0] * c[2] - a[0] * b[2] * c[1];
+inline float SarrusDet(const Vector3 &a, const Vector3 &b, const Vector3 &c)
+{
+    return a[0] * b[1] * c[2] + b[0] * c[1] * a[2] + c[0] * a[1] * b[2]
+           - c[0] * b[1] * a[2] - a[1] * b[0] * c[2] - a[0] * b[2] * c[1];
 }
 
 // in many case we know three points A,B,C in two axis base B1 and B2
@@ -424,205 +438,210 @@ inline float SarrusDet( const Vector3& a, const Vector3& b, const Vector3& c ){
 // NOTE: the third coord of the A,B,C point is ignored
 // NOTE: see the commented out section to fill M and D
 //++timo TODO: update the other members to use this when possible
-void MatrixForPoints( Vector3 M[3], Vector3 D[2], brushprimit_texdef_t *T ){
+void MatrixForPoints(Vector3 M[3], Vector3 D[2], brushprimit_texdef_t *T)
+{
 //	Vector3 M[3]; // columns of the matrix .. easier that way (the indexing is not standard! it's column-line .. later computations are easier that way)
-	float det;
+    float det;
 //	Vector3 D[2];
-	M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
+    M[2][0] = 1.0f;
+    M[2][1] = 1.0f;
+    M[2][2] = 1.0f;
 #if 0
-	// fill the data vectors
-	M[0][0] = A2[0]; M[0][1] = B2[0]; M[0][2] = C2[0];
-	M[1][0] = A2[1]; M[1][1] = B2[1]; M[1][2] = C2[1];
-	M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
-	D[0][0] = A1[0];
-	D[0][1] = B1[0];
-	D[0][2] = C1[0];
-	D[1][0] = A1[1];
-	D[1][1] = B1[1];
-	D[1][2] = C1[1];
+    // fill the data vectors
+    M[0][0] = A2[0]; M[0][1] = B2[0]; M[0][2] = C2[0];
+    M[1][0] = A2[1]; M[1][1] = B2[1]; M[1][2] = C2[1];
+    M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
+    D[0][0] = A1[0];
+    D[0][1] = B1[0];
+    D[0][2] = C1[0];
+    D[1][0] = A1[1];
+    D[1][1] = B1[1];
+    D[1][2] = C1[1];
 #endif
-	// solve
-	det = SarrusDet( M[0], M[1], M[2] );
-	T->coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
-	T->coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
-	T->coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
-	T->coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
-	T->coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
-	T->coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
+    // solve
+    det = SarrusDet(M[0], M[1], M[2]);
+    T->coords[0][0] = SarrusDet(D[0], M[1], M[2]) / det;
+    T->coords[0][1] = SarrusDet(M[0], D[0], M[2]) / det;
+    T->coords[0][2] = SarrusDet(M[0], M[1], D[0]) / det;
+    T->coords[1][0] = SarrusDet(D[1], M[1], M[2]) / det;
+    T->coords[1][1] = SarrusDet(M[0], D[1], M[2]) / det;
+    T->coords[1][2] = SarrusDet(M[0], M[1], D[1]) / det;
 }
 
 //++timo replace everywhere texX by texS etc. ( ----> and in q3map !)
 // NOTE : ComputeAxisBase here and in q3map code must always BE THE SAME !
 // WARNING : special case behaviour of atan2(y,x) <-> atan(y/x) might not be the same everywhere when x == 0
 // rotation by (0,RotY,RotZ) assigns X to normal
-void ComputeAxisBase( const Vector3& normal, Vector3& texS, Vector3& texT ){
+void ComputeAxisBase(const Vector3 &normal, Vector3 &texS, Vector3 &texT)
+{
 #if 1
-	const Vector3 up( 0, 0, 1 );
-	const Vector3 down( 0, 0, -1 );
-
-	if ( vector3_equal_epsilon( normal, up, float(1e-6) ) ) {
-		texS = Vector3( 0, 1, 0 );
-		texT = Vector3( 1, 0, 0 );
-	}
-	else if ( vector3_equal_epsilon( normal, down, float(1e-6) ) ) {
-		texS = Vector3( 0, 1, 0 );
-		texT = Vector3( -1, 0, 0 );
-	}
-	else
-	{
-		texS = vector3_normalised( vector3_cross( normal, up ) );
-		texT = vector3_normalised( vector3_cross( normal, texS ) );
-		vector3_negate( texS );
-	}
+    const Vector3 up(0, 0, 1);
+    const Vector3 down(0, 0, -1);
+
+    if (vector3_equal_epsilon(normal, up, float(1e-6))) {
+        texS = Vector3(0, 1, 0);
+        texT = Vector3(1, 0, 0);
+    } else if (vector3_equal_epsilon(normal, down, float(1e-6))) {
+        texS = Vector3(0, 1, 0);
+        texT = Vector3(-1, 0, 0);
+    } else {
+        texS = vector3_normalised(vector3_cross(normal, up));
+        texT = vector3_normalised(vector3_cross(normal, texS));
+        vector3_negate(texS);
+    }
 
 #else
-	float RotY,RotZ;
-	// do some cleaning
-	/*
-	   if (fabs(normal[0])<1e-6)
-	      normal[0]=0.0f;
-	   if (fabs(normal[1])<1e-6)
-	      normal[1]=0.0f;
-	   if (fabs(normal[2])<1e-6)
-	      normal[2]=0.0f;
-	 */
-	RotY = -atan2( normal[2],sqrt( normal[1] * normal[1] + normal[0] * normal[0] ) );
-	RotZ = atan2( normal[1],normal[0] );
-	// rotate (0,1,0) and (0,0,1) to compute texS and texT
-	texS[0] = -sin( RotZ );
-	texS[1] = cos( RotZ );
-	texS[2] = 0;
-	// the texT vector is along -Z ( T texture coorinates axis )
-	texT[0] = -sin( RotY ) * cos( RotZ );
-	texT[1] = -sin( RotY ) * sin( RotZ );
-	texT[2] = -cos( RotY );
+    float RotY,RotZ;
+    // do some cleaning
+    /*
+       if (fabs(normal[0])<1e-6)
+          normal[0]=0.0f;
+       if (fabs(normal[1])<1e-6)
+          normal[1]=0.0f;
+       if (fabs(normal[2])<1e-6)
+          normal[2]=0.0f;
+     */
+    RotY = -atan2( normal[2],sqrt( normal[1] * normal[1] + normal[0] * normal[0] ) );
+    RotZ = atan2( normal[1],normal[0] );
+    // rotate (0,1,0) and (0,0,1) to compute texS and texT
+    texS[0] = -sin( RotZ );
+    texS[1] = cos( RotZ );
+    texS[2] = 0;
+    // the texT vector is along -Z ( T texture coorinates axis )
+    texT[0] = -sin( RotY ) * cos( RotZ );
+    texT[1] = -sin( RotY ) * sin( RotZ );
+    texT[2] = -cos( RotY );
 #endif
 }
 
 #if 0 // texdef conversion
 void FaceToBrushPrimitFace( face_t *f ){
-	Vector3 texX,texY;
-	Vector3 proj;
-	// ST of (0,0) (1,0) (0,1)
-	float ST[3][5]; // [ point index ] [ xyz ST ]
-	//++timo not used as long as brushprimit_texdef and texdef are static
+    Vector3 texX,texY;
+    Vector3 proj;
+    // ST of (0,0) (1,0) (0,1)
+    float ST[3][5]; // [ point index ] [ xyz ST ]
+    //++timo not used as long as brushprimit_texdef and texdef are static
 /*	f->brushprimit_texdef.contents=f->texdef.contents;
     f->brushprimit_texdef.flags=f->texdef.flags;
     f->brushprimit_texdef.value=f->texdef.value;
     strcpy(f->brushprimit_texdef.name,f->texdef.name); */
 #ifdef DBG_BP
-	if ( f->plane.normal[0] == 0.0f && f->plane.normal[1] == 0.0f && f->plane.normal[2] == 0.0f ) {
-		globalOutputStream() << "Warning : f->plane.normal is (0,0,0) in FaceToBrushPrimitFace\n";
-	}
-	// check d_texture
-	if ( !f->d_texture ) {
-		globalOutputStream() << "Warning : f.d_texture is 0 in FaceToBrushPrimitFace\n";
-		return;
-	}
+    if ( f->plane.normal[0] == 0.0f && f->plane.normal[1] == 0.0f && f->plane.normal[2] == 0.0f ) {
+        globalOutputStream() << "Warning : f->plane.normal is (0,0,0) in FaceToBrushPrimitFace\n";
+    }
+    // check d_texture
+    if ( !f->d_texture ) {
+        globalOutputStream() << "Warning : f.d_texture is 0 in FaceToBrushPrimitFace\n";
+        return;
+    }
 #endif
-	// compute axis base
-	ComputeAxisBase( f->plane.normal,texX,texY );
-	// compute projection vector
-	VectorCopy( f->plane.normal,proj );
-	VectorScale( proj,f->plane.dist,proj );
-	// (0,0) in plane axis base is (0,0,0) in world coordinates + projection on the affine plane
-	// (1,0) in plane axis base is texX in world coordinates + projection on the affine plane
-	// (0,1) in plane axis base is texY in world coordinates + projection on the affine plane
-	// use old texture code to compute the ST coords of these points
-	VectorCopy( proj,ST[0] );
-	EmitTextureCoordinates( ST[0], f->pShader->getTexture(), f );
-	VectorCopy( texX,ST[1] );
-	VectorAdd( ST[1],proj,ST[1] );
-	EmitTextureCoordinates( ST[1], f->pShader->getTexture(), f );
-	VectorCopy( texY,ST[2] );
-	VectorAdd( ST[2],proj,ST[2] );
-	EmitTextureCoordinates( ST[2], f->pShader->getTexture(), f );
-	// compute texture matrix
-	f->brushprimit_texdef.coords[0][2] = ST[0][3];
-	f->brushprimit_texdef.coords[1][2] = ST[0][4];
-	f->brushprimit_texdef.coords[0][0] = ST[1][3] - f->brushprimit_texdef.coords[0][2];
-	f->brushprimit_texdef.coords[1][0] = ST[1][4] - f->brushprimit_texdef.coords[1][2];
-	f->brushprimit_texdef.coords[0][1] = ST[2][3] - f->brushprimit_texdef.coords[0][2];
-	f->brushprimit_texdef.coords[1][1] = ST[2][4] - f->brushprimit_texdef.coords[1][2];
+    // compute axis base
+    ComputeAxisBase( f->plane.normal,texX,texY );
+    // compute projection vector
+    VectorCopy( f->plane.normal,proj );
+    VectorScale( proj,f->plane.dist,proj );
+    // (0,0) in plane axis base is (0,0,0) in world coordinates + projection on the affine plane
+    // (1,0) in plane axis base is texX in world coordinates + projection on the affine plane
+    // (0,1) in plane axis base is texY in world coordinates + projection on the affine plane
+    // use old texture code to compute the ST coords of these points
+    VectorCopy( proj,ST[0] );
+    EmitTextureCoordinates( ST[0], f->pShader->getTexture(), f );
+    VectorCopy( texX,ST[1] );
+    VectorAdd( ST[1],proj,ST[1] );
+    EmitTextureCoordinates( ST[1], f->pShader->getTexture(), f );
+    VectorCopy( texY,ST[2] );
+    VectorAdd( ST[2],proj,ST[2] );
+    EmitTextureCoordinates( ST[2], f->pShader->getTexture(), f );
+    // compute texture matrix
+    f->brushprimit_texdef.coords[0][2] = ST[0][3];
+    f->brushprimit_texdef.coords[1][2] = ST[0][4];
+    f->brushprimit_texdef.coords[0][0] = ST[1][3] - f->brushprimit_texdef.coords[0][2];
+    f->brushprimit_texdef.coords[1][0] = ST[1][4] - f->brushprimit_texdef.coords[1][2];
+    f->brushprimit_texdef.coords[0][1] = ST[2][3] - f->brushprimit_texdef.coords[0][2];
+    f->brushprimit_texdef.coords[1][1] = ST[2][4] - f->brushprimit_texdef.coords[1][2];
 }
 
 // compute texture coordinates for the winding points
 void EmitBrushPrimitTextureCoordinates( face_t * f, Winding * w ){
-	Vector3 texX,texY;
-	float x,y;
-	// compute axis base
-	ComputeAxisBase( f->plane.normal,texX,texY );
-	// in case the texcoords matrix is empty, build a default one
-	// same behaviour as if scale[0]==0 && scale[1]==0 in old code
-	if ( f->brushprimit_texdef.coords[0][0] == 0 && f->brushprimit_texdef.coords[1][0] == 0 && f->brushprimit_texdef.coords[0][1] == 0 && f->brushprimit_texdef.coords[1][1] == 0 ) {
-		f->brushprimit_texdef.coords[0][0] = 1.0f;
-		f->brushprimit_texdef.coords[1][1] = 1.0f;
-		ConvertTexMatWithQTexture( &f->brushprimit_texdef, 0, &f->brushprimit_texdef, f->pShader->getTexture() );
-	}
-	int i;
-	for ( i = 0 ; i < w.numpoints ; i++ )
-	{
-		x = vector3_dot( w.point_at( i ),texX );
-		y = vector3_dot( w.point_at( i ),texY );
+    Vector3 texX,texY;
+    float x,y;
+    // compute axis base
+    ComputeAxisBase( f->plane.normal,texX,texY );
+    // in case the texcoords matrix is empty, build a default one
+    // same behaviour as if scale[0]==0 && scale[1]==0 in old code
+    if ( f->brushprimit_texdef.coords[0][0] == 0 && f->brushprimit_texdef.coords[1][0] == 0 && f->brushprimit_texdef.coords[0][1] == 0 && f->brushprimit_texdef.coords[1][1] == 0 ) {
+        f->brushprimit_texdef.coords[0][0] = 1.0f;
+        f->brushprimit_texdef.coords[1][1] = 1.0f;
+        ConvertTexMatWithQTexture( &f->brushprimit_texdef, 0, &f->brushprimit_texdef, f->pShader->getTexture() );
+    }
+    int i;
+    for ( i = 0 ; i < w.numpoints ; i++ )
+    {
+        x = vector3_dot( w.point_at( i ),texX );
+        y = vector3_dot( w.point_at( i ),texY );
 #if 0
 #ifdef DBG_BP
-		if ( g_bp_globals.bNeedConvert ) {
-			// check we compute the same ST as the traditional texture computation used before
-			float S = f->brushprimit_texdef.coords[0][0] * x + f->brushprimit_texdef.coords[0][1] * y + f->brushprimit_texdef.coords[0][2];
-			float T = f->brushprimit_texdef.coords[1][0] * x + f->brushprimit_texdef.coords[1][1] * y + f->brushprimit_texdef.coords[1][2];
-			if ( fabs( S - w.point_at( i )[3] ) > 1e-2 || fabs( T - w.point_at( i )[4] ) > 1e-2 ) {
-				if ( fabs( S - w.point_at( i )[3] ) > 1e-4 || fabs( T - w.point_at( i )[4] ) > 1e-4 ) {
-					globalOutputStream() << "Warning : precision loss in brush -> brush primitive texture computation\n";
-				}
-				else{
-					globalOutputStream() << "Warning : brush -> brush primitive texture computation bug detected\n";
-				}
-			}
-		}
+        if ( g_bp_globals.bNeedConvert ) {
+            // check we compute the same ST as the traditional texture computation used before
+            float S = f->brushprimit_texdef.coords[0][0] * x + f->brushprimit_texdef.coords[0][1] * y + f->brushprimit_texdef.coords[0][2];
+            float T = f->brushprimit_texdef.coords[1][0] * x + f->brushprimit_texdef.coords[1][1] * y + f->brushprimit_texdef.coords[1][2];
+            if ( fabs( S - w.point_at( i )[3] ) > 1e-2 || fabs( T - w.point_at( i )[4] ) > 1e-2 ) {
+                if ( fabs( S - w.point_at( i )[3] ) > 1e-4 || fabs( T - w.point_at( i )[4] ) > 1e-4 ) {
+                    globalOutputStream() << "Warning : precision loss in brush -> brush primitive texture computation\n";
+                }
+                else{
+                    globalOutputStream() << "Warning : brush -> brush primitive texture computation bug detected\n";
+                }
+            }
+        }
 #endif
 #endif
-		w.point_at( i )[3] = f->brushprimit_texdef.coords[0][0] * x + f->brushprimit_texdef.coords[0][1] * y + f->brushprimit_texdef.coords[0][2];
-		w.point_at( i )[4] = f->brushprimit_texdef.coords[1][0] * x + f->brushprimit_texdef.coords[1][1] * y + f->brushprimit_texdef.coords[1][2];
-	}
+        w.point_at( i )[3] = f->brushprimit_texdef.coords[0][0] * x + f->brushprimit_texdef.coords[0][1] * y + f->brushprimit_texdef.coords[0][2];
+        w.point_at( i )[4] = f->brushprimit_texdef.coords[1][0] * x + f->brushprimit_texdef.coords[1][1] * y + f->brushprimit_texdef.coords[1][2];
+    }
 }
 #endif
 
 typedef float texmat_t[2][3];
 
-void TexMat_Scale( texmat_t texmat, float s, float t ){
-	texmat[0][0] *= s;
-	texmat[0][1] *= s;
-	texmat[0][2] *= s;
-	texmat[1][0] *= t;
-	texmat[1][1] *= t;
-	texmat[1][2] *= t;
+void TexMat_Scale(texmat_t texmat, float s, float t)
+{
+    texmat[0][0] *= s;
+    texmat[0][1] *= s;
+    texmat[0][2] *= s;
+    texmat[1][0] *= t;
+    texmat[1][1] *= t;
+    texmat[1][2] *= t;
 }
 
-void TexMat_Assign( texmat_t texmat, const texmat_t other ){
-	texmat[0][0] = other[0][0];
-	texmat[0][1] = other[0][1];
-	texmat[0][2] = other[0][2];
-	texmat[1][0] = other[1][0];
-	texmat[1][1] = other[1][1];
-	texmat[1][2] = other[1][2];
+void TexMat_Assign(texmat_t texmat, const texmat_t other)
+{
+    texmat[0][0] = other[0][0];
+    texmat[0][1] = other[0][1];
+    texmat[0][2] = other[0][2];
+    texmat[1][0] = other[1][0];
+    texmat[1][1] = other[1][1];
+    texmat[1][2] = other[1][2];
 }
 
-void ConvertTexMatWithDimensions( const texmat_t texmat1, std::size_t w1, std::size_t h1,
-								  texmat_t texmat2, std::size_t w2, std::size_t h2 ){
-	TexMat_Assign( texmat2, texmat1 );
-	TexMat_Scale( texmat2, static_cast<float>( w1 ) / static_cast<float>( w2 ), static_cast<float>( h1 ) / static_cast<float>( h2 ) );
+void ConvertTexMatWithDimensions(const texmat_t texmat1, std::size_t w1, std::size_t h1,
+                                 texmat_t texmat2, std::size_t w2, std::size_t h2)
+{
+    TexMat_Assign(texmat2, texmat1);
+    TexMat_Scale(texmat2, static_cast<float>( w1 ) / static_cast<float>( w2 ),
+                 static_cast<float>( h1 ) / static_cast<float>( h2 ));
 }
 
 #if 0
 // convert a texture matrix between two qtexture_t
 // if 0 for qtexture_t, basic 2x2 texture is assumed ( straight mapping between s/t coordinates and geometric coordinates )
 void ConvertTexMatWithQTexture( const float texMat1[2][3], const qtexture_t *qtex1, float texMat2[2][3], const qtexture_t *qtex2 ){
-	ConvertTexMatWithDimensions( texMat1, ( qtex1 ) ? qtex1->width : 2, ( qtex1 ) ? qtex1->height : 2,
-								 texMat2, ( qtex2 ) ? qtex2->width : 2, ( qtex2 ) ? qtex2->height : 2 );
+    ConvertTexMatWithDimensions( texMat1, ( qtex1 ) ? qtex1->width : 2, ( qtex1 ) ? qtex1->height : 2,
+                                 texMat2, ( qtex2 ) ? qtex2->width : 2, ( qtex2 ) ? qtex2->height : 2 );
 }
 
 void ConvertTexMatWithQTexture( const brushprimit_texdef_t *texMat1, const qtexture_t *qtex1, brushprimit_texdef_t *texMat2, const qtexture_t *qtex2 ){
-	ConvertTexMatWithQTexture( texMat1->coords, qtex1, texMat2->coords, qtex2 );
+    ConvertTexMatWithQTexture( texMat1->coords, qtex1, texMat2->coords, qtex2 );
 }
 #endif
 
@@ -630,136 +649,137 @@ void ConvertTexMatWithQTexture( const brushprimit_texdef_t *texMat1, const qtext
 // these shift scale rot values are to be understood in the local axis base
 // Note: this code looks similar to Texdef_fromTransform, but the algorithm is slightly different.
 
-void TexMatToFakeTexCoords( const brushprimit_texdef_t& bp_texdef, texdef_t& texdef ){
-	texdef.scale[0] = static_cast<float>( 1.0 / vector2_length( Vector2( bp_texdef.coords[0][0], bp_texdef.coords[1][0] ) ) );
-	texdef.scale[1] = static_cast<float>( 1.0 / vector2_length( Vector2( bp_texdef.coords[0][1], bp_texdef.coords[1][1] ) ) );
-
-	texdef.rotate = -static_cast<float>( radians_to_degrees( arctangent_yx( bp_texdef.coords[1][0], bp_texdef.coords[0][0] ) ) );
-
-	texdef.shift[0] = -bp_texdef.coords[0][2];
-	texdef.shift[1] = bp_texdef.coords[1][2];
-
-	// determine whether or not an axis is flipped using a 2d cross-product
-	double cross = vector2_cross( Vector2( bp_texdef.coords[0][0], bp_texdef.coords[0][1] ), Vector2( bp_texdef.coords[1][0], bp_texdef.coords[1][1] ) );
-	if ( cross < 0 ) {
-		// This is a bit of a compromise when using BPs--since we don't know *which* axis was flipped,
-		// we pick one (rather arbitrarily) using the following convention: If the X-axis is between
-		// 0 and 180, we assume it's the Y-axis that flipped, otherwise we assume it's the X-axis and
-		// subtract out 180 degrees to compensate.
-		if ( texdef.rotate >= 180.0f ) {
-			texdef.rotate -= 180.0f;
-			texdef.scale[0] = -texdef.scale[0];
-		}
-		else
-		{
-			texdef.scale[1] = -texdef.scale[1];
-		}
-	}
+void TexMatToFakeTexCoords(const brushprimit_texdef_t &bp_texdef, texdef_t &texdef)
+{
+    texdef.scale[0] = static_cast<float>( 1.0 /
+                                          vector2_length(Vector2(bp_texdef.coords[0][0], bp_texdef.coords[1][0])));
+    texdef.scale[1] = static_cast<float>( 1.0 /
+                                          vector2_length(Vector2(bp_texdef.coords[0][1], bp_texdef.coords[1][1])));
+
+    texdef.rotate = -static_cast<float>( radians_to_degrees(
+            arctangent_yx(bp_texdef.coords[1][0], bp_texdef.coords[0][0])));
+
+    texdef.shift[0] = -bp_texdef.coords[0][2];
+    texdef.shift[1] = bp_texdef.coords[1][2];
+
+    // determine whether or not an axis is flipped using a 2d cross-product
+    double cross = vector2_cross(Vector2(bp_texdef.coords[0][0], bp_texdef.coords[0][1]),
+                                 Vector2(bp_texdef.coords[1][0], bp_texdef.coords[1][1]));
+    if (cross < 0) {
+        // This is a bit of a compromise when using BPs--since we don't know *which* axis was flipped,
+        // we pick one (rather arbitrarily) using the following convention: If the X-axis is between
+        // 0 and 180, we assume it's the Y-axis that flipped, otherwise we assume it's the X-axis and
+        // subtract out 180 degrees to compensate.
+        if (texdef.rotate >= 180.0f) {
+            texdef.rotate -= 180.0f;
+            texdef.scale[0] = -texdef.scale[0];
+        } else {
+            texdef.scale[1] = -texdef.scale[1];
+        }
+    }
 }
 
 // compute back the texture matrix from fake shift scale rot
-void FakeTexCoordsToTexMat( const texdef_t& texdef, brushprimit_texdef_t& bp_texdef ){
-	double r = degrees_to_radians( -texdef.rotate );
-	double c = cos( r );
-	double s = sin( r );
-	double x = 1.0f / texdef.scale[0];
-	double y = 1.0f / texdef.scale[1];
-	bp_texdef.coords[0][0] = static_cast<float>( x * c );
-	bp_texdef.coords[1][0] = static_cast<float>( x * s );
-	bp_texdef.coords[0][1] = static_cast<float>( y * -s );
-	bp_texdef.coords[1][1] = static_cast<float>( y * c );
-	bp_texdef.coords[0][2] = -texdef.shift[0];
-	bp_texdef.coords[1][2] = texdef.shift[1];
+void FakeTexCoordsToTexMat(const texdef_t &texdef, brushprimit_texdef_t &bp_texdef)
+{
+    double r = degrees_to_radians(-texdef.rotate);
+    double c = cos(r);
+    double s = sin(r);
+    double x = 1.0f / texdef.scale[0];
+    double y = 1.0f / texdef.scale[1];
+    bp_texdef.coords[0][0] = static_cast<float>( x * c );
+    bp_texdef.coords[1][0] = static_cast<float>( x * s );
+    bp_texdef.coords[0][1] = static_cast<float>( y * -s );
+    bp_texdef.coords[1][1] = static_cast<float>( y * c );
+    bp_texdef.coords[0][2] = -texdef.shift[0];
+    bp_texdef.coords[1][2] = texdef.shift[1];
 }
 
 #if 0 // texture locking (brush primit)
 // used for texture locking
 // will move the texture according to a geometric vector
 void ShiftTextureGeometric_BrushPrimit( face_t *f, Vector3& delta ){
-	Vector3 texS,texT;
-	float tx,ty;
-	Vector3 M[3]; // columns of the matrix .. easier that way
-	float det;
-	Vector3 D[2];
-	// compute plane axis base ( doesn't change with translation )
-	ComputeAxisBase( f->plane.normal, texS, texT );
-	// compute translation vector in plane axis base
-	tx = vector3_dot( delta, texS );
-	ty = vector3_dot( delta, texT );
-	// fill the data vectors
-	M[0][0] = tx; M[0][1] = 1.0f + tx; M[0][2] = tx;
-	M[1][0] = ty; M[1][1] = ty; M[1][2] = 1.0f + ty;
-	M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
-	D[0][0] = f->brushprimit_texdef.coords[0][2];
-	D[0][1] = f->brushprimit_texdef.coords[0][0] + f->brushprimit_texdef.coords[0][2];
-	D[0][2] = f->brushprimit_texdef.coords[0][1] + f->brushprimit_texdef.coords[0][2];
-	D[1][0] = f->brushprimit_texdef.coords[1][2];
-	D[1][1] = f->brushprimit_texdef.coords[1][0] + f->brushprimit_texdef.coords[1][2];
-	D[1][2] = f->brushprimit_texdef.coords[1][1] + f->brushprimit_texdef.coords[1][2];
-	// solve
-	det = SarrusDet( M[0], M[1], M[2] );
-	f->brushprimit_texdef.coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
-	f->brushprimit_texdef.coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
-	f->brushprimit_texdef.coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
-	f->brushprimit_texdef.coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
-	f->brushprimit_texdef.coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
-	f->brushprimit_texdef.coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
+    Vector3 texS,texT;
+    float tx,ty;
+    Vector3 M[3]; // columns of the matrix .. easier that way
+    float det;
+    Vector3 D[2];
+    // compute plane axis base ( doesn't change with translation )
+    ComputeAxisBase( f->plane.normal, texS, texT );
+    // compute translation vector in plane axis base
+    tx = vector3_dot( delta, texS );
+    ty = vector3_dot( delta, texT );
+    // fill the data vectors
+    M[0][0] = tx; M[0][1] = 1.0f + tx; M[0][2] = tx;
+    M[1][0] = ty; M[1][1] = ty; M[1][2] = 1.0f + ty;
+    M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
+    D[0][0] = f->brushprimit_texdef.coords[0][2];
+    D[0][1] = f->brushprimit_texdef.coords[0][0] + f->brushprimit_texdef.coords[0][2];
+    D[0][2] = f->brushprimit_texdef.coords[0][1] + f->brushprimit_texdef.coords[0][2];
+    D[1][0] = f->brushprimit_texdef.coords[1][2];
+    D[1][1] = f->brushprimit_texdef.coords[1][0] + f->brushprimit_texdef.coords[1][2];
+    D[1][2] = f->brushprimit_texdef.coords[1][1] + f->brushprimit_texdef.coords[1][2];
+    // solve
+    det = SarrusDet( M[0], M[1], M[2] );
+    f->brushprimit_texdef.coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
+    f->brushprimit_texdef.coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
+    f->brushprimit_texdef.coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
+    f->brushprimit_texdef.coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
+    f->brushprimit_texdef.coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
+    f->brushprimit_texdef.coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
 }
 
 // shift a texture (texture adjustments) along it's current texture axes
 // x and y are geometric values, which we must compute as ST increments
 // this depends on the texture size and the pixel/texel ratio
 void ShiftTextureRelative_BrushPrimit( face_t *f, float x, float y ){
-	float s,t;
-	// as a ratio against texture size
-	// the scale of the texture is not relevant here (we work directly on a transformation from the base vectors)
-	s = ( x * 2.0 ) / (float)f->pShader->getTexture().width;
-	t = ( y * 2.0 ) / (float)f->pShader->getTexture().height;
-	f->brushprimit_texdef.coords[0][2] -= s;
-	f->brushprimit_texdef.coords[1][2] -= t;
+    float s,t;
+    // as a ratio against texture size
+    // the scale of the texture is not relevant here (we work directly on a transformation from the base vectors)
+    s = ( x * 2.0 ) / (float)f->pShader->getTexture().width;
+    t = ( y * 2.0 ) / (float)f->pShader->getTexture().height;
+    f->brushprimit_texdef.coords[0][2] -= s;
+    f->brushprimit_texdef.coords[1][2] -= t;
 }
 #endif
 
 // TTimo: FIXME: I don't like that, it feels broken
 //   (and it's likely that it's not used anymore)
 // best fitted 2D vector is x.X+y.Y
-void ComputeBest2DVector( Vector3& v, Vector3& X, Vector3& Y, int &x, int &y ){
-	double sx,sy;
-	sx = vector3_dot( v, X );
-	sy = vector3_dot( v, Y );
-	if ( fabs( sy ) > fabs( sx ) ) {
-		x = 0;
-		if ( sy > 0.0 ) {
-			y =  1;
-		}
-		else{
-			y = -1;
-		}
-	}
-	else
-	{
-		y = 0;
-		if ( sx > 0.0 ) {
-			x =  1;
-		}
-		else{
-			x = -1;
-		}
-	}
+void ComputeBest2DVector(Vector3 &v, Vector3 &X, Vector3 &Y, int &x, int &y)
+{
+    double sx, sy;
+    sx = vector3_dot(v, X);
+    sy = vector3_dot(v, Y);
+    if (fabs(sy) > fabs(sx)) {
+        x = 0;
+        if (sy > 0.0) {
+            y = 1;
+        } else {
+            y = -1;
+        }
+    } else {
+        y = 0;
+        if (sx > 0.0) {
+            x = 1;
+        } else {
+            x = -1;
+        }
+    }
 }
 
 
 #if 0 // texdef conversion
 void BrushPrimitFaceToFace( face_t *face ){
-	// we have parsed brush primitives and need conversion back to standard format
-	// NOTE: converting back is a quick hack, there's some information lost and we can't do anything about it
-	// FIXME: if we normalize the texture matrix to a standard 2x2 size, we end up with wrong scaling
-	// I tried various tweaks, no luck .. seems shifting is lost
-	brushprimit_texdef_t aux;
-	ConvertTexMatWithQTexture( &face->brushprimit_texdef, face->pShader->getTexture(), &aux, 0 );
-	TexMatToFakeTexCoords( aux.coords, face->texdef.shift, &face->texdef.rotate, face->texdef.scale );
-	face->texdef.scale[0] /= 2.0;
-	face->texdef.scale[1] /= 2.0;
+    // we have parsed brush primitives and need conversion back to standard format
+    // NOTE: converting back is a quick hack, there's some information lost and we can't do anything about it
+    // FIXME: if we normalize the texture matrix to a standard 2x2 size, we end up with wrong scaling
+    // I tried various tweaks, no luck .. seems shifting is lost
+    brushprimit_texdef_t aux;
+    ConvertTexMatWithQTexture( &face->brushprimit_texdef, face->pShader->getTexture(), &aux, 0 );
+    TexMatToFakeTexCoords( aux.coords, face->texdef.shift, &face->texdef.rotate, face->texdef.scale );
+    face->texdef.scale[0] /= 2.0;
+    face->texdef.scale[1] /= 2.0;
 }
 #endif
 
@@ -786,87 +806,87 @@ Vector3 txl_matrix[3];
 Vector3 txl_origin;
 
 void TextureLockTransformation_BrushPrimit( face_t *f ){
-	Vector3 Orig,texS,texT;      // axis base of initial plane
-	// used by transformation algo
-	Vector3 temp; int j;
-	Vector3 vRotate;                        // rotation vector
-
-	Vector3 rOrig,rvecS,rvecT;   // geometric transformation of (0,0) (1,0) (0,1) { initial plane axis base }
-	Vector3 rNormal,rtexS,rtexT; // axis base for the transformed plane
-	Vector3 lOrig,lvecS,lvecT;  // [2] are not used ( but usefull for debugging )
-	Vector3 M[3];
-	float det;
-	Vector3 D[2];
-
-	// compute plane axis base
-	ComputeAxisBase( f->plane.normal, texS, texT );
-	VectorSet( Orig, 0.0f, 0.0f, 0.0f );
-
-	// compute coordinates of (0,0) (1,0) (0,1) ( expressed in initial plane axis base ) after transformation
-	// (0,0) (1,0) (0,1) ( expressed in initial plane axis base ) <-> (0,0,0) texS texT ( expressed world axis base )
-	// input: Orig, texS, texT (and the global locking params)
-	// ouput: rOrig, rvecS, rvecT, rNormal
-	if ( txlock_bRotation ) {
-		// rotation vector
-		VectorSet( vRotate, 0.0f, 0.0f, 0.0f );
-		vRotate[txl_nAxis] = txl_fDeg;
-		VectorRotateOrigin( Orig, vRotate, txl_vOrigin, rOrig );
-		VectorRotateOrigin( texS, vRotate, txl_vOrigin, rvecS );
-		VectorRotateOrigin( texT, vRotate, txl_vOrigin, rvecT );
-		// compute normal of plane after rotation
-		VectorRotate( f->plane.normal, vRotate, rNormal );
-	}
-	else
-	{
-		for ( j = 0 ; j < 3 ; j++ )
-			rOrig[j] = vector3_dot( vector3_subtracted( Orig, txl_origin ), txl_matrix[j] ) + txl_origin[j];
-		for ( j = 0 ; j < 3 ; j++ )
-			rvecS[j] = vector3_dot( vector3_subtracted( texS, txl_origin ), txl_matrix[j] ) + txl_origin[j];
-		for ( j = 0 ; j < 3 ; j++ )
-			rvecT[j] = vector3_dot( vector3_subtracted( texT, txl_origin ), txl_matrix[j] ) + txl_origin[j];
-		// we also need the axis base of the target plane, apply the transformation matrix to the normal too..
-		for ( j = 0 ; j < 3 ; j++ )
-			rNormal[j] = vector3_dot( f->plane.normal, txl_matrix[j] );
-	}
-
-	// compute rotated plane axis base
-	ComputeAxisBase( rNormal, rtexS, rtexT );
-	// compute S/T coordinates of the three points in rotated axis base ( in M matrix )
-	lOrig[0] = vector3_dot( rOrig, rtexS );
-	lOrig[1] = vector3_dot( rOrig, rtexT );
-	lvecS[0] = vector3_dot( rvecS, rtexS );
-	lvecS[1] = vector3_dot( rvecS, rtexT );
-	lvecT[0] = vector3_dot( rvecT, rtexS );
-	lvecT[1] = vector3_dot( rvecT, rtexT );
-	M[0][0] = lOrig[0]; M[1][0] = lOrig[1]; M[2][0] = 1.0f;
-	M[0][1] = lvecS[0]; M[1][1] = lvecS[1]; M[2][1] = 1.0f;
-	M[0][2] = lvecT[0]; M[1][2] = lvecT[1]; M[2][2] = 1.0f;
-	// fill data vector
-	D[0][0] = f->brushprimit_texdef.coords[0][2];
-	D[0][1] = f->brushprimit_texdef.coords[0][0] + f->brushprimit_texdef.coords[0][2];
-	D[0][2] = f->brushprimit_texdef.coords[0][1] + f->brushprimit_texdef.coords[0][2];
-	D[1][0] = f->brushprimit_texdef.coords[1][2];
-	D[1][1] = f->brushprimit_texdef.coords[1][0] + f->brushprimit_texdef.coords[1][2];
-	D[1][2] = f->brushprimit_texdef.coords[1][1] + f->brushprimit_texdef.coords[1][2];
-	// solve
-	det = SarrusDet( M[0], M[1], M[2] );
-	f->brushprimit_texdef.coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
-	f->brushprimit_texdef.coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
-	f->brushprimit_texdef.coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
-	f->brushprimit_texdef.coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
-	f->brushprimit_texdef.coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
-	f->brushprimit_texdef.coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
+    Vector3 Orig,texS,texT;      // axis base of initial plane
+    // used by transformation algo
+    Vector3 temp; int j;
+    Vector3 vRotate;                        // rotation vector
+
+    Vector3 rOrig,rvecS,rvecT;   // geometric transformation of (0,0) (1,0) (0,1) { initial plane axis base }
+    Vector3 rNormal,rtexS,rtexT; // axis base for the transformed plane
+    Vector3 lOrig,lvecS,lvecT;  // [2] are not used ( but usefull for debugging )
+    Vector3 M[3];
+    float det;
+    Vector3 D[2];
+
+    // compute plane axis base
+    ComputeAxisBase( f->plane.normal, texS, texT );
+    VectorSet( Orig, 0.0f, 0.0f, 0.0f );
+
+    // compute coordinates of (0,0) (1,0) (0,1) ( expressed in initial plane axis base ) after transformation
+    // (0,0) (1,0) (0,1) ( expressed in initial plane axis base ) <-> (0,0,0) texS texT ( expressed world axis base )
+    // input: Orig, texS, texT (and the global locking params)
+    // ouput: rOrig, rvecS, rvecT, rNormal
+    if ( txlock_bRotation ) {
+        // rotation vector
+        VectorSet( vRotate, 0.0f, 0.0f, 0.0f );
+        vRotate[txl_nAxis] = txl_fDeg;
+        VectorRotateOrigin( Orig, vRotate, txl_vOrigin, rOrig );
+        VectorRotateOrigin( texS, vRotate, txl_vOrigin, rvecS );
+        VectorRotateOrigin( texT, vRotate, txl_vOrigin, rvecT );
+        // compute normal of plane after rotation
+        VectorRotate( f->plane.normal, vRotate, rNormal );
+    }
+    else
+    {
+        for ( j = 0 ; j < 3 ; j++ )
+            rOrig[j] = vector3_dot( vector3_subtracted( Orig, txl_origin ), txl_matrix[j] ) + txl_origin[j];
+        for ( j = 0 ; j < 3 ; j++ )
+            rvecS[j] = vector3_dot( vector3_subtracted( texS, txl_origin ), txl_matrix[j] ) + txl_origin[j];
+        for ( j = 0 ; j < 3 ; j++ )
+            rvecT[j] = vector3_dot( vector3_subtracted( texT, txl_origin ), txl_matrix[j] ) + txl_origin[j];
+        // we also need the axis base of the target plane, apply the transformation matrix to the normal too..
+        for ( j = 0 ; j < 3 ; j++ )
+            rNormal[j] = vector3_dot( f->plane.normal, txl_matrix[j] );
+    }
+
+    // compute rotated plane axis base
+    ComputeAxisBase( rNormal, rtexS, rtexT );
+    // compute S/T coordinates of the three points in rotated axis base ( in M matrix )
+    lOrig[0] = vector3_dot( rOrig, rtexS );
+    lOrig[1] = vector3_dot( rOrig, rtexT );
+    lvecS[0] = vector3_dot( rvecS, rtexS );
+    lvecS[1] = vector3_dot( rvecS, rtexT );
+    lvecT[0] = vector3_dot( rvecT, rtexS );
+    lvecT[1] = vector3_dot( rvecT, rtexT );
+    M[0][0] = lOrig[0]; M[1][0] = lOrig[1]; M[2][0] = 1.0f;
+    M[0][1] = lvecS[0]; M[1][1] = lvecS[1]; M[2][1] = 1.0f;
+    M[0][2] = lvecT[0]; M[1][2] = lvecT[1]; M[2][2] = 1.0f;
+    // fill data vector
+    D[0][0] = f->brushprimit_texdef.coords[0][2];
+    D[0][1] = f->brushprimit_texdef.coords[0][0] + f->brushprimit_texdef.coords[0][2];
+    D[0][2] = f->brushprimit_texdef.coords[0][1] + f->brushprimit_texdef.coords[0][2];
+    D[1][0] = f->brushprimit_texdef.coords[1][2];
+    D[1][1] = f->brushprimit_texdef.coords[1][0] + f->brushprimit_texdef.coords[1][2];
+    D[1][2] = f->brushprimit_texdef.coords[1][1] + f->brushprimit_texdef.coords[1][2];
+    // solve
+    det = SarrusDet( M[0], M[1], M[2] );
+    f->brushprimit_texdef.coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
+    f->brushprimit_texdef.coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
+    f->brushprimit_texdef.coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
+    f->brushprimit_texdef.coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
+    f->brushprimit_texdef.coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
+    f->brushprimit_texdef.coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
 }
 
 // texture locking
 // called before the points on the face are actually rotated
 void RotateFaceTexture_BrushPrimit( face_t *f, int nAxis, float fDeg, Vector3& vOrigin ){
-	// this is a placeholder to call the general texture locking algorithm
-	txlock_bRotation = true;
-	txl_nAxis = nAxis;
-	txl_fDeg = fDeg;
-	VectorCopy( vOrigin, txl_vOrigin );
-	TextureLockTransformation_BrushPrimit( f );
+    // this is a placeholder to call the general texture locking algorithm
+    txlock_bRotation = true;
+    txl_nAxis = nAxis;
+    txl_fDeg = fDeg;
+    VectorCopy( vOrigin, txl_vOrigin );
+    TextureLockTransformation_BrushPrimit( f );
 }
 
 // compute the new brush primit texture matrix for a transformation matrix and a flip order flag (change plane orientation)
@@ -874,491 +894,508 @@ void RotateFaceTexture_BrushPrimit( face_t *f, int nAxis, float fDeg, Vector3& v
 // this needs to be called on the face BEFORE any geometric transformation
 // it will compute the texture matrix that will represent the same texture on the face after the geometric transformation is done
 void ApplyMatrix_BrushPrimit( face_t *f, Vector3 matrix[3], Vector3& origin ){
-	// this is a placeholder to call the general texture locking algorithm
-	txlock_bRotation = false;
-	VectorCopy( matrix[0], txl_matrix[0] );
-	VectorCopy( matrix[1], txl_matrix[1] );
-	VectorCopy( matrix[2], txl_matrix[2] );
-	VectorCopy( origin, txl_origin );
-	TextureLockTransformation_BrushPrimit( f );
+    // this is a placeholder to call the general texture locking algorithm
+    txlock_bRotation = false;
+    VectorCopy( matrix[0], txl_matrix[0] );
+    VectorCopy( matrix[1], txl_matrix[1] );
+    VectorCopy( matrix[2], txl_matrix[2] );
+    VectorCopy( origin, txl_origin );
+    TextureLockTransformation_BrushPrimit( f );
 }
 #endif
 
 // don't do C==A!
-void BPMatMul( float A[2][3], float B[2][3], float C[2][3] ){
-	C[0][0] = A[0][0] * B[0][0] + A[0][1] * B[1][0];
-	C[1][0] = A[1][0] * B[0][0] + A[1][1] * B[1][0];
-	C[0][1] = A[0][0] * B[0][1] + A[0][1] * B[1][1];
-	C[1][1] = A[1][0] * B[0][1] + A[1][1] * B[1][1];
-	C[0][2] = A[0][0] * B[0][2] + A[0][1] * B[1][2] + A[0][2];
-	C[1][2] = A[1][0] * B[0][2] + A[1][1] * B[1][2] + A[1][2];
-}
-
-void BPMatDump( float A[2][3] ){
-	globalOutputStream() << "" << A[0][0]
-						 << " " << A[0][1]
-						 << " " << A[0][2]
-						 << "\n" << A[1][0]
-						 << " " << A[1][2]
-						 << " " << A[1][2]
-						 << "\n0 0 1\n";
-}
-
-void BPMatRotate( float A[2][3], float theta ){
-	float m[2][3];
-	float aux[2][3];
-	memset( &m, 0, sizeof( float ) * 6 );
-	m[0][0] = static_cast<float>( cos( degrees_to_radians( theta ) ) );
-	m[0][1] = static_cast<float>( -sin( degrees_to_radians( theta ) ) );
-	m[1][0] = -m[0][1];
-	m[1][1] = m[0][0];
-	BPMatMul( A, m, aux );
-	BPMatCopy( aux,A );
+void BPMatMul(float A[2][3], float B[2][3], float C[2][3])
+{
+    C[0][0] = A[0][0] * B[0][0] + A[0][1] * B[1][0];
+    C[1][0] = A[1][0] * B[0][0] + A[1][1] * B[1][0];
+    C[0][1] = A[0][0] * B[0][1] + A[0][1] * B[1][1];
+    C[1][1] = A[1][0] * B[0][1] + A[1][1] * B[1][1];
+    C[0][2] = A[0][0] * B[0][2] + A[0][1] * B[1][2] + A[0][2];
+    C[1][2] = A[1][0] * B[0][2] + A[1][1] * B[1][2] + A[1][2];
+}
+
+void BPMatDump(float A[2][3])
+{
+    globalOutputStream() << "" << A[0][0]
+                         << " " << A[0][1]
+                         << " " << A[0][2]
+                         << "\n" << A[1][0]
+                         << " " << A[1][2]
+                         << " " << A[1][2]
+                         << "\n0 0 1\n";
+}
+
+void BPMatRotate(float A[2][3], float theta)
+{
+    float m[2][3];
+    float aux[2][3];
+    memset(&m, 0, sizeof(float) * 6);
+    m[0][0] = static_cast<float>( cos(degrees_to_radians(theta)));
+    m[0][1] = static_cast<float>( -sin(degrees_to_radians(theta)));
+    m[1][0] = -m[0][1];
+    m[1][1] = m[0][0];
+    BPMatMul(A, m, aux);
+    BPMatCopy(aux, A);
 }
 
 #if 0 // camera-relative texture shift
 // get the relative axes of the current texturing
 void BrushPrimit_GetRelativeAxes( face_t *f, Vector3& vecS, Vector3& vecT ){
-	float vS[2],vT[2];
-	// first we compute them as expressed in plane axis base
-	// BP matrix has coordinates of plane axis base expressed in geometric axis base
-	// so we use the line vectors
-	vS[0] = f->brushprimit_texdef.coords[0][0];
-	vS[1] = f->brushprimit_texdef.coords[0][1];
-	vT[0] = f->brushprimit_texdef.coords[1][0];
-	vT[1] = f->brushprimit_texdef.coords[1][1];
-	// now compute those vectors in geometric space
-	Vector3 texS, texT; // axis base of the plane (geometric)
-	ComputeAxisBase( f->plane.normal, texS, texT );
-	// vecS[] = vS[0].texS[] + vS[1].texT[]
-	// vecT[] = vT[0].texS[] + vT[1].texT[]
-	vecS[0] = vS[0] * texS[0] + vS[1] * texT[0];
-	vecS[1] = vS[0] * texS[1] + vS[1] * texT[1];
-	vecS[2] = vS[0] * texS[2] + vS[1] * texT[2];
-	vecT[0] = vT[0] * texS[0] + vT[1] * texT[0];
-	vecT[1] = vT[0] * texS[1] + vT[1] * texT[1];
-	vecT[2] = vT[0] * texS[2] + vT[1] * texT[2];
+    float vS[2],vT[2];
+    // first we compute them as expressed in plane axis base
+    // BP matrix has coordinates of plane axis base expressed in geometric axis base
+    // so we use the line vectors
+    vS[0] = f->brushprimit_texdef.coords[0][0];
+    vS[1] = f->brushprimit_texdef.coords[0][1];
+    vT[0] = f->brushprimit_texdef.coords[1][0];
+    vT[1] = f->brushprimit_texdef.coords[1][1];
+    // now compute those vectors in geometric space
+    Vector3 texS, texT; // axis base of the plane (geometric)
+    ComputeAxisBase( f->plane.normal, texS, texT );
+    // vecS[] = vS[0].texS[] + vS[1].texT[]
+    // vecT[] = vT[0].texS[] + vT[1].texT[]
+    vecS[0] = vS[0] * texS[0] + vS[1] * texT[0];
+    vecS[1] = vS[0] * texS[1] + vS[1] * texT[1];
+    vecS[2] = vS[0] * texS[2] + vS[1] * texT[2];
+    vecT[0] = vT[0] * texS[0] + vT[1] * texT[0];
+    vecT[1] = vT[0] * texS[1] + vT[1] * texT[1];
+    vecT[2] = vT[0] * texS[2] + vT[1] * texT[2];
 }
 
 // brush primitive texture adjustments, use the camera view to map adjustments
 // ShiftTextureRelative_BrushPrimit ( s , t ) will shift relative to the texture
 void ShiftTextureRelative_Camera( face_t *f, int x, int y ){
-	Vector3 vecS, vecT;
-	float XY[2]; // the values we are going to send for translation
-	float sgn[2]; // +1 or -1
-	int axis[2];
-	CamWnd* pCam;
-
-	// get the two relative texture axes for the current texturing
-	BrushPrimit_GetRelativeAxes( f, vecS, vecT );
-
-	// center point of the face, project it on the camera space
-	Vector3 C;
-	VectorClear( C );
-	int i;
-	for ( i = 0; i < f->face_winding->numpoints; i++ )
-	{
-		VectorAdd( C,f->face_winding->point_at( i ),C );
-	}
-	VectorScale( C,1.0 / f->face_winding->numpoints,C );
-
-	pCam = g_pParentWnd->GetCamWnd();
-	pCam->MatchViewAxes( C, vecS, axis[0], sgn[0] );
-	pCam->MatchViewAxes( C, vecT, axis[1], sgn[1] );
-
-	// this happens when the two directions can't be mapped on two different directions on the screen
-	// then the move will occur against a single axis
-	// (i.e. the user is not positioned well enough to send understandable shift commands)
-	// NOTE: in most cases this warning is not very relevant because the user would use one of the two axes
-	// for which the solution is easy (the other one being unknown)
-	// so this warning could be removed
-	if ( axis[0] == axis[1] ) {
-		globalOutputStream() << "Warning: degenerate in ShiftTextureRelative_Camera\n";
-	}
-
-	// compute the X Y geometric increments
-	// those geometric increments will be applied along the texture axes (the ones we computed above)
-	XY[0] = 0;
-	XY[1] = 0;
-	if ( x != 0 ) {
-		// moving right/left
-		XY[axis[0]] += sgn[0] * x;
-	}
-	if ( y != 0 ) {
-		XY[axis[1]] += sgn[1] * y;
-	}
-	// we worked out a move along vecS vecT, and we now it's geometric amplitude
-	// apply it
-	ShiftTextureRelative_BrushPrimit( f, XY[0], XY[1] );
+    Vector3 vecS, vecT;
+    float XY[2]; // the values we are going to send for translation
+    float sgn[2]; // +1 or -1
+    int axis[2];
+    CamWnd* pCam;
+
+    // get the two relative texture axes for the current texturing
+    BrushPrimit_GetRelativeAxes( f, vecS, vecT );
+
+    // center point of the face, project it on the camera space
+    Vector3 C;
+    VectorClear( C );
+    int i;
+    for ( i = 0; i < f->face_winding->numpoints; i++ )
+    {
+        VectorAdd( C,f->face_winding->point_at( i ),C );
+    }
+    VectorScale( C,1.0 / f->face_winding->numpoints,C );
+
+    pCam = g_pParentWnd->GetCamWnd();
+    pCam->MatchViewAxes( C, vecS, axis[0], sgn[0] );
+    pCam->MatchViewAxes( C, vecT, axis[1], sgn[1] );
+
+    // this happens when the two directions can't be mapped on two different directions on the screen
+    // then the move will occur against a single axis
+    // (i.e. the user is not positioned well enough to send understandable shift commands)
+    // NOTE: in most cases this warning is not very relevant because the user would use one of the two axes
+    // for which the solution is easy (the other one being unknown)
+    // so this warning could be removed
+    if ( axis[0] == axis[1] ) {
+        globalOutputStream() << "Warning: degenerate in ShiftTextureRelative_Camera\n";
+    }
+
+    // compute the X Y geometric increments
+    // those geometric increments will be applied along the texture axes (the ones we computed above)
+    XY[0] = 0;
+    XY[1] = 0;
+    if ( x != 0 ) {
+        // moving right/left
+        XY[axis[0]] += sgn[0] * x;
+    }
+    if ( y != 0 ) {
+        XY[axis[1]] += sgn[1] * y;
+    }
+    // we worked out a move along vecS vecT, and we now it's geometric amplitude
+    // apply it
+    ShiftTextureRelative_BrushPrimit( f, XY[0], XY[1] );
 }
 #endif
 
 
-void BPTexdef_Assign( brushprimit_texdef_t& bp_td, const brushprimit_texdef_t& bp_other ){
-	bp_td = bp_other;
-}
-
-void BPTexdef_Shift( brushprimit_texdef_t& bp_td, float s, float t ){
-	// shift a texture (texture adjustments) along it's current texture axes
-	// x and y are geometric values, which we must compute as ST increments
-	// this depends on the texture size and the pixel/texel ratio
-	// as a ratio against texture size
-	// the scale of the texture is not relevant here (we work directly on a transformation from the base vectors)
-	bp_td.coords[0][2] -= s;
-	bp_td.coords[1][2] += t;
-}
-
-void BPTexdef_Scale( brushprimit_texdef_t& bp_td, float s, float t ){
-	// apply same scale as the spinner button of the surface inspector
-	texdef_t texdef;
-	// compute fake shift scale rot
-	TexMatToFakeTexCoords( bp_td, texdef );
-	// update
-	texdef.scale[0] += s;
-	texdef.scale[1] += t;
-	// compute new normalized texture matrix
-	FakeTexCoordsToTexMat( texdef, bp_td );
-}
-
-void BPTexdef_Rotate( brushprimit_texdef_t& bp_td, float angle ){
-	// apply same scale as the spinner button of the surface inspector
-	texdef_t texdef;
-	// compute fake shift scale rot
-	TexMatToFakeTexCoords( bp_td, texdef );
-	// update
-	texdef.rotate += angle;
-	// compute new normalized texture matrix
-	FakeTexCoordsToTexMat( texdef, bp_td );
-}
-
-void BPTexdef_Construct( brushprimit_texdef_t& bp_td, std::size_t width, std::size_t height ){
-	bp_td.coords[0][0] = 1.0f;
-	bp_td.coords[1][1] = 1.0f;
-	ConvertTexMatWithDimensions( bp_td.coords, 2, 2, bp_td.coords, width, height );
-}
-
-void Texdef_Assign( TextureProjection& projection, const TextureProjection& other ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		BPTexdef_Assign( projection.m_brushprimit_texdef, other.m_brushprimit_texdef );
-	}
-	else
-	{
-		Texdef_Assign( projection.m_texdef, other.m_texdef );
-		if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE ) {
-			projection.m_basis_s = other.m_basis_s;
-			projection.m_basis_t = other.m_basis_t;
-		}
-	}
-}
-
-void Texdef_Shift( TextureProjection& projection, float s, float t ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		BPTexdef_Shift( projection.m_brushprimit_texdef, s, t );
-	}
-	else
-	{
-		Texdef_Shift( projection.m_texdef, s, t );
-	}
-}
-
-void Texdef_Scale( TextureProjection& projection, float s, float t ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		BPTexdef_Scale( projection.m_brushprimit_texdef, s, t );
-	}
-	else
-	{
-		Texdef_Scale( projection.m_texdef, s, t );
-	}
-}
-
-void Texdef_Rotate( TextureProjection& projection, float angle ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		BPTexdef_Rotate( projection.m_brushprimit_texdef, angle );
-	}
-	else
-	{
-		Texdef_Rotate( projection.m_texdef, angle );
-	}
-}
-
-void Texdef_FitTexture( TextureProjection& projection, std::size_t width, std::size_t height, const Vector3& normal, const Winding& w, float s_repeat, float t_repeat ){
-	if ( w.numpoints < 3 ) {
-		return;
-	}
-
-	Matrix4 st2tex;
-	Texdef_toTransform( projection, (float)width, (float)height, st2tex );
-
-	// the current texture transform
-	Matrix4 local2tex = st2tex;
-	{
-		Matrix4 xyz2st;
-		Texdef_basisForNormal( projection, normal, xyz2st );
-		matrix4_multiply_by_matrix4( local2tex, xyz2st );
-	}
-
-	// the bounds of the current texture transform
-	AABB bounds;
-	for ( Winding::const_iterator i = w.begin(); i != w.end(); ++i )
-	{
-		Vector3 texcoord = matrix4_transformed_point( local2tex, ( *i ).vertex );
-		aabb_extend_by_point_safe( bounds, texcoord );
-	}
-	bounds.origin.z() = 0;
-	bounds.extents.z() = 1;
-
-	// the bounds of a perfectly fitted texture transform
-	AABB perfect( Vector3( s_repeat * 0.5, t_repeat * 0.5, 0 ), Vector3( s_repeat * 0.5, t_repeat * 0.5, 1 ) );
-
-	// the difference between the current texture transform and the perfectly fitted transform
-	Matrix4 matrix( matrix4_translation_for_vec3( bounds.origin - perfect.origin ) );
-	matrix4_pivoted_scale_by_vec3( matrix, bounds.extents / perfect.extents, perfect.origin );
-	matrix4_affine_invert( matrix );
-
-	// apply the difference to the current texture transform
-	matrix4_premultiply_by_matrix4( st2tex, matrix );
+void BPTexdef_Assign(brushprimit_texdef_t &bp_td, const brushprimit_texdef_t &bp_other)
+{
+    bp_td = bp_other;
+}
+
+void BPTexdef_Shift(brushprimit_texdef_t &bp_td, float s, float t)
+{
+    // shift a texture (texture adjustments) along it's current texture axes
+    // x and y are geometric values, which we must compute as ST increments
+    // this depends on the texture size and the pixel/texel ratio
+    // as a ratio against texture size
+    // the scale of the texture is not relevant here (we work directly on a transformation from the base vectors)
+    bp_td.coords[0][2] -= s;
+    bp_td.coords[1][2] += t;
+}
+
+void BPTexdef_Scale(brushprimit_texdef_t &bp_td, float s, float t)
+{
+    // apply same scale as the spinner button of the surface inspector
+    texdef_t texdef;
+    // compute fake shift scale rot
+    TexMatToFakeTexCoords(bp_td, texdef);
+    // update
+    texdef.scale[0] += s;
+    texdef.scale[1] += t;
+    // compute new normalized texture matrix
+    FakeTexCoordsToTexMat(texdef, bp_td);
+}
+
+void BPTexdef_Rotate(brushprimit_texdef_t &bp_td, float angle)
+{
+    // apply same scale as the spinner button of the surface inspector
+    texdef_t texdef;
+    // compute fake shift scale rot
+    TexMatToFakeTexCoords(bp_td, texdef);
+    // update
+    texdef.rotate += angle;
+    // compute new normalized texture matrix
+    FakeTexCoordsToTexMat(texdef, bp_td);
+}
+
+void BPTexdef_Construct(brushprimit_texdef_t &bp_td, std::size_t width, std::size_t height)
+{
+    bp_td.coords[0][0] = 1.0f;
+    bp_td.coords[1][1] = 1.0f;
+    ConvertTexMatWithDimensions(bp_td.coords, 2, 2, bp_td.coords, width, height);
+}
+
+void Texdef_Assign(TextureProjection &projection, const TextureProjection &other)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        BPTexdef_Assign(projection.m_brushprimit_texdef, other.m_brushprimit_texdef);
+    } else {
+        Texdef_Assign(projection.m_texdef, other.m_texdef);
+        if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE) {
+            projection.m_basis_s = other.m_basis_s;
+            projection.m_basis_t = other.m_basis_t;
+        }
+    }
+}
+
+void Texdef_Shift(TextureProjection &projection, float s, float t)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        BPTexdef_Shift(projection.m_brushprimit_texdef, s, t);
+    } else {
+        Texdef_Shift(projection.m_texdef, s, t);
+    }
+}
+
+void Texdef_Scale(TextureProjection &projection, float s, float t)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        BPTexdef_Scale(projection.m_brushprimit_texdef, s, t);
+    } else {
+        Texdef_Scale(projection.m_texdef, s, t);
+    }
+}
+
+void Texdef_Rotate(TextureProjection &projection, float angle)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        BPTexdef_Rotate(projection.m_brushprimit_texdef, angle);
+    } else {
+        Texdef_Rotate(projection.m_texdef, angle);
+    }
+}
+
+void Texdef_FitTexture(TextureProjection &projection, std::size_t width, std::size_t height, const Vector3 &normal,
+                       const Winding &w, float s_repeat, float t_repeat)
+{
+    if (w.numpoints < 3) {
+        return;
+    }
+
+    Matrix4 st2tex;
+    Texdef_toTransform(projection, (float) width, (float) height, st2tex);
+
+    // the current texture transform
+    Matrix4 local2tex = st2tex;
+    {
+        Matrix4 xyz2st;
+        Texdef_basisForNormal(projection, normal, xyz2st);
+        matrix4_multiply_by_matrix4(local2tex, xyz2st);
+    }
+
+    // the bounds of the current texture transform
+    AABB bounds;
+    for (Winding::const_iterator i = w.begin(); i != w.end(); ++i) {
+        Vector3 texcoord = matrix4_transformed_point(local2tex, (*i).vertex);
+        aabb_extend_by_point_safe(bounds, texcoord);
+    }
+    bounds.origin.z() = 0;
+    bounds.extents.z() = 1;
+
+    // the bounds of a perfectly fitted texture transform
+    AABB perfect(Vector3(s_repeat * 0.5, t_repeat * 0.5, 0), Vector3(s_repeat * 0.5, t_repeat * 0.5, 1));
+
+    // the difference between the current texture transform and the perfectly fitted transform
+    Matrix4 matrix(matrix4_translation_for_vec3(bounds.origin - perfect.origin));
+    matrix4_pivoted_scale_by_vec3(matrix, bounds.extents / perfect.extents, perfect.origin);
+    matrix4_affine_invert(matrix);
 
-	Texdef_fromTransform( projection, (float)width, (float)height, st2tex );
-	Texdef_normalise( projection, (float)width, (float)height );
-}
-
-float Texdef_getDefaultTextureScale(){
-	return g_texdef_default_scale;
-}
-
-void TexDef_Construct_Default( TextureProjection& projection ){
-	projection.m_texdef.scale[0] = Texdef_getDefaultTextureScale();
-	projection.m_texdef.scale[1] = Texdef_getDefaultTextureScale();
+    // apply the difference to the current texture transform
+    matrix4_premultiply_by_matrix4(st2tex, matrix);
+
+    Texdef_fromTransform(projection, (float) width, (float) height, st2tex);
+    Texdef_normalise(projection, (float) width, (float) height);
+}
+
+float Texdef_getDefaultTextureScale()
+{
+    return g_texdef_default_scale;
+}
+
+void TexDef_Construct_Default(TextureProjection &projection)
+{
+    projection.m_texdef.scale[0] = Texdef_getDefaultTextureScale();
+    projection.m_texdef.scale[1] = Texdef_getDefaultTextureScale();
+
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        FakeTexCoordsToTexMat(projection.m_texdef, projection.m_brushprimit_texdef);
+    }
+}
+
+
+void ShiftScaleRotate_fromFace(texdef_t &shiftScaleRotate, const TextureProjection &projection)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        TexMatToFakeTexCoords(projection.m_brushprimit_texdef, shiftScaleRotate);
+    } else {
+        shiftScaleRotate = projection.m_texdef;
+    }
+}
+
+void ShiftScaleRotate_toFace(const texdef_t &shiftScaleRotate, TextureProjection &projection)
+{
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES) {
+        // compute texture matrix
+        // the matrix returned must be understood as a qtexture_t with width=2 height=2
+        FakeTexCoordsToTexMat(shiftScaleRotate, projection.m_brushprimit_texdef);
+    } else {
+        projection.m_texdef = shiftScaleRotate;
+    }
+}
 
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		FakeTexCoordsToTexMat( projection.m_texdef, projection.m_brushprimit_texdef );
-	}
-}
 
-
-
-void ShiftScaleRotate_fromFace( texdef_t& shiftScaleRotate, const TextureProjection& projection ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		TexMatToFakeTexCoords( projection.m_brushprimit_texdef, shiftScaleRotate );
-	}
-	else
-	{
-		shiftScaleRotate = projection.m_texdef;
-	}
-}
-
-void ShiftScaleRotate_toFace( const texdef_t& shiftScaleRotate, TextureProjection& projection ){
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
-		// compute texture matrix
-		// the matrix returned must be understood as a qtexture_t with width=2 height=2
-		FakeTexCoordsToTexMat( shiftScaleRotate, projection.m_brushprimit_texdef );
-	}
-	else
-	{
-		projection.m_texdef = shiftScaleRotate;
-	}
-}
-
-
-inline void print_vector3( const Vector3& v ){
-	globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )\n";
+inline void print_vector3(const Vector3 &v)
+{
+    globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )\n";
+}
+
+inline void print_3x3(const Matrix4 &m)
+{
+    globalOutputStream() << "( " << m.xx() << " " << m.xy() << " " << m.xz() << " ) "
+                         << "( " << m.yx() << " " << m.yy() << " " << m.yz() << " ) "
+                         << "( " << m.zx() << " " << m.zy() << " " << m.zz() << " )\n";
 }
 
-inline void print_3x3( const Matrix4& m ){
-	globalOutputStream() << "( " << m.xx() << " " << m.xy() << " " << m.xz() << " ) "
-						 << "( " << m.yx() << " " << m.yy() << " " << m.yz() << " ) "
-						 << "( " << m.zx() << " " << m.zy() << " " << m.zz() << " )\n";
-}
 
+inline Matrix4 matrix4_rotation_for_vector3(const Vector3 &x, const Vector3 &y, const Vector3 &z)
+{
+    return Matrix4(
+            x.x(), x.y(), x.z(), 0,
+            y.x(), y.y(), y.z(), 0,
+            z.x(), z.y(), z.z(), 0,
+            0, 0, 0, 1
+    );
+}
+
+inline Matrix4 matrix4_swap_axes(const Vector3 &from, const Vector3 &to)
+{
+    if (from.x() != 0 && to.y() != 0) {
+        return matrix4_rotation_for_vector3(to, from, g_vector3_axis_z);
+    }
+
+    if (from.x() != 0 && to.z() != 0) {
+        return matrix4_rotation_for_vector3(to, g_vector3_axis_y, from);
+    }
 
-inline Matrix4 matrix4_rotation_for_vector3( const Vector3& x, const Vector3& y, const Vector3& z ){
-	return Matrix4(
-			   x.x(), x.y(), x.z(), 0,
-			   y.x(), y.y(), y.z(), 0,
-			   z.x(), z.y(), z.z(), 0,
-			   0, 0, 0, 1
-			   );
-}
+    if (from.y() != 0 && to.z() != 0) {
+        return matrix4_rotation_for_vector3(g_vector3_axis_x, to, from);
+    }
 
-inline Matrix4 matrix4_swap_axes( const Vector3& from, const Vector3& to ){
-	if ( from.x() != 0 && to.y() != 0 ) {
-		return matrix4_rotation_for_vector3( to, from, g_vector3_axis_z );
-	}
+    if (from.y() != 0 && to.x() != 0) {
+        return matrix4_rotation_for_vector3(from, to, g_vector3_axis_z);
+    }
 
-	if ( from.x() != 0 && to.z() != 0 ) {
-		return matrix4_rotation_for_vector3( to, g_vector3_axis_y, from );
-	}
+    if (from.z() != 0 && to.x() != 0) {
+        return matrix4_rotation_for_vector3(from, g_vector3_axis_y, to);
+    }
 
-	if ( from.y() != 0 && to.z() != 0 ) {
-		return matrix4_rotation_for_vector3( g_vector3_axis_x, to, from );
-	}
+    if (from.z() != 0 && to.y() != 0) {
+        return matrix4_rotation_for_vector3(g_vector3_axis_x, from, to);
+    }
 
-	if ( from.y() != 0 && to.x() != 0 ) {
-		return matrix4_rotation_for_vector3( from, to, g_vector3_axis_z );
-	}
+    ERROR_MESSAGE("unhandled axis swap case");
 
-	if ( from.z() != 0 && to.x() != 0 ) {
-		return matrix4_rotation_for_vector3( from, g_vector3_axis_y, to );
-	}
-
-	if ( from.z() != 0 && to.y() != 0 ) {
-		return matrix4_rotation_for_vector3( g_vector3_axis_x, from, to );
-	}
-
-	ERROR_MESSAGE( "unhandled axis swap case" );
-
-	return g_matrix4_identity;
+    return g_matrix4_identity;
 }
 
-inline Matrix4 matrix4_reflection_for_plane( const Plane3& plane ){
-	return Matrix4(
-			   static_cast<float>( 1 - ( 2 * plane.a * plane.a ) ),
-			   static_cast<float>( -2 * plane.a * plane.b ),
-			   static_cast<float>( -2 * plane.a * plane.c ),
-			   0,
-			   static_cast<float>( -2 * plane.b * plane.a ),
-			   static_cast<float>( 1 - ( 2 * plane.b * plane.b ) ),
-			   static_cast<float>( -2 * plane.b * plane.c ),
-			   0,
-			   static_cast<float>( -2 * plane.c * plane.a ),
-			   static_cast<float>( -2 * plane.c * plane.b ),
-			   static_cast<float>( 1 - ( 2 * plane.c * plane.c ) ),
-			   0,
-			   static_cast<float>( -2 * plane.d * plane.a ),
-			   static_cast<float>( -2 * plane.d * plane.b ),
-			   static_cast<float>( -2 * plane.d * plane.c ),
-			   1
-			   );
+inline Matrix4 matrix4_reflection_for_plane(const Plane3 &plane)
+{
+    return Matrix4(
+            static_cast<float>( 1 - (2 * plane.a * plane.a)),
+            static_cast<float>( -2 * plane.a * plane.b ),
+            static_cast<float>( -2 * plane.a * plane.c ),
+            0,
+            static_cast<float>( -2 * plane.b * plane.a ),
+            static_cast<float>( 1 - (2 * plane.b * plane.b)),
+            static_cast<float>( -2 * plane.b * plane.c ),
+            0,
+            static_cast<float>( -2 * plane.c * plane.a ),
+            static_cast<float>( -2 * plane.c * plane.b ),
+            static_cast<float>( 1 - (2 * plane.c * plane.c)),
+            0,
+            static_cast<float>( -2 * plane.d * plane.a ),
+            static_cast<float>( -2 * plane.d * plane.b ),
+            static_cast<float>( -2 * plane.d * plane.c ),
+            1
+    );
 }
 
-inline Matrix4 matrix4_reflection_for_plane45( const Plane3& plane, const Vector3& from, const Vector3& to ){
-	Vector3 first = from;
-	Vector3 second = to;
-
-	if ( vector3_dot( from, plane.normal() ) > 0 == vector3_dot( to, plane.normal() ) > 0 ) {
-		first = vector3_negated( first );
-		second = vector3_negated( second );
-	}
+inline Matrix4 matrix4_reflection_for_plane45(const Plane3 &plane, const Vector3 &from, const Vector3 &to)
+{
+    Vector3 first = from;
+    Vector3 second = to;
+
+    if ((vector3_dot(from, plane.normal()) > 0) == (vector3_dot(to, plane.normal()) > 0)) {
+        first = vector3_negated(first);
+        second = vector3_negated(second);
+    }
 
 #if 0
-	globalOutputStream() << "normal: ";
-	print_vector3( plane.normal() );
+    globalOutputStream() << "normal: ";
+    print_vector3( plane.normal() );
 
-	globalOutputStream() << "from: ";
-	print_vector3( first );
+    globalOutputStream() << "from: ";
+    print_vector3( first );
 
-	globalOutputStream() << "to: ";
-	print_vector3( second );
+    globalOutputStream() << "to: ";
+    print_vector3( second );
 #endif
 
-	Matrix4 swap = matrix4_swap_axes( first, second );
+    Matrix4 swap = matrix4_swap_axes(first, second);
 
-	Matrix4 tmp = matrix4_reflection_for_plane( plane );
+    swap.tx() = -static_cast<float>( -2 * plane.a * plane.d );
+    swap.ty() = -static_cast<float>( -2 * plane.b * plane.d );
+    swap.tz() = -static_cast<float>( -2 * plane.c * plane.d );
 
-	swap.tx() = -static_cast<float>( -2 * plane.a * plane.d );
-	swap.ty() = -static_cast<float>( -2 * plane.b * plane.d );
-	swap.tz() = -static_cast<float>( -2 * plane.c * plane.d );
-
-	return swap;
+    return swap;
 }
 
-void Texdef_transformLocked( TextureProjection& projection, std::size_t width, std::size_t height, const Plane3& plane, const Matrix4& identity2transformed ){
-	//globalOutputStream() << "identity2transformed: " << identity2transformed << "\n";
+void Texdef_transformLocked(TextureProjection &projection, std::size_t width, std::size_t height, const Plane3 &plane,
+                            const Matrix4 &identity2transformed)
+{
+    //globalOutputStream() << "identity2transformed: " << identity2transformed << "\n";
 
-	//globalOutputStream() << "plane.normal(): " << plane.normal() << "\n";
+    //globalOutputStream() << "plane.normal(): " << plane.normal() << "\n";
 
-	Vector3 normalTransformed( matrix4_transformed_direction( identity2transformed, plane.normal() ) );
+    Vector3 normalTransformed(matrix4_transformed_direction(identity2transformed, plane.normal()));
 
-	//globalOutputStream() << "normalTransformed: " << normalTransformed << "\n";
+    //globalOutputStream() << "normalTransformed: " << normalTransformed << "\n";
 
-	// identity: identity space
-	// transformed: transformation
-	// stIdentity: base st projection space before transformation
-	// stTransformed: base st projection space after transformation
-	// stOriginal: original texdef space
+    // identity: identity space
+    // transformed: transformation
+    // stIdentity: base st projection space before transformation
+    // stTransformed: base st projection space after transformation
+    // stOriginal: original texdef space
 
-	// stTransformed2stOriginal = stTransformed -> transformed -> identity -> stIdentity -> stOriginal
+    // stTransformed2stOriginal = stTransformed -> transformed -> identity -> stIdentity -> stOriginal
 
-	Matrix4 identity2stIdentity;
-	Texdef_basisForNormal( projection, plane.normal(), identity2stIdentity );
-	//globalOutputStream() << "identity2stIdentity: " << identity2stIdentity << "\n";
+    Matrix4 identity2stIdentity;
+    Texdef_basisForNormal(projection, plane.normal(), identity2stIdentity);
+    //globalOutputStream() << "identity2stIdentity: " << identity2stIdentity << "\n";
 
-	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE ) {
-		matrix4_transform_direction( identity2transformed, projection.m_basis_s );
-		matrix4_transform_direction( identity2transformed, projection.m_basis_t );
-	}
+    if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE) {
+        matrix4_transform_direction(identity2transformed, projection.m_basis_s);
+        matrix4_transform_direction(identity2transformed, projection.m_basis_t);
+    }
 
-	Matrix4 transformed2stTransformed;
-	Texdef_basisForNormal( projection, normalTransformed, transformed2stTransformed );
+    Matrix4 transformed2stTransformed;
+    Texdef_basisForNormal(projection, normalTransformed, transformed2stTransformed);
 
-	Matrix4 stTransformed2identity( matrix4_affine_inverse( matrix4_multiplied_by_matrix4( transformed2stTransformed, identity2transformed ) ) );
+    Matrix4 stTransformed2identity(
+            matrix4_affine_inverse(matrix4_multiplied_by_matrix4(transformed2stTransformed, identity2transformed)));
 
-	Vector3 originalProjectionAxis( vector4_to_vector3( matrix4_affine_inverse( identity2stIdentity ).z() ) );
+    Vector3 originalProjectionAxis(vector4_to_vector3(matrix4_affine_inverse(identity2stIdentity).z()));
 
-	Vector3 transformedProjectionAxis( vector4_to_vector3( stTransformed2identity.z() ) );
+    Vector3 transformedProjectionAxis(vector4_to_vector3(stTransformed2identity.z()));
 
-	Matrix4 stIdentity2stOriginal;
-	Texdef_toTransform( projection, (float)width, (float)height, stIdentity2stOriginal );
-	Matrix4 identity2stOriginal( matrix4_multiplied_by_matrix4( stIdentity2stOriginal, identity2stIdentity ) );
+    Matrix4 stIdentity2stOriginal;
+    Texdef_toTransform(projection, (float) width, (float) height, stIdentity2stOriginal);
+    Matrix4 identity2stOriginal(matrix4_multiplied_by_matrix4(stIdentity2stOriginal, identity2stIdentity));
 
-	//globalOutputStream() << "originalProj: " << originalProjectionAxis << "\n";
-	//globalOutputStream() << "transformedProj: " << transformedProjectionAxis << "\n";
-	double dot = vector3_dot( originalProjectionAxis, transformedProjectionAxis );
-	//globalOutputStream() << "dot: " << dot << "\n";
-	if ( dot == 0 ) {
-		// The projection axis chosen for the transformed normal is at 90 degrees
-		// to the transformed projection axis chosen for the original normal.
-		// This happens when the projection axis is ambiguous - e.g. for the plane
-		// 'X == Y' the projection axis could be either X or Y.
-		//globalOutputStream() << "flipped\n";
+    //globalOutputStream() << "originalProj: " << originalProjectionAxis << "\n";
+    //globalOutputStream() << "transformedProj: " << transformedProjectionAxis << "\n";
+    double dot = vector3_dot(originalProjectionAxis, transformedProjectionAxis);
+    //globalOutputStream() << "dot: " << dot << "\n";
+    if (dot == 0) {
+        // The projection axis chosen for the transformed normal is at 90 degrees
+        // to the transformed projection axis chosen for the original normal.
+        // This happens when the projection axis is ambiguous - e.g. for the plane
+        // 'X == Y' the projection axis could be either X or Y.
+        //globalOutputStream() << "flipped\n";
 #if 0
-		globalOutputStream() << "projection off by 90\n";
-		globalOutputStream() << "normal: ";
-		print_vector3( plane.normal() );
-		globalOutputStream() << "original projection: ";
-		print_vector3( originalProjectionAxis );
-		globalOutputStream() << "transformed projection: ";
-		print_vector3( transformedProjectionAxis );
+        globalOutputStream() << "projection off by 90\n";
+        globalOutputStream() << "normal: ";
+        print_vector3( plane.normal() );
+        globalOutputStream() << "original projection: ";
+        print_vector3( originalProjectionAxis );
+        globalOutputStream() << "transformed projection: ";
+        print_vector3( transformedProjectionAxis );
 #endif
 
-		Matrix4 identityCorrected = matrix4_reflection_for_plane45( plane, originalProjectionAxis, transformedProjectionAxis );
+        Matrix4 identityCorrected = matrix4_reflection_for_plane45(plane, originalProjectionAxis,
+                                                                   transformedProjectionAxis);
 
-		identity2stOriginal = matrix4_multiplied_by_matrix4( identity2stOriginal, identityCorrected );
-	}
+        identity2stOriginal = matrix4_multiplied_by_matrix4(identity2stOriginal, identityCorrected);
+    }
 
-	Matrix4 stTransformed2stOriginal = matrix4_multiplied_by_matrix4( identity2stOriginal, stTransformed2identity );
+    Matrix4 stTransformed2stOriginal = matrix4_multiplied_by_matrix4(identity2stOriginal, stTransformed2identity);
 
-	Texdef_fromTransform( projection, (float)width, (float)height, stTransformed2stOriginal );
-	Texdef_normalise( projection, (float)width, (float)height );
+    Texdef_fromTransform(projection, (float) width, (float) height, stTransformed2stOriginal);
+    Texdef_normalise(projection, (float) width, (float) height);
 }
 
 #if 1
-void Q3_to_matrix( const texdef_t& texdef, float width, float height, const Vector3& normal, Matrix4& matrix ){
-	Normal_GetTransform( normal, matrix );
 
-	Matrix4 transform;
+void Q3_to_matrix(const texdef_t &texdef, float width, float height, const Vector3 &normal, Matrix4 &matrix)
+{
+    Normal_GetTransform(normal, matrix);
+
+    Matrix4 transform;
 
-	Texdef_toTransform( texdef, width, height, transform );
+    Texdef_toTransform(texdef, width, height, transform);
 
-	matrix4_multiply_by_matrix4( matrix, transform );
+    matrix4_multiply_by_matrix4(matrix, transform);
 }
 
-void BP_from_matrix( brushprimit_texdef_t& bp_texdef, const Vector3& normal, const Matrix4& transform ){
-	Matrix4 basis;
-	basis = g_matrix4_identity;
-	ComputeAxisBase( normal, vector4_to_vector3( basis.x() ), vector4_to_vector3( basis.y() ) );
-	vector4_to_vector3( basis.z() ) = normal;
-	matrix4_transpose( basis );
-	matrix4_affine_invert( basis );
+void BP_from_matrix(brushprimit_texdef_t &bp_texdef, const Vector3 &normal, const Matrix4 &transform)
+{
+    Matrix4 basis;
+    basis = g_matrix4_identity;
+    ComputeAxisBase(normal, vector4_to_vector3(basis.x()), vector4_to_vector3(basis.y()));
+    vector4_to_vector3(basis.z()) = normal;
+    matrix4_transpose(basis);
+    matrix4_affine_invert(basis);
 
-	Matrix4 basis2texture = matrix4_multiplied_by_matrix4( basis, transform );
+    Matrix4 basis2texture = matrix4_multiplied_by_matrix4(basis, transform);
 
-	BPTexdef_fromTransform( bp_texdef, basis2texture );
+    BPTexdef_fromTransform(bp_texdef, basis2texture);
 }
 
-void Q3_to_BP( const texdef_t& texdef, float width, float height, const Vector3& normal, brushprimit_texdef_t& bp_texdef ){
-	Matrix4 matrix;
-	Q3_to_matrix( texdef, width, height, normal, matrix );
-	BP_from_matrix( bp_texdef, normal, matrix );
+void Q3_to_BP(const texdef_t &texdef, float width, float height, const Vector3 &normal, brushprimit_texdef_t &bp_texdef)
+{
+    Matrix4 matrix;
+    Q3_to_matrix(texdef, width, height, normal, matrix);
+    BP_from_matrix(bp_texdef, normal, matrix);
 }
+
 #endif