带阴影矩阵的投影，简单测试失败

Question

我写了一个小程序来测试投影的工作方式。

我想特别检查一下，投影点（可能是三角形的顶点）不在光源和平面之间，而是位于光源本身之后，即光源位于点和飞机。

问题是我的小程序甚至没有在光线和平面之间的点处工作。我查了计算的数十倍，所以我想误差应的逻辑，但我不能找到它..

下面的代码

public class test { 

    int x = 0; 
    int y = 1; 
    int z = 2; 
    int w = 3; 
    float floor[][] = { 
     {-100.0f, -100.0f, 0.0f}, 
     {100.0f, -100.0f, 0.0f}, 
     {100.0f, 100.0f, 0.0f}, 
     {-100.0f, 100.0f, 0.0f}}; 
    private float shadow_floor[] = new float[16]; 
    float light_position[] = {0.0f, 0.0f, 10.0f, 1.0f}; 

    public test() { 
     //Find floorplane based on thre known points 
     float plane_floor[] = calculatePlane(floor[1], floor[2], floor[3]); 

     //store shadowMatrix for floor 
     shadow_floor = shadowMatrix(plane_floor, light_position); 

     float[] point = new float[]{1.0f, 0.0f, 5.0f, 1.0f}; 

     float[] projectedPoint = pointFmatrixF(point, shadow_floor); 

     System.out.println("point: (" + point[x] + ", " + point[y] + ", " + point[z] + ", " 
       + point[w] + ")"); 
     System.out.println("projectedPoint: (" + projectedPoint[x] + ", " + projectedPoint[y] 
       + ", " + projectedPoint[z] + ", " + projectedPoint[w] + ")"); 
    } 

    public static void main(String args[]) { 
     test test = new test(); 
    } 

    // make shadow matrix 
    public float[] shadowMatrix(float plane[], float light_pos[]) { 
     float shadow_mat[] = new float[16]; 
     float dot; 


     dot = plane[x] * light_pos[x] + plane[y] * light_pos[y] 
       + plane[z] * light_pos[z] + plane[w] * light_pos[w]; 

     shadow_mat[0] = dot - light_pos[x] * plane[x]; 
     shadow_mat[4] = -light_pos[x] * plane[y]; 
     shadow_mat[8] = -light_pos[x] * plane[z]; 
     shadow_mat[12] = -light_pos[x] * plane[3]; 

     shadow_mat[1] = -light_pos[y] * plane[x]; 
     shadow_mat[5] = dot - light_pos[y] * plane[y]; 
     shadow_mat[9] = -light_pos[y] * plane[z]; 
     shadow_mat[13] = -light_pos[y] * plane[w]; 

     shadow_mat[2] = -light_pos[z] * plane[x]; 
     shadow_mat[6] = -light_pos[z] * plane[y]; 
     shadow_mat[10] = dot - light_pos[z] * plane[z]; 
     shadow_mat[14] = -light_pos[z] * plane[w]; 

     shadow_mat[3] = -light_pos[w] * plane[x]; 
     shadow_mat[7] = -light_pos[w] * plane[y]; 
     shadow_mat[11] = -light_pos[w] * plane[z]; 
     shadow_mat[15] = dot - light_pos[w] * plane[w]; 

     return shadow_mat; 
    } 

    public float[] calculatePlane(float p1[], float p2[], float p3[]) { 
     //Array for planlikningen 
     float plane[] = new float[4]; 

     //Gitt to vektorer (tre punkter) i planet kan normalen regnes ut 
     //Vi vil ha aboluttverdier 
     plane[x] = Math.abs(((p2[y] - p1[y]) * (p3[z] - p1[z])) - ((p2[z] - p1[z]) 
       * (p3[y] - p1[y]))); 
     plane[y] = Math.abs(((p2[z] - p1[z]) * (p3[x] - p1[x])) - ((p2[x] - p1[x]) 
       * (p3[z] - p1[z]))); 
     plane[z] = Math.abs(((p2[x] - p1[x]) * (p3[y] - p1[y])) - ((p2[y] - p1[y]) 
       * (p3[x] - p1[x]))); 
     plane[w] = -(plane[x] * p1[x] + plane[y] * p1[y] + plane[z] * p1[z]); 


     return plane; 
    } 

    public float[] pointFmatrixF(float[] point, float[] matrix) { 
     int x = 0; 
     int y = 1; 
     int z = 2; 
     float[] transformedPoint = new float[4]; 

     transformedPoint[x] = 
       matrix[0] * point[x] 
       + matrix[4] * point[y] 
       + matrix[8] * point[z] 
       + matrix[12]; 
     transformedPoint[y] = 
       matrix[1] * point[x] 
       + matrix[5] * point[y] 
       + matrix[9] * point[z] 
       + matrix[13]; 
     transformedPoint[z] = 
       matrix[2] * point[x] 
       + matrix[6] * point[y] 
       + matrix[10] * point[z] 
       + matrix[14]; 
     transformedPoint[w] = 1; 

     return transformedPoint; 
    } 
} 

如果飞机是xy平面，灯亮（0,0,10）和点（1,0,5）上，那么平面上的投影点应该是（2,0,0），但程序正在返回（400000.0,0.0,0.0,1.0）

Answer 1

解决了，我错误地假设投影点的最后一个坐标是1，但事实并非如此。

https://math.stackexchange.com/questions/320527/projecting-a-point-on-a-plane-through-a-matrix