Как я могу сделать треугольник после умножения на матрицу проекции

Question

Я пытаюсь сделать 3d-игру с Java с нуля, но у меня проблема с рендерингом треугольника после того, как я умножил каждую вершину с помощью матрицы проекции

Я уже пытаюсь использовать спроецированные вершины x и y, но в результате все вершины находятся в одном и том же X, поэтому я пытаюсь повернуть треугольник X или Y или Z, но результат будет одинаковым.

Результат рендеринга (рисование краской):

Я знаю, что треугольник выровнен с камерой, но я попытался переместить перекрывающуюся вершину, изменив ее координаты X, Y или Z, но это не сработало

import java.awt.Color;
import java.awt.Graphics;

import measurement.MatrixF;
import measurement.Vector3f;
import model.Mesh;
import model.Triangle;
import toolbox.GE;
import toolbox.Matrix;
import toolbox.Vector;

public class MeshRenderer {

    private int width, height;
    private float fNear, fFar;
    private float fov;
    private float fAspectRatio;
    private float fovRad;
    private float theta;
    private MatrixF projectionMatrix;
    private MatrixF rotXMatrix;
    private MatrixF rotYMatrix;
    private MatrixF rotZMatrix;
    private Vector3f globalTranslation;

    public MeshRenderer(float fNear, float fFar, float fov, int width, int height) {
        this.fNear = fNear;
        this.fFar = fFar;
        this.fov = fov;
        this.fAspectRatio = height / width;
        this.width = width;
        this.height = height;
        this.fovRad = (float) (1.0f / Math.tan(Math.toRadians(fov / 2)));

        projectionMatrix = new MatrixF(4, 4);
        rotXMatrix = new MatrixF(4, 4);
        rotYMatrix = new MatrixF(4, 4);
        rotZMatrix = new MatrixF(4, 4);

        projectionMatrix.m[0][0] = fAspectRatio * fovRad;
        projectionMatrix.m[1][1] = fovRad;
        projectionMatrix.m[2][2] = (-(fFar + fNear)) / (fFar - fNear);
        projectionMatrix.m[3][2] = (-2 * fFar * fNear) / (fFar - fNear);
        projectionMatrix.m[2][3] = -1.0f;   
        projectionMatrix.m[3][3] = 0.0f;

        rotXMatrix.m[0][0] = 1;
        rotXMatrix.m[1][1] = (float) Math.cos(theta);
        rotXMatrix.m[2][1] = (float) -Math.sin(theta);
        rotXMatrix.m[1][2] = (float) Math.sin(theta);
        rotXMatrix.m[2][2] = (float) Math.cos(theta);

        rotYMatrix.m[0][0] = (float) Math.cos(theta);
        rotYMatrix.m[2][0] = (float) Math.sin(theta);
        rotYMatrix.m[1][1] = (float) 1.0;
        rotYMatrix.m[0][2] = (float) -Math.sin(theta);
        rotYMatrix.m[2][2] = (float) Math.cos(theta);

        rotXMatrix.m[2][2] = 1;
        rotXMatrix.m[0][0] = (float) Math.cos(theta);
        rotXMatrix.m[1][0] = (float) -Math.sin(theta);
        rotXMatrix.m[0][1] = (float) Math.sin(theta);
        rotXMatrix.m[1][1] = (float) Math.cos(theta);

        //projectionMatrix = Matrix.transpose(projectionMatrix);
        globalTranslation = new Vector3f(0.0f, 0.0f, 0.0f);
    }

    public void renderMesh(Mesh mesh, Graphics g) {

        for(int i = 0; i < mesh.tris.length; i++) {
            Triangle tri =  new Triangle(mesh.tris[i].p[0], mesh.tris[i].p[1], mesh.tris[i].p[2]);
            Triangle translatedTri = tri;
            Triangle projectedTri = new Triangle();

            theta += 0.0001;
            this.calculateRotationMatrix(theta);

            translatedTri.p[0] = Matrix.multiplyMatrixVector(tri.p[0], rotYMatrix);
            translatedTri.p[1] = Matrix.multiplyMatrixVector(tri.p[1], rotYMatrix);
            translatedTri.p[2] = Matrix.multiplyMatrixVector(tri.p[2], rotYMatrix);

            translatedTri.p[0].z = tri.p[0].z + globalTranslation.z;
            translatedTri.p[1].z = tri.p[1].z + globalTranslation.z;
            translatedTri.p[2].z = tri.p[2].z + globalTranslation.z;

            projectedTri.p[0] = Matrix.multiplyMatrixVector(translatedTri.p[0], projectionMatrix);
            projectedTri.p[1] = Matrix.multiplyMatrixVector(translatedTri.p[1], projectionMatrix);
            projectedTri.p[2] = Matrix.multiplyMatrixVector(translatedTri.p[2], projectionMatrix);

            projectedTri.p[0].x += 1.0f; projectedTri.p[0].y += 1.0f;
            projectedTri.p[1].x += 1.0f; projectedTri.p[1].y += 1.0f;
            projectedTri.p[2].x += 1.0f; projectedTri.p[2].y += 1.0f;

            float scale = 0.5f;

            projectedTri.p[0].x *= scale * width;
            projectedTri.p[0].y *= scale * height;
            projectedTri.p[1].x *= scale * width; 
            projectedTri.p[1].y *= scale * height;
            projectedTri.p[2].x *= scale * width; 
            projectedTri.p[2].y *= scale * height;


            GE.drawTriangle(projectedTri.p[0].x, projectedTri.p[0].y, projectedTri.p[1].x, projectedTri.p[1].y, projectedTri.p[2].x, projectedTri.p[2].y, Color.WHITE, g);

            for(int j = 0; j < projectedTri.p.length; j++) {
                g.setColor(new Color(255, 0, (j * 50)));
                g.fillRect((int)projectedTri.p[j].x - 8, (int)projectedTri.p[j].y - 8, 16 - j, 16 - j);
            }

            translatedTri.p[0].z = tri.p[0].z - globalTranslation.z;
            translatedTri.p[1].z = tri.p[1].z - globalTranslation.z;
            translatedTri.p[2].z = tri.p[2].z - globalTranslation.z;
        }
    }

    private void calculateRotationMatrix(float theta) {
        rotXMatrix.m[0][0] = 1;
        rotXMatrix.m[1][1] = (float) Math.cos(theta);
        rotXMatrix.m[2][1] = (float) -Math.sin(theta);
        rotXMatrix.m[1][2] = (float) Math.sin(theta);
        rotXMatrix.m[2][2] = (float) Math.cos(theta);

        rotYMatrix.m[0][0] = (float) Math.cos(theta);
        rotYMatrix.m[2][0] = (float) Math.sin(theta);
        rotYMatrix.m[1][1] = (float) 1.0;
        rotYMatrix.m[0][2] = (float) -Math.sin(theta);
        rotYMatrix.m[2][2] = (float) Math.cos(theta);

        rotXMatrix.m[2][2] = 1;
        rotXMatrix.m[0][0] = (float) Math.cos(theta);
        rotXMatrix.m[1][0] = (float) -Math.sin(theta);
        rotXMatrix.m[0][1] = (float) Math.sin(theta);
        rotXMatrix.m[1][1] = (float) Math.cos(theta);
    }

    public Vector3f getTranslation() {
        return globalTranslation;
    }

    public float getfNear() {
        return fNear;
    }

    public float getfFar() {
        return fFar;
    }

    public float getFov() {
        return fov;
    }

    public float getfAspectRatio() {
        return fAspectRatio;
    }

    public float getFovRad() {
        return fovRad;
    }

}

Матрица (4x4) умножается на функцию vector3 на всякий случай:

        Vector3f o = new Vector3f(0, 0, 0);
        o.x = (i.x * m.m[0][0]) + (i.y * m.m[1][0]) + (i.z * m.m[2][0]) + m.m[3][0];
        o.y = (i.x * m.m[0][1]) + (i.y * m.m[1][1]) + (i.z * m.m[2][1]) + m.m[3][1];
        o.z = (i.x * m.m[0][2]) + (i.y * m.m[1][2]) + (i.z * m.m[2][2]) + m.m[3][2];
        float w = (i.x * m.m[0][3]) + (i.y * m.m[1][3]) + (i.z * m.m[2][3]) + m.m[3][3];

        if (w != 0.0f)
        {
            o.x /= w; o.y /= w; o.z /= w;
        }

        return o;
    }

Answer 1

Не зная, как именно используется этот класс, трудно точно сказать, в чем проблема, но, FWIW, я не вижу слишком много не так с математикой:

• Есть пара мест, где вы, вероятно, намеревались инициализировать rotZMatrix вместо повторной инициализации rotXMatrix, но на самом деле код тоже не используется.

• При добавлении globalTranslation вы перезаписываете повернутую координату z на предварительно повернутую координату z, когда вы, вероятно, просто хотите обновить повернутую координату.

• Неясно, инициализирован ли MatrixF тождеством или нулями - но если последнее, вам, вероятно, следует заполнить элемент m[3][3] матриц вращения значением 1,0.

• Естественно, вы, вероятно, захотите поднять theta вычисление приращения и поворота за пределы треугольной петли, если у вас более одного треугольника.

Я предполагаю, что проблема в том, что вы оставляете globalTranslation в нуле и что сетка находится около начала координат - следовательно, преобразованная геометрия находится на изнаночной стороне ближней плоскости и за пределами усеченного вида. Большинство графических движков отбраковывают такую ​​геометрию, так как результаты посттрансформации будут находиться вне пространства клипа и будут выглядеть все более аномальными вокруг и позади точки зрения.

Я бы порекомендовал попробовать настроить globalTranslation.z для обеспечения 0 < fNear < translatedTri.p[i].z < fFar для всех переведенных точек.

(Вы также можете попытаться временно поменять матрицу перспективы на матрицу ортографической проекции, чтобы определить, находится ли проблема в математике проекции / гомогенизации или где-либо еще.)