OpenGL根据x和y计算z坐标

Question

Say i have drawn a quad with points A(0,0,a) B(1,0,b) C(1,1,c) and D(0,1,d) and want to find out the coordinates P(0.6,0.25,p), how would i go about doing this? I'm hoping theres something less processor heavy i've missed, because thus far i've been trying to take the difference of Ax and Bx and then Cx and Dx and then finding the difference between those and its all a bit messy.

For example, say i want to find the point where the mouse is in this picture :

Is there an easier or less processor heavy way of finding the point there? (Not picking or raycasting, because the mouse wont be there, the mouse was just pointing at where i'd like it to happen, for example)

Answer 1

FYI: Using ray-casting should be adequate to do what you are looking for. You need to rotate the perspective of your fulcrum to focus from the absolute 0 above and absolute 1 of the location of your model. If you want another way to check quickly, barycentric coordinates are also useful.

Using barycentric coordinates you can determine a point inside a triangle:

function pointInTriangle(x1, y1, x2, y2, x3, y3, x, y:Number):Boolean
{
 var denominator:Number = ((y2 - y3)*(x1 - x3) + (x3 - x2)*(y1 - y3));
 var a:Number = ((y2 - y3)*(x - x3) + (x3 - x2)*(y - y3)) / denominator;
 var b:Number = ((y3 - y1)*(x - x3) + (x1 - x3)*(y - y3)) / denominator;
 var c:Number = 1 - a - b;

 return 0 <= a && a <= 1 && 0 <= b && b <= 1 && 0 <= c && c <= 1;
}

Barycentric coordinate allows to express new p coordinates as a linear combination of p1, p2, p3. More precisely, it defines 3 scalars a, b, c:

x = a * x1 + b * x2 + c * x3 y = a * y1 + b * y2 + c * y3 a + b + c = 1

The way to compute a, b, c is as follows:

a = ((y2 - y3) (x - x3) + (x3 - x2) (y - y3)) / ((y2 - y3) (x1 - x3) + (x3 - x2) (y1 - y3)) b = ((y3 - y1) (x - x3) + (x1 - x3) (y - y3)) / ((y2 - y3) (x1 - x3) + (x3 - x2) (y1 - y3)) c = 1 - a - b

p is inside of T if and only if 0 <= a <= 1 and 0 <= b <= 1 and 0 <= c <= 1

reference http://totologic.blogspot.fr/2014/01/accurate-point-in-triangle-test.html

Answer 2

This is not going to be the prettiest read, but here are a couple of samples of what you are looking to do. A downloadable project would probably be more useful for you, not sure that I could post all of that here though.

(This is basic ray-triangle intersection)

The use of OpenGL should be noted (this is c++ code below) The key part of the code that you would want to replicate outside of OpenGL (if glaux.lib is not used):

gluUnProject( PosX, PosY, 0, modelview, projection, viewport, &x1, &x2, &x3);
vnear.x = (float)x1; vnear.y = (float)x2; vnear.z = (float)x3;
gluUnProject( PosX, PosY, 1.0, modelview, projection, viewport, &x1, &x2, &x3);
vfar.x = (float)x1; vfar.y = (float)x2; vfar.z = (float)x3;

A basic collision class should be created:

class CCollision
{
public:
        CVec vnear;     // Where is 0 and where is 100% of fulcrum
        CVec vfar;
public:
    CCollision(void);
    ~CCollision(void);
public:
    bool checkLine (CVec &v1, CVec &v2,CVec &v3, CVec &p );
    bool checkLine( float *triangle, CVec &p );
    bool checkLine( float* v1, float* v2, float* v3, CVec &p ); 
    void projectRay ( int x, int y );
};

The definitions are as follows:

CCollision::CCollision(void){}
CCollision::~CCollision(void){}

bool CCollision::checkLine( float *triangle, CVec &p )
{
    CVec p1 = CVec( triangle[0], triangle[1], triangle[2] );
    CVec p2 = CVec( triangle[3], triangle[4], triangle[5] );
    CVec p3 = CVec( triangle[6], triangle[7], triangle[8] );
    return checkLine( p1, p2, p3, p );

}

bool CCollision::checkLine( float *v1, float *v2, float *v3, CVec &p )
{
    CVec p1 = CVec( v1[0], v1[1], v1[2] );
    CVec p2 = CVec( v2[0], v2[1], v2[2] );
    CVec p3 = CVec( v3[0], v3[1], v3[2] );
    return checkLine( p1, p2, p3, p );
}

bool CCollision::checkLine( CVec &v1, CVec &v2, CVec &v3, CVec &p )
{
    CVec sect;

    // Find Triangle Normal, then normalize it (use Magnitude)
    CVec Normal;
    Normal = ( v2 - v1 )%( v3 - v1 );
    Normal.Normalize(); // Normalize

    // Find the distance to the plane, based on the Normal.
    float distanceNear = (vnear-v1)^Normal;
    float distanceFar  = (vfar-v1)^Normal;

    if (( (distanceNear * distanceFar) >= 0.0f)||( distanceNear == distanceFar))
        return false; // Are they equal?

    // Find exact intersection point.
    sect = vnear + (vfar-vnear) * ( -distanceNear/(distanceFar-distanceNear) );

    // Check all points against the Normalized vector.
    CVec v;

    // Point 1
    v = Normal%( v2-v1 );
    if ( (v^( sect-v1 )) < 0.0f )
        return false;

    // Point 2
    v = Normal%( v3-v2 );
    if ( (v^( sect-v2 )) < 0.0f )
        return false;

    // Point 3
    v = Normal%( v1-v3 );
    if ( (v^( sect-v1 )) < 0.0f )
        return false;

    // Lastly, lets set the intersection point.
    p = sect;

    return true;
}


void CCollision::projectRay( int x, int y )
{
    GLint viewport[4];
    GLdouble modelview[16];
    GLdouble projection[16];
    GLdouble PosX, PosY, x1, x2, x3;

    glGetDoublev(GL_MODELVIEW_MATRIX, modelview );
    glGetDoublev(GL_PROJECTION_MATRIX, projection);

    glGetIntegerv(GL_VIEWPORT, viewport);

    PosX = (float)x;
    PosY = (float)viewport[3] - (float)y;

    gluUnProject( PosX, PosY, 0, modelview, projection, viewport, &x1, &x2, &x3);
    vnear.x = (float)x1; vnear.y = (float)x2; vnear.z = (float)x3;
    gluUnProject( PosX, PosY, 1.0, modelview, projection, viewport, &x1, &x2, &x3);
    vfar.x = (float)x1; vfar.y = (float)x2; vfar.z = (float)x3;
}

The way to use the code above is to capture the input and specify the needed data:

case WM_LBUTTONDOWN:
    project->scene->bCheckForCollision = true;
project->scene->collision.projectRay(
        LOWORD(((LPARAM *)m.LParam.ToPointer())),
        HIWORD((LPARAM *)m.LParam.ToPointer())

); } That would be using a mouse click as the capture, though we want to do it from a perspective matrix in all reality.

This code above comes from a working terrain generator I wrote back in 2005.

Alternatively, another way would be to run the inTriangle code I previously provided, then detecting slope for each side of the triangle. This would require rolling through all points.

A better way would be to create a perspective matrix like the one we described above. For a visual example of what you need to do:

rotate a camera to be looking directly down on the player

(c)-----> Player [ (terrain)

now, using the same concept I originally posted, you can identify the intersect point by creating a near/far vector from the perspective. This never needs to be drawn, but you are casting a ray to the exact point.