//vec3 vec3_origin = {0,0,0};
-void PlaneFromPoints( float *p0, float *p1, float *p2, PLANE *plane ){
- vec3 t1, t2;
- vec length;
-
- VectorSubtract( p0, p1, t1 );
- VectorSubtract( p2, p1, t2 );
- plane->normal[0] = t1[1] * t2[2] - t1[2] * t2[1];
- plane->normal[1] = t1[2] * t2[0] - t1[0] * t2[2];
- plane->normal[2] = t1[0] * t2[1] - t1[1] * t2[0];
-
- length = (vec)( sqrt( plane->normal[0] * plane->normal[0] +
- plane->normal[1] * plane->normal[1] +
- plane->normal[2] * plane->normal[2] ) );
- if ( length == 0 ) {
- VectorClear( plane->normal );
- }
- else
- {
- plane->normal[0] /= length;
- plane->normal[1] /= length;
- plane->normal[2] /= length;
- }
- plane->dist = DotProduct( p0, plane->normal );
+void PlaneFromPoints(float *p0, float *p1, float *p2, PLANE *plane)
+{
+ vec3 t1, t2;
+ vec length;
+
+ VectorSubtract(p0, p1, t1);
+ VectorSubtract(p2, p1, t2);
+ plane->normal[0] = t1[1] * t2[2] - t1[2] * t2[1];
+ plane->normal[1] = t1[2] * t2[0] - t1[0] * t2[2];
+ plane->normal[2] = t1[0] * t2[1] - t1[1] * t2[0];
+
+ length = (vec) (sqrt(plane->normal[0] * plane->normal[0] +
+ plane->normal[1] * plane->normal[1] +
+ plane->normal[2] * plane->normal[2]));
+ if (length == 0) {
+ VectorClear(plane->normal);
+ } else {
+ plane->normal[0] /= length;
+ plane->normal[1] /= length;
+ plane->normal[2] /= length;
+ }
+ plane->dist = DotProduct(p0, plane->normal);
}
/*
void VectorMA (vec3 va, vec scale, vec3 vb, vec3 vc)
AllocWinding
=============
*/
-MY_WINDING *AllocWinding( int points ){
- MY_WINDING *w;
- int s;
-
- s = sizeof( vec ) * 3 * points + sizeof( int );
- w = (MY_WINDING*)malloc( s );
- memset( w, 0, s );
- return w;
+MY_WINDING *AllocWinding(int points)
+{
+ MY_WINDING *w;
+ int s;
+
+ s = sizeof(vec) * 3 * points + sizeof(int);
+ w = (MY_WINDING *) malloc(s);
+ memset(w, 0, s);
+ return w;
}
/*
vec VectorNormalize (vec3 in, vec3 out)
BaseWindingForPlane
=================
*/
-MY_WINDING *BaseWindingForPlane( vec3 normal, vec dist ){
- int i, x;
- vec max, v;
- vec3 org, vright, vup;
- MY_WINDING *w;
+MY_WINDING *BaseWindingForPlane(vec3 normal, vec dist)
+{
+ int i, x;
+ vec max, v;
+ vec3 org, vright, vup;
+ MY_WINDING *w;
// find the major axis
- max = -BOGUS_RANGE;
- x = -1;
- for ( i = 0 ; i < 3; i++ )
- {
- v = (vec)( fabs( normal[i] ) );
- if ( v > max ) {
- x = i;
- max = v;
- }
- }
- if ( x == -1 ) {
- x = 2;
- }
-
- VectorCopy( vec3_origin,vup );
- switch ( x )
- {
- case 0:
- case 1:
- vup[2] = 1;
- break;
- case 2:
- vup[0] = 1;
- break;
- }
-
- v = DotProduct( vup, normal );
- VectorMA( vup, -v, normal, vup );
- VectorNormalize( vup, vup );
-
- VectorScale( normal, dist, org );
-
- CrossProduct( vup, normal, vright );
-
- VectorScale( vup, 65536, vup );
- VectorScale( vright, 65536, vright );
+ max = -BOGUS_RANGE;
+ x = -1;
+ for (i = 0; i < 3; i++) {
+ v = (vec) (fabs(normal[i]));
+ if (v > max) {
+ x = i;
+ max = v;
+ }
+ }
+ if (x == -1) {
+ x = 2;
+ }
+
+ VectorCopy(vec3_origin, vup);
+ switch (x) {
+ case 0:
+ case 1:
+ vup[2] = 1;
+ break;
+ case 2:
+ vup[0] = 1;
+ break;
+ }
+
+ v = DotProduct(vup, normal);
+ VectorMA(vup, -v, normal, vup);
+ VectorNormalize(vup, vup);
+
+ VectorScale(normal, dist, org);
+
+ CrossProduct(vup, normal, vright);
+
+ VectorScale(vup, 65536, vup);
+ VectorScale(vright, 65536, vright);
// project a really big axis aligned box onto the plane
- w = AllocWinding( 4 );
+ w = AllocWinding(4);
- VectorSubtract( org, vright, w->p[0] );
- VectorAdd( w->p[0], vup, w->p[0] );
+ VectorSubtract(org, vright, w->p[0]);
+ VectorAdd(w->p[0], vup, w->p[0]);
- VectorAdd( org, vright, w->p[1] );
- VectorAdd( w->p[1], vup, w->p[1] );
+ VectorAdd(org, vright, w->p[1]);
+ VectorAdd(w->p[1], vup, w->p[1]);
- VectorAdd( org, vright, w->p[2] );
- VectorSubtract( w->p[2], vup, w->p[2] );
+ VectorAdd(org, vright, w->p[2]);
+ VectorSubtract(w->p[2], vup, w->p[2]);
- VectorSubtract( org, vright, w->p[3] );
- VectorSubtract( w->p[3], vup, w->p[3] );
+ VectorSubtract(org, vright, w->p[3]);
+ VectorSubtract(w->p[3], vup, w->p[3]);
- w->numpoints = 4;
+ w->numpoints = 4;
- return w;
+ return w;
}
-void FreeWinding( MY_WINDING *w ){
- if ( *(unsigned *)w == 0xdeaddead ) {
+void FreeWinding(MY_WINDING *w)
+{
+ if (*(unsigned *) w == 0xdeaddead) {
// Error ("FreeWinding: freed a freed winding");
- return;
- }
- *(unsigned *)w = 0xdeaddead;
+ return;
+ }
+ *(unsigned *) w = 0xdeaddead;
- free( w );
+ free(w);
}
/*
ChopWindingInPlace
=============
*/
-void ChopWindingInPlace( MY_WINDING **inout, vec3 normal, vec dist, vec epsilon ){
- MY_WINDING *in;
- vec dists[MAX_POINTS_ON_WINDING + 4];
- int sides[MAX_POINTS_ON_WINDING + 4];
- int counts[3];
- static vec dot; // VC 4.2 optimizer bug if not static
- int i, j;
- vec *p1, *p2;
- vec3 mid;
- MY_WINDING *f;
- int maxpts;
-
- in = *inout;
- counts[0] = counts[1] = counts[2] = 0;
+void ChopWindingInPlace(MY_WINDING **inout, vec3 normal, vec dist, vec epsilon)
+{
+ MY_WINDING *in;
+ vec dists[MAX_POINTS_ON_WINDING + 4];
+ int sides[MAX_POINTS_ON_WINDING + 4];
+ int counts[3];
+ static vec dot; // VC 4.2 optimizer bug if not static
+ int i, j;
+ vec *p1, *p2;
+ vec3 mid;
+ MY_WINDING *f;
+ int maxpts;
+
+ in = *inout;
+ counts[0] = counts[1] = counts[2] = 0;
// determine sides for each point
- for ( i = 0 ; i < in->numpoints ; i++ )
- {
- dot = DotProduct( in->p[i], normal );
- dot -= dist;
- dists[i] = dot;
- if ( dot > epsilon ) {
- sides[i] = SIDE_FRONT;
- }
- else if ( dot < -epsilon ) {
- sides[i] = SIDE_BACK;
- }
- else
- {
- sides[i] = SIDE_ON;
- }
- counts[sides[i]]++;
- }
- sides[i] = sides[0];
- dists[i] = dists[0];
-
- if ( !counts[0] ) {
- FreeWinding( in );
- *inout = NULL;
- return;
- }
- if ( !counts[1] ) {
- return; // inout stays the same
-
- }
- maxpts = in->numpoints + 4; // cant use counts[0]+2 because
- // of fp grouping errors
-
- f = AllocWinding( maxpts );
-
- for ( i = 0 ; i < in->numpoints ; i++ )
- {
- p1 = in->p[i];
-
- if ( sides[i] == SIDE_ON ) {
- VectorCopy( p1, f->p[f->numpoints] );
- f->numpoints++;
- continue;
- }
-
- if ( sides[i] == SIDE_FRONT ) {
- VectorCopy( p1, f->p[f->numpoints] );
- f->numpoints++;
- }
-
- if ( sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i] ) {
- continue;
- }
-
- // generate a split point
- p2 = in->p[( i + 1 ) % in->numpoints];
-
- dot = dists[i] / ( dists[i] - dists[i + 1] );
- for ( j = 0 ; j < 3 ; j++ )
- { // avoid round off error when possible
- if ( normal[j] == 1 ) {
- mid[j] = dist;
- }
- else if ( normal[j] == -1 ) {
- mid[j] = -dist;
- }
- else{
- mid[j] = p1[j] + dot * ( p2[j] - p1[j] );
- }
- }
-
- VectorCopy( mid, f->p[f->numpoints] );
- f->numpoints++;
- }
+ for (i = 0; i < in->numpoints; i++) {
+ dot = DotProduct(in->p[i], normal);
+ dot -= dist;
+ dists[i] = dot;
+ if (dot > epsilon) {
+ sides[i] = SIDE_FRONT;
+ } else if (dot < -epsilon) {
+ sides[i] = SIDE_BACK;
+ } else {
+ sides[i] = SIDE_ON;
+ }
+ counts[sides[i]]++;
+ }
+ sides[i] = sides[0];
+ dists[i] = dists[0];
+
+ if (!counts[0]) {
+ FreeWinding(in);
+ *inout = NULL;
+ return;
+ }
+ if (!counts[1]) {
+ return; // inout stays the same
+
+ }
+ maxpts = in->numpoints + 4; // cant use counts[0]+2 because
+ // of fp grouping errors
+
+ f = AllocWinding(maxpts);
+
+ for (i = 0; i < in->numpoints; i++) {
+ p1 = in->p[i];
+
+ if (sides[i] == SIDE_ON) {
+ VectorCopy(p1, f->p[f->numpoints]);
+ f->numpoints++;
+ continue;
+ }
+
+ if (sides[i] == SIDE_FRONT) {
+ VectorCopy(p1, f->p[f->numpoints]);
+ f->numpoints++;
+ }
+
+ if (sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i]) {
+ continue;
+ }
+
+ // generate a split point
+ p2 = in->p[(i + 1) % in->numpoints];
+
+ dot = dists[i] / (dists[i] - dists[i + 1]);
+ for (j = 0; j < 3; j++) { // avoid round off error when possible
+ if (normal[j] == 1) {
+ mid[j] = dist;
+ } else if (normal[j] == -1) {
+ mid[j] = -dist;
+ } else {
+ mid[j] = p1[j] + dot * (p2[j] - p1[j]);
+ }
+ }
+
+ VectorCopy(mid, f->p[f->numpoints]);
+ f->numpoints++;
+ }
// if (f->numpoints > maxpts)
// Error ("ClipWinding: points exceeded estimate");
// if (f->numpoints > MAX_POINTS_ON_WINDING)
// Error ("ClipWinding: MAX_POINTS_ON_WINDING");
- FreeWinding( in );
- *inout = f;
+ FreeWinding(in);
+ *inout = f;
}
-void UseFaceBounds(){
- LPVOID vp;
- float Dot, BestDot;
- float planepts[3][3];
- int BestFace;
- int i, j;
- int NumFaces;
- vec3 SurfNormal;
- vec3 vmin,vmax;
- PLANE plane[MAX_FACES * 2];
- PLANE pface;
- MY_WINDING *w;
-
- switch ( Plane )
- {
- case PLANE_XY1:
- SurfNormal[0] = 0.0;
- SurfNormal[1] = 0.0;
- SurfNormal[2] = -1.0;
- break;
- case PLANE_XZ0:
- SurfNormal[0] = 0.0;
- SurfNormal[1] = 1.0;
- SurfNormal[2] = 0.0;
- break;
- case PLANE_XZ1:
- SurfNormal[0] = 0.0;
- SurfNormal[1] = -1.0;
- SurfNormal[2] = 0.0;
- break;
- case PLANE_YZ0:
- SurfNormal[0] = 1.0;
- SurfNormal[1] = 0.0;
- SurfNormal[2] = 0.0;
- break;
- case PLANE_YZ1:
- SurfNormal[0] = -1.0;
- SurfNormal[1] = 0.0;
- SurfNormal[2] = 0.0;
- break;
- default:
- SurfNormal[0] = 0.0;
- SurfNormal[1] = 0.0;
- SurfNormal[2] = 1.0;
- }
+void UseFaceBounds()
+{
+ LPVOID vp;
+ float Dot, BestDot;
+ float planepts[3][3];
+ int BestFace;
+ int i, j;
+ int NumFaces;
+ vec3 SurfNormal;
+ vec3 vmin, vmax;
+ PLANE plane[MAX_FACES * 2];
+ PLANE pface;
+ MY_WINDING *w;
+
+ switch (Plane) {
+ case PLANE_XY1:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] = -1.0;
+ break;
+ case PLANE_XZ0:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] = 1.0;
+ SurfNormal[2] = 0.0;
+ break;
+ case PLANE_XZ1:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] = -1.0;
+ SurfNormal[2] = 0.0;
+ break;
+ case PLANE_YZ0:
+ SurfNormal[0] = 1.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] = 0.0;
+ break;
+ case PLANE_YZ1:
+ SurfNormal[0] = -1.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] = 0.0;
+ break;
+ default:
+ SurfNormal[0] = 0.0;
+ SurfNormal[1] = 0.0;
+ SurfNormal[2] = 1.0;
+ }
#if 0
- i = g_FuncTable.m_pfnAllocateSelectedBrushHandles();
- vp = g_FuncTable.m_pfnGetSelectedBrushHandle( 0 );
- NumFaces = g_FuncTable.m_pfnGetFaceCount( vp );
-
- BestFace = -1;
- BestDot = 0.0;
-
- for ( i = 0; i < NumFaces; i++ )
- {
- _QERFaceData* QERFaceData = g_FuncTable.m_pfnGetFaceData( vp,i );
- planepts[0][0] = QERFaceData->m_v1[0];
- planepts[0][1] = QERFaceData->m_v1[1];
- planepts[0][2] = QERFaceData->m_v1[2];
- planepts[1][0] = QERFaceData->m_v2[0];
- planepts[1][1] = QERFaceData->m_v2[1];
- planepts[1][2] = QERFaceData->m_v2[2];
- planepts[2][0] = QERFaceData->m_v3[0];
- planepts[2][1] = QERFaceData->m_v3[1];
- planepts[2][2] = QERFaceData->m_v3[2];
-
- PlaneFromPoints( planepts[0], planepts[1], planepts[2], &plane[2 * i] );
- VectorSubtract( vec3_origin, plane[2 * i].normal, plane[2 * i + 1].normal );
- plane[2 * i + 1].dist = -plane[2 * i].dist;
-
- Dot = DotProduct( plane[2 * i].normal,SurfNormal );
- if ( Dot > BestDot ) {
- BestDot = Dot;
- BestFace = i;
- if ( strlen( QERFaceData->m_TextureName ) ) {
- strcpy( Texture[Game][0],QERFaceData->m_TextureName );
- }
- }
- }
- for ( i = 0; i < NumFaces; i++ )
- {
- if ( i == BestFace ) {
- continue;
- }
- _QERFaceData* QERFaceData = g_FuncTable.m_pfnGetFaceData( vp,i );
- if ( strlen( QERFaceData->m_TextureName ) ) {
- if ( strcmp( Texture[Game][0],QERFaceData->m_TextureName ) ) {
- strcpy( Texture[Game][1],QERFaceData->m_TextureName );
- }
- }
- }
-
-
- g_FuncTable.m_pfnReleaseSelectedBrushHandles();
-
- w = BaseWindingForPlane( plane[BestFace * 2].normal, plane[BestFace * 2].dist );
-
- for ( i = 0 ; i < NumFaces && w; i++ )
- {
- if ( BestFace == i ) {
- continue;
- }
- ChopWindingInPlace( &w, plane[i * 2 + 1].normal, plane[i * 2 + 1].dist, 0 );
- }
- if ( !w ) {
- return;
- }
-
- // Get bounding box for this face
- vmin[0] = vmax[0] = w->p[0][0];
- vmin[1] = vmax[1] = w->p[0][1];
- vmin[2] = vmax[2] = w->p[0][2];
- for ( j = 1; j < w->numpoints; j++ )
- {
- vmin[0] = min( vmin[0],w->p[j][0] );
- vmin[1] = min( vmin[1],w->p[j][1] );
- vmin[2] = min( vmin[2],w->p[j][2] );
- vmax[0] = max( vmax[0],w->p[j][0] );
- vmax[1] = max( vmax[1],w->p[j][1] );
- vmax[2] = max( vmax[2],w->p[j][2] );
- }
-
- FreeWinding( w );
-
- VectorCopy( plane[BestFace * 2].normal,pface.normal );
- pface.dist = plane[BestFace * 2].dist;
- switch ( Plane )
- {
- case PLANE_XZ0:
- case PLANE_XZ1:
- if ( pface.normal[1] == 0. ) {
- return;
- }
- Hll = vmin[0];
- Hur = vmax[0];
- Vll = vmin[2];
- Vur = vmax[2];
- Z00 = ( pface.dist - pface.normal[0] * Hll - pface.normal[2] * Vll ) / pface.normal[1];
- Z01 = ( pface.dist - pface.normal[0] * Hll - pface.normal[2] * Vur ) / pface.normal[1];
- Z10 = ( pface.dist - pface.normal[0] * Hur - pface.normal[2] * Vll ) / pface.normal[1];
- Z11 = ( pface.dist - pface.normal[0] * Hur - pface.normal[2] * Vur ) / pface.normal[1];
- break;
- case PLANE_YZ0:
- case PLANE_YZ1:
- if ( pface.normal[0] == 0. ) {
- return;
- }
- Hll = vmin[1];
- Hur = vmax[1];
- Vll = vmin[2];
- Vur = vmax[2];
- Z00 = ( pface.dist - pface.normal[1] * Hll - pface.normal[2] * Vll ) / pface.normal[0];
- Z01 = ( pface.dist - pface.normal[1] * Hll - pface.normal[2] * Vur ) / pface.normal[0];
- Z10 = ( pface.dist - pface.normal[1] * Hur - pface.normal[2] * Vll ) / pface.normal[0];
- Z11 = ( pface.dist - pface.normal[1] * Hur - pface.normal[2] * Vur ) / pface.normal[0];
- break;
- default:
- if ( pface.normal[2] == 0. ) {
- return;
- }
- Hll = vmin[0];
- Hur = vmax[0];
- Vll = vmin[1];
- Vur = vmax[1];
- Z00 = ( pface.dist - pface.normal[0] * Hll - pface.normal[1] * Vll ) / pface.normal[2];
- Z01 = ( pface.dist - pface.normal[0] * Hll - pface.normal[1] * Vur ) / pface.normal[2];
- Z10 = ( pface.dist - pface.normal[0] * Hur - pface.normal[1] * Vll ) / pface.normal[2];
- Z11 = ( pface.dist - pface.normal[0] * Hur - pface.normal[1] * Vur ) / pface.normal[2];
- }
+ i = g_FuncTable.m_pfnAllocateSelectedBrushHandles();
+ vp = g_FuncTable.m_pfnGetSelectedBrushHandle( 0 );
+ NumFaces = g_FuncTable.m_pfnGetFaceCount( vp );
+
+ BestFace = -1;
+ BestDot = 0.0;
+
+ for ( i = 0; i < NumFaces; i++ )
+ {
+ _QERFaceData* QERFaceData = g_FuncTable.m_pfnGetFaceData( vp,i );
+ planepts[0][0] = QERFaceData->m_v1[0];
+ planepts[0][1] = QERFaceData->m_v1[1];
+ planepts[0][2] = QERFaceData->m_v1[2];
+ planepts[1][0] = QERFaceData->m_v2[0];
+ planepts[1][1] = QERFaceData->m_v2[1];
+ planepts[1][2] = QERFaceData->m_v2[2];
+ planepts[2][0] = QERFaceData->m_v3[0];
+ planepts[2][1] = QERFaceData->m_v3[1];
+ planepts[2][2] = QERFaceData->m_v3[2];
+
+ PlaneFromPoints( planepts[0], planepts[1], planepts[2], &plane[2 * i] );
+ VectorSubtract( vec3_origin, plane[2 * i].normal, plane[2 * i + 1].normal );
+ plane[2 * i + 1].dist = -plane[2 * i].dist;
+
+ Dot = DotProduct( plane[2 * i].normal,SurfNormal );
+ if ( Dot > BestDot ) {
+ BestDot = Dot;
+ BestFace = i;
+ if ( strlen( QERFaceData->m_TextureName ) ) {
+ strcpy( Texture[Game][0],QERFaceData->m_TextureName );
+ }
+ }
+ }
+ for ( i = 0; i < NumFaces; i++ )
+ {
+ if ( i == BestFace ) {
+ continue;
+ }
+ _QERFaceData* QERFaceData = g_FuncTable.m_pfnGetFaceData( vp,i );
+ if ( strlen( QERFaceData->m_TextureName ) ) {
+ if ( strcmp( Texture[Game][0],QERFaceData->m_TextureName ) ) {
+ strcpy( Texture[Game][1],QERFaceData->m_TextureName );
+ }
+ }
+ }
+
+
+ g_FuncTable.m_pfnReleaseSelectedBrushHandles();
+
+ w = BaseWindingForPlane( plane[BestFace * 2].normal, plane[BestFace * 2].dist );
+
+ for ( i = 0 ; i < NumFaces && w; i++ )
+ {
+ if ( BestFace == i ) {
+ continue;
+ }
+ ChopWindingInPlace( &w, plane[i * 2 + 1].normal, plane[i * 2 + 1].dist, 0 );
+ }
+ if ( !w ) {
+ return;
+ }
+
+ // Get bounding box for this face
+ vmin[0] = vmax[0] = w->p[0][0];
+ vmin[1] = vmax[1] = w->p[0][1];
+ vmin[2] = vmax[2] = w->p[0][2];
+ for ( j = 1; j < w->numpoints; j++ )
+ {
+ vmin[0] = min( vmin[0],w->p[j][0] );
+ vmin[1] = min( vmin[1],w->p[j][1] );
+ vmin[2] = min( vmin[2],w->p[j][2] );
+ vmax[0] = max( vmax[0],w->p[j][0] );
+ vmax[1] = max( vmax[1],w->p[j][1] );
+ vmax[2] = max( vmax[2],w->p[j][2] );
+ }
+
+ FreeWinding( w );
+
+ VectorCopy( plane[BestFace * 2].normal,pface.normal );
+ pface.dist = plane[BestFace * 2].dist;
+ switch ( Plane )
+ {
+ case PLANE_XZ0:
+ case PLANE_XZ1:
+ if ( pface.normal[1] == 0. ) {
+ return;
+ }
+ Hll = vmin[0];
+ Hur = vmax[0];
+ Vll = vmin[2];
+ Vur = vmax[2];
+ Z00 = ( pface.dist - pface.normal[0] * Hll - pface.normal[2] * Vll ) / pface.normal[1];
+ Z01 = ( pface.dist - pface.normal[0] * Hll - pface.normal[2] * Vur ) / pface.normal[1];
+ Z10 = ( pface.dist - pface.normal[0] * Hur - pface.normal[2] * Vll ) / pface.normal[1];
+ Z11 = ( pface.dist - pface.normal[0] * Hur - pface.normal[2] * Vur ) / pface.normal[1];
+ break;
+ case PLANE_YZ0:
+ case PLANE_YZ1:
+ if ( pface.normal[0] == 0. ) {
+ return;
+ }
+ Hll = vmin[1];
+ Hur = vmax[1];
+ Vll = vmin[2];
+ Vur = vmax[2];
+ Z00 = ( pface.dist - pface.normal[1] * Hll - pface.normal[2] * Vll ) / pface.normal[0];
+ Z01 = ( pface.dist - pface.normal[1] * Hll - pface.normal[2] * Vur ) / pface.normal[0];
+ Z10 = ( pface.dist - pface.normal[1] * Hur - pface.normal[2] * Vll ) / pface.normal[0];
+ Z11 = ( pface.dist - pface.normal[1] * Hur - pface.normal[2] * Vur ) / pface.normal[0];
+ break;
+ default:
+ if ( pface.normal[2] == 0. ) {
+ return;
+ }
+ Hll = vmin[0];
+ Hur = vmax[0];
+ Vll = vmin[1];
+ Vur = vmax[1];
+ Z00 = ( pface.dist - pface.normal[0] * Hll - pface.normal[1] * Vll ) / pface.normal[2];
+ Z01 = ( pface.dist - pface.normal[0] * Hll - pface.normal[1] * Vur ) / pface.normal[2];
+ Z10 = ( pface.dist - pface.normal[0] * Hur - pface.normal[1] * Vll ) / pface.normal[2];
+ Z11 = ( pface.dist - pface.normal[0] * Hur - pface.normal[1] * Vur ) / pface.normal[2];
+ }
#endif
}
projects / xonotic / netradiant.git / blobdiff