Perspective Projection et OPENGL Compute Shaders

Question

Je suis suit ce site pour apprendre raytracing en utilisant les shaders de calcul: https://github.com/LWJGL/lwjgl3-wiki/wiki/2.6.1.-Ray-tracing-with-OpenGL-Compute-Shaders-%28Part-I%29

Ma question, Le tutoriel détaille une procédure pour obtenir la projection en perspective. Je pense que j'ai suivi ses pas correctement mais je reçois le mauvais résultat et je crois que j'ai fait une erreur dans mes calculs matriciels.

Mon code pour la perspective La projection

//Getting the perspective projection using glm::perspective 
glm::mat4 projection = glm::perspective(60.0f, 1024.0f/768.0f, 1.0f, 2.0f); 

//My Camera Position 
glm::vec3 camPos=glm::vec3(3.0, 2.0, 7.0); 

//My View matrix using glm::lookAt 
glm::mat4 view = glm::lookAt(camPos, glm::vec3(0.0, 0.5, 0.0),glm::vec3(0.0, 1.0, 0.0)); 

//Calculating inverse of the view*projection 
glm::mat4 inv = glm::inverse(view*projection); 

//Calculating the rays from camera position to the corners of the frustum as detailed in the site. 
glm::vec4 ray00=glm::vec4(-1, -1, 0, 1) * inv; 
ray00 /= ray00.w; 
ray00 -= glm::vec4(camPos,1.0); 

glm::vec4 ray10 = glm::vec4(+1, -1, 0, 1) * inv; 
ray10 /= ray10.w; 
ray10 -= glm::vec4(camPos,1.0); 

glm::vec4 ray01=glm::vec4(-1, 1, 0, 1) * inv; 
ray01 /= ray01.w; 
ray01 -= glm::vec4(camPos,1.0); 

glm::vec4 ray11 = glm::vec4(+1, +1, 0, 1) * inv; 
ray11 /= ray11.w; 
ray11 -= glm::vec4(camPos,1.0); 

Résultat de Transformations ci-dessus: [! [Entrer image description ici] [1]]

[1]

d'information En plus, J'appelle mes shaders de calcul en utilisant

//Dispatch Shaders. 
glDispatchCompute ((GLuint)1024.0/16, (GLuint)768.0f/8 , 1); 

Je passe aussi les valeurs au shader en utilisant le

//Querying the location for ray00 and assigning the value. Similarly for the rest 
GLuint ray00Id = glGetUniformLocation(computeS, "ray00"); 
glUniform3f(ray00Id, ray00.x, ray00.y, ray00.z); 

GLuint ray01Id = glGetUniformLocation(computeS, "ray01"); 
glUniform3f(ray01Id, ray01.x, ray01.y, ray01.z); 

GLuint ray10Id = glGetUniformLocation(computeS, "ray10"); 
glUniform3f(ray10Id, ray10.x, ray10.y, ray10.z); 

GLuint ray11Id = glGetUniformLocation(computeS, "ray11"); 
glUniform3f(ray11Id, ray11.x, ray11.y, ray11.z); 

GLuint camId = glGetUniformLocation(computeS, "eye"); 
glUniform3f(camId, camPos.x, camPos.y, camPos.z); 

Mise à jour de réponse suite à la suggestion derhass.

Mon image ressemble maintenant à: Latest Image

Answer 1

La bibliothèque GLM utilise les conventions de la matrice standard OpenGL, ce qui signifie que les matrices sont créées avec l'ordre de multiplication Matrix * Vector à l'esprit. Ainsi, le code suivant est erroné:

//Calculating inverse of the view*projection 
glm::mat4 inv = glm::inverse(view*projection); 

La composition de la matrice de vue (transformation de l'espace mondial à l'espace des yeux) et la matrice de projection (transformation de l'espace visuel pour couper l'espace) est projection * view, pas view * projection que vous mettez il (qui appliquerait la projection avant la vue).