fly/flightgear
1
0
Fork 0
Code Activity

Here is a cleaned up hitlist that should solve the PLib conflict

Browse source 
and fixes a 'potential bug' if the FGFS View code were to change

I also consolidated the specialized IntersectLeaf()
as they really didn't gain us much outside of their having
'more direct access into the SSG controlled data'

I would like to see the fgCurrentElevation functions moved
out of hitlist.cxx.

The one obstacle is their being dependent on my PLib
auxillary functions

ssgGetEntityTransform()
ssgGetCurrentBSphere()

code has been run through astyle with the default options
This commit is contained in:
curt 2002-03-18 16:25:16 +00:00
parent 8138c82b58
commit 464f036f35
2 changed files with 413 additions and 674 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

558
src/Scenery/hitlist.cxx
View file

@ -6,19 +6,9 @@
# include <config.h> # include <config.h>
#endif #endif
#ifdef HAVE_WINDOWS_H
# include <windows.h>
#endif
#include <float.h> #include <float.h>
#include <math.h> #include <math.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <plib/sg.h>
#include <simgear/constants.h>
#include <simgear/sg_inlines.h> #include <simgear/sg_inlines.h>
#include <simgear/debug/logstream.hxx> #include <simgear/debug/logstream.hxx>
#include <simgear/math/point3d.hxx> #include <simgear/math/point3d.hxx>
@ -32,7 +22,16 @@
extern ssgBranch *terrain_branch; extern ssgBranch *terrain_branch;
static int sgdIsectInfLinePlane( sgdVec3 dst, const sgdVec3 l_org, // forward declaration of our helper/convenience functions
static void sgMultMat4(sgdMat4 dst, sgdMat4 m1, sgMat4 m2);
static void ssgGetEntityTransform(ssgEntity *entity, sgMat4 m );
static void ssgGetCurrentBSphere( ssgEntity *entity, sgVec3 center, float *radius, sgMat4 m );
// ======================
// This is same as PLib's sgdIsectInfLinePlane()
// and can be replaced by it after the next PLib release
static int fgdIsectInfLinePlane( sgdVec3 dst, const sgdVec3 l_org,
const sgdVec3 l_vec, const sgdVec4 plane ) const sgdVec3 l_vec, const sgdVec4 plane )
{ {
SGDfloat tmp = sgdScalarProductVec3 ( l_vec, plane ) ; SGDfloat tmp = sgdScalarProductVec3 ( l_vec, plane ) ;
@ -49,12 +48,15 @@ static int sgdIsectInfLinePlane( sgdVec3 dst, const sgdVec3 l_org,
return true ; return true ;
} }
// ======================
/* /*
* Given a point and a triangle lying on the same plane * Given a point and a triangle lying on the same plane
* check to see if the point is inside the triangle * check to see if the point is inside the triangle
*/ */
static bool sgdPointInTriangle( sgdVec3 point, sgdVec3 tri[3] ) // This is same as PLib's sgdPointInTriangle()
// and can be replaced by it after the next PLib release
static bool fgdPointInTriangle( sgdVec3 point, sgdVec3 tri[3] )
{ {
sgdVec3 dif; sgdVec3 dif;
@ -144,6 +146,7 @@ static bool sgdPointInTriangle( sgdVec3 point, sgdVec3 tri[3] )
return true; return true;
} }
// ======================
inline static int isZeroAreaTri( sgdVec3 tri[3] ) inline static int isZeroAreaTri( sgdVec3 tri[3] )
{ {
@ -152,48 +155,13 @@ inline static int isZeroAreaTri( sgdVec3 tri[3] )
sgdEqualVec3(tri[2], tri[0]) ); sgdEqualVec3(tri[2], tri[0]) );
} }
/* FGHitList::FGHitList() :
* Given a point and a triangle lying on the same plane last(NULL), test_dist(DBL_MAX)
* check to see if the point is inside the triangle
*/
#if 0
static bool PointInTri( sgdVec3 P, sgdVec3 V[3] )
{ {
sgdVec3 X,W1,W2;
sgdSubVec3(X,P,V[0]);
sgdSubVec3(W1,V[1],V[2]);
sgdSubVec3(W2,V[2],V[0]);
sgdVec3 C;
sgdVectorProductVec3(C, W1, W2);
double d = sgdScalarProductVec3(X,C);
// Test not needed if you KNOW point is on plane of triangle
// and triangle is not degenerate
if( d > -FLT_EPSILON && d < FLT_EPSILON )
return false;
double u11 = sgdScalarProductVec3(W1,W1);
double u22 = sgdScalarProductVec3(W2,W2);
double u12 = sgdScalarProductVec3(W1,W2);
double y1 = sgdScalarProductVec3(X,W1);
double y2 = sgdScalarProductVec3(X,W2);
double z1 = (y1*u22 - y2*u12)/d;
if( z1>0 || z1>1 )
return false;
double z2 = (y2*u11 - y1*u12)/d;
if( z2>0 || z2>1 )
return false;
return true;
} }
#endif
FGHitList::~FGHitList() {}
/* /*
Find the intersection of an infinite line with a leaf Find the intersection of an infinite line with a leaf
@ -235,7 +203,6 @@ int FGHitList::IntersectLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdSetVec3( tri[1], leaf->getVertex( i2 ) ); sgdSetVec3( tri[1], leaf->getVertex( i2 ) );
sgdSetVec3( tri[2], leaf->getVertex( i3 ) ); sgdSetVec3( tri[2], leaf->getVertex( i3 ) );
// avoid division by zero when two points are the same
if( isZeroAreaTri( tri ) ) if( isZeroAreaTri( tri ) )
continue; continue;
@ -243,8 +210,8 @@ int FGHitList::IntersectLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdMakePlane( plane, tri[0], tri[1], tri[2] ); sgdMakePlane( plane, tri[0], tri[1], tri[2] );
sgdVec3 point; sgdVec3 point;
if( sgdIsectInfLinePlane( point, orig, dir, plane ) ) { if( fgdIsectInfLinePlane( point, orig, dir, plane ) ) {
if( sgdPointInTriangle( point, tri ) ) { if( fgdPointInTriangle( point, tri ) ) {
// transform point into passed into desired coordinate frame // transform point into passed into desired coordinate frame
sgdXformPnt3( point, point, m ); sgdXformPnt3( point, point, m );
add(leaf,i,point,plane); add(leaf,i,point,plane);
@ -255,22 +222,28 @@ int FGHitList::IntersectLeaf( ssgLeaf *leaf, sgdMat4 m,
return num_hits; return num_hits;
} }
// ======================
//================= int FGHitList::IntersectLeaf( ssgLeaf *leaf, sgdMat4 m,
int FGHitList::IntersectPolyOrFanLeaf( ssgLeaf *leaf, sgdMat4 m, sgdVec3 orig, sgdVec3 dir,
sgdVec3 orig, sgdVec3 dir ) GLenum primType )
{ {
double tmp_dist; double tmp_dist;
// number of hits but there could be more that // number of hits but there could be more that
// were not found because of short circut switch ! // were not found because of short circut switch !
// so you may want to use the unspecialized IntersectLeaf() // so you may want to use the unspecialized IntersectLeaf()
int num_hits = 0; int n, num_hits = 0;
int ntri = leaf->getNumTriangles(); int ntri = leaf->getNumTriangles();
for ( int n = 0; n < ntri; ++n ) { for ( n = 0; n < ntri; ++n )
{
sgdVec3 tri[3]; sgdVec3 tri[3];
switch ( primType )
{
case GL_POLYGON :
case GL_TRIANGLE_FAN :
if ( !n ) { if ( !n ) {
sgdSetVec3( tri[0], leaf->getVertex( short(0) ) ); sgdSetVec3( tri[0], leaf->getVertex( short(0) ) );
sgdSetVec3( tri[1], leaf->getVertex( short(1) ) ); sgdSetVec3( tri[1], leaf->getVertex( short(1) ) );
@ -279,121 +252,14 @@ int FGHitList::IntersectPolyOrFanLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdCopyVec3( tri[1], tri[2] ); sgdCopyVec3( tri[1], tri[2] );
sgdSetVec3( tri[2], leaf->getVertex( short(n+2) ) ); sgdSetVec3( tri[2], leaf->getVertex( short(n+2) ) );
} }
break;
if( isZeroAreaTri( tri ) ) case GL_TRIANGLES :
continue;
sgdVec4 plane;
sgdMakePlane( plane, tri[0], tri[1], tri[2] );
sgdVec3 point;
//inlined IsectInfLinePlane( point dst, orig, dir, plane )
{
SGDfloat tmp = sgdScalarProductVec3 ( dir, plane ) ;
/* Is line parallel to plane? */
if ( sgdAbs ( tmp ) < FLT_EPSILON /*DBL_EPSILON*/ )
continue ;
sgdScaleVec3 ( point, dir,
-( sgdScalarProductVec3 ( orig, plane ) + plane[3] )
/ tmp ) ;
sgdAddVec3 ( point, orig ) ;
} // end of inlined intersection routine
// short circut if this point is further away then a previous hit
tmp_dist = sgdScalarProductVec3(point,point);
if( tmp_dist > test_dist )
continue;
if( sgdPointInTriangle( point, tri ) ) {
// transform point into passed coordinate frame
sgdXformPnt3( point, point, m );
add(leaf,n,point,plane);
test_dist = tmp_dist;
num_hits++;
}
}
return num_hits;
}
//===============
int FGHitList::IntersectTriLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir )
{
double tmp_dist;
// number of hits but there could be more that
// were not found because of short circut switch !
// so you may want to use the unspecialized IntersectLeaf()
int num_hits = 0;
int ntri = leaf->getNumTriangles();
for ( int n = 0; n < ntri; ++n ) {
sgdVec3 tri[3];
sgdSetVec3( tri[0], leaf->getVertex( short(n*3) ) ); sgdSetVec3( tri[0], leaf->getVertex( short(n*3) ) );
sgdSetVec3( tri[1], leaf->getVertex( short(n*3+1) ) ); sgdSetVec3( tri[1], leaf->getVertex( short(n*3+1) ) );
sgdSetVec3( tri[2], leaf->getVertex( short(n*3+2) ) ); sgdSetVec3( tri[2], leaf->getVertex( short(n*3+2) ) );
break;
// avoid division by zero when two points are the same case GL_TRIANGLE_STRIP :
if( isZeroAreaTri( tri ) ) case GL_QUAD_STRIP :
continue;
sgdVec4 plane;
sgdMakePlane( plane, tri[0], tri[1], tri[2] );
sgdVec3 point;
//inlined IsectInfLinePlane( point dst, orig, dir, plane )
{
SGDfloat tmp = sgdScalarProductVec3 ( dir, plane ) ;
/* Is line parallel to plane? */
if ( sgdAbs ( tmp ) < FLT_EPSILON /*DBL_EPSILON*/ )
continue ;
sgdScaleVec3 ( point, dir,
-( sgdScalarProductVec3 ( orig, plane ) + plane[3] )
/ tmp ) ;
sgdAddVec3 ( point, orig ) ;
} // end of inlined intersection routine
// short circut if this point is further away then a previous hit
tmp_dist = sgdScalarProductVec3(point,point);
if( tmp_dist > test_dist )
continue;
if( sgdPointInTriangle( point, tri ) ) {
// transform point into passed coordinate frame
sgdXformPnt3( point, point, m );
add(leaf,n,point,plane);
test_dist = tmp_dist;
num_hits++;
}
}
return num_hits;
}
//============================
int FGHitList::IntersectStripLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir )
{
double tmp_dist;
// number of hits but there could be more that
// were not found because of short circut switch !
// so you may want to use the unspecialized IntersectLeaf()
int num_hits = 0;
int ntri = leaf->getNumTriangles();
for ( int n = 0; n < ntri; ++n ) {
sgdVec3 tri[3];
if ( !n ) { if ( !n ) {
sgdSetVec3( tri[0], leaf->getVertex( short(0) ) ); sgdSetVec3( tri[0], leaf->getVertex( short(0) ) );
sgdSetVec3( tri[1], leaf->getVertex( short(1) ) ); sgdSetVec3( tri[1], leaf->getVertex( short(1) ) );
@ -410,6 +276,15 @@ int FGHitList::IntersectStripLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdSetVec3( tri[2], leaf->getVertex( short(n+2) ) ); sgdSetVec3( tri[2], leaf->getVertex( short(n+2) ) );
} }
} }
break;
case GL_QUADS :
sgdSetVec3( tri[0], leaf->getVertex( short(n*2) ) );
sgdSetVec3( tri[1], leaf->getVertex( short(n*2+1) ) );
sgdSetVec3( tri[2], leaf->getVertex( short(n*2 + 2 - (n&1)*4) ) );
break;
default:
return IntersectLeaf( leaf, m, orig, dir);
}
if( isZeroAreaTri( tri ) ) if( isZeroAreaTri( tri ) )
continue; continue;
@ -417,29 +292,29 @@ int FGHitList::IntersectStripLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec4 plane; sgdVec4 plane;
sgdMakePlane( plane, tri[0], tri[1], tri[2] ); sgdMakePlane( plane, tri[0], tri[1], tri[2] );
sgdVec3 point; sgdVec3 point, test;
//inlined IsectInfLinePlane( point dst, orig, dir, plane ) // find point of intersection of line from point org
{ // in direction dir with triangle's plane
SGDfloat tmp = sgdScalarProductVec3 ( dir, plane ) ; SGDfloat tmp = sgdScalarProductVec3 ( dir, plane ) ;
/* Is line parallel to plane? */ /* Is line parallel to plane? */
if ( sgdAbs ( tmp ) < FLT_EPSILON /*DBL_EPSILON*/ ) if ( sgdAbs ( tmp ) < FLT_EPSILON /*DBL_EPSILON*/ )
continue ; continue ;
// find parametric point
sgdScaleVec3 ( point, dir, sgdScaleVec3 ( point, dir,
-( sgdScalarProductVec3 ( orig, plane ) + plane[3] ) -( sgdScalarProductVec3 ( orig, plane ) + plane[3] )
/ tmp ) ; / tmp ) ;
sgdAddVec3 ( point, orig ) ;
} // end of inlined intersection routine
// short circut if this point is further away then a previous hit // short circut if this point is further away then a previous hit
tmp_dist = sgdScalarProductVec3(point,point); tmp_dist = sgdDistanceSquaredVec3(point, orig );
if( tmp_dist > test_dist ) if( tmp_dist > test_dist )
continue; continue;
if( sgdPointInTriangle( point, tri ) ) { // place parametric point in world
sgdAddVec3 ( point, orig ) ;
if( fgdPointInTriangle( point, tri ) ) {
// transform point into passed coordinate frame // transform point into passed coordinate frame
sgdXformPnt3( point, point, m ); sgdXformPnt3( point, point, m );
add(leaf,n,point,plane); add(leaf,n,point,plane);
@ -451,70 +326,107 @@ int FGHitList::IntersectStripLeaf( ssgLeaf *leaf, sgdMat4 m,
} }
// ====================== // ======================
inline static bool IN_RANGE( sgdVec3 v, double radius ) {
return ( sgdScalarProductVec3(v, v) < (radius*radius) );
}
int FGHitList::IntersectQuadsLeaf( ssgLeaf *leaf, sgdMat4 m, // ======================
void FGHitList::IntersectBranch( ssgBranch *branch, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir ) sgdVec3 orig, sgdVec3 dir )
{ {
double tmp_dist; /* the lookat vector and matrix in branch's coordinate frame
* but we won't determine these unless needed,
* This 'lazy evaluation' is a result of profiling data */
sgdVec3 orig_leaf, dir_leaf;
sgdMat4 m_leaf;
// number of hits but there could be more that // 'lazy evaluation' flag
// were not found because of short circut switch ! int first_time = 1;
// so you may want to use the unspecialized IntersectLeaf()
int num_hits = 0;
int ntri = leaf->getNumTriangles(); for ( ssgEntity *kid = branch->getKid( 0 );
for ( int n = 0; n < ntri; ++n ) { kid != NULL;
sgdVec3 tri[3]; kid = branch->getNextKid() )
sgdSetVec3( tri[0], leaf->getVertex( short(n*2) ) );
sgdSetVec3( tri[1], leaf->getVertex( short(n*2+1) ) );
sgdSetVec3( tri[2], leaf->getVertex( short(n*2 + 2 - (n&1)*4) ) );
if( isZeroAreaTri( tri ) )
continue;
sgdVec4 plane;
sgdMakePlane( plane, tri[0], tri[1], tri[2] );
sgdVec3 point;
//inlined IsectInfLinePlane( point dst, orig, dir, plane )
{ {
SGDfloat tmp = sgdScalarProductVec3 ( dir, plane ) ; if ( kid->getTraversalMask() & SSGTRAV_HOT )
{
sgdVec3 center;
sgdSetVec3( center,
kid->getBSphere()->getCenter()[0],
kid->getBSphere()->getCenter()[1],
kid->getBSphere()->getCenter()[2] );
sgdXformPnt3( center, m ) ;
/* Is line parallel to plane? */ // sgdClosestPointToLineDistSquared( center, orig, dir )
if ( sgdAbs ( tmp ) < FLT_EPSILON /*DBL_EPSILON*/ ) // inlined here because because of profiling results
continue ; sgdVec3 u, u1, v;
sgdSubVec3(u, center, orig);
sgdScaleVec3( u1, dir, sgdScalarProductVec3(u,dir)
/ sgdScalarProductVec3(dir,dir) );
sgdSubVec3(v, u, u1);
sgdScaleVec3 ( point, dir, // double because of possible overflow
-( sgdScalarProductVec3 ( orig, plane ) + plane[3] ) if ( IN_RANGE( v, double(kid->getBSphere()->getRadius()) ) )
/ tmp ) ; {
if ( kid->isAKindOf ( ssgTypeBranch() ) )
sgdAddVec3 ( point, orig ) ; {
} // end of inlined intersection routine sgdMat4 m_new;
if ( kid->isA( ssgTypeTransform() ) )
// short circut if this point is further away then a previous hit {
tmp_dist = sgdScalarProductVec3(point,point); sgMat4 fxform;
if( tmp_dist > test_dist ) ((ssgTransform *)kid)->getTransform( fxform );
continue; sgMultMat4(m_new, m, fxform);
} else {
if( sgdPointInTriangle( point, tri ) ) { sgdCopyMat4(m_new, m);
// transform point into passed coordinate frame
sgdXformPnt3( point, point, m );
add(leaf,n,point,plane);
test_dist = tmp_dist;
num_hits++;
} }
IntersectBranch( (ssgBranch *)kid, m_new, orig, dir );
} }
return num_hits; else if ( kid->isAKindOf( ssgTypeLeaf() ) )
{
if ( first_time ) {
sgdTransposeNegateMat4( m_leaf, m );
sgdXformPnt3( orig_leaf, orig, m_leaf );
sgdXformPnt3( dir_leaf, dir, m_leaf );
first_time = 0;
}
GLenum primType = ((ssgLeaf *)kid)->getPrimitiveType();
IntersectLeaf( (ssgLeaf *)kid, m, orig_leaf, dir_leaf, primType );
}
} // Out of range
} // branch not requested to be traversed
} // end for loop
} }
// ======================
// a temporary hack until we get everything rewritten with sgdVec3
static inline Point3D operator + (const Point3D& a, const sgdVec3 b)
{
return Point3D(a.x()+b[0], a.y()+b[1], a.z()+b[2]);
}
// ======================
void FGHitList::Intersect( ssgBranch *scene, sgdVec3 orig, sgdVec3 dir ) {
sgdMat4 m;
clear();
sgdMakeIdentMat4 ( m ) ;
IntersectBranch( scene, m, orig, dir );
}
// ======================
void FGHitList::Intersect( ssgBranch *scene, sgdMat4 m, sgdVec3 orig, sgdVec3 dir )
{
clear();
IntersectBranch( scene, m, orig, dir );
}
// ======================
// Need these because of mixed matrix types // Need these because of mixed matrix types
static void sgMultMat4(sgdMat4 dst, sgdMat4 m1, sgMat4 m2) static void sgMultMat4(sgdMat4 dst, sgdMat4 m1, sgMat4 m2)
{ {
for ( int j = 0 ; j < 4 ; j++ ) { for ( int j = 0 ; j < 4 ; j++ )
{
dst[0][j] = m2[0][0] * m1[0][j] + dst[0][j] = m2[0][0] * m1[0][j] +
m2[0][1] * m1[1][j] + m2[0][1] * m1[1][j] +
m2[0][2] * m1[2][j] + m2[0][2] * m1[2][j] +
@ -537,105 +449,8 @@ static void sgMultMat4(sgdMat4 dst, sgdMat4 m1, sgMat4 m2)
} }
} }
/* // ======================
* static void ssgGetEntityTransform(ssgEntity *entity, sgMat4 m )
*/
void FGHitList::IntersectBranch( ssgBranch *branch, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir )
{
/* the lookat vector and matrix in branch's coordinate frame
* but we won't determine these unless needed,
* This 'lazy evaluation' is a result of profiling data */
sgdVec3 orig_leaf, dir_leaf;
sgdMat4 m_leaf;
// 'lazy evaluation' flag
int first_time = 1;
for ( ssgEntity *kid = branch->getKid( 0 );
kid != NULL;
kid = branch->getNextKid() )
{
if ( kid->getTraversalMask() & SSGTRAV_HOT ) {
sgdVec3 center;
sgdSetVec3( center,
kid->getBSphere()->getCenter()[0],
kid->getBSphere()->getCenter()[1],
kid->getBSphere()->getCenter()[2] );
sgdXformPnt3( center, m ) ;
// sgdClosestPointToLineDistSquared( center, orig, dir )
// inlined here because because of profiling results
sgdVec3 u, u1, v;
sgdSubVec3(u, center, orig);
sgdScaleVec3( u1, dir, sgdScalarProductVec3(u,dir)
/ sgdScalarProductVec3(dir,dir) );
sgdSubVec3(v, u, u1);
// doubles because of possible overflow
#define SQUARE(x) (x*x)
if( sgdScalarProductVec3(v, v)
< SQUARE( double(kid->getBSphere()->getRadius()) ) )
{
// possible intersections
if ( kid->isAKindOf ( ssgTypeBranch() ) ) {
sgdMat4 m_new;
if ( kid->isA( ssgTypeTransform() ) )
{
sgMat4 fxform;
((ssgTransform *)kid)->getTransform( fxform );
sgMultMat4(m_new, m, fxform);
} else {
sgdCopyMat4(m_new, m);
}
IntersectBranch( (ssgBranch *)kid, m_new, orig, dir );
} else if ( kid->isAKindOf( ssgTypeLeaf() ) ) {
if ( first_time ) {
// OK we need these
sgdTransposeNegateMat4( m_leaf, m);
sgdXformPnt3( orig_leaf, orig, m_leaf );
sgdXformPnt3( dir_leaf, dir, m_leaf );
first_time = 0;
}
GLenum primType = ((ssgLeaf *)kid)->getPrimitiveType();
switch ( primType ) {
case GL_POLYGON :
case GL_TRIANGLE_FAN :
IntersectPolyOrFanLeaf( (ssgLeaf *)kid, m,
orig_leaf, dir_leaf );
break;
case GL_TRIANGLES :
IntersectTriLeaf( (ssgLeaf *)kid, m,
orig_leaf, dir_leaf );
break;
case GL_TRIANGLE_STRIP :
case GL_QUAD_STRIP :
IntersectStripLeaf( (ssgLeaf *)kid, m,
orig_leaf, dir_leaf );
break;
case GL_QUADS :
IntersectQuadsLeaf( (ssgLeaf *)kid, m,
orig_leaf, dir_leaf );
break;
default:
IntersectLeaf( (ssgLeaf *)kid, m,
orig_leaf, dir_leaf );
}
}
} else {
// end of the line for this branch
}
} else {
// branch requested not to be traversed
}
}
}
void ssgGetEntityTransform(ssgEntity *entity, sgMat4 m )
{ {
/* /*
Walk backwards up the tree, transforming the Walk backwards up the tree, transforming the
@ -650,7 +465,6 @@ void ssgGetEntityTransform(ssgEntity *entity, sgMat4 m )
If this node has a parent - get the composite If this node has a parent - get the composite
matrix for the parent. matrix for the parent.
*/ */
if ( entity->getNumParents() > 0 ) if ( entity->getNumParents() > 0 )
ssgGetEntityTransform ( entity->getParent(0), mat ) ; ssgGetEntityTransform ( entity->getParent(0), mat ) ;
else else
@ -659,7 +473,6 @@ void ssgGetEntityTransform(ssgEntity *entity, sgMat4 m )
/* /*
If this node has a transform - then concatenate it. If this node has a transform - then concatenate it.
*/ */
if ( entity -> isAKindOf ( ssgTypeTransform () ) ) { if ( entity -> isAKindOf ( ssgTypeTransform () ) ) {
sgMat4 this_mat ; sgMat4 this_mat ;
((ssgTransform *) entity) -> getTransform ( this_mat ) ; ((ssgTransform *) entity) -> getTransform ( this_mat ) ;
@ -668,32 +481,11 @@ void ssgGetEntityTransform(ssgEntity *entity, sgMat4 m )
sgCopyMat4 ( m, mat ) ; sgCopyMat4 ( m, mat ) ;
} }
#if 0
// previously used method
// This expects the inital m to be the identity transform
void ssgGetEntityTransform(ssgEntity *branch, sgMat4 m )
{
for ( ssgEntity *parent = branch->getParent(0);
parent != NULL;
parent = parent->getParent(0) )
{
// recurse till we are at the scene root
// then just unwinding the stack should
// give us our cumulative transform :-) NHV
ssgGetEntityTransform( parent, m );
if ( parent->isA( ssgTypeTransform() ) ) {
sgMat4 xform;
((ssgTransform *)parent)->getTransform( xform );
sgPreMultMat4( m, xform );
}
}
}
#endif // 0
// ======================
// return the passed entitity's bsphere's center point radius and // return the passed entitity's bsphere's center point radius and
// fully formed current model matrix for entity // fully formed current model matrix for entity
void ssgGetCurrentBSphere( ssgEntity *entity, sgVec3 center, static void ssgGetCurrentBSphere( ssgEntity *entity, sgVec3 center, float *radius, sgMat4 m )
float *radius, sgMat4 m )
{ {
sgSphere *bsphere = entity->getBSphere(); sgSphere *bsphere = entity->getBSphere();
*radius = (double)bsphere->getRadius(); *radius = (double)bsphere->getRadius();
@ -703,43 +495,7 @@ void ssgGetCurrentBSphere( ssgEntity *entity, sgVec3 center,
} }
void FGHitList::Intersect( ssgBranch *scene, sgdVec3 orig, sgdVec3 dir ) { // ======================
sgdMat4 m;
clear();
sgdMakeIdentMat4 ( m ) ;
IntersectBranch( scene, m, orig, dir);
}
static void CurrentNormalInLocalPlane(sgVec3 dst, sgVec3 src) {
sgVec3 tmp;
sgSetVec3(tmp, src[0], src[1], src[2] );
sgMat4 TMP;
sgTransposeNegateMat4 ( TMP, globals->get_current_view()->get_UP() ) ;
sgXformVec3(tmp, tmp, TMP);
sgSetVec3(dst, tmp[2], tmp[1], tmp[0] );
}
// a temporary hack until we get everything rewritten with sgdVec3
static inline Point3D operator + (const Point3D& a, const sgdVec3 b)
{
return Point3D(a.x()+b[0], a.y()+b[1], a.z()+b[2]);
}
/*
* This method is faster
*/
void FGHitList::Intersect( ssgBranch *scene, sgdMat4 m, sgdVec3 orig,
sgdVec3 dir )
{
clear();
IntersectBranch( scene, m, orig, dir);
}
// Determine scenery altitude via ssg. // Determine scenery altitude via ssg.
// returned results are in meters // returned results are in meters
bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center, bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center,
@ -752,7 +508,6 @@ bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center,
sgdVec3 orig, dir; sgdVec3 orig, dir;
sgdCopyVec3(orig, view_pos ); sgdCopyVec3(orig, view_pos );
sgdCopyVec3(dir, abs_view_pos ); sgdCopyVec3(dir, abs_view_pos );
// sgdNormalizeVec3(dir);
// !! why is terrain not globals->get_terrain() // !! why is terrain not globals->get_terrain()
hit_list->Intersect( terrain_branch, orig, dir ); hit_list->Intersect( terrain_branch, orig, dir );
@ -781,14 +536,16 @@ bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center,
*terrain_elev = result; *terrain_elev = result;
*radius = geoc.radius(); *radius = geoc.radius();
sgVec3 tmp; sgVec3 tmp;
sgMat4 TMP;
sgSetVec3(tmp, hit_list->get_normal(this_hit)); sgSetVec3(tmp, hit_list->get_normal(this_hit));
// cout << "cur_normal: " << tmp[0] << " " << tmp[1] << " " // cout << "cur_normal: " << tmp[0] << " " << tmp[1] << " "
// << tmp[2] << endl; // << tmp[2] << endl;
sgTransposeNegateMat4 ( TMP, globals->get_current_view()->get_UP() ) ;
sgXformVec3(tmp, tmp, TMP);
// cout << "NED: " << tmp[0] << " " << tmp[1] << " " << tmp[2] << endl;
sgdSetVec3( normal, tmp[2], tmp[1], tmp[0] );
/* ssgState *IntersectedLeafState = /* ssgState *IntersectedLeafState =
((ssgLeaf*)hit_list->get_entity(this_hit))->getState(); */ ((ssgLeaf*)hit_list->get_entity(this_hit))->getState(); */
CurrentNormalInLocalPlane(tmp, tmp);
sgdSetVec3( normal, tmp );
// cout << "NED: " << tmp[0] << " " << tmp[1] << " " << tmp[2] << endl;
return true; return true;
} else { } else {
SG_LOG( SG_TERRAIN, SG_INFO, "no terrain intersection" ); SG_LOG( SG_TERRAIN, SG_INFO, "no terrain intersection" );
@ -800,6 +557,7 @@ bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center,
} }
// ======================
// Determine scenery altitude via ssg. // Determine scenery altitude via ssg.
// returned results are in meters // returned results are in meters
bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center, bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center,
@ -807,10 +565,6 @@ bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center,
FGHitList *hit_list, FGHitList *hit_list,
double *terrain_elev, double *radius, double *normal) double *terrain_elev, double *radius, double *normal)
{ {
#ifndef FAST_HITLIST__TEST
return fgCurrentElev( abs_view_pos, scenery_center, hit_list,
terrain_elev,radius,normal);
#else
sgdVec3 view_pos; sgdVec3 view_pos;
sgdSubVec3( view_pos, abs_view_pos, scenery_center ); sgdSubVec3( view_pos, abs_view_pos, scenery_center );
@ -849,20 +603,18 @@ bool fgCurrentElev( sgdVec3 abs_view_pos, sgdVec3 scenery_center,
*terrain_elev = result; *terrain_elev = result;
*radius = geoc.radius(); *radius = geoc.radius();
sgVec3 tmp; sgVec3 tmp;
sgMat4 TMP;
sgSetVec3(tmp, hit_list->get_normal(this_hit)); sgSetVec3(tmp, hit_list->get_normal(this_hit));
// cout << "cur_normal: " << tmp[0] << " " << tmp[1] << " " sgTransposeNegateMat4 ( TMP, globals->get_current_view()->get_UP() ) ;
// << tmp[2] << endl; sgXformVec3(tmp, tmp, TMP);
sgdSetVec3( normal, tmp[2], tmp[1], tmp[0] );
/* ssgState *IntersectedLeafState = /* ssgState *IntersectedLeafState =
((ssgLeaf*)hit_list->get_entity(this_hit))->getState(); */ ((ssgLeaf*)hit_list->get_entity(this_hit))->getState(); */
CurrentNormalInLocalPlane(tmp, tmp);
sgdSetVec3( normal, tmp );
// cout << "NED: " << tmp[0] << " " << tmp[1] << " " << tmp[2] << endl;
return true; return true;
} else { } else {
SG_LOG( SG_TERRAIN, SG_DEBUG, "DOING FULL TERRAIN INTERSECTION" ); SG_LOG( SG_TERRAIN, SG_DEBUG, "DOING FULL TERRAIN INTERSECTION" );
return fgCurrentElev( abs_view_pos, scenery_center, hit_list, return fgCurrentElev( abs_view_pos, scenery_center, hit_list,
terrain_elev,radius,normal); terrain_elev,radius,normal);
} }
#endif // !FAST_HITLIST__TEST
} }

33
src/Scenery/hitlist.hxx
View file

@ -15,8 +15,6 @@
#include <plib/ssg.h> #include <plib/ssg.h>
#define FAST_HITLIST__TEST 1
SG_USING_STD(vector); SG_USING_STD(vector);
class FGHitRec { class FGHitRec {
@ -53,7 +51,9 @@ private:
public: public:
FGHitList() { last = NULL; test_dist=DBL_MAX; } FGHitList();
~FGHitList();
void init(void) { list.clear(); test_dist=DBL_MAX; } void init(void) { list.clear(); test_dist=DBL_MAX; }
void clear(void) { init(); last = NULL; } void clear(void) { init(); last = NULL; }
void add( ssgEntity *ent, int idx, sgdVec3 point, sgdVec3 normal ) { void add( ssgEntity *ent, int idx, sgdVec3 point, sgdVec3 normal ) {
@ -67,34 +67,21 @@ public:
double *get_point(int i) { return list[i].get_point(); } double *get_point(int i) { return list[i].get_point(); }
double *get_normal(int i) { return list[i].get_normal(); } double *get_normal(int i) { return list[i].get_normal(); }
void Intersect( ssgBranch *branch, void Intersect( ssgBranch *branch, sgdVec3 orig, sgdVec3 dir );
sgdVec3 orig, sgdVec3 dir ); void Intersect( ssgBranch *scene, sgdMat4 m, sgdVec3 orig, sgdVec3 dir );
void Intersect( ssgBranch *scene, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir );
void IntersectBranch( ssgBranch *branch, sgdMat4 m, void IntersectBranch( ssgBranch *branch, sgdMat4 m, sgdVec3 orig, sgdVec3 dir);
sgdVec3 orig, sgdVec3 dir);
void IntersectCachedLeaf( sgdVec3 orig, sgdVec3 dir);
int IntersectLeaf( ssgLeaf *leaf, sgdMat4 m, int IntersectLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir ); sgdVec3 orig, sgdVec3 dir );
int IntersectPolyOrFanLeaf( ssgLeaf *leaf, sgdMat4 m, int IntersectLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir ); sgdVec3 orig, sgdVec3 dir,
GLenum primType );
int IntersectTriLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir );
int IntersectStripLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir );
int IntersectQuadsLeaf( ssgLeaf *leaf, sgdMat4 m,
sgdVec3 orig, sgdVec3 dir );
}; };
// Associated function, assuming a wgs84 world with 0,0,0 at the // Associated functions, assuming a wgs84 world with 0,0,0 at the
// center, find the current terrain intersection elevation for the // center, find the current terrain intersection elevation for the
// point specified. // point specified.
bool fgCurrentElev( sgdVec3 abs_view_pos, bool fgCurrentElev( sgdVec3 abs_view_pos,