Gerrard's questions

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?