Parallax Corrected Cubemaps

4.1 Em Código

Só precisamos de uma pequena função para fazer a intersecção de um raio com uma caixa por dentro.

Usando o código no artigo mencionado na introdução, eu fiz uma versão mais genérica dele e também adicionei uma checagem de aabb para evitar que o raio faça intersecção por fora da caixa pois percebi que causa vários problemas gráficos em alguns cenários.

1. //P is rayOrigin + (rayDirection * t)
2. //where t is the return value
3. //returns -1.0 if the ray is outside the box
4. float intersectRayInsideBox(vec3 rayOrigin, vec3 rayDirection, mat4 worldToLocal) {
5. vec3 localOrigin = (worldToLocal * vec4(rayOrigin, 1.0)).xyz;
6. vec3 aabbCheck = abs(localOrigin);
7. if (max(aabbCheck.x, max(aabbCheck.y, aabbCheck.z)) > 1.0) {
8. return -1.0;
9. }
10. vec3 localDirection = mat3(worldToLocal) * rayDirection;
11. vec3 firstPlane = (vec3(-1.0) - localOrigin) / localDirection;
12. vec3 secondPlane = (vec3(1.0) - localOrigin) / localDirection;
13. vec3 furthestPlane = max(firstPlane, secondPlane);
14. return min(furthestPlane.x, min(furthestPlane.y, furthestPlane.z));
15. }

Mesmo se a função foi feita para um aabb, ela na verdade suporta qualquer caixa rotacionada ou escalada, já que aplicamos o inverso da matriz da caixa ao raio (a matriz worldToLocal) ao invés da caixa que é sempre um AABB 2x2x2 na perspectiva da função.

No lado da CPU, só precisamos calcular a matriz worldToLocal e enviá-la para o shader junto com a posição do cubemap.

1. Vector3f position = new Vector3f(0f, 2f, 0f);
2. Quaternionf rotation = new Quaternionf(0f, 0f, 0f, 1f);
3. Vector3f halfExtents = new Vector3f(5f, 2f, 5f);
5. Matrix4f worldToLocal = new Matrix4f()
6. .translate(position)
7. .rotate(rotation)
8. .scale(halfExtents)
9. .invert()
10. ;
12. Vector3f cubemapPosition = new Vector3f(0f, 1.65f, 0f);

"position" é a posição da caixa, "rotation" é a rotação da caixa definida por um quaternion, "halfExtents" é a metade das extensões da caixa (uma caixa de comprimento 10,0 tem uma meia extensão de 5.0 no eixo X) e "cubemapPosition" é a posição do cubemap de onde ele foi gerado.

1. uniform mat4 cubemapWorldToLocal;
2. uniform vec3 cubemapPosition;

Como a intersecção só funciona se o fragmento estiver dentro da caixa, você deve fazer a caixa um pouco maior do que a área que ela representa.

E então, só precisamos fazer a intersecção do raio da posição do fragmento usando a direção refletida para encontrar P e então fazer sample do cubemap usando a direção corrigida.

1. vec3 viewDirection = normalize(worldPosition - viewPosition);
2. vec3 reflectedDirection = reflect(viewDirection, normal);
3. vec3 reflection = vec3(0.0);
4. float t = intersectRayInsideBox(worldPosition, reflectedDirection, cubemapWorldToLocal);
5. if (t >= 0.0) {
6. vec3 P = worldPosition + (reflectedDirection * t);
7. vec3 correctedDirection = normalize(P - cubemapPosition);
8. reflection = texture(reflectionCubemap, correctedDirection).rgb;
9. }