Rendering model with multiple tiling textures

Question

See edit:

How would I go about rendering a model with multiple tiling textures? I have a few ideas, but all of them have drawbacks, here are a few (by the way this is for an opengl game):

-Use a huge texture, but this comes at the cost of the texture being expensive

-Render diffrent objects for each textured object (eg: one model could be bricks for a house, another could by the roof, each with their own tiled texture), but this would become very messy, very quickly.

Here is an (amazing) image to help demonstrate what I'm trying to do.

The repeating "R" on the red area represents perhaps a repeating brick texture, while the green one represents a roof, maybe roof shingles. To add on to that, I've added a window texture.

My question is, how do most games deal with this? I can't seem to wrap my head around how I could fit this in one texture, but yet I see many other games do exactly what I want.

EDIT:

This should give a better visual demo. I want a large mesh (not very large in the demo) using one texture atlas. (Please keep in mind not all textures in the atlas will be the same size!)

Lets say this is my object, it uses each texture on the atlas, but not the same amount of repeats (brick repeats 3 times, when the smiley face repeats 9 or so times)

How do most games achieve something like this? Without using some huge file with repeating textures.

Example (from BOTW) I assume they didn't just repeat this texture on the atlas, considering how large that would be (and expensive).

Answer 1

I'm not very fluent in OpenGL, so I'll present a rough sketch here and leave it as a community wiki in case someone who knows the tech better would like to update it with precise code hints.

First, if you're targeting OpenGL 3.0 or higher, you can use Array Textures. These let you pack multiple tiling textures of the same resolution into a single sampler. Your workflow would look like this:

1. In your modelling tool, set up and export your model with 3-channel texture coordinates (often called UVW). U & V will be the normal 2D texture coordinates that you're used to, and can range over whatever parts of the texture space you want, even overlapping other parts of the UV net. The third component, W, will be a material index - so for instance the parts that are supposed to be "brick" might have a W coordinate of 0, "cobblestone" might be W = 1, and "shingles" might be W = 2.

   Alternatively, you could set up an importer that reads a material or submesh index from your model and uses that to construct these W coordinates, if that's more convenient than authoring them.

2. Load your textures into a Texture Array, in the same order as the W coordinates you assigned (ie. 0 = brick, 1 = cobblestone, 2 = shingles, etc...)

3. In your shader, use a sampler2DArray to reference this texture, and pass it the 3D texture coordinate created above. It will use the third channel of the texture coordinate to select the right material "page" from the array and sample that.

If you need to target devices that do not support Array Textures, then you can do a flavour of this using a texture atlas, with a bit more fuss:

• Instead of storing your textures as pages in an array, they'll be laid out side-by-side in a single large 2D texture, like tiles.
• In your shader, you'll use the third texture coordinate to select an offset into this grid of tiles.
• In the pixel/fragment shader, you'll use the frac or fmod functions to wrap your texture coordinates into the 0...1 range (effectively doing what the Repeat texture sampling mode normally does in hardware), and scale this range to the size of a single tile within the atlas.
• Combining this tile offset and wrapped coordinates-within-tile you'll get your final sample position within the atlas.
• You may need to make your tiles slightly smaller to allow some padding between them, to ensure adjacent tiles don't bleed together at the smaller mip levels.

Answer 2

I seem to have found probably the best answer for my case, it may be lazy, but if you have time, I would try and do what @DMGregory suggested, as it is probably more efficient.

So what I ended up doing was using the material file that is exported with the OBJ, which lets me define when a face should use a different texture. So I would render one texture, then swap textures, render the rest of faces with this texture, do that again and so on until the whole model was rendered. Of course this means many extra draw calls, but for me, this seemed to be the easiest option.