Comment projeter correctement un point derrière la caméra?

Je fais un jeu en 3D dans lequel je place un marqueur d'exclamation au-dessus des points d'intérêt.

Afin de savoir où sur l'écran 2D dois-je placer mon marqueur, je projette manuellement le point 3D où le marqueur doit être.

Cela ressemble à ceci:

Ça a l'air plutôt bien. Lorsque le marqueur est en dehors de l'écran, je coupe simplement les coordonnées pour qu'elles s'insèrent dans l'écran. Cela ressemble à ceci:

Jusqu'à présent, l'idée se passe plutôt bien. Cependant, lorsque les points d'intérêt sont derrière la caméra, les coordonnées X, Y résultantes sont inversées (comme en positif / négatif), et je fais apparaître le marqueur dans le coin opposé de l'écran, comme ceci:

(Le point projeté puis fixé est la pointe du marqueur. Ne vous souciez pas de la rotation du marqueur)

Cela a du sens, car les coordonnées derrière le tronc sont inversées en X et Y. Donc, ce que je fais, c'est inverser les coordonnées quand elles sont derrière la caméra. Cependant, je ne sais toujours pas quelle est exactement la condition lorsque les coordonnées doivent être inversées.

Voici à quoi ressemble mon code de projection (en C # avec SharpDX):

    public override PointF ProjectPosition(float viewportWidth, float viewportHeight, float y)
    {
        var projectionMatrix = Matrix.PerspectiveFovRH(GetCalibratedFOV(Camera.FOV, viewportWidth, viewportHeight), viewportWidth / viewportHeight, Camera.Near, Camera.Far);
        var viewMatrix = Matrix.LookAtRH(new Vector3(Camera.PositionX, Camera.PositionY, Camera.PositionZ), new Vector3(Camera.LookAtX, Camera.LookAtY, Camera.LookAtZ), Vector3.UnitY);
        var worldMatrix = Matrix.RotationY(Rotation) * Matrix.Scaling(Scaling) * Matrix.Translation(PositionX, PositionY, PositionZ);
        var worldViewProjectionMatrix = worldMatrix * viewMatrix * projectionMatrix;

        Vector4 targetVector = new Vector4(0, y, 0, 1);
        Vector4 projectedVector = Vector4.Transform(targetVector, worldViewProjectionMatrix);

        float screenX = (((projectedVector.X / projectedVector.W) + 1.0f) / 2.0f) * viewportWidth;
        float screenY = ((1.0f - (projectedVector.Y / projectedVector.W)) / 2.0f) * viewportHeight;
        float screenZ = projectedVector.Z / projectedVector.W;

        // Invert X and Y when behind the camera
        if (projectedVector.Z < 0 ||
            projectedVector.W < 0)
        {
            screenX = -screenX;
            screenY = -screenY;
        }

        return new PointF(screenX, screenY);
    }

Comme vous pouvez le voir, mon idée actuelle est d'inverser les coordonnées lorsque les coordonnées Z ou W sont négatives. Cela fonctionne la plupart du temps, mais il existe encore des emplacements de caméra très spécifiques où cela ne fonctionne pas. En particulier, ce point montre une coordonnée qui fonctionne et l'autre non (l'emplacement correct doit être en bas à droite):

J'ai essayé d'inverser quand:

• Z est négatif (c'est ce qui a le plus de sens pour moi)
• W est négatif (je ne comprends pas la signification d'une valeur W négative)
• Soit Zou West négatif (ce qui fonctionne actuellement la plupart du temps)
• Zet Wsont de signe différent, alias: Z / W < 0(est logique pour moi. ne fonctionne pas cependant)

Mais je n'ai toujours pas trouvé de manière cohérente avec laquelle tous mes points sont correctement projetés.

Des idées?

Que diriez-vous de le faire un peu différemment?

Commencez comme d'habitude et rendez tous les marqueurs dans la fenêtre. Si un marqueur est en dehors de la fenêtre - continuez:

1. Obtenez les positions du marqueur A
2. Obtenez la position de la caméra B(peut-être légèrement devant elle)
3. Calculer un vecteur 3D ABentre ces deux
4. Convertir et normaliser ce vecteur en limites d'écran 2D ( Asera au centre de la vue et Bfrappera une bordure de vues)

Les lignes de couleur sont des ABvecteurs. Les fines lignes noires représentent la hauteur des caractères. À droite, l'écran 2D

5. Peut-être ajoutez une règle, que tout derrière la caméra passe toujours au bord inférieur
6. Dessinez le marqueur dans l'espace d'écran en ce qui concerne les tailles et les chevauchements des marqueurs

Vous devrez peut-être essayer cela pour voir si le marqueur qui disparaît de la fenêtre sautera entre les positions. Si cela se produit, vous pouvez essayer de modifier la position lorsque le marqueur s'approche de la bordure de la fenêtre.

Étant donné les trois vecteurs [camera position], [camera direction]et [object position]. Calculez le produit scalaire de [camera direction]et [object position]-[camera position]. Si le résultat est négatif, l'objet est derrière la caméra.

Étant donné que j'ai bien compris votre code, ce serait:

if((PositionX - Camera.PositionX) * Camera.LookAtX
    + (PositionY - Camera.PositionY) * Camera.LookAtY
    + (PositionZ - Camera.PositionZ) * Camera.LookAtZ
    < 0)

Test uniquement (projeté.W <0), pas (Z <0 || W <0).

Dans certaines formulations d'espace clip ( toux OpenGL toux ), la plage visible comprend des valeurs Z positives et négatives, tandis que W est toujours positif devant la caméra et négatif derrière.

float screenX = (((projectedVector.X / abs(projectedVector.W)) + 1.0f) / 2.0f) * viewportWidth;
float screenY = ((1.0f - (projectedVector.Y / abs(projectedVector.W))) / 2.0f) * viewportHeight;

Et supprimez cette partie

// Invert X and Y when behind the camera
if (projectedVector.Z < 0 || projectedVector.W < 0)
{
    screenX = -screenX;
    screenY = -screenY;
}

Essayez un panneau d'affichage, qui fera automatiquement la photo face à la caméra, et dessinera automatiquement la photo sur l'écran au bon endroit