Radiant:

misc...
	* new texture lock algorithm for BP map format, supporting any affine transformations
	* more robust texture lock algorithm for AP map format, locking what is possible to; also improves seamless face2face tex paste function

radiant/brush.h

@@ -369,7 +369,7 @@ SavedState( const FaceShader& faceShader ){
 
 void exportState( FaceShader& faceShader ) const {
 	faceShader.setShader( m_shader.c_str() );
-	//faceShader.setFlags( m_flags );
+	//faceShader.setFlags( m_flags ); //detail, structural flags aren't undoable with this
 	faceShader.m_flags = m_flags;
 }
 };
@@ -902,6 +902,7 @@ void exportState( Face& face ) const {
 	m_planeState.exportState( face.getPlane() );
 	m_shaderState.exportState( face.getShader() );
 	m_texdefState.exportState( face.getTexdef() );
+	face.centroid_saved_reset();
 }
 
 void release(){
@@ -924,6 +925,8 @@ TextureProjection m_texdefTransformed;
 
 Winding m_winding;
 Vector3 m_centroid;
+Vector3 m_centroid_saved; //this is far not pretty hack! (invariant point for texlock in AP)
+bool m_centroid_saved_reset; //fixme please :3
 bool m_filtered;
 
 FaceObserver* m_observer;
@@ -941,6 +944,7 @@ Face( FaceObserver* observer ) :
 	m_refcount( 0 ),
 	m_shader( texdef_name_default() ),
 	m_texdef( m_shader, TextureProjection(), false ),
+	m_centroid_saved_reset( true ),
 	m_filtered( false ),
 	m_observer( observer ),
 	m_undoable_observer( 0 ),
@@ -961,6 +965,7 @@ Face(
 	m_refcount( 0 ),
 	m_shader( shader ),
 	m_texdef( m_shader, projection ),
+	m_centroid_saved_reset( true ),
 	m_observer( observer ),
 	m_undoable_observer( 0 ),
 	m_map( 0 ){
@@ -974,6 +979,7 @@ Face( const Face& other, FaceObserver* observer ) :
 	m_refcount( 0 ),
 	m_shader( other.m_shader.getShader(), other.m_shader.m_flags ),
 	m_texdef( m_shader, other.getTexdef().normalised() ),
+	m_centroid_saved_reset( true ),
 	m_observer( observer ),
 	m_undoable_observer( 0 ),
 	m_map( 0 ){
@@ -1074,7 +1080,11 @@ void render( Renderer& renderer, const Matrix4& localToWorld ) const {
 
 void transform( const Matrix4& matrix, bool mirror ){
 	if ( g_brush_texturelock_enabled ) {
-		Texdef_transformLocked( m_texdefTransformed, m_shader.width(), m_shader.height(), m_plane.plane3(), matrix );
+		if( m_centroid_saved_reset ){
+			m_centroid_saved = m_centroid;
+			m_centroid_saved_reset = false;
+		}
+		Texdef_transformLocked( m_texdefTransformed, m_shader.width(), m_shader.height(), m_plane.plane3(), matrix, contributes() ? m_centroid_saved : static_cast<Vector3>( m_plane.plane3().normal() * m_plane.plane3().dist() ) );
 	}
 
 	m_planeTransformed.transform( matrix, mirror );
@@ -1105,6 +1115,8 @@ void freezeTransform(){
 	m_plane = m_planeTransformed;
 	planepts_assign( m_move_planepts, m_move_planeptsTransformed );
 	m_texdef.m_projection = m_texdefTransformed;
+
+	m_centroid_saved_reset = true;
 }
 
 void update_move_planepts_vertex( std::size_t index, PlanePoints planePoints ){
@@ -1258,6 +1270,10 @@ Winding& getWinding(){
 	return m_winding;
 }
 
+void centroid_saved_reset() {
+	m_centroid_saved_reset = true;
+}
+
 const Plane3& plane3() const {
 	m_observer->evaluateTransform();
 	return m_planeTransformed.plane3();

radiant/brush_primit.cpp

@@ -1447,25 +1447,291 @@ inline Matrix4 matrix4_reflection_for_plane45( const Plane3& plane, const Vector
 	return swap;
 }
 
-void Texdef_transformLocked( TextureProjection& projection, std::size_t width, std::size_t height, const Plane3& plane, const Matrix4& identity2transformed ){
+double Det3x3( double a00, double a01, double a02,
-	if( identity2transformed == g_matrix4_identity ) return; //TODO FIXME !!! this is called with g_matrix4_identity after every transform (and whole pipeline?)
+			  double a10, double a11, double a12,
+			  double a20, double a21, double a22 ){
+	return
+		a00 * ( a11 * a22 - a12 * a21 )
+		-   a01 * ( a10 * a22 - a12 * a20 )
+		+   a02 * ( a10 * a21 - a11 * a20 );
+}
+
+Vector3 plane3_project_point( const Plane3& plane, const Vector3& point, const Vector3& direction ){
+	const float f = vector3_dot( plane.normal(), direction );
+	const float d = ( vector3_dot( plane.normal() * plane.dist()- point, plane.normal() ) ) / f;
+	return point + direction * d;
+}
+
+Vector3 plane3_project_point( const Plane3& plane, const Vector3& point ){
+	return ( point - plane.normal() * vector3_dot( point, plane.normal() ) + plane.normal() * plane.dist() );
+}
+
+const Vector3 BaseAxes[] = {
+            Vector3( 0.0,  0.0,  1.0), Vector3( 1.0,  0.0,  0.0), Vector3( 0.0, -1.0,  0.0),
+            Vector3( 0.0,  0.0, -1.0), Vector3( 1.0,  0.0,  0.0), Vector3( 0.0, -1.0,  0.0),
+            Vector3( 1.0,  0.0,  0.0), Vector3( 0.0,  1.0,  0.0), Vector3( 0.0,  0.0, -1.0),
+            Vector3(-1.0,  0.0,  0.0), Vector3( 0.0,  1.0,  0.0), Vector3( 0.0,  0.0, -1.0),
+            Vector3( 0.0,  1.0,  0.0), Vector3( 1.0,  0.0,  0.0), Vector3( 0.0,  0.0, -1.0),
+            Vector3( 0.0, -1.0,  0.0), Vector3( 1.0,  0.0,  0.0), Vector3( 0.0,  0.0, -1.0),
+        };
+
+std::size_t planeNormalIndex( const Vector3& normal ) {
+	std::size_t bestIndex = 0;
+	float bestDot = 0.f;
+	for( std::size_t i = 0; i < 6; ++i ) {
+		const float dot = vector3_dot( normal, BaseAxes[i * 3] );
+		if( dot > bestDot ) { // no need to use -altaxis for qbsp, but -oldaxis is necessary
+			bestDot = dot;
+			bestIndex = i;
+		}
+	}
+	return bestIndex;
+}
+
+#include "math/quaternion.h"
+
+void Texdef_transformLocked( TextureProjection& projection, std::size_t width, std::size_t height, const Plane3& plane, const Matrix4& identity2transformed, const Vector3 centroid ){
+	if( identity2transformed == g_matrix4_identity ){
+		return; //TODO FIXME !!! this (and whole pipeline?) is called with g_matrix4_identity after every transform
+	}
+	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
+#if 1
+//			globalOutputStream() << "identity2transformed: " << identity2transformed << "\n";
+//			globalOutputStream() << "BP in: ( " << projection.m_brushprimit_texdef.coords[0][0] << " " << projection.m_brushprimit_texdef.coords[0][1] << " " << projection.m_brushprimit_texdef.coords[0][2] << " ) ( " << projection.m_brushprimit_texdef.coords[1][0] << " " << projection.m_brushprimit_texdef.coords[1][1] << " " << projection.m_brushprimit_texdef.coords[1][2] << " )\n";
+		DoubleVector3 texX, texY;
+		DoubleVector3 points[3];
+		DoubleVector3 st[3];
+
+		ComputeAxisBase( plane.normal(), texX, texY );
+		const DoubleVector3 anchor = plane.normal() * plane.dist();
+
+		points[0] = anchor;
+		points[1] = texX + anchor;
+		points[2] = texY + anchor;
+
+		Matrix4 local2tex;
+		Texdef_Construct_local2tex( projection, width, height, plane.normal(), local2tex );
+		for ( std::size_t i = 0; i < 3; ++i )
+		{
+			DoubleVector3 texcoord = matrix4_transformed_point( local2tex, points[i] );
+			st[i][0] = texcoord[0];
+			st[i][1] = texcoord[1];
+			matrix4_transform_point( identity2transformed, points[i] );
+		}
+
+
+		double xyI[2], xyJ[2], xyK[2];
+		double stI[2], stJ[2], stK[2];
+		double D, D0, D1, D2;
+
+		Matrix4 maa( matrix4_affine_inverse( identity2transformed ) );
+		matrix4_transpose( maa );
+		DoubleVector3 normalTransformed( vector3_normalised( matrix4_transformed_direction( maa, plane.normal() ) ) );
+
+		ComputeAxisBase( normalTransformed, texX, texY );
+
+		xyI[0] = vector3_dot( points[0], texX );
+		xyI[1] = vector3_dot( points[0], texY );
+		xyJ[0] = vector3_dot( points[1], texX );
+		xyJ[1] = vector3_dot( points[1], texY );
+		xyK[0] = vector3_dot( points[2], texX );
+		xyK[1] = vector3_dot( points[2], texY );
+		stI[0] = st[0][0]; stI[1] = st[0][1];
+		stJ[0] = st[1][0]; stJ[1] = st[1][1];
+		stK[0] = st[2][0]; stK[1] = st[2][1];
+
+		//   - solve linear equations:
+		//     - (x, y) := xyz . (texX, texY)
+		//     - st[i] = texMat[i][0]*x + texMat[i][1]*y + texMat[i][2]
+		//       (for three vertices)
+		D = Det3x3(
+			xyI[0], xyI[1], 1,
+			xyJ[0], xyJ[1], 1,
+			xyK[0], xyK[1], 1
+			);
+		if ( D != 0 ) {
+			for ( std::size_t i = 0; i < 2; ++i )
+			{
+				D0 = Det3x3(
+					stI[i], xyI[1], 1,
+					stJ[i], xyJ[1], 1,
+					stK[i], xyK[1], 1
+					);
+				D1 = Det3x3(
+					xyI[0], stI[i], 1,
+					xyJ[0], stJ[i], 1,
+					xyK[0], stK[i], 1
+					);
+				D2 = Det3x3(
+					xyI[0], xyI[1], stI[i],
+					xyJ[0], xyJ[1], stJ[i],
+					xyK[0], xyK[1], stK[i]
+					);
+				projection.m_brushprimit_texdef.coords[i][0] = D0 / D;
+				projection.m_brushprimit_texdef.coords[i][1] = D1 / D;
+				projection.m_brushprimit_texdef.coords[i][2] = fmod( D2 / D, 1 );
+			}
+//				globalOutputStream() << "BP out: ( " << projection.m_brushprimit_texdef.coords[0][0] << " " << projection.m_brushprimit_texdef.coords[0][1] << " " << projection.m_brushprimit_texdef.coords[0][2] << " ) ( " << projection.m_brushprimit_texdef.coords[1][0] << " " << projection.m_brushprimit_texdef.coords[1][1] << " " << projection.m_brushprimit_texdef.coords[1][2] << " )\n";
+		}
+#else
+			globalOutputStream() << "\t\t**********\n";
+			globalOutputStream() << "identity2transformed: " << identity2transformed << "\n";
+		Matrix4 maa( matrix4_affine_inverse( identity2transformed ) );
+		matrix4_transpose( maa );
+		Vector3 normalTransformed( vector3_normalised( matrix4_transformed_direction( maa, plane.normal() ) ) );
+
+
+		Matrix4 xyz2st;
+		Texdef_basisForNormal( projection, plane.normal(), xyz2st );
+			globalOutputStream() << "plane.normal() " << plane.normal() << "\n";
+			globalOutputStream() << "normalTransformed " << normalTransformed << "\n";
+			globalOutputStream() << "Texdef_basisForNormal " << xyz2st << "\n";
+		Matrix4 local2tex;
+		Texdef_toTransform( projection, (float)width, (float)height, local2tex );
+			globalOutputStream() << "BP: ( " << projection.m_brushprimit_texdef.coords[0][0] << " " << projection.m_brushprimit_texdef.coords[0][1] << " " << projection.m_brushprimit_texdef.coords[0][2] << " ) ( " << projection.m_brushprimit_texdef.coords[1][0] << " " << projection.m_brushprimit_texdef.coords[1][1] << " " << projection.m_brushprimit_texdef.coords[1][2] << " )\n";
+			globalOutputStream() << "Texdef_toTransform " << local2tex << "\n";
+		local2tex = matrix4_multiplied_by_matrix4( matrix4_transposed( xyz2st ), local2tex );
+			globalOutputStream() << "Texdef_toTransform rebased " << local2tex << "\n";
+		local2tex = matrix4_multiplied_by_matrix4( identity2transformed, local2tex );
+			globalOutputStream() << "Texdef_toTransform rebased transformed " << local2tex << "\n";
+		Texdef_basisForNormal( projection, normalTransformed, xyz2st );
+			globalOutputStream() << "NEW Texdef_basisForNormal " << xyz2st << "\n";
+		//local2tex = matrix4_multiplied_by_matrix4( matrix4_affine_inverse( xyz2st ), local2tex );
+		local2tex = matrix4_multiplied_by_matrix4( xyz2st, local2tex );
+			globalOutputStream() << "Texdef_toTransform rebased transformed back to basis" << local2tex << "\n";
+		Texdef_fromTransform( projection, (float)width, (float)height, local2tex );
+			globalOutputStream() << "BP NEW: ( " << projection.m_brushprimit_texdef.coords[0][0] << " " << projection.m_brushprimit_texdef.coords[0][1] << " " << projection.m_brushprimit_texdef.coords[0][2] << " ) ( " << projection.m_brushprimit_texdef.coords[1][0] << " " << projection.m_brushprimit_texdef.coords[1][1] << " " << projection.m_brushprimit_texdef.coords[1][2] << " )\n";
+#endif // 0
+	}
+	else if( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_QUAKE ) {
+//			globalOutputStream() << "\t\t***: " << centroid << "\n";
+//			globalOutputStream() << "identity2transformed: " << identity2transformed << "\n";
+//			globalOutputStream() << "AP: scale( " << projection.m_texdef.scale[0] << " " << projection.m_texdef.scale[1] << " ) shift( " << projection.m_texdef.shift[0] << " " << projection.m_texdef.shift[1] << " ) rotate: " << projection.m_texdef.rotate << "\n";
+		if( projection.m_texdef.scale[0] == 0.0f || projection.m_texdef.scale[1] == 0.0f ) {
+			return;
+		}
+
+		const Vector3 oldInvariant( centroid );
+		const Vector3 offset = matrix4_transformed_point( identity2transformed, Vector3( 0, 0, 0 ) );
+		#if 0//not ok, if scaling
+		Vector3 newNormal  = matrix4_transformed_point( identity2transformed, plane.normal() ) - offset;
+		#else
+		Matrix4 maa( matrix4_affine_inverse( identity2transformed ) );
+		matrix4_transpose( maa );
+		Vector3 newNormal( vector3_normalised( matrix4_transformed_direction( maa, plane.normal() ) ) );
+		#endif
+#if 0
+		// fix some rounding errors - if the old and new texture axes are almost the same, use the old axis
+		if( vector3_equal_epsilon( newNormal, plane.normal(), 0.01f ) ){
+			newNormal = plane.normal();
+		}
+#endif
+		// calculate the current texture coordinates of the origin
+		const std::size_t index = planeNormalIndex( plane.normal() );
+		Vector3 xAxis = BaseAxes[index * 3 + 1];
+		Vector3 yAxis = BaseAxes[index * 3 + 2];
+		Vector3 zAxis = BaseAxes[( index / 2 ) * 6];
+//			globalOutputStream() << xAxis << " " << yAxis << " " << zAxis << "\n";
+        Matrix4 rotmat = matrix4_rotation_for_axisangle( vector3_cross( yAxis, xAxis ), degrees_to_radians( projection.m_texdef.rotate ) );
+        matrix4_transform_direction( rotmat, xAxis );
+        matrix4_transform_direction( rotmat, yAxis );
+
+		const Vector2 oldInvariantTexCoords( vector3_dot( xAxis / projection.m_texdef.scale[0], oldInvariant ) + projection.m_texdef.shift[0],
+											vector3_dot( yAxis / projection.m_texdef.scale[1], oldInvariant ) + projection.m_texdef.shift[1] );
+//			globalOutputStream() << "oldInvariantTexCoords: " << oldInvariantTexCoords[0] << " " << oldInvariantTexCoords[1] << "\n";
+		// project the texture axes onto the boundary plane along the texture Z axis
+		const Vector3 boundaryOffset     = plane3_project_point( plane, Vector3( 0, 0, 0 ), zAxis );
+		const Vector3 oldXAxisOnBoundary = plane3_project_point( plane, xAxis * projection.m_texdef.scale[0], zAxis ) - boundaryOffset;
+		const Vector3 oldYAxisOnBoundary = plane3_project_point( plane, yAxis * projection.m_texdef.scale[1], zAxis ) - boundaryOffset;
+
+		// transform the projected texture axes and compensate the translational component
+		const Vector3 transformedXAxis = matrix4_transformed_point( identity2transformed, oldXAxisOnBoundary ) - offset;
+		const Vector3 transformedYAxis = matrix4_transformed_point( identity2transformed, oldYAxisOnBoundary ) - offset;
+
+		// obtain the new texture plane norm and the new base texture axes
+		const std::size_t newIndex = planeNormalIndex( newNormal );
+		xAxis = BaseAxes[newIndex * 3 + 1];
+		yAxis = BaseAxes[newIndex * 3 + 2];
+		zAxis = BaseAxes[( newIndex / 2 ) * 6];
+
+		const Plane3 newTexturePlane( zAxis, 0 );
+
+		// project the transformed texture axes onto the new texture projection plane
+		const Vector3 projectedTransformedXAxis = plane3_project_point( newTexturePlane, transformedXAxis );
+		const Vector3 projectedTransformedYAxis = plane3_project_point( newTexturePlane, transformedYAxis );
+
+		const Vector3 normalizedXAxis = vector3_normalised( projectedTransformedXAxis );
+		const Vector3 normalizedYAxis = vector3_normalised( projectedTransformedYAxis );
+
+		// determine the rotation angle from the dot product of the new base axes and the transformed, projected and normalized texture axes
+		float cosX = vector3_dot( xAxis, normalizedXAxis );
+		float cosY = vector3_dot( yAxis, normalizedYAxis );
+
+		float radX = std::acos( cosX );
+		if( vector3_dot( vector3_cross( xAxis, normalizedXAxis ), zAxis ) < 0.0 )
+			radX *= -1.0f;
+
+		float radY = std::acos( cosY );
+		if( vector3_dot( vector3_cross( yAxis, normalizedYAxis ), zAxis ) < 0.0 )
+			radY *= -1.0f;
+
+		// choosing between the X and Y axis rotations
+		float rad = width >= height ? radX : radY;
+
+		// for some reason, when the texture plane normal is the Y axis, we must rotation clockwise
+		if( ( newIndex / 2 ) * 6 == 12 )
+			rad *= -1.0f;
+
+		//	doSetRotation( newNormal, newRotation, newRotation );
+        rotmat = matrix4_rotation_for_axisangle( vector3_cross( yAxis, xAxis ), rad );
+        matrix4_transform_direction( rotmat, xAxis );
+        matrix4_transform_direction( rotmat, yAxis );
+
+		// finally compute the scaling factors
+		Vector2 newScale( vector3_length( projectedTransformedXAxis ),
+						  vector3_length( projectedTransformedYAxis ) );
+
+		// the sign of the scaling factors depends on the angle between the new texture axis and the projected transformed axis
+		if( vector3_dot( xAxis, normalizedXAxis ) < 0 )
+			newScale[0] *= -1.0f;
+		if( vector3_dot( yAxis, normalizedYAxis ) < 0 )
+			newScale[1] *= -1.0f;
+
+		// compute the parameters of the transformed texture coordinate system
+		const Vector3 newInvariant =  matrix4_transformed_point( identity2transformed, oldInvariant );
+
+		// determine the new texture coordinates of the transformed center of the face, sans offsets
+		const Vector2 newInvariantTexCoords( vector3_dot( xAxis / newScale[0], newInvariant ),
+											vector3_dot( yAxis / newScale[1], newInvariant ) );
+//			globalOutputStream() << "newInvariantTexCoords: " << newInvariantTexCoords[0] << " " << newInvariantTexCoords[1] << "\n";
+		// since the center should be invariant, the offsets are determined by the difference of the current and
+		// the original texture coordinates of the center
+		projection.m_texdef.shift[0] = oldInvariantTexCoords[0] - newInvariantTexCoords[0];
+		projection.m_texdef.shift[1] = oldInvariantTexCoords[1] - newInvariantTexCoords[1];
+		projection.m_texdef.scale[0] = newScale[0];
+		projection.m_texdef.scale[1] = newScale[1];
+		projection.m_texdef.rotate = radians_to_degrees( rad );
+		Texdef_normalise( projection, (float)width, (float)height );
+//			globalOutputStream() << "AP new: scale( " << projection.m_texdef.scale[0] << " " << projection.m_texdef.scale[1] << " ) shift( " << projection.m_texdef.shift[0] << " " << projection.m_texdef.shift[1] << " ) rotate: " << projection.m_texdef.rotate << "\n";
+	}
+	else{ //TEXDEFTYPEID_HALFLIFE
 //			globalOutputStream() << "\t\t----------------------\n";
-//		globalOutputStream() << "AP: scale[0]:" << projection.m_texdef.scale[0] << " scale[1]:" << projection.m_texdef.scale[1] << " shift[0]:" << projection.m_texdef.shift[0] << " shift[1]:" << projection.m_texdef.shift[1] << " rotate:" << projection.m_texdef.rotate << "\n";
+//			globalOutputStream() << "AP: scale( " << projection.m_texdef.scale[0] << " " << projection.m_texdef.scale[1] << " ) shift( " << projection.m_texdef.shift[0] << " " << projection.m_texdef.shift[1] << " ) rotate: " << projection.m_texdef.rotate << "\n";
-//		globalOutputStream() << "BP: coords[0][0]:" << projection.m_brushprimit_texdef.coords[0][0] << " coords[0][1]:" << projection.m_brushprimit_texdef.coords[0][1] << " coords[0][2]:" << projection.m_brushprimit_texdef.coords[0][2] << " coords[1][0]:" << projection.m_brushprimit_texdef.coords[1][0] << " coords[1][1]:" << projection.m_brushprimit_texdef.coords[1][1] << " coords[1][2]:" << projection.m_brushprimit_texdef.coords[1][2] << "\n";
+//			globalOutputStream() << "BP: ( " << projection.m_brushprimit_texdef.coords[0][0] << " " << projection.m_brushprimit_texdef.coords[0][1] << " " << projection.m_brushprimit_texdef.coords[0][2] << " ) ( " << projection.m_brushprimit_texdef.coords[1][0] << " " << projection.m_brushprimit_texdef.coords[1][1] << " " << projection.m_brushprimit_texdef.coords[1][2] << " )\n";
 //			globalOutputStream() << "width:" << width << " height" << height << "\n";
 
 		//globalOutputStream() << "identity2transformed: " << identity2transformed << "\n";
 
 		//globalOutputStream() << "plane.normal(): " << plane.normal() << "\n";
-#if 0
+		#if 0
 		Vector3 normalTransformed( matrix4_transformed_direction( identity2transformed, plane.normal() ) );
-#else //preserves scale in BP while scaling, but not shift //fixes QNAN
+		#else //preserves scale in BP while scaling, but not shift //fixes QNAN
 		Matrix4 maa( matrix4_affine_inverse( identity2transformed ) );
 		matrix4_transpose( maa );
 		//Vector4 vec4 = matrix4_transformed_vector4( maa, Vector4( plane.normal(), 0 ) );
 		//Vector3 normalTransformed( vector3_normalised( vector4_to_vector3( vec4 ) ) );
 		Vector3 normalTransformed( vector3_normalised( matrix4_transformed_direction( maa, plane.normal() ) ) );
-#endif
+		#endif
 
 		//globalOutputStream() << "normalTransformed: " << normalTransformed << "\n";
 
@@ -1510,7 +1776,7 @@ void Texdef_transformLocked( TextureProjection& projection, std::size_t width, s
 			// 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
+	#if 0
 			globalOutputStream() << "projection off by 90\n";
 			globalOutputStream() << "normal: ";
 			print_vector3( plane.normal() );
@@ -1518,7 +1784,7 @@ void Texdef_transformLocked( TextureProjection& projection, std::size_t width, s
 			print_vector3( originalProjectionAxis );
 			globalOutputStream() << "transformed projection: ";
 			print_vector3( transformedProjectionAxis );
-#endif
+	#endif
 
 			Matrix4 identityCorrected = matrix4_reflection_for_plane45( plane, originalProjectionAxis, transformedProjectionAxis );
 
@@ -1531,11 +1797,12 @@ void Texdef_transformLocked( TextureProjection& projection, std::size_t width, s
 		Matrix4 stTransformed2stOriginal = matrix4_multiplied_by_matrix4( identity2stOriginal, stTransformed2identity );
 //			globalOutputStream() << "stTransformed2stOriginal: " << stTransformed2stOriginal << "\n";
 		Texdef_fromTransform( projection, (float)width, (float)height, stTransformed2stOriginal );
-//		globalOutputStream() << "AP: scale[0]:" << projection.m_texdef.scale[0] << " scale[1]:" << projection.m_texdef.scale[1] << " shift[0]:" << projection.m_texdef.shift[0] << " shift[1]:" << projection.m_texdef.shift[1] << " rotate:" << projection.m_texdef.rotate << "\n";
+//			globalOutputStream() << "AP: scale( " << projection.m_texdef.scale[0] << " " << projection.m_texdef.scale[1] << " ) shift( " << projection.m_texdef.shift[0] << " " << projection.m_texdef.shift[1] << " ) rotate: " << projection.m_texdef.rotate << "\n";
-//		globalOutputStream() << "BP: coords[0][0]:" << projection.m_brushprimit_texdef.coords[0][0] << " coords[0][1]:" << projection.m_brushprimit_texdef.coords[0][1] << " coords[0][2]:" << projection.m_brushprimit_texdef.coords[0][2] << " coords[1][0]:" << projection.m_brushprimit_texdef.coords[1][0] << " coords[1][1]:" << projection.m_brushprimit_texdef.coords[1][1] << " coords[1][2]:" << projection.m_brushprimit_texdef.coords[1][2] << "\n";
+//			globalOutputStream() << "BP: ( " << projection.m_brushprimit_texdef.coords[0][0] << " " << projection.m_brushprimit_texdef.coords[0][1] << " " << projection.m_brushprimit_texdef.coords[0][2] << " ) ( " << projection.m_brushprimit_texdef.coords[1][0] << " " << projection.m_brushprimit_texdef.coords[1][1] << " " << projection.m_brushprimit_texdef.coords[1][2] << " )\n";
 		Texdef_normalise( projection, (float)width, (float)height );
-//		globalOutputStream() << "AP norm: scale[0]:" << projection.m_texdef.scale[0] << " scale[1]:" << projection.m_texdef.scale[1] << " shift[0]:" << projection.m_texdef.shift[0] << " shift[1]:" << projection.m_texdef.shift[1] << " rotate:" << projection.m_texdef.rotate << "\n";
+//			globalOutputStream() << "AP norm: scale( " << projection.m_texdef.scale[0] << " " << projection.m_texdef.scale[1] << " ) shift( " << projection.m_texdef.shift[0] << " " << projection.m_texdef.shift[1] << " ) rotate: " << projection.m_texdef.rotate << "\n";
-//		globalOutputStream() << "BP norm: coords[0][0]:" << projection.m_brushprimit_texdef.coords[0][0] << " coords[0][1]:" << projection.m_brushprimit_texdef.coords[0][1] << " coords[0][2]:" << projection.m_brushprimit_texdef.coords[0][2] << " coords[1][0]:" << projection.m_brushprimit_texdef.coords[1][0] << " coords[1][1]:" << projection.m_brushprimit_texdef.coords[1][1] << " coords[1][2]:" << projection.m_brushprimit_texdef.coords[1][2] << "\n";
+//			globalOutputStream() << "BP norm: ( " << projection.m_brushprimit_texdef.coords[0][0] << " " << projection.m_brushprimit_texdef.coords[0][1] << " " << projection.m_brushprimit_texdef.coords[0][2] << " ) ( " << projection.m_brushprimit_texdef.coords[1][0] << " " << projection.m_brushprimit_texdef.coords[1][1] << " " << projection.m_brushprimit_texdef.coords[1][2] << " )\n";
+	}
 }
 
 #if 1

radiant/brush_primit.h

@@ -116,7 +116,7 @@ void Texdef_EmitTextureCoordinates( const TextureProjection& projection, std::si
 void ShiftScaleRotate_fromFace( texdef_t& shiftScaleRotate, const TextureProjection& projection );
 void ShiftScaleRotate_toFace( const texdef_t& shiftScaleRotate, TextureProjection& projection );
 
-void Texdef_transformLocked( TextureProjection& projection, std::size_t width, std::size_t height, const Plane3& plane, const Matrix4& transform );
+void Texdef_transformLocked( TextureProjection& projection, std::size_t width, std::size_t height, const Plane3& plane, const Matrix4& transform, const Vector3 centroid = Vector3( 0, 0, 0 ) );
 void Texdef_normalise( TextureProjection& projection, float width, float height );
 
 enum TexdefTypeId

radiant/camwindow.cpp

@@ -1615,6 +1615,7 @@ void ShowStatsToggle(){
 #include "stream/stringstream.h"
 
 void CamWnd::Cam_Draw(){
+//		globalOutputStream() << "Cam_Draw()\n";
 	glViewport( 0, 0, m_Camera.width, m_Camera.height );
 #if 0
 	GLint viewprt[4];

radiant/surfacedialog.cpp

@@ -1502,6 +1502,11 @@ void Face_setTexture_Seamless( Face& face, const char* shader, const TextureProj
 	face.SetShader( shader );
 
 	DoubleLine line = plane3_intersect_plane3( g_faceTextureClipboard.m_plane, face.getPlane().plane3() );
+	if( vector3_length_squared( line.direction ) == 0 ){
+		face.SetTexdef( projection );
+		face.SetFlags( flags );
+		return;
+	}
 	Quaternion rotation = Quaternion( vector3_cross( g_faceTextureClipboard.m_plane.normal(), face.getPlane().plane3().normal() ),
 									static_cast<float>( 1.0 + vector3_dot( g_faceTextureClipboard.m_plane.normal(), face.getPlane().plane3().normal() ) ) );
 	//Quaternion rotation = quaternion_for_unit_vectors( g_faceTextureClipboard.m_plane.normal(), face.getPlane().plane3().normal() );
@@ -1528,7 +1533,9 @@ void Face_setTexture_Seamless( Face& face, const char* shader, const TextureProj
 
 	//globalOutputStream() << "transform: " << transform << "\n";
 	TextureProjection proj = projection;
-	Texdef_transformLocked( proj, g_faceTextureClipboard.m_width, g_faceTextureClipboard.m_height, g_faceTextureClipboard.m_plane, transform );
+	proj.m_brushprimit_texdef.addScale( g_faceTextureClipboard.m_width, g_faceTextureClipboard.m_height );
+	Texdef_transformLocked( proj, g_faceTextureClipboard.m_width, g_faceTextureClipboard.m_height, g_faceTextureClipboard.m_plane, transform, line.origin );
+	proj.m_brushprimit_texdef.removeScale( g_faceTextureClipboard.m_width, g_faceTextureClipboard.m_height );
 
 
 	//face.SetTexdef( projection );

radiant/xywindow.cpp

@@ -2679,6 +2679,7 @@ void XYWnd::updateModelview(){
 //#define DBG_SCENEDUMP
 
 void XYWnd::XY_Draw(){
+//		globalOutputStream() << "XY_Draw()\n";
 	//
 	// clear
 	//