Question

对于学校，我最近开始创建自己的光线跟踪器。然而，无论是计算观察光线还是检查三角形和光线之间的交叉点，我都遇到了麻烦。据我所知，计算似乎正确执行，因为我将相机放在原点并让它面向-z轴朝向它前面的物体，允许手动进行简单的矢量数学运算。一切似乎都结束了，但屏幕上什么都没画。

我将发布使用计算观察光线的代码。

public Ray generateRay(float nX, float nY , Point2f coordinates)
{
    // Compute l, r, b and t.
    Vector3f temp = VectorHelper.multiply(u, nX/2.0f);
    float r = temp.x + Position.x;
    temp = VectorHelper.multiply(u, -nX/2.0f);
    float l = temp.x + Position.x;
    temp = VectorHelper.multiply(v, nY/2.0f);
    float t = temp.y + Position.y;
    temp = VectorHelper.multiply(v, -nY/2.0f);
    float b = temp.y + Position.y;

    // Compute the u and v coordinates.
    float uCo = (l + (r - l) * (coordinates.x + 0.5f)/nX);
    float vCo = (b + (t - b) * (coordinates.y + 0.5f)/nY);

    // Compute the ray's direction.
    Vector3f rayDirection = VectorHelper.multiply(w, -FocalLength);
    temp = VectorHelper.add(VectorHelper.multiply(u, uCo), VectorHelper.multiply(v, vCo));
    rayDirection = VectorHelper.add(rayDirection, temp);
    rayDirection = VectorHelper.add(rayDirection, Position);
    rayDirection = VectorHelper.normalize(VectorHelper.add(rayDirection, temp));

    // Create and return the ray.
    return new Ray(Position, rayDirection);
}

以下代码是我用来计算交叉点的代码。它使用Cramer's Rule来求解矩阵方程。

public static Point3f rayTriangleIntersection(
        Ray ray, Point3f vertexA, Point3f vertexB, Point3f vertexC)
{
    // Solve the linear system formed by the ray and the parametric surface
    // formed by the points of the triangle.
    // | a d g |   | B |   | j |
    // | b e h | * | Y | = | k |
    // | c f i | * | t | = | l |
    // The following uses Cramer's rule to that effect.
    float a = vertexA.x - vertexB.x; float d = vertexA.x - vertexC.x; float g = ray.getDirection().x;
    float b = vertexA.y - vertexB.y; float e = vertexA.y - vertexC.y; float h = ray.getDirection().y;
    float c = vertexA.z - vertexB.z; float f = vertexA.z - vertexC.z; float i = ray.getDirection().z;

    float j = vertexA.x - ray.getOrigin().x;
    float k = vertexA.y - ray.getOrigin().y;
    float l = vertexA.z - ray.getOrigin().z;

    // Compute some subterms in advance.
    float eihf = (e * i) - (h * f);
    float gfdi = (g * f) - (d * i);
    float dheg = (d * h) - (e * g);
    float akjb = (a * k) - (j * b);
    float jcal = (j * c) - (a * l);
    float blkc = (b * l) - (k * c);
    // Compute common division number.
    float m = (a * eihf) + (b * gfdi) + (c * dheg);

    // Compute unknown t and check whether the point is within the given
    // depth interval.
    float t = -((f * akjb) + (e * jcal) + (d * blkc)) / m;
    if (t < 0)
        return null;

    // Compute unknown gamma and check whether the point intersects the
    // triangle.
    float gamma = ((i * akjb) + (h * jcal) + (g * blkc)) / m;
    if (gamma < 0 || gamma > 1)
        return null;

    // Compute unknown beta and check whether the point intersects the
    // triangle.
    float beta = ((j * eihf) + (k * gfdi) + (l * dheg)) / m;
    if (beta < 0 || beta > (1 - gamma))
        return null;

    // Else, compute the intersection point and return it.
    Point3f result = new Point3f();
    result.x = ray.getOrigin().x + t * ray.getDirection().x;
    result.y = ray.getOrigin().y + t * ray.getDirection().y;
    result.z = ray.getOrigin().z + t * ray.getDirection().z;
    return result;
}

我的问题很简单。我究竟做错了什么？我已经查看并调试了这个代码，并且不能单独列出错误，谷歌提供的内容比我在我使用的书中已有的理论要多得多。此外，代码仍然相当粗糙，因为我只是专注于在清理它之前使其工作。

提前致谢，

凯文

Answer 1

很难准确说出出了什么问题。特别是因为您没有使用描述性变量名称（nX，nY等等）

以下是一些提示：

首先确保它不是显示代码中的错误。伪造一个交叉点，以证明当你碰到某些东西时你会得到可见的输出，例如：使屏幕右下角的所有光线都与轴对齐的平面或类似的东西相撞，以便您可以轻松验证坐标
首先尝试光线/球体交点。它比光线/三角形交叉点更容易。
考虑使用矢量/矩阵运算，而不是手动计算所有组件。在许多混乱的字母中犯错误太容易了。
如果您有比例问题（例如对象太小），请仔细检查世界和屏幕坐标之间的转换。世界坐标将在小的双数范围内（例如0.2 .... 5.0），而屏幕坐标应根据您的视图大小（例如0 ... 1024）为像素位置。您应该在世界坐标中完成大部分数学操作，只能在渲染代码的开头和结尾处从/向屏幕坐标转换。
在调试器中逐步执行顶级光线跟踪代码，并确保为每个屏幕坐标（尤其是屏幕的角落）生成合理方向的光线。
检查相机方向是否指向目标物体。让它看向完全相反的方向是一个很容易的错误！

应该有效的示例设置：

摄像机位置[0 0 4]
对象位置[0 0 0]
相机方向[0 0 -1]（如果你想让它看向原点，请注意减号！）
UP向量[0 0.75 0]
右矢量[+/- 1 0 0]

然后你的光线方向应该是（像素[screenX，screenY]）：

ray = DIRECTION +（2 *（screenX / screenWidth）-1）* RIGHT +（1-2 *（screenY / screenHeight））* UP

ray = normalize（ray）

Raytracer，计算观察光线（Java）

1 个答案: