How to upload multiple textures to a shader?

[st0rmbtw]

I'm writing a batched sprite renderer. Each sprite can have a unique texture and a unique sampler.
In a GLSL shader I have an array of sampler2D:

uniform sampler2D u_textures[32];

In OpenGL it's very simple, you just bind all textures you want and upload them as an array of their ids.
In LLGL textures and sampler are separate, and I can't figure out how to use them.

[LukasBanana]

The idea for this was to use BindingDescriptor::arraySize but this is only half implemented and the documentation also only mentions Vulkan. What you can do is to declare 32 binding descriptors for textures and another 32 for samplers because in LLGL, you have to bind textures and samplers separately to the same binding slot for GL. If you want to take advantage of binding multiple resources at once (like the glBindTextures function) you can declare those resources in a resource heap, i.e. heapBindings instead of bindings field in your pipeline layout. So in your case, this could look something like this:

const std::uint32_t yourStartBindingSlot = 0;
const std::uint32_t textureSamplerCount = 32;

// Bind all textures consecutively to take advantage of binding multiple textures at once
for (std::uint32_t i = 0; i < textureSamplerCount; ++i) {
    layoutDesc.heapBindings.push_back(
        LLGL::BindingDescriptor{
            /*name:*/       "u_textures",
            /*type:*/       LLGL::ResourceType::Texture,
            /*bindFlags:*/  LLGL::BindFlags::Sampled,
            /*stageFlags:*/ LLGL::StageFlags::FragmentStage,
            /*slot:*/       yourStartBindingSlot + i
        }
    );
}

// Now declare binding slots for all samplers consecutively
for (std::uint32_t i = 0; i < textureSamplerCount; ++i) {
    layoutDesc.heapBindings.push_back(
        LLGL::BindingDescriptor{
            /*name:*/       "", // GL samplers are nameless in LLGL
            /*type:*/       LLGL::ResourceType::Sampler,
            /*bindFlags:*/  0, // sampler have no binding flags in LLGL
            /*stageFlags:*/ LLGL::StageFlags::FragmentStage,
            /*slot:*/       yourStartBindingSlot + i // Same binding slot as for the textures
        }
    );
};

Now you have to put all your resources into a ResourceHeap:

// Create empty resource heap for your PipelineLayout
LLGL::ResourceHeap* heap = renderer->CreateResourceHeap(myPipelineLayout);

// Place resources in your heap.
// Their indices correspond to the order of your 'heapBindings' entries, not the resource slots!
renderer->WriteResourceHeap(*heap, /*firstDescriptor:*/ 0, { myTex0, myTex1, ..., myTex31 });
renderer->WriteResourceHeap(*heap, /*firstDescriptor:*/ 32, { mySampler0, mySampler1, ..., mySampler31 });

Now you can bind them all at once during your render passes:

cmdBuffer->SetResourceHeap(*heap);

FWIW: The combination of texture and sampler in GL is really more of a restriction than a feature, but especially mobile drivers prefer them even in Vulkan where you have both combined and separate samplers. This code sample looks like a lot compared to how simple it looks in the GL API, but with an abstraction layer, it's important to separate the native binding slots because the binding models work very differently between the rendering APIs. Vulkan for instance requires unique binding slots for each resource while D3D11 and GL allow shared binding slots across all resources types. I hope this helps, I will try to improve the usability of the arraySize field to make better use of array textures in the future.

[st0rmbtw]

When I set the size of the samplers array greater than 1 in the shader I get this error:

glDebugMessageCallback (GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH): GL_INVALID_VALUE error generated. <index> must be less than OBJECT_ACTIVE_UNIFORMS_ARB.

uniform sampler2D u_textures[2]; // Error

uniform sampler2D u_textures[1]; // Ok

[LukasBanana]

I reproduced the error. There's a bit more that has to be revised here, the GL backend assumes that glGetUniformLocation can be used as input for glGetActiveUniform. I already fixed that part but the index-to-slot mapping doesn't work with array resources at the moment. I can probably take care of that within the next two weeks and will provide updates in this thread. Until then, I suggest you use a sampler2DArray instead and index through the layers of your array texture. You can take a look at the PBR example how to create a Texture2DArray resource.

4c1e085 is a partial fix that should resolve your shader error, but it still won't bind all resources correctly.

[st0rmbtw]

Thank you! But I'm afraid that I can't use the Texture2DArray because I have so many textures that combining them all together would create a super big texture that it likely would exceed the maximum texture size.

[LukasBanana]

I implemented a fix for GL and D3D11 with 46445a7. The other backends will follow, but please note that LLGL only allows resource arrays for resource heaps (see the new ResourceArrays test). This was already stated in the documentation of arraySize.

For your example, you can create a pipeline layout and resource heap like this:

LLGL::PipelineLayout* psoLayout = renderer->CreatePipelineLayout(
    LLGL::Parse(
        "heap{ texture(u_textures@0[2]):frag, sampler(0[2]):frag }"
    )
);
LLGL::ResourceHeap* resHeap = renderer->CreateResourceHeap(
    psoLayout,
    { myTexture0, myTexture1, mySampler0, mySampler1 }
);

And then bind your resources with SetResourceHeap(*resHeap) instead of SetResource(0, ...). Resource heaps are a bit more constrained than individual resources, but if a Texture2DArray doesn't work for you, you would otherwise have to use individual texture identifiers instead of an array.