La Mise En Œuvre De Ray Cueillette

J'ai un moteur de rendu de l'utilisation de directx et openGL, et une scène 3d. La fenêtre et la fenêtre sont de mêmes dimensions.

Comment puis-je mettre en œuvre la cueillette donné les coordonnées de la souris en x et y dans une plate-forme indépendante de la sorte?

Jetez un oeil à ce guide, il pourrait être utile

InformationsquelleAutor Tom J Nowell | 2010-01-19

29

Si vous le pouvez, faites la cueillette sur le CPU par le calcul d'un rayon de l'œil à travers le pointeur de la souris se croisent et s'entrecroisent avec vos modèles.

Si ce n'est pas une option, j'irais avec un certain type de l'ID de rendu. Attribuer à chaque objet que vous souhaitez sélectionner une couleur unique, rendre les objets avec ces couleurs et, enfin, la lecture de la couleur dans le framebuffer sous le pointeur de la souris.

EDIT: Si la question est de savoir comment construire les rayons à partir de la position de la souris vous avez besoin des éléments suivants: une matrice de projection P et la caméra transformer C. Si les coordonnées du pointeur de la souris est (x, y) et la taille de la fenêtre d'affichage est (largeur, hauteur) une position dans le clip de l'espace le long de la raie est:
```
mouse_clip = [
  float(x) * 2 /float(width) - 1,
  1 - float(y) * 2 /float(height),
  0,
  1]
```
(Remarquez que je suis retournée à l'axe des y comme souvent à l'origine des coordonnées de la souris sont dans le coin supérieur gauche)

La suite est tout aussi vrai:
```
mouse_clip = P * C * mouse_worldspace
```
Qui donne:
```
mouse_worldspace = inverse(C) * inverse(P) * mouse_clip
```
Nous avons maintenant:
```
p = C.position(); //origin of camera in worldspace
n = normalize(mouse_worldspace - p); //unit vector from p through mouse pos in worldspace
```
- Je le sais! la question est de savoir comment!!!!
- Ce n'était pas totalement clair à partir de la question. De toute façon, j'ai édité ma réponse, j'espère que ça aide.
- Il est intéressant de noter que si vous utilisez DirectX-même matrices puis la multiplication ordre est inversé.
- merci 🙂 j'aurais été plus clair au premier abord, mais votre édité réponse est ce que je voulais!
- Je ne sais pas si l'erreur est dans votre travail ou de la mienne, mais je n'ai pu avoir cet algorithme de travailler quand j'ai utilisé la valeur négative de la proximité de plan de découpe pour la coordonnée z de la mouse_clip. C'est à dire: mouse_clip = [float(x) * 2 / float(width) - 1, 1 - float(y) * 2 / float(height), -1 * near_clipping_plane, 1]
- Juste pour sauver les autres le problème: Cette méthode ne fonctionne que si le 3. coordonner dans mouse_clip n'est pas 0 mais -near_depth. En outre, pour une matrice orthogonale p doit être calculé différemment.
- Devrait mouseWorldSpace être divisé par sa propre w coordonner, car il a une transformation de perspective appliquée?
InformationsquelleAutor Andreas Brinck
24

Voici l'affichage frustum:

Vous devez d'abord déterminer où sur la nearplane le clic de la souris qui s'est passé:
1. de redimensionner la fenêtre de coordonnées (0..640,0..480) sur [-1,1], avec (-1,-1) dans le coin inférieur gauche et (1,1) en haut à droite.
2. "annuler" la projection en multipliant les coordonnées relatives à ce que j'appelle le "unview" matrice: unview = (P * M).inverse() = M.inverse() * P.inverse(), où M est la matrice ModelView et P est la matrice de projection.
Puis déterminer l'endroit où l'appareil photo est en worldspace, et dessiner un rayon de départ à la caméra et passant par le point que vous avez trouvé sur le nearplane.

La caméra est à M.inverse().col(4), c'est à dire la dernière colonne de l'inverse de la matrice ModelView.

Finale de pseudo:
```
normalised_x = 2 * mouse_x /win_width - 1
normalised_y = 1 - 2 * mouse_y /win_height
//note the y pos is inverted, so +y is at the top of the screen

unviewMat = (projectionMat * modelViewMat).inverse()

near_point = unviewMat * Vec(normalised_x, normalised_y, 0, 1)
camera_pos = ray_origin = modelViewMat.inverse().col(4)
ray_dir = near_point - camera_pos
```
- c'est quoi ce "modelView" matrice de vous allusion? C'est que la combinaison de la modelToWorld de la matrice du modèle que nous essayons de frapper et de l'appareil photo viewMatrix?
- Il a été un moment depuis que j'ai écrit cela, mais je pense que c'est la matrice qui transforme les coordonnées du monde dans l'appareil coordonnées. Si il y a une ligne dans le vertex shader comme gl_Position = projection * modelView * vertexPos;, c'est le bit dans le milieu, où l' projection de la matrice est la traduction de la caméra à la fenêtre d'affichage des coordonnées. HTH :/
InformationsquelleAutor nornagon
1

Bien, assez simple, la théorie derrière cela est toujours le même

1) Unproject deux fois votre 2D coordonner sur l'espace 3D. (chaque API a sa propre fonction, mais vous pouvez implémenter votre propre si vous le souhaitez). L'un au Min Z, l'un au Max de la Z.

2) Avec ces deux valeurs, calculer le vecteur qui va de Min Z et le point de Max Z.

3) Avec le vecteur et un point de calculer le rayon qui va de Min Z pour MaxZ

4) Maintenant, vous avez un rayon, et avec cela, vous pouvez faire un rayon-triangle/ray-plan/ray-quelque chose d'intersection et d'obtenir votre résultat...

InformationsquelleAutor feal87
1

J'ai peu de DirectX expérience, mais je suis sûr que c'est similaire à OpenGL. Ce que vous voulez, c'est le gluUnproject appel.

En supposant que vous avez un valide Z buffer, vous pouvez interroger le contenu de la mémoire tampon Z à une position de la souris avec:
```
//obtain the viewport, modelview matrix and projection matrix
//you may keep the viewport and projection matrices throughout the program if you don't change them
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
glGetIntegerv(GL_VIEWPORT, viewport);
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
glGetDoublev(GL_PROJECTION_MATRIX, projection);

//obtain the Z position (not world coordinates but in range 0 - 1)
GLfloat z_cursor;
glReadPixels(x_cursor, y_cursor, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &z_cursor);

//obtain the world coordinates
GLdouble x, y, z;
gluUnProject(x_cursor, y_cursor, z_cursor, modelview, projection, viewport, &x, &y, &z);
```
si vous ne souhaitez pas utiliser la glu vous pouvez également mettre en œuvre les gluUnProject vous pourriez également mettre en œuvre vous-même, c'est la fonctionnalité est relativement simple et est décrite à opengl.org
- merci, si Id besoin d'un API agnostique méthode était possible
- comme je l'ai dit, si vous ne voulez pas utiliser la glu fonction, vous pouvez juste mettre en œuvre les fonctionnalités de vous-même, vous auriez alors besoin est d'obtenir le modelview et matrices de projection pour chacun et pour obtenir le z de la position de la fenêtre pour chaque.
- ce qui m'obligerait à trouver la même xyz, je pourrais alors le poste que xyz, puis marquez-le comme la réponse à la place de celui-ci, vous voyez mon raisonnement? Quelqu'un d'autre a posté le maths de toute façon
InformationsquelleAutor wich

Ok, ce sujet est vieux, mais il était le meilleur que j'ai trouvé sur le sujet, et il m'a aidé un peu, donc je vais poster ici pour ceux qui suivent 😉

C'est la façon dont je l'ai eu à travailler sans avoir à calculer l'inverse de la matrice de Projection:

void Application::leftButtonPress(u32 x, u32 y){
    GL::Viewport vp = GL::getViewport(); //just a call to glGet GL_VIEWPORT
vec3f p = vec3f::from(                        
        ((float)(vp.width - x) /(float)vp.width),
        ((float)y /(float)vp.height),
            1.);
    //alternatively vec3f p = vec3f::from(                        
    //     ((float)x /(float)vp.width),
    //     ((float)(vp.height - y) /(float)vp.height),
    //     1.);

    p *= vec3f::from(APP_FRUSTUM_WIDTH, APP_FRUSTUM_HEIGHT, 1.);
    p += vec3f::from(APP_FRUSTUM_LEFT, APP_FRUSTUM_BOTTOM, 0.);

    //now p elements are in (-1, 1)
    vec3f near = p * vec3f::from(APP_FRUSTUM_NEAR);
    vec3f far = p * vec3f::from(APP_FRUSTUM_FAR);

    //ray in world coordinates
    Ray ray = { _camera->getPos(), -(_camera->getBasis() * (far - near).normalize()) };

    _ray->set(ray.origin, ray.dir, 10000.); //this is a debugging vertex array to see the Ray on screen

    Node* node = _scene->collide(ray, Transform());
   cout << "node is : " << node << endl;
}

Cela suppose une projection en perspective, mais jamais posé la question qui se pose pour les orthographiques de l'un en premier lieu.

InformationsquelleAutor nulleight

0

J'ai eu la même situation avec des rayons de la cueillette, mais quelque chose est faux. J'ai effectué la unproject opération de la bonne façon, mais il ne fonctionne tout simplement pas. Je pense, j'ai fait une erreur, mais ne peut pas trouver. Mon matix multiplication , inverse et vecteur par matix multiplications tous vu bien fonctionner, j'ai testé les.
Dans mon code je suis en réagissant sur WM_LBUTTONDOWN. Donc, lParam renvoie [Y][X] coordonnées que 2 mots dans un dword. Je les extraire, puis de les convertir à l'espace normalisé, j'ai vérifié cette partie fonctionne aussi très bien. Lorsque je clique sur le coin inférieur gauche - j'obtiens des valeurs proches de -1, -1 et de bonnes valeurs pour toutes les 3 autres coins. Je suis alors à l'aide de linepoins.vtx tableau pour le débogage et Il n'est même pas proche de la réalité.
```
unsigned int x_coord=lParam&0x0000ffff; //X RAW COORD
unsigned int y_coord=client_area.bottom-(lParam>>16); //Y RAW COORD

double xn=((double)x_coord/client_area.right)*2-1; //X [-1 +1]
double yn=1-((double)y_coord/client_area.bottom)*2;//Y [-1 +1]

_declspec(align(16))gl_vec4 pt_eye(xn,yn,0.0,1.0); 
gl_mat4 view_matrix_inversed;
gl_mat4 projection_matrix_inversed;
cam.matrixProjection.inverse(&projection_matrix_inversed);
cam.matrixView.inverse(&view_matrix_inversed);

gl_mat4::vec4_multiply_by_matrix4(&pt_eye,&projection_matrix_inversed);
gl_mat4::vec4_multiply_by_matrix4(&pt_eye,&view_matrix_inversed);

line_points.vtx[line_points.count*4]=pt_eye.x-cam.pos.x;
line_points.vtx[line_points.count*4+1]=pt_eye.y-cam.pos.y;
line_points.vtx[line_points.count*4+2]=pt_eye.z-cam.pos.z;
line_points.vtx[line_points.count*4+3]=1.0;
```
InformationsquelleAutor Antiusninja

Vous devez vous connecter pour publier un commentaire.