462 lines
16 KiB
C++
Executable File
462 lines
16 KiB
C++
Executable File
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
#include "stdafx.h"
|
|
#include "qe3.h"
|
|
|
|
// compute a determinant using Sarrus rule
|
|
//++timo "inline" this with a macro
|
|
// NOTE : the three vec3_t are understood as columns of the matrix
|
|
vec_t SarrusDet(vec3_t a, vec3_t b, vec3_t 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];
|
|
}
|
|
|
|
//++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(vec3_t normal,vec3_t texS,vec3_t texT )
|
|
{
|
|
vec_t 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);
|
|
}
|
|
|
|
void FaceToBrushPrimitFace(face_t *f)
|
|
{
|
|
vec3_t texX,texY;
|
|
vec3_t proj;
|
|
// ST of (0,0) (1,0) (0,1)
|
|
vec_t 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 _DEBUG
|
|
if ( f->plane.normal[0]==0.0f && f->plane.normal[1]==0.0f && f->plane.normal[2]==0.0f )
|
|
{
|
|
Sys_Printf("Warning : f->plane.normal is (0,0,0) in FaceToBrushPrimitFace\n");
|
|
}
|
|
// check d_texture
|
|
if (!f->d_texture)
|
|
{
|
|
Sys_Printf("Warning : f.d_texture is NULL 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->d_texture, f);
|
|
VectorCopy(texX,ST[1]);
|
|
VectorAdd(ST[1],proj,ST[1]);
|
|
EmitTextureCoordinates(ST[1], f->d_texture, f);
|
|
VectorCopy(texY,ST[2]);
|
|
VectorAdd(ST[2],proj,ST[2]);
|
|
EmitTextureCoordinates(ST[2], f->d_texture, 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_t * w)
|
|
{
|
|
vec3_t texX,texY;
|
|
vec_t 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, NULL, &f->brushprimit_texdef, f->d_texture );
|
|
}
|
|
int i;
|
|
for (i=0 ; i<w->numpoints ; i++)
|
|
{
|
|
x=DotProduct(w->points[i],texX);
|
|
y=DotProduct(w->points[i],texY);
|
|
#ifdef _DEBUG
|
|
if (g_qeglobals.bNeedConvert)
|
|
{
|
|
// check we compute the same ST as the traditional texture computation used before
|
|
vec_t S=f->brushprimit_texdef.coords[0][0]*x+f->brushprimit_texdef.coords[0][1]*y+f->brushprimit_texdef.coords[0][2];
|
|
vec_t 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->points[i][3])>1e-2 || fabs(T-w->points[i][4])>1e-2 )
|
|
{
|
|
if ( fabs(S-w->points[i][3])>1e-4 || fabs(T-w->points[i][4])>1e-4 )
|
|
Sys_Printf("Warning : precision loss in brush -> brush primitive texture computation\n");
|
|
else
|
|
Sys_Printf("Warning : brush -> brush primitive texture computation bug detected\n");
|
|
}
|
|
}
|
|
#endif
|
|
w->points[i][3]=f->brushprimit_texdef.coords[0][0]*x+f->brushprimit_texdef.coords[0][1]*y+f->brushprimit_texdef.coords[0][2];
|
|
w->points[i][4]=f->brushprimit_texdef.coords[1][0]*x+f->brushprimit_texdef.coords[1][1]*y+f->brushprimit_texdef.coords[1][2];
|
|
}
|
|
}
|
|
|
|
// parse a brush in brush primitive format
|
|
void BrushPrimit_Parse(brush_t *b)
|
|
{
|
|
epair_t *ep;
|
|
face_t *f;
|
|
int i,j;
|
|
GetToken (true);
|
|
if (strcmp (token, "{"))
|
|
{
|
|
Warning ("parsing brush primitive");
|
|
return;
|
|
}
|
|
do
|
|
{
|
|
if (!GetToken (true))
|
|
break;
|
|
if (!strcmp (token, "}") )
|
|
break;
|
|
// reading of b->epairs if any
|
|
if (strcmp (token, "(") )
|
|
{
|
|
ep = ParseEpair();
|
|
ep->next = b->epairs;
|
|
b->epairs = ep;
|
|
}
|
|
else
|
|
// it's a face
|
|
{
|
|
f = Face_Alloc();
|
|
f->next = NULL;
|
|
if (!b->brush_faces)
|
|
b->brush_faces = f;
|
|
else
|
|
{
|
|
face_t *scan;
|
|
for (scan=b->brush_faces ; scan->next ; scan=scan->next)
|
|
;
|
|
scan->next = f;
|
|
}
|
|
|
|
// read the three point plane definition
|
|
for (i=0 ; i<3 ; i++)
|
|
{
|
|
if (i != 0)
|
|
GetToken (true);
|
|
if (strcmp (token, "(") )
|
|
{
|
|
Warning ("parsing brush");
|
|
return;
|
|
}
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
GetToken (false);
|
|
f->planepts[i][j] = atof(token);
|
|
}
|
|
GetToken (false);
|
|
if (strcmp (token, ")") )
|
|
{
|
|
Warning ("parsing brush");
|
|
return;
|
|
}
|
|
}
|
|
// texture coordinates
|
|
GetToken (false);
|
|
if (strcmp(token, "("))
|
|
{
|
|
Warning ("parsing brush primitive");
|
|
return;
|
|
}
|
|
GetToken (false);
|
|
if (strcmp(token, "("))
|
|
{
|
|
Warning ("parsing brush primitive");
|
|
return;
|
|
}
|
|
for (j=0;j<3;j++)
|
|
{
|
|
GetToken(false);
|
|
f->brushprimit_texdef.coords[0][j]=atof(token);
|
|
}
|
|
GetToken (false);
|
|
if (strcmp(token, ")"))
|
|
{
|
|
Warning ("parsing brush primitive");
|
|
return;
|
|
}
|
|
GetToken (false);
|
|
if (strcmp(token, "("))
|
|
{
|
|
Warning ("parsing brush primitive");
|
|
return;
|
|
}
|
|
for (j=0;j<3;j++)
|
|
{
|
|
GetToken(false);
|
|
f->brushprimit_texdef.coords[1][j]=atof(token);
|
|
}
|
|
GetToken (false);
|
|
if (strcmp(token, ")"))
|
|
{
|
|
Warning ("parsing brush primitive");
|
|
return;
|
|
}
|
|
GetToken (false);
|
|
if (strcmp(token, ")"))
|
|
{
|
|
Warning ("parsing brush primitive");
|
|
return;
|
|
}
|
|
// read the texturedef
|
|
GetToken (false);
|
|
//strcpy(f->texdef.name, token);
|
|
f->texdef.SetName(token);
|
|
if (TokenAvailable ())
|
|
{
|
|
GetToken (false);
|
|
f->texdef.contents = atoi(token);
|
|
GetToken (false);
|
|
f->texdef.flags = atoi(token);
|
|
GetToken (false);
|
|
f->texdef.value = atoi(token);
|
|
}
|
|
}
|
|
} while (1);
|
|
}
|
|
|
|
// compute a fake shift scale rot representation from the texture matrix
|
|
// these shift scale rot values are to be understood in the local axis base
|
|
void TexMatToFakeTexCoords( vec_t texMat[2][3], float shift[2], float *rot, float scale[2] )
|
|
{
|
|
#ifdef _DEBUG
|
|
// check this matrix is orthogonal
|
|
if (fabs(texMat[0][0]*texMat[0][1]+texMat[1][0]*texMat[1][1])>ZERO_EPSILON)
|
|
Sys_Printf("Warning : non orthogonal texture matrix in TexMatToFakeTexCoords\n");
|
|
#endif
|
|
scale[0]=sqrt(texMat[0][0]*texMat[0][0]+texMat[1][0]*texMat[1][0]);
|
|
scale[1]=sqrt(texMat[0][1]*texMat[0][1]+texMat[1][1]*texMat[1][1]);
|
|
#ifdef _DEBUG
|
|
if (scale[0]<ZERO_EPSILON || scale[1]<ZERO_EPSILON)
|
|
Sys_Printf("Warning : unexpected scale==0 in TexMatToFakeTexCoords\n");
|
|
#endif
|
|
// compute rotate value
|
|
if (fabs(texMat[0][0])<ZERO_EPSILON)
|
|
{
|
|
#ifdef _DEBUG
|
|
// check brushprimit_texdef[1][0] is not zero
|
|
if (fabs(texMat[1][0])<ZERO_EPSILON)
|
|
Sys_Printf("Warning : unexpected texdef[1][0]==0 in TexMatToFakeTexCoords\n");
|
|
#endif
|
|
// rotate is +-90
|
|
if (texMat[1][0]>0)
|
|
*rot=90.0f;
|
|
else
|
|
*rot=-90.0f;
|
|
}
|
|
else
|
|
*rot = RAD2DEG( atan2( texMat[1][0], texMat[0][0] ) );
|
|
shift[0] = -texMat[0][2];
|
|
shift[1] = texMat[1][2];
|
|
}
|
|
|
|
// compute back the texture matrix from fake shift scale rot
|
|
// the matrix returned must be understood as a qtexture_t with width=2 height=2 ( the default one )
|
|
void FakeTexCoordsToTexMat( float shift[2], float rot, float scale[2], vec_t texMat[2][3] )
|
|
{
|
|
texMat[0][0] = scale[0] * cos( DEG2RAD( rot ) );
|
|
texMat[1][0] = scale[0] * sin( DEG2RAD( rot ) );
|
|
texMat[0][1] = -1.0f * scale[1] * sin( DEG2RAD( rot ) );
|
|
texMat[1][1] = scale[1] * cos( DEG2RAD( rot ) );
|
|
texMat[0][2] = -shift[0];
|
|
texMat[1][2] = shift[1];
|
|
}
|
|
|
|
// convert a texture matrix between two qtexture_t
|
|
// if NULL for qtexture_t, basic 2x2 texture is assumed ( straight mapping between s/t coordinates and geometric coordinates )
|
|
void ConvertTexMatWithQTexture( brushprimit_texdef_t *texMat1, qtexture_t *qtex1, brushprimit_texdef_t *texMat2, qtexture_t *qtex2 )
|
|
{
|
|
float s1,s2;
|
|
s1 = ( qtex1 ? static_cast<float>( qtex1->width ) : 2.0f ) / ( qtex2 ? static_cast<float>( qtex2->width ) : 2.0f );
|
|
s2 = ( qtex1 ? static_cast<float>( qtex1->height ) : 2.0f ) / ( qtex2 ? static_cast<float>( qtex2->height ) : 2.0f );
|
|
texMat2->coords[0][0]=s1*texMat1->coords[0][0];
|
|
texMat2->coords[0][1]=s1*texMat1->coords[0][1];
|
|
texMat2->coords[0][2]=s1*texMat1->coords[0][2];
|
|
texMat2->coords[1][0]=s2*texMat1->coords[1][0];
|
|
texMat2->coords[1][1]=s2*texMat1->coords[1][1];
|
|
texMat2->coords[1][2]=s2*texMat1->coords[1][2];
|
|
}
|
|
|
|
// texture locking
|
|
void Face_MoveTexture_BrushPrimit(face_t *f, vec3_t delta)
|
|
{
|
|
vec3_t texS,texT;
|
|
vec_t tx,ty;
|
|
vec3_t M[3]; // columns of the matrix .. easier that way
|
|
vec_t det;
|
|
vec3_t 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 = DotProduct( delta, texS );
|
|
ty = DotProduct( 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;
|
|
}
|
|
|
|
// call Face_MoveTexture_BrushPrimit after vec3_t computation
|
|
void Select_ShiftTexture_BrushPrimit( face_t *f, int x, int y )
|
|
{
|
|
vec3_t texS,texT;
|
|
vec3_t delta;
|
|
ComputeAxisBase( f->plane.normal, texS, texT );
|
|
VectorScale( texS, static_cast<float>(x), texS );
|
|
VectorScale( texT, static_cast<float>(y), texT );
|
|
VectorCopy( texS, delta );
|
|
VectorAdd( delta, texT, delta );
|
|
Face_MoveTexture_BrushPrimit( f, delta );
|
|
}
|
|
|
|
// texture locking
|
|
// called before the points on the face are actually rotated
|
|
void RotateFaceTexture_BrushPrimit(face_t *f, int nAxis, float fDeg, vec3_t vOrigin )
|
|
{
|
|
vec3_t texS,texT; // axis base of the initial plane
|
|
vec3_t vRotate; // rotation vector
|
|
vec3_t Orig;
|
|
vec3_t rOrig,rvecS,rvecT; // (0,0) (1,0) (0,1) ( initial plane axis base ) after rotation ( world axis base )
|
|
vec3_t rNormal; // normal of the plane after rotation
|
|
vec3_t rtexS,rtexT; // axis base of the rotated plane
|
|
vec3_t lOrig,lvecS,lvecT; // [2] are not used ( but usefull for debugging )
|
|
vec3_t M[3];
|
|
vec_t det;
|
|
vec3_t D[2];
|
|
// compute plane axis base
|
|
ComputeAxisBase( f->plane.normal, texS, texT );
|
|
// compute coordinates of (0,0) (1,0) (0,1) ( initial plane axis base ) after rotation
|
|
// (0,0) (1,0) (0,1) ( initial plane axis base ) <-> (0,0,0) texS texT ( world axis base )
|
|
// rotation vector
|
|
VectorSet( vRotate, 0.0f, 0.0f, 0.0f );
|
|
vRotate[nAxis]=fDeg;
|
|
VectorSet( Orig, 0.0f, 0.0f, 0.0f );
|
|
VectorRotate( Orig, vRotate, vOrigin, rOrig );
|
|
VectorRotate( texS, vRotate, vOrigin, rvecS );
|
|
VectorRotate( texT, vRotate, vOrigin, rvecT );
|
|
// compute normal of plane after rotation
|
|
VectorRotate( f->plane.normal, vRotate, rNormal );
|
|
// 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] = DotProduct( rOrig, rtexS );
|
|
lOrig[1] = DotProduct( rOrig, rtexT );
|
|
lvecS[0] = DotProduct( rvecS, rtexS );
|
|
lvecS[1] = DotProduct( rvecS, rtexT );
|
|
lvecT[0] = DotProduct( rvecT, rtexS );
|
|
lvecT[1] = DotProduct( 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;
|
|
}
|
|
|
|
// best fitted 2D vector is x.X+y.Y
|
|
void ComputeBest2DVector( vec3_t v, vec3_t X, vec3_t Y, int &x, int &y )
|
|
{
|
|
double sx,sy;
|
|
sx = DotProduct( v, X );
|
|
sy = DotProduct( 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;
|
|
}
|
|
}
|