2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
5 This file is part of GtkRadiant.
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "brush_primit.h"
23 #include "globaldefs.h"
25 #include "debugging/debugging.h"
28 #include "itextures.h"
33 #include "texturelib.h"
34 #include "math/matrix.h"
35 #include "math/plane.h"
36 #include "math/aabb.h"
39 #include "preferences.h"
43 \brief Construct a transform from XYZ space to ST space (3d to 2d).
44 This will be one of three axis-aligned spaces, depending on the surface normal.
45 NOTE: could also be done by swapping values.
47 void Normal_GetTransform( const Vector3& normal, Matrix4& transform ){
48 switch ( projectionaxis_for_normal( normal ) )
50 case eProjectionAxisZ:
63 case eProjectionAxisY:
76 case eProjectionAxisX:
90 transform[3] = transform[7] = transform[11] = transform[12] = transform[13] = transform[14] = 0;
95 \brief Construct a transform in ST space from the texdef.
96 Transforms constructed from quake's texdef format are (-shift)*(1/scale)*(-rotate) with x translation sign flipped.
97 This would really make more sense if it was inverseof(shift*rotate*scale).. oh well.
99 inline void Texdef_toTransform( const texdef_t& texdef, float width, float height, Matrix4& transform ){
100 double inverse_scale[2];
102 // transform to texdef shift/scale/rotate
103 inverse_scale[0] = 1 / ( texdef.scale[0] * width );
104 inverse_scale[1] = 1 / ( texdef.scale[1] * -height );
105 transform[12] = texdef.shift[0] / width;
106 transform[13] = -texdef.shift[1] / -height;
107 double c = cos( degrees_to_radians( -texdef.rotate ) );
108 double s = sin( degrees_to_radians( -texdef.rotate ) );
109 transform[0] = static_cast<float>( c * inverse_scale[0] );
110 transform[1] = static_cast<float>( s * inverse_scale[1] );
111 transform[4] = static_cast<float>( -s * inverse_scale[0] );
112 transform[5] = static_cast<float>( c * inverse_scale[1] );
113 transform[2] = transform[3] = transform[6] = transform[7] = transform[8] = transform[9] = transform[11] = transform[14] = 0;
114 transform[10] = transform[15] = 1;
117 inline void BPTexdef_toTransform( const brushprimit_texdef_t& bp_texdef, Matrix4& transform ){
118 transform = g_matrix4_identity;
119 transform.xx() = bp_texdef.coords[0][0];
120 transform.yx() = bp_texdef.coords[0][1];
121 transform.tx() = bp_texdef.coords[0][2];
122 transform.xy() = bp_texdef.coords[1][0];
123 transform.yy() = bp_texdef.coords[1][1];
124 transform.ty() = bp_texdef.coords[1][2];
127 inline void Texdef_toTransform( const TextureProjection& projection, float width, float height, Matrix4& transform ){
128 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
129 BPTexdef_toTransform( projection.m_brushprimit_texdef, transform );
133 Texdef_toTransform( projection.m_texdef, width, height, transform );
137 // handles degenerate cases, just in case library atan2 doesn't
138 inline double arctangent_yx( double y, double x ){
139 if ( fabs( x ) > 1.0E-6 ) {
140 return atan2( y, x );
151 inline void Texdef_fromTransform( texdef_t& texdef, float width, float height, const Matrix4& transform ){
152 texdef.scale[0] = static_cast<float>( ( 1.0 / vector2_length( Vector2( transform[0], transform[4] ) ) ) / width );
153 texdef.scale[1] = static_cast<float>( ( 1.0 / vector2_length( Vector2( transform[1], transform[5] ) ) ) / height );
155 texdef.rotate = static_cast<float>( -radians_to_degrees( arctangent_yx( -transform[4], transform[0] ) ) );
157 if ( texdef.rotate == -180.0f ) {
158 texdef.rotate = 180.0f;
161 texdef.shift[0] = transform[12] * width;
162 texdef.shift[1] = transform[13] * height;
164 // If the 2d cross-product of the x and y axes is positive, one of the axes has a negative scale.
165 if ( vector2_cross( Vector2( transform[0], transform[4] ), Vector2( transform[1], transform[5] ) ) > 0 ) {
166 if ( texdef.rotate >= 180.0f ) {
167 texdef.rotate -= 180.0f;
168 texdef.scale[0] = -texdef.scale[0];
172 texdef.scale[1] = -texdef.scale[1];
175 //globalOutputStream() << "fromTransform: " << texdef.shift[0] << " " << texdef.shift[1] << " " << texdef.scale[0] << " " << texdef.scale[1] << " " << texdef.rotate << "\n";
178 inline void BPTexdef_fromTransform( brushprimit_texdef_t& bp_texdef, const Matrix4& transform ){
179 bp_texdef.coords[0][0] = transform.xx();
180 bp_texdef.coords[0][1] = transform.yx();
181 bp_texdef.coords[0][2] = transform.tx();
182 bp_texdef.coords[1][0] = transform.xy();
183 bp_texdef.coords[1][1] = transform.yy();
184 bp_texdef.coords[1][2] = transform.ty();
187 inline void Texdef_fromTransform( TextureProjection& projection, float width, float height, const Matrix4& transform ){
188 ASSERT_MESSAGE( ( transform[0] != 0 || transform[4] != 0 )
189 && ( transform[1] != 0 || transform[5] != 0 ), "invalid texture matrix" );
191 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
192 BPTexdef_fromTransform( projection.m_brushprimit_texdef, transform );
196 Texdef_fromTransform( projection.m_texdef, width, height, transform );
200 inline void Texdef_normalise( texdef_t& texdef, float width, float height ){
201 // it may be useful to also normalise the rotation here, if this function is used elsewhere.
202 texdef.shift[0] = float_mod( texdef.shift[0], width );
203 texdef.shift[1] = float_mod( texdef.shift[1], height );
204 //globalOutputStream() << "normalise: " << texdef.shift[0] << " " << texdef.shift[1] << " " << texdef.scale[0] << " " << texdef.scale[1] << " " << texdef.rotate << "\n";
207 inline void BPTexdef_normalise( brushprimit_texdef_t& bp_texdef, float width, float height ){
208 bp_texdef.coords[0][2] = float_mod( bp_texdef.coords[0][2], width );
209 bp_texdef.coords[1][2] = float_mod( bp_texdef.coords[1][2], height );
212 /// \brief Normalise \p projection for a given texture \p width and \p height.
214 /// All texture-projection translation (shift) values are congruent modulo the dimensions of the texture.
215 /// This function normalises shift values to the smallest positive congruent values.
216 void Texdef_normalise( TextureProjection& projection, float width, float height ){
217 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
218 BPTexdef_normalise( projection.m_brushprimit_texdef, width, height );
222 Texdef_normalise( projection.m_texdef, width, height );
226 void ComputeAxisBase( const Vector3& normal, Vector3& texS, Vector3& texT );
228 inline void DebugAxisBase( const Vector3& normal ){
230 ComputeAxisBase( normal, x, y );
231 globalOutputStream() << "BP debug: " << x << y << normal << "\n";
234 void Texdef_basisForNormal( const TextureProjection& projection, const Vector3& normal, Matrix4& basis ){
235 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
236 basis = g_matrix4_identity;
237 ComputeAxisBase( normal, vector4_to_vector3( basis.x() ), vector4_to_vector3( basis.y() ) );
238 vector4_to_vector3( basis.z() ) = normal;
239 matrix4_transpose( basis );
240 //DebugAxisBase(normal);
242 else if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE ) {
243 basis = g_matrix4_identity;
244 vector4_to_vector3( basis.x() ) = projection.m_basis_s;
245 vector4_to_vector3( basis.y() ) = vector3_negated( projection.m_basis_t );
246 vector4_to_vector3( basis.z() ) = vector3_normalised( vector3_cross( vector4_to_vector3( basis.x() ), vector4_to_vector3( basis.y() ) ) );
247 matrix4_multiply_by_matrix4( basis, matrix4_rotation_for_z_degrees( -projection.m_texdef.rotate ) );
248 //globalOutputStream() << "debug: " << projection.m_basis_s << projection.m_basis_t << normal << "\n";
249 matrix4_transpose( basis );
253 Normal_GetTransform( normal, basis );
257 void Texdef_EmitTextureCoordinates( const TextureProjection& projection, std::size_t width, std::size_t height, Winding& w, const Vector3& normal, const Matrix4& localToWorld ){
258 if ( w.numpoints < 3 ) {
261 //globalOutputStream() << "normal: " << normal << "\n";
264 Texdef_toTransform( projection, (float)width, (float)height, local2tex );
265 //globalOutputStream() << "texdef: " << static_cast<const Vector3&>(local2tex.x()) << static_cast<const Vector3&>(local2tex.y()) << "\n";
269 TextureProjection tmp;
270 Texdef_fromTransform( tmp, (float)width, (float)height, local2tex );
271 Matrix4 tmpTransform;
272 Texdef_toTransform( tmp, (float)width, (float)height, tmpTransform );
273 ASSERT_MESSAGE( matrix4_equal_epsilon( local2tex, tmpTransform, 0.0001f ), "bleh" );
279 // we don't care if it's not normalised...
280 Texdef_basisForNormal( projection, matrix4_transformed_direction( localToWorld, normal ), xyz2st );
281 //globalOutputStream() << "basis: " << static_cast<const Vector3&>(xyz2st.x()) << static_cast<const Vector3&>(xyz2st.y()) << static_cast<const Vector3&>(xyz2st.z()) << "\n";
282 matrix4_multiply_by_matrix4( local2tex, xyz2st );
285 Vector3 tangent( vector3_normalised( vector4_to_vector3( matrix4_transposed( local2tex ).x() ) ) );
286 Vector3 bitangent( vector3_normalised( vector4_to_vector3( matrix4_transposed( local2tex ).y() ) ) );
288 matrix4_multiply_by_matrix4( local2tex, localToWorld );
290 for ( Winding::iterator i = w.begin(); i != w.end(); ++i )
292 Vector3 texcoord = matrix4_transformed_point( local2tex, ( *i ).vertex );
293 ( *i ).texcoord[0] = texcoord[0];
294 ( *i ).texcoord[1] = texcoord[1];
296 ( *i ).tangent = tangent;
297 ( *i ).bitangent = bitangent;
302 \brief Provides the axis-base of the texture ST space for this normal,
303 as they had been transformed to world XYZ space.
305 void TextureAxisFromNormal( const Vector3& normal, Vector3& s, Vector3& t ){
306 switch ( projectionaxis_for_normal( normal ) )
308 case eProjectionAxisZ:
318 case eProjectionAxisY:
328 case eProjectionAxisX:
341 void Texdef_Assign( texdef_t& td, const texdef_t& other ){
345 void Texdef_Shift( texdef_t& td, float s, float t ){
350 void Texdef_Scale( texdef_t& td, float s, float t ){
355 void Texdef_Rotate( texdef_t& td, float angle ){
357 td.rotate = static_cast<float>( float_to_integer( td.rotate ) % 360 );
360 // NOTE: added these from Ritual's Q3Radiant
361 void ClearBounds( Vector3& mins, Vector3& maxs ){
362 mins[0] = mins[1] = mins[2] = 99999;
363 maxs[0] = maxs[1] = maxs[2] = -99999;
366 void AddPointToBounds( const Vector3& v, Vector3& mins, Vector3& maxs ){
370 for ( i = 0 ; i < 3 ; i++ )
373 if ( val < mins[i] ) {
376 if ( val > maxs[i] ) {
382 template<typename Element>
383 inline BasicVector3<Element> vector3_inverse( const BasicVector3<Element>& self ){
384 return BasicVector3<Element>(
385 Element( 1.0 / self.x() ),
386 Element( 1.0 / self.y() ),
387 Element( 1.0 / self.z() )
391 // low level functions .. put in mathlib?
392 #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]; }
393 // apply a scale transformation to the BP matrix
394 #define BPMatScale( m,sS,sT ) {m[0][0] *= sS; m[1][0] *= sS; m[0][1] *= sT; m[1][1] *= sT; }
395 // apply a translation transformation to a BP matrix
396 #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; }
397 // 2D homogeneous matrix product C = A*B
398 void BPMatMul( float A[2][3], float B[2][3], float C[2][3] );
399 // apply a rotation (degrees)
400 void BPMatRotate( float A[2][3], float theta );
402 void BPMatDump( float A[2][3] );
410 bp_globals_t g_bp_globals;
411 float g_texdef_default_scale;
413 // compute a determinant using Sarrus rule
414 //++timo "inline" this with a macro
415 // NOTE : the three vectors are understood as columns of the matrix
416 inline float SarrusDet( const Vector3& a, const Vector3& b, const Vector3& c ){
417 return a[0] * b[1] * c[2] + b[0] * c[1] * a[2] + c[0] * a[1] * b[2]
418 - c[0] * b[1] * a[2] - a[1] * b[0] * c[2] - a[0] * b[2] * c[1];
421 // in many case we know three points A,B,C in two axis base B1 and B2
422 // and we want the matrix M so that A(B1) = T * A(B2)
423 // NOTE: 2D homogeneous space stuff
424 // NOTE: we don't do any check to see if there's a solution or we have a particular case .. need to make sure before calling
425 // NOTE: the third coord of the A,B,C point is ignored
426 // NOTE: see the commented out section to fill M and D
427 //++timo TODO: update the other members to use this when possible
428 void MatrixForPoints( Vector3 M[3], Vector3 D[2], brushprimit_texdef_t *T ){
429 // 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)
432 M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
434 // fill the data vectors
435 M[0][0] = A2[0]; M[0][1] = B2[0]; M[0][2] = C2[0];
436 M[1][0] = A2[1]; M[1][1] = B2[1]; M[1][2] = C2[1];
437 M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
446 det = SarrusDet( M[0], M[1], M[2] );
447 T->coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
448 T->coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
449 T->coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
450 T->coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
451 T->coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
452 T->coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
455 //++timo replace everywhere texX by texS etc. ( ----> and in q3map !)
456 // NOTE : ComputeAxisBase here and in q3map code must always BE THE SAME !
457 // WARNING : special case behaviour of atan2(y,x) <-> atan(y/x) might not be the same everywhere when x == 0
458 // rotation by (0,RotY,RotZ) assigns X to normal
459 void ComputeAxisBase( const Vector3& normal, Vector3& texS, Vector3& texT ){
461 const Vector3 up( 0, 0, 1 );
462 const Vector3 down( 0, 0, -1 );
464 if ( vector3_equal_epsilon( normal, up, float(1e-6) ) ) {
465 texS = Vector3( 0, 1, 0 );
466 texT = Vector3( 1, 0, 0 );
468 else if ( vector3_equal_epsilon( normal, down, float(1e-6) ) ) {
469 texS = Vector3( 0, 1, 0 );
470 texT = Vector3( -1, 0, 0 );
474 texS = vector3_normalised( vector3_cross( normal, up ) );
475 texT = vector3_normalised( vector3_cross( normal, texS ) );
476 vector3_negate( texS );
483 if (fabs(normal[0])<1e-6)
485 if (fabs(normal[1])<1e-6)
487 if (fabs(normal[2])<1e-6)
490 RotY = -atan2( normal[2],sqrt( normal[1] * normal[1] + normal[0] * normal[0] ) );
491 RotZ = atan2( normal[1],normal[0] );
492 // rotate (0,1,0) and (0,0,1) to compute texS and texT
493 texS[0] = -sin( RotZ );
494 texS[1] = cos( RotZ );
496 // the texT vector is along -Z ( T texture coorinates axis )
497 texT[0] = -sin( RotY ) * cos( RotZ );
498 texT[1] = -sin( RotY ) * sin( RotZ );
499 texT[2] = -cos( RotY );
503 #if 0 // texdef conversion
504 void FaceToBrushPrimitFace( face_t *f ){
507 // ST of (0,0) (1,0) (0,1)
508 float ST[3][5]; // [ point index ] [ xyz ST ]
509 //++timo not used as long as brushprimit_texdef and texdef are static
510 /* f->brushprimit_texdef.contents=f->texdef.contents;
511 f->brushprimit_texdef.flags=f->texdef.flags;
512 f->brushprimit_texdef.value=f->texdef.value;
513 strcpy(f->brushprimit_texdef.name,f->texdef.name); */
515 if ( f->plane.normal[0] == 0.0f && f->plane.normal[1] == 0.0f && f->plane.normal[2] == 0.0f ) {
516 globalOutputStream() << "Warning : f->plane.normal is (0,0,0) in FaceToBrushPrimitFace\n";
519 if ( !f->d_texture ) {
520 globalOutputStream() << "Warning : f.d_texture is 0 in FaceToBrushPrimitFace\n";
525 ComputeAxisBase( f->plane.normal,texX,texY );
526 // compute projection vector
527 VectorCopy( f->plane.normal,proj );
528 VectorScale( proj,f->plane.dist,proj );
529 // (0,0) in plane axis base is (0,0,0) in world coordinates + projection on the affine plane
530 // (1,0) in plane axis base is texX in world coordinates + projection on the affine plane
531 // (0,1) in plane axis base is texY in world coordinates + projection on the affine plane
532 // use old texture code to compute the ST coords of these points
533 VectorCopy( proj,ST[0] );
534 EmitTextureCoordinates( ST[0], f->pShader->getTexture(), f );
535 VectorCopy( texX,ST[1] );
536 VectorAdd( ST[1],proj,ST[1] );
537 EmitTextureCoordinates( ST[1], f->pShader->getTexture(), f );
538 VectorCopy( texY,ST[2] );
539 VectorAdd( ST[2],proj,ST[2] );
540 EmitTextureCoordinates( ST[2], f->pShader->getTexture(), f );
541 // compute texture matrix
542 f->brushprimit_texdef.coords[0][2] = ST[0][3];
543 f->brushprimit_texdef.coords[1][2] = ST[0][4];
544 f->brushprimit_texdef.coords[0][0] = ST[1][3] - f->brushprimit_texdef.coords[0][2];
545 f->brushprimit_texdef.coords[1][0] = ST[1][4] - f->brushprimit_texdef.coords[1][2];
546 f->brushprimit_texdef.coords[0][1] = ST[2][3] - f->brushprimit_texdef.coords[0][2];
547 f->brushprimit_texdef.coords[1][1] = ST[2][4] - f->brushprimit_texdef.coords[1][2];
550 // compute texture coordinates for the winding points
551 void EmitBrushPrimitTextureCoordinates( face_t * f, Winding * w ){
555 ComputeAxisBase( f->plane.normal,texX,texY );
556 // in case the texcoords matrix is empty, build a default one
557 // same behaviour as if scale[0]==0 && scale[1]==0 in old code
558 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 ) {
559 f->brushprimit_texdef.coords[0][0] = 1.0f;
560 f->brushprimit_texdef.coords[1][1] = 1.0f;
561 ConvertTexMatWithQTexture( &f->brushprimit_texdef, 0, &f->brushprimit_texdef, f->pShader->getTexture() );
564 for ( i = 0 ; i < w.numpoints ; i++ )
566 x = vector3_dot( w.point_at( i ),texX );
567 y = vector3_dot( w.point_at( i ),texY );
570 if ( g_bp_globals.bNeedConvert ) {
571 // check we compute the same ST as the traditional texture computation used before
572 float S = f->brushprimit_texdef.coords[0][0] * x + f->brushprimit_texdef.coords[0][1] * y + f->brushprimit_texdef.coords[0][2];
573 float T = f->brushprimit_texdef.coords[1][0] * x + f->brushprimit_texdef.coords[1][1] * y + f->brushprimit_texdef.coords[1][2];
574 if ( fabs( S - w.point_at( i )[3] ) > 1e-2 || fabs( T - w.point_at( i )[4] ) > 1e-2 ) {
575 if ( fabs( S - w.point_at( i )[3] ) > 1e-4 || fabs( T - w.point_at( i )[4] ) > 1e-4 ) {
576 globalOutputStream() << "Warning : precision loss in brush -> brush primitive texture computation\n";
579 globalOutputStream() << "Warning : brush -> brush primitive texture computation bug detected\n";
585 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];
586 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];
591 typedef float texmat_t[2][3];
593 void TexMat_Scale( texmat_t texmat, float s, float t ){
602 void TexMat_Assign( texmat_t texmat, const texmat_t other ){
603 texmat[0][0] = other[0][0];
604 texmat[0][1] = other[0][1];
605 texmat[0][2] = other[0][2];
606 texmat[1][0] = other[1][0];
607 texmat[1][1] = other[1][1];
608 texmat[1][2] = other[1][2];
611 void ConvertTexMatWithDimensions( const texmat_t texmat1, std::size_t w1, std::size_t h1,
612 texmat_t texmat2, std::size_t w2, std::size_t h2 ){
613 TexMat_Assign( texmat2, texmat1 );
614 TexMat_Scale( texmat2, static_cast<float>( w1 ) / static_cast<float>( w2 ), static_cast<float>( h1 ) / static_cast<float>( h2 ) );
618 // convert a texture matrix between two qtexture_t
619 // if 0 for qtexture_t, basic 2x2 texture is assumed ( straight mapping between s/t coordinates and geometric coordinates )
620 void ConvertTexMatWithQTexture( const float texMat1[2][3], const qtexture_t *qtex1, float texMat2[2][3], const qtexture_t *qtex2 ){
621 ConvertTexMatWithDimensions( texMat1, ( qtex1 ) ? qtex1->width : 2, ( qtex1 ) ? qtex1->height : 2,
622 texMat2, ( qtex2 ) ? qtex2->width : 2, ( qtex2 ) ? qtex2->height : 2 );
625 void ConvertTexMatWithQTexture( const brushprimit_texdef_t *texMat1, const qtexture_t *qtex1, brushprimit_texdef_t *texMat2, const qtexture_t *qtex2 ){
626 ConvertTexMatWithQTexture( texMat1->coords, qtex1, texMat2->coords, qtex2 );
630 // compute a fake shift scale rot representation from the texture matrix
631 // these shift scale rot values are to be understood in the local axis base
632 // Note: this code looks similar to Texdef_fromTransform, but the algorithm is slightly different.
634 void TexMatToFakeTexCoords( const brushprimit_texdef_t& bp_texdef, texdef_t& texdef ){
635 texdef.scale[0] = static_cast<float>( 1.0 / vector2_length( Vector2( bp_texdef.coords[0][0], bp_texdef.coords[1][0] ) ) );
636 texdef.scale[1] = static_cast<float>( 1.0 / vector2_length( Vector2( bp_texdef.coords[0][1], bp_texdef.coords[1][1] ) ) );
638 texdef.rotate = -static_cast<float>( radians_to_degrees( arctangent_yx( bp_texdef.coords[1][0], bp_texdef.coords[0][0] ) ) );
640 texdef.shift[0] = -bp_texdef.coords[0][2];
641 texdef.shift[1] = bp_texdef.coords[1][2];
643 // determine whether or not an axis is flipped using a 2d cross-product
644 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] ) );
646 // This is a bit of a compromise when using BPs--since we don't know *which* axis was flipped,
647 // we pick one (rather arbitrarily) using the following convention: If the X-axis is between
648 // 0 and 180, we assume it's the Y-axis that flipped, otherwise we assume it's the X-axis and
649 // subtract out 180 degrees to compensate.
650 if ( texdef.rotate >= 180.0f ) {
651 texdef.rotate -= 180.0f;
652 texdef.scale[0] = -texdef.scale[0];
656 texdef.scale[1] = -texdef.scale[1];
661 // compute back the texture matrix from fake shift scale rot
662 void FakeTexCoordsToTexMat( const texdef_t& texdef, brushprimit_texdef_t& bp_texdef ){
663 double r = degrees_to_radians( -texdef.rotate );
666 double x = 1.0f / texdef.scale[0];
667 double y = 1.0f / texdef.scale[1];
668 bp_texdef.coords[0][0] = static_cast<float>( x * c );
669 bp_texdef.coords[1][0] = static_cast<float>( x * s );
670 bp_texdef.coords[0][1] = static_cast<float>( y * -s );
671 bp_texdef.coords[1][1] = static_cast<float>( y * c );
672 bp_texdef.coords[0][2] = -texdef.shift[0];
673 bp_texdef.coords[1][2] = texdef.shift[1];
676 #if 0 // texture locking (brush primit)
677 // used for texture locking
678 // will move the texture according to a geometric vector
679 void ShiftTextureGeometric_BrushPrimit( face_t *f, Vector3& delta ){
682 Vector3 M[3]; // columns of the matrix .. easier that way
685 // compute plane axis base ( doesn't change with translation )
686 ComputeAxisBase( f->plane.normal, texS, texT );
687 // compute translation vector in plane axis base
688 tx = vector3_dot( delta, texS );
689 ty = vector3_dot( delta, texT );
690 // fill the data vectors
691 M[0][0] = tx; M[0][1] = 1.0f + tx; M[0][2] = tx;
692 M[1][0] = ty; M[1][1] = ty; M[1][2] = 1.0f + ty;
693 M[2][0] = 1.0f; M[2][1] = 1.0f; M[2][2] = 1.0f;
694 D[0][0] = f->brushprimit_texdef.coords[0][2];
695 D[0][1] = f->brushprimit_texdef.coords[0][0] + f->brushprimit_texdef.coords[0][2];
696 D[0][2] = f->brushprimit_texdef.coords[0][1] + f->brushprimit_texdef.coords[0][2];
697 D[1][0] = f->brushprimit_texdef.coords[1][2];
698 D[1][1] = f->brushprimit_texdef.coords[1][0] + f->brushprimit_texdef.coords[1][2];
699 D[1][2] = f->brushprimit_texdef.coords[1][1] + f->brushprimit_texdef.coords[1][2];
701 det = SarrusDet( M[0], M[1], M[2] );
702 f->brushprimit_texdef.coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
703 f->brushprimit_texdef.coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
704 f->brushprimit_texdef.coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
705 f->brushprimit_texdef.coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
706 f->brushprimit_texdef.coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
707 f->brushprimit_texdef.coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
710 // shift a texture (texture adjustments) along it's current texture axes
711 // x and y are geometric values, which we must compute as ST increments
712 // this depends on the texture size and the pixel/texel ratio
713 void ShiftTextureRelative_BrushPrimit( face_t *f, float x, float y ){
715 // as a ratio against texture size
716 // the scale of the texture is not relevant here (we work directly on a transformation from the base vectors)
717 s = ( x * 2.0 ) / (float)f->pShader->getTexture().width;
718 t = ( y * 2.0 ) / (float)f->pShader->getTexture().height;
719 f->brushprimit_texdef.coords[0][2] -= s;
720 f->brushprimit_texdef.coords[1][2] -= t;
724 // TTimo: FIXME: I don't like that, it feels broken
725 // (and it's likely that it's not used anymore)
726 // best fitted 2D vector is x.X+y.Y
727 void ComputeBest2DVector( Vector3& v, Vector3& X, Vector3& Y, int &x, int &y ){
729 sx = vector3_dot( v, X );
730 sy = vector3_dot( v, Y );
731 if ( fabs( sy ) > fabs( sx ) ) {
753 #if 0 // texdef conversion
754 void BrushPrimitFaceToFace( face_t *face ){
755 // we have parsed brush primitives and need conversion back to standard format
756 // NOTE: converting back is a quick hack, there's some information lost and we can't do anything about it
757 // FIXME: if we normalize the texture matrix to a standard 2x2 size, we end up with wrong scaling
758 // I tried various tweaks, no luck .. seems shifting is lost
759 brushprimit_texdef_t aux;
760 ConvertTexMatWithQTexture( &face->brushprimit_texdef, face->pShader->getTexture(), &aux, 0 );
761 TexMatToFakeTexCoords( aux.coords, face->texdef.shift, &face->texdef.rotate, face->texdef.scale );
762 face->texdef.scale[0] /= 2.0;
763 face->texdef.scale[1] /= 2.0;
768 #if 0 // texture locking (brush primit)
769 // TEXTURE LOCKING -----------------------------------------------------------------------------------------------------
770 // (Relevant to the editor only?)
772 // internally used for texture locking on rotation and flipping
773 // the general algorithm is the same for both lockings, it's only the geometric transformation part that changes
774 // so I wanted to keep it in a single function
775 // if there are more linear transformations that need the locking, going to a C++ or code pointer solution would be best
776 // (but right now I want to keep brush_primit.cpp striclty C)
778 bool txlock_bRotation;
780 // rotation locking params
785 // flip locking params
786 Vector3 txl_matrix[3];
789 void TextureLockTransformation_BrushPrimit( face_t *f ){
790 Vector3 Orig,texS,texT; // axis base of initial plane
791 // used by transformation algo
793 Vector3 vRotate; // rotation vector
795 Vector3 rOrig,rvecS,rvecT; // geometric transformation of (0,0) (1,0) (0,1) { initial plane axis base }
796 Vector3 rNormal,rtexS,rtexT; // axis base for the transformed plane
797 Vector3 lOrig,lvecS,lvecT; // [2] are not used ( but usefull for debugging )
802 // compute plane axis base
803 ComputeAxisBase( f->plane.normal, texS, texT );
804 VectorSet( Orig, 0.0f, 0.0f, 0.0f );
806 // compute coordinates of (0,0) (1,0) (0,1) ( expressed in initial plane axis base ) after transformation
807 // (0,0) (1,0) (0,1) ( expressed in initial plane axis base ) <-> (0,0,0) texS texT ( expressed world axis base )
808 // input: Orig, texS, texT (and the global locking params)
809 // ouput: rOrig, rvecS, rvecT, rNormal
810 if ( txlock_bRotation ) {
812 VectorSet( vRotate, 0.0f, 0.0f, 0.0f );
813 vRotate[txl_nAxis] = txl_fDeg;
814 VectorRotateOrigin( Orig, vRotate, txl_vOrigin, rOrig );
815 VectorRotateOrigin( texS, vRotate, txl_vOrigin, rvecS );
816 VectorRotateOrigin( texT, vRotate, txl_vOrigin, rvecT );
817 // compute normal of plane after rotation
818 VectorRotate( f->plane.normal, vRotate, rNormal );
822 for ( j = 0 ; j < 3 ; j++ )
823 rOrig[j] = vector3_dot( vector3_subtracted( Orig, txl_origin ), txl_matrix[j] ) + txl_origin[j];
824 for ( j = 0 ; j < 3 ; j++ )
825 rvecS[j] = vector3_dot( vector3_subtracted( texS, txl_origin ), txl_matrix[j] ) + txl_origin[j];
826 for ( j = 0 ; j < 3 ; j++ )
827 rvecT[j] = vector3_dot( vector3_subtracted( texT, txl_origin ), txl_matrix[j] ) + txl_origin[j];
828 // we also need the axis base of the target plane, apply the transformation matrix to the normal too..
829 for ( j = 0 ; j < 3 ; j++ )
830 rNormal[j] = vector3_dot( f->plane.normal, txl_matrix[j] );
833 // compute rotated plane axis base
834 ComputeAxisBase( rNormal, rtexS, rtexT );
835 // compute S/T coordinates of the three points in rotated axis base ( in M matrix )
836 lOrig[0] = vector3_dot( rOrig, rtexS );
837 lOrig[1] = vector3_dot( rOrig, rtexT );
838 lvecS[0] = vector3_dot( rvecS, rtexS );
839 lvecS[1] = vector3_dot( rvecS, rtexT );
840 lvecT[0] = vector3_dot( rvecT, rtexS );
841 lvecT[1] = vector3_dot( rvecT, rtexT );
842 M[0][0] = lOrig[0]; M[1][0] = lOrig[1]; M[2][0] = 1.0f;
843 M[0][1] = lvecS[0]; M[1][1] = lvecS[1]; M[2][1] = 1.0f;
844 M[0][2] = lvecT[0]; M[1][2] = lvecT[1]; M[2][2] = 1.0f;
846 D[0][0] = f->brushprimit_texdef.coords[0][2];
847 D[0][1] = f->brushprimit_texdef.coords[0][0] + f->brushprimit_texdef.coords[0][2];
848 D[0][2] = f->brushprimit_texdef.coords[0][1] + f->brushprimit_texdef.coords[0][2];
849 D[1][0] = f->brushprimit_texdef.coords[1][2];
850 D[1][1] = f->brushprimit_texdef.coords[1][0] + f->brushprimit_texdef.coords[1][2];
851 D[1][2] = f->brushprimit_texdef.coords[1][1] + f->brushprimit_texdef.coords[1][2];
853 det = SarrusDet( M[0], M[1], M[2] );
854 f->brushprimit_texdef.coords[0][0] = SarrusDet( D[0], M[1], M[2] ) / det;
855 f->brushprimit_texdef.coords[0][1] = SarrusDet( M[0], D[0], M[2] ) / det;
856 f->brushprimit_texdef.coords[0][2] = SarrusDet( M[0], M[1], D[0] ) / det;
857 f->brushprimit_texdef.coords[1][0] = SarrusDet( D[1], M[1], M[2] ) / det;
858 f->brushprimit_texdef.coords[1][1] = SarrusDet( M[0], D[1], M[2] ) / det;
859 f->brushprimit_texdef.coords[1][2] = SarrusDet( M[0], M[1], D[1] ) / det;
863 // called before the points on the face are actually rotated
864 void RotateFaceTexture_BrushPrimit( face_t *f, int nAxis, float fDeg, Vector3& vOrigin ){
865 // this is a placeholder to call the general texture locking algorithm
866 txlock_bRotation = true;
869 VectorCopy( vOrigin, txl_vOrigin );
870 TextureLockTransformation_BrushPrimit( f );
873 // compute the new brush primit texture matrix for a transformation matrix and a flip order flag (change plane orientation)
874 // this matches the select_matrix algo used in select.cpp
875 // this needs to be called on the face BEFORE any geometric transformation
876 // it will compute the texture matrix that will represent the same texture on the face after the geometric transformation is done
877 void ApplyMatrix_BrushPrimit( face_t *f, Vector3 matrix[3], Vector3& origin ){
878 // this is a placeholder to call the general texture locking algorithm
879 txlock_bRotation = false;
880 VectorCopy( matrix[0], txl_matrix[0] );
881 VectorCopy( matrix[1], txl_matrix[1] );
882 VectorCopy( matrix[2], txl_matrix[2] );
883 VectorCopy( origin, txl_origin );
884 TextureLockTransformation_BrushPrimit( f );
889 void BPMatMul( float A[2][3], float B[2][3], float C[2][3] ){
890 C[0][0] = A[0][0] * B[0][0] + A[0][1] * B[1][0];
891 C[1][0] = A[1][0] * B[0][0] + A[1][1] * B[1][0];
892 C[0][1] = A[0][0] * B[0][1] + A[0][1] * B[1][1];
893 C[1][1] = A[1][0] * B[0][1] + A[1][1] * B[1][1];
894 C[0][2] = A[0][0] * B[0][2] + A[0][1] * B[1][2] + A[0][2];
895 C[1][2] = A[1][0] * B[0][2] + A[1][1] * B[1][2] + A[1][2];
898 void BPMatDump( float A[2][3] ){
899 globalOutputStream() << "" << A[0][0]
908 void BPMatRotate( float A[2][3], float theta ){
911 memset( &m, 0, sizeof( float ) * 6 );
912 m[0][0] = static_cast<float>( cos( degrees_to_radians( theta ) ) );
913 m[0][1] = static_cast<float>( -sin( degrees_to_radians( theta ) ) );
916 BPMatMul( A, m, aux );
920 #if 0 // camera-relative texture shift
921 // get the relative axes of the current texturing
922 void BrushPrimit_GetRelativeAxes( face_t *f, Vector3& vecS, Vector3& vecT ){
924 // first we compute them as expressed in plane axis base
925 // BP matrix has coordinates of plane axis base expressed in geometric axis base
926 // so we use the line vectors
927 vS[0] = f->brushprimit_texdef.coords[0][0];
928 vS[1] = f->brushprimit_texdef.coords[0][1];
929 vT[0] = f->brushprimit_texdef.coords[1][0];
930 vT[1] = f->brushprimit_texdef.coords[1][1];
931 // now compute those vectors in geometric space
932 Vector3 texS, texT; // axis base of the plane (geometric)
933 ComputeAxisBase( f->plane.normal, texS, texT );
934 // vecS[] = vS[0].texS[] + vS[1].texT[]
935 // vecT[] = vT[0].texS[] + vT[1].texT[]
936 vecS[0] = vS[0] * texS[0] + vS[1] * texT[0];
937 vecS[1] = vS[0] * texS[1] + vS[1] * texT[1];
938 vecS[2] = vS[0] * texS[2] + vS[1] * texT[2];
939 vecT[0] = vT[0] * texS[0] + vT[1] * texT[0];
940 vecT[1] = vT[0] * texS[1] + vT[1] * texT[1];
941 vecT[2] = vT[0] * texS[2] + vT[1] * texT[2];
944 // brush primitive texture adjustments, use the camera view to map adjustments
945 // ShiftTextureRelative_BrushPrimit ( s , t ) will shift relative to the texture
946 void ShiftTextureRelative_Camera( face_t *f, int x, int y ){
948 float XY[2]; // the values we are going to send for translation
949 float sgn[2]; // +1 or -1
953 // get the two relative texture axes for the current texturing
954 BrushPrimit_GetRelativeAxes( f, vecS, vecT );
956 // center point of the face, project it on the camera space
960 for ( i = 0; i < f->face_winding->numpoints; i++ )
962 VectorAdd( C,f->face_winding->point_at( i ),C );
964 VectorScale( C,1.0 / f->face_winding->numpoints,C );
966 pCam = g_pParentWnd->GetCamWnd();
967 pCam->MatchViewAxes( C, vecS, axis[0], sgn[0] );
968 pCam->MatchViewAxes( C, vecT, axis[1], sgn[1] );
970 // this happens when the two directions can't be mapped on two different directions on the screen
971 // then the move will occur against a single axis
972 // (i.e. the user is not positioned well enough to send understandable shift commands)
973 // NOTE: in most cases this warning is not very relevant because the user would use one of the two axes
974 // for which the solution is easy (the other one being unknown)
975 // so this warning could be removed
976 if ( axis[0] == axis[1] ) {
977 globalOutputStream() << "Warning: degenerate in ShiftTextureRelative_Camera\n";
980 // compute the X Y geometric increments
981 // those geometric increments will be applied along the texture axes (the ones we computed above)
986 XY[axis[0]] += sgn[0] * x;
989 XY[axis[1]] += sgn[1] * y;
991 // we worked out a move along vecS vecT, and we now it's geometric amplitude
993 ShiftTextureRelative_BrushPrimit( f, XY[0], XY[1] );
998 void BPTexdef_Assign( brushprimit_texdef_t& bp_td, const brushprimit_texdef_t& bp_other ){
1002 void BPTexdef_Shift( brushprimit_texdef_t& bp_td, float s, float t ){
1003 // shift a texture (texture adjustments) along it's current texture axes
1004 // x and y are geometric values, which we must compute as ST increments
1005 // this depends on the texture size and the pixel/texel ratio
1006 // as a ratio against texture size
1007 // the scale of the texture is not relevant here (we work directly on a transformation from the base vectors)
1008 bp_td.coords[0][2] -= s;
1009 bp_td.coords[1][2] += t;
1012 void BPTexdef_Scale( brushprimit_texdef_t& bp_td, float s, float t ){
1013 // apply same scale as the spinner button of the surface inspector
1015 // compute fake shift scale rot
1016 TexMatToFakeTexCoords( bp_td, texdef );
1018 texdef.scale[0] += s;
1019 texdef.scale[1] += t;
1020 // compute new normalized texture matrix
1021 FakeTexCoordsToTexMat( texdef, bp_td );
1024 void BPTexdef_Rotate( brushprimit_texdef_t& bp_td, float angle ){
1025 // apply same scale as the spinner button of the surface inspector
1027 // compute fake shift scale rot
1028 TexMatToFakeTexCoords( bp_td, texdef );
1030 texdef.rotate += angle;
1031 // compute new normalized texture matrix
1032 FakeTexCoordsToTexMat( texdef, bp_td );
1035 void BPTexdef_Construct( brushprimit_texdef_t& bp_td, std::size_t width, std::size_t height ){
1036 bp_td.coords[0][0] = 1.0f;
1037 bp_td.coords[1][1] = 1.0f;
1038 ConvertTexMatWithDimensions( bp_td.coords, 2, 2, bp_td.coords, width, height );
1041 void Texdef_Assign( TextureProjection& projection, const TextureProjection& other ){
1042 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
1043 BPTexdef_Assign( projection.m_brushprimit_texdef, other.m_brushprimit_texdef );
1047 Texdef_Assign( projection.m_texdef, other.m_texdef );
1048 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE ) {
1049 projection.m_basis_s = other.m_basis_s;
1050 projection.m_basis_t = other.m_basis_t;
1055 void Texdef_Shift( TextureProjection& projection, float s, float t ){
1056 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
1057 BPTexdef_Shift( projection.m_brushprimit_texdef, s, t );
1061 Texdef_Shift( projection.m_texdef, s, t );
1065 void Texdef_Scale( TextureProjection& projection, float s, float t ){
1066 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
1067 BPTexdef_Scale( projection.m_brushprimit_texdef, s, t );
1071 Texdef_Scale( projection.m_texdef, s, t );
1075 void Texdef_Rotate( TextureProjection& projection, float angle ){
1076 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
1077 BPTexdef_Rotate( projection.m_brushprimit_texdef, angle );
1081 Texdef_Rotate( projection.m_texdef, angle );
1085 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 ){
1086 if ( w.numpoints < 3 ) {
1091 Texdef_toTransform( projection, (float)width, (float)height, st2tex );
1093 // the current texture transform
1094 Matrix4 local2tex = st2tex;
1097 Texdef_basisForNormal( projection, normal, xyz2st );
1098 matrix4_multiply_by_matrix4( local2tex, xyz2st );
1101 // the bounds of the current texture transform
1103 for ( Winding::const_iterator i = w.begin(); i != w.end(); ++i )
1105 Vector3 texcoord = matrix4_transformed_point( local2tex, ( *i ).vertex );
1106 aabb_extend_by_point_safe( bounds, texcoord );
1108 bounds.origin.z() = 0;
1109 bounds.extents.z() = 1;
1111 // the bounds of a perfectly fitted texture transform
1112 AABB perfect( Vector3( s_repeat * 0.5, t_repeat * 0.5, 0 ), Vector3( s_repeat * 0.5, t_repeat * 0.5, 1 ) );
1114 // the difference between the current texture transform and the perfectly fitted transform
1115 Matrix4 matrix( matrix4_translation_for_vec3( bounds.origin - perfect.origin ) );
1116 matrix4_pivoted_scale_by_vec3( matrix, bounds.extents / perfect.extents, perfect.origin );
1117 matrix4_affine_invert( matrix );
1119 // apply the difference to the current texture transform
1120 matrix4_premultiply_by_matrix4( st2tex, matrix );
1122 Texdef_fromTransform( projection, (float)width, (float)height, st2tex );
1123 Texdef_normalise( projection, (float)width, (float)height );
1126 float Texdef_getDefaultTextureScale(){
1127 return g_texdef_default_scale;
1130 void TexDef_Construct_Default( TextureProjection& projection ){
1131 projection.m_texdef.scale[0] = Texdef_getDefaultTextureScale();
1132 projection.m_texdef.scale[1] = Texdef_getDefaultTextureScale();
1134 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
1135 FakeTexCoordsToTexMat( projection.m_texdef, projection.m_brushprimit_texdef );
1141 void ShiftScaleRotate_fromFace( texdef_t& shiftScaleRotate, const TextureProjection& projection ){
1142 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
1143 TexMatToFakeTexCoords( projection.m_brushprimit_texdef, shiftScaleRotate );
1147 shiftScaleRotate = projection.m_texdef;
1151 void ShiftScaleRotate_toFace( const texdef_t& shiftScaleRotate, TextureProjection& projection ){
1152 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
1153 // compute texture matrix
1154 // the matrix returned must be understood as a qtexture_t with width=2 height=2
1155 FakeTexCoordsToTexMat( shiftScaleRotate, projection.m_brushprimit_texdef );
1159 projection.m_texdef = shiftScaleRotate;
1164 inline void print_vector3( const Vector3& v ){
1165 globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )\n";
1168 inline void print_3x3( const Matrix4& m ){
1169 globalOutputStream() << "( " << m.xx() << " " << m.xy() << " " << m.xz() << " ) "
1170 << "( " << m.yx() << " " << m.yy() << " " << m.yz() << " ) "
1171 << "( " << m.zx() << " " << m.zy() << " " << m.zz() << " )\n";
1175 inline Matrix4 matrix4_rotation_for_vector3( const Vector3& x, const Vector3& y, const Vector3& z ){
1177 x.x(), x.y(), x.z(), 0,
1178 y.x(), y.y(), y.z(), 0,
1179 z.x(), z.y(), z.z(), 0,
1184 inline Matrix4 matrix4_swap_axes( const Vector3& from, const Vector3& to ){
1185 if ( from.x() != 0 && to.y() != 0 ) {
1186 return matrix4_rotation_for_vector3( to, from, g_vector3_axis_z );
1189 if ( from.x() != 0 && to.z() != 0 ) {
1190 return matrix4_rotation_for_vector3( to, g_vector3_axis_y, from );
1193 if ( from.y() != 0 && to.z() != 0 ) {
1194 return matrix4_rotation_for_vector3( g_vector3_axis_x, to, from );
1197 if ( from.y() != 0 && to.x() != 0 ) {
1198 return matrix4_rotation_for_vector3( from, to, g_vector3_axis_z );
1201 if ( from.z() != 0 && to.x() != 0 ) {
1202 return matrix4_rotation_for_vector3( from, g_vector3_axis_y, to );
1205 if ( from.z() != 0 && to.y() != 0 ) {
1206 return matrix4_rotation_for_vector3( g_vector3_axis_x, from, to );
1209 ERROR_MESSAGE( "unhandled axis swap case" );
1211 return g_matrix4_identity;
1214 inline Matrix4 matrix4_reflection_for_plane( const Plane3& plane ){
1216 static_cast<float>( 1 - ( 2 * plane.a * plane.a ) ),
1217 static_cast<float>( -2 * plane.a * plane.b ),
1218 static_cast<float>( -2 * plane.a * plane.c ),
1220 static_cast<float>( -2 * plane.b * plane.a ),
1221 static_cast<float>( 1 - ( 2 * plane.b * plane.b ) ),
1222 static_cast<float>( -2 * plane.b * plane.c ),
1224 static_cast<float>( -2 * plane.c * plane.a ),
1225 static_cast<float>( -2 * plane.c * plane.b ),
1226 static_cast<float>( 1 - ( 2 * plane.c * plane.c ) ),
1228 static_cast<float>( -2 * plane.d * plane.a ),
1229 static_cast<float>( -2 * plane.d * plane.b ),
1230 static_cast<float>( -2 * plane.d * plane.c ),
1235 inline Matrix4 matrix4_reflection_for_plane45( const Plane3& plane, const Vector3& from, const Vector3& to ){
1236 Vector3 first = from;
1237 Vector3 second = to;
1239 if ( (vector3_dot( from, plane.normal() ) > 0) == (vector3_dot( to, plane.normal() ) > 0) ) {
1240 first = vector3_negated( first );
1241 second = vector3_negated( second );
1245 globalOutputStream() << "normal: ";
1246 print_vector3( plane.normal() );
1248 globalOutputStream() << "from: ";
1249 print_vector3( first );
1251 globalOutputStream() << "to: ";
1252 print_vector3( second );
1255 Matrix4 swap = matrix4_swap_axes( first, second );
1257 swap.tx() = -static_cast<float>( -2 * plane.a * plane.d );
1258 swap.ty() = -static_cast<float>( -2 * plane.b * plane.d );
1259 swap.tz() = -static_cast<float>( -2 * plane.c * plane.d );
1264 void Texdef_transformLocked( TextureProjection& projection, std::size_t width, std::size_t height, const Plane3& plane, const Matrix4& identity2transformed ){
1265 //globalOutputStream() << "identity2transformed: " << identity2transformed << "\n";
1267 //globalOutputStream() << "plane.normal(): " << plane.normal() << "\n";
1269 Vector3 normalTransformed( matrix4_transformed_direction( identity2transformed, plane.normal() ) );
1271 //globalOutputStream() << "normalTransformed: " << normalTransformed << "\n";
1273 // identity: identity space
1274 // transformed: transformation
1275 // stIdentity: base st projection space before transformation
1276 // stTransformed: base st projection space after transformation
1277 // stOriginal: original texdef space
1279 // stTransformed2stOriginal = stTransformed -> transformed -> identity -> stIdentity -> stOriginal
1281 Matrix4 identity2stIdentity;
1282 Texdef_basisForNormal( projection, plane.normal(), identity2stIdentity );
1283 //globalOutputStream() << "identity2stIdentity: " << identity2stIdentity << "\n";
1285 if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_HALFLIFE ) {
1286 matrix4_transform_direction( identity2transformed, projection.m_basis_s );
1287 matrix4_transform_direction( identity2transformed, projection.m_basis_t );
1290 Matrix4 transformed2stTransformed;
1291 Texdef_basisForNormal( projection, normalTransformed, transformed2stTransformed );
1293 Matrix4 stTransformed2identity( matrix4_affine_inverse( matrix4_multiplied_by_matrix4( transformed2stTransformed, identity2transformed ) ) );
1295 Vector3 originalProjectionAxis( vector4_to_vector3( matrix4_affine_inverse( identity2stIdentity ).z() ) );
1297 Vector3 transformedProjectionAxis( vector4_to_vector3( stTransformed2identity.z() ) );
1299 Matrix4 stIdentity2stOriginal;
1300 Texdef_toTransform( projection, (float)width, (float)height, stIdentity2stOriginal );
1301 Matrix4 identity2stOriginal( matrix4_multiplied_by_matrix4( stIdentity2stOriginal, identity2stIdentity ) );
1303 //globalOutputStream() << "originalProj: " << originalProjectionAxis << "\n";
1304 //globalOutputStream() << "transformedProj: " << transformedProjectionAxis << "\n";
1305 double dot = vector3_dot( originalProjectionAxis, transformedProjectionAxis );
1306 //globalOutputStream() << "dot: " << dot << "\n";
1308 // The projection axis chosen for the transformed normal is at 90 degrees
1309 // to the transformed projection axis chosen for the original normal.
1310 // This happens when the projection axis is ambiguous - e.g. for the plane
1311 // 'X == Y' the projection axis could be either X or Y.
1312 //globalOutputStream() << "flipped\n";
1314 globalOutputStream() << "projection off by 90\n";
1315 globalOutputStream() << "normal: ";
1316 print_vector3( plane.normal() );
1317 globalOutputStream() << "original projection: ";
1318 print_vector3( originalProjectionAxis );
1319 globalOutputStream() << "transformed projection: ";
1320 print_vector3( transformedProjectionAxis );
1323 Matrix4 identityCorrected = matrix4_reflection_for_plane45( plane, originalProjectionAxis, transformedProjectionAxis );
1325 identity2stOriginal = matrix4_multiplied_by_matrix4( identity2stOriginal, identityCorrected );
1328 Matrix4 stTransformed2stOriginal = matrix4_multiplied_by_matrix4( identity2stOriginal, stTransformed2identity );
1330 Texdef_fromTransform( projection, (float)width, (float)height, stTransformed2stOriginal );
1331 Texdef_normalise( projection, (float)width, (float)height );
1335 void Q3_to_matrix( const texdef_t& texdef, float width, float height, const Vector3& normal, Matrix4& matrix ){
1336 Normal_GetTransform( normal, matrix );
1340 Texdef_toTransform( texdef, width, height, transform );
1342 matrix4_multiply_by_matrix4( matrix, transform );
1345 void BP_from_matrix( brushprimit_texdef_t& bp_texdef, const Vector3& normal, const Matrix4& transform ){
1347 basis = g_matrix4_identity;
1348 ComputeAxisBase( normal, vector4_to_vector3( basis.x() ), vector4_to_vector3( basis.y() ) );
1349 vector4_to_vector3( basis.z() ) = normal;
1350 matrix4_transpose( basis );
1351 matrix4_affine_invert( basis );
1353 Matrix4 basis2texture = matrix4_multiplied_by_matrix4( basis, transform );
1355 BPTexdef_fromTransform( bp_texdef, basis2texture );
1358 void Q3_to_BP( const texdef_t& texdef, float width, float height, const Vector3& normal, brushprimit_texdef_t& bp_texdef ){
1360 Q3_to_matrix( texdef, width, height, normal, matrix );
1361 BP_from_matrix( bp_texdef, normal, matrix );