Como posso corrigir a tradução de face dura ao amostrar mips inferiores do mapa de cubo de textura?

Tenho uma textura que quero usar como luz radiante indireta.

Há um problema que quando eu faço uma amostra do mip mais baixo desta textura, o resultado fica assim:

mas na verdade deveria ficar assim:

Eu uso um shader de computação para gerar dados de brilho, mas para o caso de depuração você pode usar um cubemap normal com mipmaps gerados por hardware ( glGenerateTextureMipmap) ou carregá-lo de um arquivo. O resultado será o mesmo - tradução difícil.

Sombreador de vértice:

#version 460 core

layout(location = 0) in vec3 a_position;
layout(location = 1) in vec3 a_normal;

//per instance
layout(location = 2) in vec4 a_modelToWorld0;
layout(location = 3) in vec4 a_modelToWorld1;
layout(location = 4) in vec4 a_modelToWorld2;
layout(location = 5) in vec4 a_modelToWorld3;

layout(location = 0) out vec3 v_worldPosition;
layout(location = 1) out vec3 v_worldNormal;

layout(std140, binding = 0) uniform PerFrame
{
    mat4 cameraModel;
    mat4 viewProjection;
} u_frame;

void main()
{
    mat4 model = mat4(a_modelToWorld0, a_modelToWorld1, a_modelToWorld2, a_modelToWorld3);
    
    vec4 worldPosition = model * vec4(a_position, 1.0f);

    v_worldPosition = worldPosition.xyz;
    v_worldNormal = mat3(model) * a_normal;

    gl_Position = u_frame.viewProjection * worldPosition;
}

sombreador de pixels:

#version 460 core

layout(location = 0) out vec4 f_color;

layout(location = 0) in vec3 v_worldPosition;
layout(location = 1) in vec3 v_worldNormal;

layout(std140, binding = 0) uniform PerFrame
{
    mat4 cameraModel;
    mat4 viewProjection;
} u_frame;

layout(binding = 1) uniform samplerCube u_indirectRadiance;

void main()
{
    vec3 normal = normalize(v_worldNormal);
    vec3 viewDirection = normalize(u_frame.cameraModel[3].xyz - v_worldPosition);
    vec3 reflectionDir = reflect(-viewDirection, normal);

    vec3 color = textureLod(u_indirectRadiance, reflectionDir, 10.0f).rgb;

    f_color = vec4(color, 1.0f);
}

Fiz algumas depurações e verifiquei , normale esses vetores parecem corretos: viewDirectionreflectionDir

Comparei esses valores com meu aplicativo DX11, que me fornece luz de brilho indireto correto e tudo parece igual.

Quanto ao problema em si, não se trata dos dados do cubemap porque eu os verifiquei. Tem valores corretos.

O problema é a forma como é amostrado.

código que cria o mapa do cubo radiante e o amostrador

GLuint sampler;
glCreateSamplers(1, &sampler);

glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                            
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

GLuint texture;
glCreateTextures(GL_TEXTURE_CUBE_MAP, 1, &texture);
glTextureStorage2D(texture, 11, GL_RGBA32F, 1024, 1024);

//here you can load a texture from a file
//eg. dds
/*

DirectX::TexMetadata meta;
DirectX::ScratchImage image;
//assuming that radianceCubemap.dds is 1024x1024, cubemap and has mipmaps generated correctly
DirectX::LoadFromDDSFile("assets/radianceCubemap.dds", DirectX::DDS_FLAGS_NONE, &meta, image);

GLuint target = GL_TEXTURE_CUBE_MAP;
GLuint format = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; //assuming format is DXGI_FORMAT_BC1_UNORM, but this is just an example

for (std::size_t level = 0; level < meta.mipLevels; ++level) {
    for (std::size_t face = 0; face < meta.arraySize; ++face) {
        const DirectX::Image* img = image.GetImage(level, face, 0);
        if (img) {
            glCompressedTextureSubImage3D(texture, level, 0, 0, face, img->width, img->height, 1, format, img->slicePitch, img->pixels);
        }
    }
}
*/

/*
or you can do whatever, it does not matter, just make sure it's a 1024x1024 cubemap with 11 mips
*/

meu mapa de cubo:

como você pode ver está tudo correto

O que há de errado com meu código? Como posso consertar isso?