ModernEraCaveman's questions

Acabei de escrever o código para meus objetos de textura e amostra, mas agora não sei como implementar os descritores separados em GLSL.

Acessando um amostrador de imagens combinado no conjunto de descritores 0, a ligação 0 seria feita usando:

layout(set = 0, binding = 0) uniform sampler2D texSampler;

O fragment shader então amostraria a imagem usando sampler2Da texturefunção:

layout(location = 0) in vec2 fragTexCoord;

layout(location = 0) out vec4 outColor;

void main() {
    outColor = texture(texSampler, fragTexCoord);
}

Pelo que entendi, um conjunto de descritores (ou ligação) é criado para um amostrador usando VK_DESCRIPTOR_TYPE_SAMPLERe outro é criado para uma imagem amostrada com o tipo VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE. No entanto, não sei qual sintaxe seria usada para acessar os descritores separados.

layout(set = 0, binding = 0) uniform /* idk what type it is */ sampler
layout(set = 0, binding = 1) uniform /* idk */ sampledImage
// alternatively...
layout(set = 0, binding = 0) uniform /* idk */ sampler
layout(set = 1, binding = 0) uniform /* idk */ sampledImage

Os samplers e imagens são armazenados em diferentes conjuntos/ligações conforme especificado ao criar os conjuntos de descritores?

Se sampler2Dfor usado para amostras de imagens combinadas com o descritor type VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, qual será a sintaxe usada para cada um dos tipos separados?

VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, e VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER?

Como esses objetos separados seriam chamados mainpara definir o outColorvalor?

Para obter algumas informações básicas, estou tentando criar um algoritmo rápido de geração de quadtree usando uma pesquisa de dicionário. O conceito básico envolve o mapeamento de coordenadas para nós quadtree via representação binária:

struct vec2 { // Test coordinate object
    double x, y; // replacing double with signed int everywhere does not achieve results either
    vec2(const double& x = NULL, const double& y = NULL)
        : x(x), y(y) {}
    friend std::ostream& operator<<(std::ostream& os, vec2 vector)
    {
        return os << "(" << vector.x << ", " << vector.y << ")\n";
    }
    bool operator()(const vec2& lhs, const vec2& rhs) const
    {
        /* TODO: make proper sorting function */
        if ((lhs.x < rhs.x) && (lhs.y < rhs.y)) {
            return true;
        }
        if (std::hypot(lhs.x, lhs.y) < std::hypot(rhs.x, rhs.y)) {
            return true;
        }
        
        return false;
    }
};

std::map<vec2, std::bitset<4>, vec2> nodeLoc = { // quadtree node mapping
            { ( 1, 1), 1000 }, // first quadrant
            { (-1, 1), 0100 }, // second quadrant
            { (-1,-1), 0010 }, // third quadrant
            { ( 1,-1), 0001 }, // fourth quadrant
            { ( 0, 0), 0000 }, 
            { ( 0, 1), 1100 }, // first and second
            { ( 0,-1), 0011 }, // third and fourth
            { ( 1, 0), 1001 }, // first and fourth
            { (-1, 0), 0110 }, // second and third
};

int main() {

    std::cout << nodeLoc[(-1, -1)];

    return 0;
}

A função principal deve ser impressa 0010no console, mas, 1000em vez disso, é impressa. A função map está se identificando (-1, -1)com (1, 1), mas pensei que a definição para the bool operator()impediria que eles fossem identificados como a mesma entrada. Tentei criar uma função de hash para usar com um std::unordered_map, mas acabei com um problema semelhante (embora um pouco diferente, pois (-1,1)mapearia o mesmo (1,-1)que).

Como posso criar adequadamente um mapa entre coordenadas assinadas e sua representação de nó binário?