En esta página

Qt Quick 3D - Ejemplo de reflejos en el espacio de pantalla

Muestra los reflejos en un 3D c Qt Quick.

Superficie reflectante con esferas de colores y objetos flotantes

Este ejemplo muestra cómo crear reflejos utilizando «Screen Space Reflections» (SSR) en un modelo. El SSR es un efecto de posprocesado que puede mejorar la escena añadiéndole reflejos. La idea detrás del SSR es que los reflejos se pueden calcular en el espacio de pantalla una vez que se han renderizado los objetos. Para cada fragmento, se emite un rayo desde la cámara hacia dicho fragmento y, a continuación, este se refleja en torno a la normal del fragmento. Después, seguimos el rayo reflejado y determinamos si incidirá en un objeto o no. Si incide en un objeto, el fragmento reflejará dicho objeto. Hay situaciones en las que el SSR falla. Por ejemplo, cuando el rayo reflejado incide en un objeto situado detrás de la cámara. Dado que los reflejos se calculan en el espacio de pantalla (Screen Space) una vez que los objetos han sido renderizados, no se dispone de información sobre el color de los objetos situados detrás de la cámara. Aunque el SSR presenta algunos inconvenientes, aporta mayor realismo a la escena.

Este ejemplo implementa el SSR utilizando un « Custom Materials » que se puede aplicar a un « Model », lo que hará que este refleje su entorno.

Model {
    source: "#Rectangle"
    scale: Qt.vector3d(5, 5, 5)
    eulerRotation.x: -90
    eulerRotation.z: 180
    position: Qt.vector3d(0.0, -50.0, 0.0)
    materials: ScreenSpaceReflections {
        depthBias: depthBiasSlider.value
        rayMaxDistance: distanceSlider.value
        marchSteps: marchSlider.value
        refinementSteps: refinementStepsSlider.value
        specular: specularSlider.value
        materialColor: materialColorCheckBox.checked ? "transparent" : "dimgray"
    }
}

El resto de la escena cuenta con algunos objetos que son estáticos o que giran por encima de la superficie para mostrar los reflejos.

Node {

    Model {
        source: "#Cube"
        eulerRotation.y: 0
        scale: Qt.vector3d(1, 1, 1)
        position: Qt.vector3d(50.0, 40.0, 50.0)
        materials:  PrincipledMaterial {
            baseColorMap: Texture {
                source: "qt_logo_rect.png"
            }
        }
    }

    Node{

        Model {
            source: "#Sphere"
            position: Qt.vector3d(-400.0, screenSpaceReflectionsView.modelHeight, 0.0)
            materials: PrincipledMaterial {
                baseColor: "magenta"
            }
        }
    }

    Node{
        eulerRotation.y: screenSpaceReflectionsView.modelRotation
        position.y: screenSpaceReflectionsView.modelHeight

        Model {
            source: "#Sphere"
            pivot: Qt.vector3d(0, 0.0, 0.0)
            position: Qt.vector3d(200.0, 0.0, 0.0)
            materials: PrincipledMaterial {
                baseColor: "green"
            }
        }
    }

    Node{
        eulerRotation.y: screenSpaceReflectionsView.modelRotation
        position.y: screenSpaceReflectionsView.modelHeight

        Model {
            source: "#Sphere"
            eulerRotation.y: 45
            position: Qt.vector3d(0.0, 0.0, -200.0)
            materials: PrincipledMaterial {
                baseColor: "blue"
            }
        }
    }

    Node{
        eulerRotation.y: screenSpaceReflectionsView.modelRotation
        position.y: screenSpaceReflectionsView.modelHeight

        Model {
            source: "#Sphere"
            position: Qt.vector3d(0.0, 0.0, 200.0)
            materials: PrincipledMaterial {
                baseColor: "red"
            }
        }
    }

Código del shader

Antes de profundizar en el código del shader, veamos algunos parámetros que se pueden utilizar para controlar los reflejos.

depthBiasEste parámetro se utiliza para comprobar si la diferencia entre la profundidad del rayo y el objeto se encuentra dentro de un umbral determinado.
rayMaxDistanceControla a qué distancia se encuentra el punto final del rayo en el espacio de visión.
marchStepsControla el número de pasos que se utilizan para el cálculo. Al aumentar el número de pasos, se reduce la cantidad de fragmentos que recorre el rayo en cada iteración y se mejora la calidad.
refinementStepsTras determinar dónde incide el rayo reflejado en el objeto, se lleva a cabo un proceso de refinamiento para intentar localizar el punto exacto de impacto. Este parámetro controla el número de pasos que deben utilizarse. Puede ofrecer mejores resultados cuando el « marchSteps » es pequeño.
specularUn valor entre 0 y 1 para controlar el grado de reflectividad del modelo.
materialColorAporta color al modelo. Este color se mezcla con el color del reflejo.

El sombreador comienza obteniendo una dirección desde la cámara hasta el fragmento y, a continuación, la refleja alrededor de la normal del fragmento. El punto inicial y el punto final del rayo se calculan en el espacio de vista y, a continuación, estos puntos se transforman al espacio de pantalla. La ventaja de trazar el rayo reflejado en el espacio de pantalla es que se obtiene una mejor calidad. Además, el rayo podría recorrer una gran distancia en el espacio de vista, pero solo cubrir unos pocos fragmentos en el espacio de pantalla.

Se calcula un vector que apunta desde el fragmento inicial al fragmento final y se divide por la normal del fragmento ( marchSteps).

A continuación, se invoca la función « rayMarch ». Esta hace avanzar el rayo paso a paso en el espacio de pantalla y, a continuación, lo transforma de nuevo al espacio de vista. También obtiene el objeto en este fragmento utilizando la « DEPTH_TEXTURE » de la escena. Se calcula la diferencia entre las profundidades del rayo y del objeto y se compara con la « depthBias ». Si se detecta un impacto, se invoca la función « refinementStep ».

void rayMarch(vec2 rayStepVector, vec2 size)
{
    for(int i = 0; i < marchSteps; i++)
    {
        rayData.rayFragCurr += rayStepVector;
        rayData.rayCoveredPart = length(rayData.rayFragCurr - rayData.rayFragStart) / length(rayData.rayFragEnd - rayData.rayFragStart);
        rayData.rayCoveredPart = clamp(rayData.rayCoveredPart, 0.0, 1.0);
        float rayDepth = rayViewDepthFromScreen(size);
        rayData.objHitViewPos = viewPosFromScreen(rayData.rayFragCurr, size);
        float deltaDepth = rayDepth - rayData.objHitViewPos.z;

        if(deltaDepth > 0 && deltaDepth < depthBias)
        {
            rayData.hit = 1;
            refinementStep(rayStepVector, size);
            return;
        }
    }
}

El paso de refinamiento es igual que el de « rayMarch », salvo que intenta encontrar la posición exacta en la que se produce la coincidencia, por lo que hace avanzar el rayo la mitad de la distancia del paso en cada iteración.

void refinementStep(vec2 rayStepVector, vec2 size)
{
    for(int i = 0; i < refinementSteps; i++)
    {
        rayData.rayCoveredPart = length(rayData.rayFragCurr - rayData.rayFragStart) / length(rayData.rayFragEnd - rayData.rayFragStart);
        rayData.rayCoveredPart = clamp(rayData.rayCoveredPart, 0.0, 1.0);
        float rayDepth = rayViewDepthFromScreen(size);
        rayData.objHitViewPos = viewPosFromScreen(rayData.rayFragCurr, size);
        float deltaDepth = rayDepth - rayData.objHitViewPos.z;

        rayStepVector *= 0.5;
        if(deltaDepth > 0 && deltaDepth < depthBias)
            rayData.rayFragCurr -= rayStepVector;
        else
            rayData.rayFragCurr += rayStepVector;
    }
}

La visibilidad del reflejo se establece en el valor de la colisión y, a continuación, se realizan algunas comprobaciones de visibilidad. Como se ha mencionado anteriormente, el SSR fallará si el rayo reflejado incide en algo situado detrás de la cámara, por lo que la visibilidad se atenúa en función de cuánto se dirige el rayo reflejado hacia la cámara. La visibilidad también se atenúa en función de la distancia a la que se encuentra el objeto impactado del punto de partida del rayo.

float visibility = rayData.hit;
/* Check if the ray hit an object behind the camera. This means information about the object can not be obtained from SCREEN_TEXTURE.
   Start fading the visibility according to how much the reflected ray is moving toward the opposite direction of the camera */
visibility *= (1 - max(dot(-normalize(fragViewPos), reflected), 0));

/* Fade out visibility according how far is the hit object from the fragment */
visibility *= (1 - clamp(length(rayData.objHitViewPos - rayData.rayViewStart) / rayMaxDistance, 0, 1));
visibility = clamp(visibility, 0, 1);

Por último, el color del reflejo se calcula a partir del « SCREEN_TEXTURE » y se mezcla con el color del material.

vec2 uv = rayData.rayFragCurr / size;
uv = correctTextureCoordinates(uv);
vec3 reflectionColor = texture(SCREEN_TEXTURE, uv).rgb;
reflectionColor *= specular;

vec3 mixedColor = mix(materialColor.rgb, reflectionColor, visibility);
BASE_COLOR = vec4(mixedColor, materialColor.a);

Funciones auxiliares

Hay algunas funciones auxiliares que se utilizan en el código del sombreador. La función « correctTextureCoordinates » ajusta las coordenadas de la textura según la API gráfica utilizada. Esto es necesario en el caso de D3D11 o Metal. Para obtener más información, consulta la documentación de « CustomMaterial ».

vec2 correctTextureCoordinates(vec2 uv)
{
    if(FRAMEBUFFER_Y_UP < 0 && NDC_Y_UP == 1)
        uv.y = 1 - uv.y;

    return uv;
}

La función ` rayFragOutOfBound ` comprueba si el rayo se encuentra fuera de la pantalla tras el proceso de «marching». En este caso, no se utiliza ningún color de reflexión, ya que no hay información disponible sobre nada que se encuentre fuera de la pantalla.

bool rayFragOutOfBound(vec2 rayFrag, vec2 size)
{
    if(rayFrag.x > size.x || rayFrag.y > size.y)
        return true;

    if(rayFrag.x < 0 || rayFrag.y < 0)
        return true;

    return false;
}

La función ` viewPosFromScreen ` obtiene la posición del objeto en el espacio de vista utilizando la función ` DEPTH_TEXTURE`.

vec3 viewPosFromScreen(vec2 fragPos, vec2 size)
{
    vec2 uv = fragPos / size;
    vec2 texuv = correctTextureCoordinates(uv);

    float depth = textureLod(DEPTH_TEXTURE, texuv, 0).r;
    if(NEAR_CLIP_VALUE  < 0.0)
        depth = 2 * depth - 1.0;

    vec3 ndc = vec3(2 * uv - 1, depth);
    vec4 viewPos = INVERSE_PROJECTION_MATRIX * vec4(ndc, 1.0);
    viewPos /= viewPos.w;
    return viewPos.xyz;
}

La función ` rayViewDepthFromScreen ` obtiene la posición actual del rayo en el espacio de vista. En esta ocasión, el valor de profundidad se obtiene mediante la interpolación lineal del valor entre la profundidad del punto inicial y la profundidad del punto final del rayo.

float rayViewDepthFromScreen(vec2 size)
{
    vec2 uv = rayData.rayFragCurr / size;
    float depth = mix(rayData.rayFragStartDepth, rayData.rayFragEndDepth, rayData.rayCoveredPart);
    vec3 ndc = vec3(2 * uv - 1, depth);
    vec4 viewPos = INVERSE_PROJECTION_MATRIX * vec4(ndc, 1.0);
    viewPos /= viewPos.w;
    return viewPos.z;
}

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.