masonryMaterials: Brick and Mortar

Version 2.0.0. Depends on materialLibraryKit 1.3.1 (stated in the package's own dependency entry, and installed with it automatically; nothing else is installed).

30 seamless, physically based masonry and building materials (brick, concrete, plaster, tile, roofing and street surfaces, plus toon, hand-painted and pixel-art sets) for the materialLibraryKit material library. Every material answers to one name, and every material shows at real size on any box, plane or model: a 1 m cube in brick shows about 13 courses, a 3 m wall about 40, a 10 cm cube about one, with no UV setup. Swapping a wall from red brick to toon brick or pixel brick is a change of one name.

Texture memory: 52.8 MB for all 30 (GPU, mipmaps included, every texture counted once), 63.1 MB with the 30 reference pictures and the board frame the gallery shows. The largest material is 3.0 MB.

Install and use

Install masonryMaterials from ZeroMind (search "masonryMaterials" or "Brick and Mortar"). It lands at /source/masonryMaterials.package, and materialLibraryKit 1.3.1, the shared material library it is built on, comes with it in the same install under /source/deps/. Nothing else is installed and there is no setup code: every material appears in the library's list, picker and swatch gallery on every player's machine.

Then, in a brand-new world, run this from a script or the console (execute):

local Materials = require("~materialLibraryKit.Materials")

-- a plain 1 m cube and a 3 m wall: bricks keep their real size on both
local cube = entity.spawn("brickCube", { components = { Model = { model = "cube" } } })
cube.localPosition = { -2, 0.5, 4 }
local wall = entity.spawn("brickWall", { components = { Model = { model = "cube" } } })
wall.localPosition = { 1, 1.5, 4 }
wall.localScale = { 3, 3, 0.2 }

local cubeModel = cube.component.get("Model")
local wallModel = wall.component.get("Model")
cubeModel.material = Materials.get("brickRunning").material
wallModel.material = Materials.get("brickRunning").material

-- the same wall in a cartoon world, or a retro one: only the name changes
wallModel.material = Materials.get("toonBrick").material
wallModel.material = Materials.get("pixelBrick").material

-- every roof, by name
for _, m in Materials.list({ collection = "masonry", kind = "roof" }) do
    print(m.id, m.style, m.tileSize, m.textureKB)
end

Materials.get(name) returns the material's entry (nil for an unknown name), and its material goes on any Model. The library's Materials.apply(object, name) does the same in one call, records which material the object wears and shares that choice with every player (see Multiplayer); Materials.clear(object) puts back what it wore before. To remove the example: entity.despawn(cube.id) and entity.despawn(wall.id).

Real size on anything

The masonry shaders do not use a mesh's UVs. They place the texture by where each point stands on its own object, in metres, so one texture repeat always covers the material's tileSize (the table below) whatever the object's size:

• Any size. A 1 m cube of brickRunning shows 13⅓ courses of 75 mm, a 3 m wall 40, a 10 cm cube one or two. Stretching an object adds bricks rather than stretching them. cinderBlock shows 5 courses of 200 mm per metre and tileSubway 13⅓ rows of 75 mm.
• Any shape. Each face takes the projection it faces. A box face has exactly one; a sphere, cylinder or model blends the nearest two or three over a narrow band, which reads as a soft join on strongly curved surfaces.
• Stuck to the object. The texture is measured from the object's origin along its own axes, so it moves and turns with the object. It is centred on the object's origin.
• Which way is up. On the four sides, the image's up is the object's +Y, so courses run level on an upright box. On the top face, the image's up is the object's -Z. To make a roof slab, take a flat box and tilt it about its X axis with its -Z end raised to the ridge: the courses run along the ridge and climb the slope.
• Lining up neighbours. Two separate objects line up their courses when their origins are a whole number of repeats apart. The gallery's walls and the street corner's house are single objects, so their courses run straight through.
• Roads. roadLaneMarkings is laid out around the object's origin: the dashed yellow centre line runs through the origin along the object's Z axis, with a 12 ft lane, a white edge line and an 8 ft shoulder on each side. A flat piece 12.19 m (40 ft) wide shows the whole road, and a wider piece repeats it. roadCrosswalk is centred the same way: a piece 3.66 m (12 ft) across shows one lane's three bars whole, and a wider piece repeats them lane by lane. Both draw asphalt's maps, so road pieces in different materials join without a change in the asphalt.

The gallery

To walk round every material, open the gallery scene in the package: in the shell run zero scene load masonryMaterials.MasonryGallery, or make it your world's start scene in .world_settings (startup_scene = "masonryMaterials.MasonryGallery"). All 30 stand on one ring around the spawn. Each has its own bay with a 2 x 2 m floor tile, a wall, and a cube, sphere, shader ball and cylinder standing side by side, all at real size. Its reference picture is framed on the wall beside it, and a plaque names it. The toolbar switches the lighting look for everyone (daylight, overcast, golden hour, moonlight, warm interior, studio). Materials opens the picker, which puts any material on whatever you click (in play) or have selected (in the editor), for every player. Each player arrives on a spot of their own, with the camera lifted to 4 m so the plaques stay readable.

To put the gallery in a scene of your own instead, add it in that scene's build.luau, with the player's spawn near the origin:

local g = entity.spawn("Gallery")
g.component.add("SwatchGallery", {})
g.component.add("MasonryShowcase", {})

The world this package comes from, "Brick and Mortar: The Masonry and Building Material Collection", opens straight into the gallery, with a street corner built from these materials beyond the ring.

The materials

Every material is tagged category = masonry, with its kind (brick, concrete, block, plaster, render, tile, roof, asphalt, road marking, paving), its style, tileSize (metres covered by one texture repeat), roughness and metallic ranges, textureKB (GPU texture memory, mipmaps included), animated = false, and search words. More tags make the list easy to filter:

• Kind and style: the kind and style values are tags too (brick, roof, realistic, toon, pixel, stylised; and hand-painted on the hand-painted wall).
• Tile size: tile-<metres>m, for example tile-0.9m.
• Finish (roughness): glossy (median roughness under 0.25), satin (under 0.6) or rough. Tiles are judged by their glaze, not their grout.
• Memory weight: textures-tiny (under 128 KB), textures-light (under 1.5 MB), textures-medium (under 2.5 MB) or textures-heavy (up to 3 MB).
• Metal and animation: non-metallic and not-animated on every material. Metallic is 0 everywhere.

Some examples:

• Materials.list({ collection = "masonry", kind = "brick" })
• Materials.list({ collection = "masonry", tag = "glossy" })
• Materials.list({ collection = "masonry", style = "toon" })
• Materials.list({ collection = "masonry", maxTextureKB = 1024 })
• Materials.list({ collection = "masonry", search = "herringbone" })

How to read the table. Textures lists albedo / normal / mask sizes in pixels. The mask packs ambient occlusion, roughness and metalness; - means the material does not use that map. Memory is the material's own GPU texture memory. Seam is the 4 x 4 seam score at real size and shimmer the 30 m shimmer score, both measured on 2026-10-24 on the desktop engine with materialLibraryKit 1.3.1 (see "Checked").

Texture memory

• The whole collection: 52.8 MB of GPU texture memory, mipmaps included. That is 79 textures, each counted once.
• Counted per material, as Materials.list reports it (textureKB), the 30 add up to 56.8 MB. The difference is that roadLaneMarkings and roadCrosswalk each list asphalt's 2.0 MB of maps again.
• Reference pictures: 10.0 MB (30 pictures at 512 px), plus 0.3 MB for the one frame texture all 30 boards share. They are only loaded where the gallery shows them.
• Everything together: 63.1 MB, about a sixth of the library's 384 MiB budget for low-end devices.
• Texture sizes (albedo / normal / mask, in pixels):
  • 512 / 1024 / 512 for most realistic materials (2.0 MB);
  • 1024 / 1024 / 512 for concreteCracked, tileHexMosaic and pavingSlabs, whose cracks, grout and joints need the colour detail (3.0 MB);
  • 512 / 512 / 512 for plaster (1.0 MB);
  • 512 / 512 / - for handPaintedPlasterBrick (683 KB);
  • 256 / - / - for toonBrick (85 KB);
  • 32 / - / - for pixelBrick (1 KB).
• Within the web limits: every material binds at most 4 sampled textures (the web limit is 9) and no storage buffers, and nothing is over 1024 px.
• Compression: textures are UASTC, transcoded to BC7 on desktop and ASTC on phones.

How they were made

• Baked procedurally in Luau by MasonryBaker, MasonryCatalog and the recipe modules (BrickRecipes, ConcreteRecipes, TileRecipes, RoofRecipes, PavingRecipes, StylisedRecipes).
  • MasonryBaker is Bedrock's StoneBaker (itself Heartwood's periodic baker, MIT) with masonry layouts added: rectangle layouts that know each brick's edges, and rotated boxes for herringbone.
  • Every map is periodic over one repeat, so it tiles with no seam by construction, and is drawn at real scale (1 unit = 1 m).
  • require("~masonryMaterials.MasonryRecipes").bakeAll() re-bakes the lot.
• Real-size placement. The shared shader module masonryProjection places textures in metres on each object. It follows Bedrock's stoneTriplanar (MIT), with a narrow blend so box faces take one projection. masonrySurface (physically based), roadPaint and toonMasonry all use it.
• Every bond is a real bond. Bricks are laid as rectangles of the real brick plus its joint, and each repeat holds a whole number of bond periods both ways, so courses and perpends line up across the edge.
  • brickRunning: red running bond, half-brick offset, UK 225 x 75 mm module.
  • brickFlemish: brown Flemish bond. Stretchers and headers alternate in every course, each header centred on the stretcher below, the headers burnt darker.
  • brickEnglish: buff English bond. Courses of stretchers and courses of headers alternate, with a queen closer setting the header course back a quarter brick.
  • brickCommon: American common bond. US modular brick, five running-bond courses, then a course of headers.
  • brickStack: whitewashed stack bond. Perpends run in straight columns, and limewash covers brick and mortar alike, worn thin on the arrises.
  • brickYellowStock: weathered yellow London stock. Imperial handmade bricks (9 x 3 in, 3/8 in lime joints) with soot and dark flashes.
• Roads at real US dimensions (MUTCD): 12 ft lanes, 8 ft shoulders, a 4 in yellow centre line dashed 10 ft on and 30 ft off, 6 in white edge lines, and crosswalk bars 24 in wide with 24 in gaps, 10 ft long. The paint is computed in the shader over asphalt's maps, smoothed over one screen pixel. So a dash is sharp at 1 m, filters calmly at 30 m, and costs no texture memory.
• Physically based.
  • Colour maps carry no painted-in light or shadow. Joints, grout, cracks and course steps darken through the ambient-occlusion channel and the normal map.
  • Every surface is non-metallic: metallic is 0 everywhere.
  • Roughness follows the finish:
    • glazed subway and checker tiles: 0.05–0.11 on the glaze;
    • the hexagon mosaic's satin glaze: from 0.16;
    • porcelain floor tile: 0.39–0.56;
    • slate: 0.59–0.71;
    • brick, concrete, block, render, terracotta, shingles and thatch: 0.7–0.96;
    • grout and mortar: 0.9 and up.
  • Normal maps use the green-up convention the engine reads. Joints, grout and gaps are drawn low, so they read as sunk; the test suite proves the direction on a synthetic groove.
• Reference pictures first. Every material has a reference picture (references/<id>), generated from the prompt in its catalog entry before the material was drawn. Each material was then compared with its picture side by side: one repeat lit beside the unlit picture, the material's mean colour measured against the picture's, and finally in its gallery bay with the picture hung beside it.

Checked

Every material passes the library's checks (materialLibraryKit 1.3.1, 2026-10-24, desktop engine):

• Seamless repeated 4 x 4 at real size. A plain box face exactly 4 repeats wide and tall is rendered straight on in the albedo pass (lit for the self-shading toon brick).
  • The jump in brightness across each repeat line is compared with the jumps inside a repeat, using the library's own seam statistics and thresholds. The seam score is the jump across repeat lines divided by the jump inside a repeat.
  • A render passes when the boundary jump is at most 3 code values, or the score is at most 2, or the boundary jump is no bigger than 1.1 × the strongest edges inside a repeat. Separately, the library's Checks.seams confirms every texture's opposite edges match.
  • Some scores are above 2 and pass on the last rule, because their own joints are as strong inside a repeat as across one: pixelBrick (17.0), pavingSlabs (7.95, whose tooled joints fall on the repeat), brickCommon (5.12), brickRunning (5.03), toonBrick (3.31), cinderBlock (2.60) and tileHexMosaic (2.08).
  • The library's own Checks.seams render assumes a 4 m plane holds 4 repeats, which is only true of materials whose repeat is 1 m now that size is real. So the package's tests do this render at each material's true repeat instead.
• Shimmer at 30 m. Near (about 1.5 m) and far (30 m, grazing) views. The shimmer score is how many code values the far view moves under a half-pixel camera shift, and it fails above 6. The highest are tileCheckerboard (5.39), toonBrick (4.77) and brickFlemish (4.67); every other material is under 4.
• Real size measured. On plain engine cubes, the course spacing is measured from the rendered normal pass:
  • brickRunning is 75 mm on a 1 m cube and on a 3 m wall;
  • cinderBlock is 200 mm and tileSubway 75 mm on a 1 m cube;
  • each is within 6%, and a 10 cm cube crosses one or two bed joints.
• Diagnostic views, texture memory cross-checked against what the renderer holds, and the web budget (Checks.budget: no warnings for any material).

The package's test suite (29 tests) reruns all of these. It also covers:

• the exact 30 names, every tag, the styles, the filters and the costs;
• the physical ranges, plausible albedos and the normal direction;
• the tile sizes holding whole bricks and tiles, and the road markings sharing the asphalt;
• applying a material to a world-built object, swapping to toon and clearing through the shared channel, and the picker;
• the gallery with all 30 on one ring, every material on every sample shape beside its reference, and the stylised looks;
• the dependency on materialLibraryKit 1.3.1, the scene, the versions and this README.

Each test runs inside the library's Sync.isolate(), so nothing it does reaches other players. When the gallery is not standing, the suite stands one up and removes it again. To run it:

asset.resolve("masonryMaterials.tests.masonryMaterials", "testSuite"):run()

Multiplayer

• Applied materials are shared. Materials.apply goes through the library's shared materials channel, so a material one player puts on an object every player's machine holds shows on every machine, and players who join later get it too. Objects every machine holds are the gallery's swatches, a scene's own objects, and a synced object spawned in play. The picker applies the same way.
• Lighting looks are shared the same way.
• Script-made objects stay local. An object a script spawns in edit mode, like the cube and wall in the first example, exists only on the machine that ran the script, so only that machine sees it, whichever way its material is set.
• Gallery pieces are local. The swatches and reference boards are built on each machine.

On the web

• Within the browser's limits. Every material passes the library's web budget with no warnings: at most 4 textures per draw against a browser limit of 9, no storage buffers, at most 3 MB per material, every texture GPU-compressed (UASTC), and none in a format browsers cannot filter. The paint on the two road materials is computed, so it needs no large texture.
• The gallery was made lighter to draw in 2.0.0. In a browser editor tab, 1.0.0's gallery was reported at about 12 frames per second, where an empty world ran at 60. What changed, measured on the desktop engine with the gallery in view from the spawn:
  • Each reference board was four objects: a holder, a frame, the picture, and a text caption with its own material and a script running every frame. It is now two objects that cast no shadow: the picture, and one frame panel whose texture carries the frame and the REFERENCE caption, shared by all 30 boards. The gallery went from 454 to 394 objects, and from 92 text labels with per-frame scripts to 62 (the library's own name and fact plaques). That removes 30 materials and 60 shadow casters from the scene.
  • The frame is now unlit, like the pictures, so it costs no lighting work.
  • The masonry shaders were measured for per-pixel cost: putting the engine's plain material on all 192 masonry objects changed the per-pixel shading pass by under 4% (1.04 ms against 1.00 ms on this machine). The shaders are not where the time goes, so they are unchanged, and every material looks exactly as before.
• Not measured in a browser. This release was prepared in the desktop engine, which cannot open a browser tab, and no browser was connected to measure with. Whether the gallery now holds 30 frames per second in a browser editor tab has not been confirmed. The library's own gallery reads its frame rate on every player's machine: with a browser player in the world, require("~materialLibraryKit.Gallery").requestTour() reports it in Sync.heard().
• What to expect in a browser:
  • For about 30 seconds after the world opens, the gallery and the street corner stay unbuilt while errors pile up in the log; then they build (gh#20822).
  • Every time the engine starts there is a magenta ERROR line in the log (gh#20949).

Known limits

• Curved surfaces blend projections. On a sphere, cylinder or rounded model the texture blends between neighbouring projections over a narrow band, which shows as a soft join where bricks from two directions meet. Box faces and planes take a single projection.
• US road markings only. The lane markings follow the US MUTCD (yellow centre line, 40 ft cycle).
• The checkerboard is the closest to the shimmer limit (5.39 against 6), because hard black against white is what it is.
• The toon brick has no diagnostic channels. toonMasonry lights itself, so the library's albedo, roughness and metallic views draw it magenta. Its final and normal views are normal.
• The gallery is heavy in the editor's play mode. With the full ring standing (about 360 entities), the editor spends 30–110 ms on some frames sending the gallery's swatches over the network. The library's own gallery scene does the same with no masonry content. This is reported to materialLibraryKit; the materials themselves cost nothing per frame.
• The download is larger than the texture memory. Each texture keeps a source image beside its GPU data, because materialLibraryKit measures texture cost from the source image.

Open engine issues

gh#N is issue N at github.com/OrigoZero/zero.

• gh#20822: in a browser, the gallery and the street corner stay unbuilt for about 30 seconds and errors pile up in the log meanwhile.
• gh#20949: every time the engine starts there is a magenta ERROR line.
• Shader include race on first install (reported to ZeroMind as issue 01M5QZ1QA4XQ90RN2MDK9DWSX9; no GitHub number yet): right after installing, the log can show a few #include of unknown shader module "~.shaders.masonryProjection" errors. The shaders compile moments later and every material draws correctly; nothing needs doing.
• gh#19114: two-player behaviour can't be tested inside one engine. Shared materials are checked through the library's shared channel.
• gh#1889: no asset.materialCollection.* namespace yet, so the materials are reached through Materials.*.
• gh#19414: the engine's normal-map green convention is undocumented. These maps are green-up.

Version history

• 2.0.0 (2026-10-24), on materialLibraryKit 1.3.1. This is the first version number that stands for one fixed collection; install this one. It holds:

  • the 30 materials, under the names in the table above;
  • real size on any box, plane or model, with no UV setup;
  • their 30 reference pictures, the gallery scene, the street corner and the test suite (29 tests);
  • a lighter gallery: each reference board is a picture and one shared frame panel carrying the REFERENCE caption, with no text label or shadow of its own (see "On the web");
  • a dependency entry in package.yaml that names materialLibraryKit version 1.3.1.

• 1.0.0 (2026-10-24), withdrawn. The number 1.0.0 was uploaded several times that day with different contents, so two copies called 1.0.0 may not match. The first uploads had 32 materials under older names, one texture repeat per face of a primitive, and a dependency with no version. Later uploads had the 30 names and real size. If you installed any 1.0.0, uninstall it and install 2.0.0. Scripts written against the first uploads need these names changed:

  Old name (first 1.0.0)	Name now
  redBrick	brickRunning
  flemishBond	brickFlemish
  englishBond	brickEnglish
  americanBond	brickCommon
  charcoalStackBond, whitewashedStackBond	brickStack
  londonStock	brickYellowStock
  smoothConcrete, boardFormedConcrete, stainedConcrete, crackedConcrete	concreteSmooth, concreteBoardFormed, concreteStained, concreteCracked
  interiorPlaster, sandStucco	plaster, stucco
  subwayTile, floorTileGrid, hexMosaic, checkerTile, terracottaTile	tileSubway, tileSquareGrid, tileHexMosaic, tileCheckerboard, terracottaTiles
  asphaltShingles, slateRoof, clayPantiles, thatch	roofAsphaltShingles, roofSlate, roofClayPantiles, roofThatch
  roadAsphalt, laneMarkings, zebraCrossing	asphalt, roadLaneMarkings, roadCrosswalk
  sidewalkSlabs, herringbonePavers	pavingSlabs, pavingBrickHerringbone
  handPaintedPlaster	handPaintedPlasterBrick
  reclaimedBrick, toonRoofTiles, concretePavers	removed