Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
✓ Live Streaming✓ Interactive Chat✓ Private Shows✓ HD Quality✓ Free Actions
Free to watch • No registration required • HD streaming
Texturing Terrain in Houdini COPs: Placing Materials with Masks, Not a Brush
I textured an entire desert, a lava field and an icy mountain without once picking up a brush. Not a single pixel was hand-painted. Every colour landed where it did because a mask told it to, and each mask was computed from the terrain's own shape. That was the moment texturing stopped feeling like painting and started feeling like giving instructions.
This is the texturing strand of EREMUS. In the previous post I formed the three Terrain Handbook biomes, but forming them only gave me grey geology. This post is how that geology gets its colour, and the surprising part is how little of it is manual. Following Nikola Damjanov's COPs texturing chapters I textured all three biomes the same way, and again the most useful lesson was not any single look. It was building one colouring machine and pointing it at three different worlds.
Texturing without a brush
A heightfield in Houdini carries far more than height. Every erosion pass I ran in the last post quietly wrote extra layers alongside it: where water flowed, where cavities sit in shadow, where debris settled, how sharply each edge curves. Those layers are masks, red selections painted across the terrain by the simulation rather than by me. On top of them sits one node, heightfield maskbyfeature, that can invent a fresh mask from the terrain's own features, by slope, by height, by curvature, by which direction a face points, by ambient occlusion. So before I choose a single colour I already hold a stack of selections that know where the water ran and where the peaks catch the light. To hand-paint over that would be to throw it all away.
It is just Photoshop layers
To turn those masks into colour I move the terrain into COPs, Houdini's image context. One node, SOP Import, carries every heightfield layer across as a 4K image plane. From there the workhorse is the composite node, and the moment it clicked was realising it is exactly a Photoshop layer stack: a foreground colour, a background, and a mask deciding where the foreground shows through. The blend mode is the entire vocabulary. Over to place a colour, screen to lighten an edge, multiply to sink an occluded pocket, subtract for a little grain. I stack a dozen of these, each one adding a single material exactly where one mask says it belongs, and a quickshade node previews the result live on the terrain as I tune it.
The same stack, three biomes
The graph is nearly identical for all three biomes: import the layers, build a base colour from a ramp, run a long chain of composites, then preview. What changes is the palette, which mask drives which material, and one biome-specific mask each. That is the whole trick, and it is why one method makes three worlds.
The desert is the reference build and the most layered. A warm brown ramp sets the base, then debris lifts the settled sand to a paler beige, curvature paints white highlights onto the ridge edges and black into the crevices, ambient occlusion sinks a deep red into the shadowed pockets, and a fine noise pass, masked to the flats so it never touches the peaks, adds a grain that also feeds render-time detail. It reads as layered, wind-worked sand, and none of it was drawn.
The lava world keeps the exact same chain and only swaps the palette hotter and adds one mask at the front. I isolate the flow and water layers, rename them both to lava, and blend them with a composite set to minimum, which pools the mask into the river banks where lava would collect while keeping some erosion striation. When I sampled the base colours from a reference I deliberately picked the stones, not the lava, because the glow itself is added later in the shader. Ambient occlusion then reddens the banks and curvature brightens the rocky edges. Same machine, opposite temperature.
The icy mountains swap in snow logic. A slope mask drives near-white snow across most of the surface, then a height band built from a spline ramp lets me dirty the snow at the base with a multiply while leaving the peaks pristine. A flow-direction mask adds a pale ice-blue that reads like ice running down the slopes, and debris dirties the snow in patches. As with the lava, the softest part of the snow is not painted in COPs at all; the mask decides where, and the shader does the rest.
Why masks instead of a brush
The reason to work this way is not speed, it is that the erosion already knew everything. Flow, occlusion, debris and curvature are, as Damjanov puts it, a very nice set of masks we got for free from the simulation. They already know where water ran and where edges sit, so letting them place the materials keeps the whole thing procedural: change the terrain and the texture re-derives itself, with no repainting. It also stays resolution-independent, because a mask is a rule, not a grid of pixels. The blend-mode choices are simply intent written down: lighten here, darken there, vary gently over there.
It clicked slowly, over a dozen layers, when I stopped seeing the composite node as Houdini magic and recognised the Photoshop layer stack I already knew, until I trusted the masks more than my own eye.
Where it fought back
Building three of these back to back, the friction was rarely the big idea and almost always the plumbing. Twice a layer came out wrong because a composite was set to the wrong blend mode, and a reddish-yellow mess turned correct the instant I set it back to multiply. More than once a composite did nothing at all until I renamed a plane so both inputs shared a name, the kind of invisible rule you only learn by hitting it. And a stylised contour-line pass threw an intermittent error even the tutorial's author could not fully explain, worked around by copying a single channel into a fresh alpha plane. A lot of terrain texturing turned out to be quietly babysitting blend modes and foreground weights rather than any grand technique.
Mine was chasing a wrong blend mode far too long before spotting a single dropdown set to the wrong thing
What I carried into EREMUS
EREMUS is a desert, so the dusty texture is my working template, and the parts I kept are specific. The mask-driven base means the outpost's ground can be re-textured the moment I reshape the terrain around it, without repainting anything. The habit of reading the erosion layers as ready-made selections is now simply how I think about colouring any heightfield. And the biggest shift is the quietest: a texture is not a picture I paint, it is a set of decisions about where each material belongs.
I am trying to read the erosion masks before I make any colour choices, because that keeps the material placement tied to the heightfield rather than to a painted guess. Once those masks have done the first pass of deciding where things belong, the colour becomes a layer stack I can keep tuning, instead of a flat image I would have to remake every time the terrain changes.
This is the texturing groundwork for the terrain strand. The formation post shows how these three biomes were shaped in the first place, and the next post packages the EREMUS terrain into a tunable, tiling HDA, so this whole forming-and-texturing chain becomes one reusable generator.
If you are reading this as part of my Major Study, this post is the texturing learning strand: I textured all three Terrain Handbook biomes with the same mask-driven COP method to understand how procedural materials are placed, before texturing my own EREMUS ground, and set it down in the order I actually learned it.
Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
✓ Live Streaming✓ Interactive Chat✓ Private Shows✓ HD Quality✓ Free Actions
Free to watch • No registration required • HD streaming
Terrain Formation in Houdini: What the Terrain Handbook Taught Me Across Biomes
The same erosion node built a desert ridge and a river of lava. All I changed was which kind of wear I let it simulate. That was the moment terrain stopped being scenery to me and became a system, and it happened while I was working through the Terrain Handbook to understand how EREMUS's ground should be made.
This is the terrain-formation strand of EREMUS. Before I could build my own desert basin as a procedural generator, I needed to understand how terrain actually forms in Houdini, not just which buttons to press. So I followed Nikola Damjanov's Terrain Handbook and built all three of its biomes myself, a dusty desert, a fiery lava world, and an icy mountain range. The most useful thing was not any single one of them. It was building the same small set of tools three times over and watching them produce three completely different worlds.
What a heightfield actually is
A heightfield in Houdini is not a mesh. It is a two-dimensional volume: a flat grid where the only thing you can push and pull is height. Every heightfield carries two layers that travel together, a height layer and a mask layer, and almost every terrain node reads both, height on the left input, mask on the right. The mask is just a red selection painted across the terrain that tells a node where it is allowed to act.
Once I saw it that way, the long list of nodes stopped being intimidating. Everything is doing one of five jobs: adding height (noise and pattern), shuffling height that already exists (distort), reshaping it (remap and terrace), simulating a physical process on it (erode and slump), or selecting a region to protect or target (mask by feature). You stack those, work at a low resolution while you find the shapes, and only up-res at the very end when the look is settled.
The same base, three different worlds
Every one of the three biomes starts from the exact same heightfield, the same size and the same spacing. What makes one read as sand and another as lava is not the starting grid. It is which physical process I chose to foreground, and how I made the very first shapes.
The desert is the most art-directed of the three. It does not start from noise at all, it starts from a hand-drawn curve. I drew the ridge lines I wanted on the ground plane, wrapped them into geometry, and projected that down onto the height as the skeleton of the terrain. From there it is noise and erosion to rough it up, but the defining move comes last: a flow field is computed and a slump pass lets sand settle down the slopes and gather in the crevices on its own. The desert is a story of deposition, material drifting and piling where gravity takes it.
The lava world throws the drawing away and starts from pure noise, several folded Perlin layers combined so that hills rise with channels running between them. Then it does something clever with erosion. Instead of one wear pass I split the two kinds apart: thermal erosion, the crumbling of slopes, builds the hills, while a masked water pass running only in the lowest parts carves the sharp channels the lava flows through. Debris is deliberately switched off so those channels stay crisp, and there is no slump at all, because letting material settle would fill in the very rivers the erosion worked to cut. The lava world is a story of directed erosion, two processes aimed at two different jobs.
The icy mountains start a third way again, from built geometry. I scattered pyramids across the grid and projected them up into peaks, with smaller upside-down pyramids cut in as holes to break them apart. Then two features do the heavy lifting. Big, strong terraces carve the strata you see in real mountains, and after the erosion passes the slump runs not once but twice, so snow appears to build up in the flats and shelves while rock still pokes through the steepest faces. The icy world is a story of layering and buildup, strata cut in, then snow deposited on top.
Why the differences matter
Set side by side, the lesson is simple, and it reframed how I think about terrain. The base is identical every time. Biome identity comes almost entirely from which process I let dominate: deposition for the desert, directed erosion for the lava, strata and buildup for the ice. Even the starting method carries intent. I hand-drew the desert because I wanted to art-direct where the ridges went, I started the lava from noise because I wanted chaos, and I built the mountains from geometry because I wanted deliberate, placed peaks.
Honestly it clicked in more than one place. The first was watching the same erosion node build a desert ridge and a lava channel just by turning the water off. The masks did the rest: once I saw terrain as height plus a red selection layer, the nodes stopped being mysterious. And the slump node was where it stopped feeling abstract altogether, watching sand settle into the crevices on its own.
Where it fought back
Building three biomes is not the same as them forming smoothly, and a few walls came up again and again. The first is patience. Erosion is a simulation, so every time I changed a number I waited for it to cook, and at high resolution that wait got long. The habit the course drills, and the one I have taken on, is to work at a low resolution while you find the shapes and up-res only at the end. It also runs erosion far too hard on purpose, then dials it back by blending the eroded result over the original, which turns a commitment into a control dial.
The second wall is a real limit of the format. A heightfield cannot hold an overhang, because every point on the grid has exactly one height. When the lava biome needed carved canyon walls, I had to leave heightfields entirely, convert the terrain to polygons, push the shape sideways, rebuild it through a VDB, and project it back, and running that at full resolution is heavy enough to hang the machine if you are not careful. That was a useful reminder that procedural terrain is a set of trade-offs, not a magic button, and that knowing when to step outside the heightfield is part of the skill.
Building the three back to back, the erosion cook times became the real tax, because a full pass meant waiting again every time I nudged a value, so working low-res first stopped feeling like a useful tip and became survival. The more honest wall was learning to read the terrain properly, because telling a real erosion channel from plain noise took several passes before my eye adjusted. The masks caught me out first too, as I kept feeding height into the mask input and wondering why nothing changed.
What I carried into EREMUS
EREMUS is a desert, so of the three biomes the dusty one is my closest template, and the parts I took from it are specific. The art-directed start, drawing the ridge lines rather than hoping noise lands them, suits a world with an outpost whose terrain has to be shaped around it. The slump pass gives the sand its settled, drifted look almost for free. And the ordering the whole course teaches, big shapes first, then detail, then erosion, then resolution last, is now simply how I build any heightfield.
The more important thing I took is not a biome at all, it is the way of seeing. Terrain is a base shape plus a chosen process, height plus mask, worked low and resolved late. Building all three is what let me build the EREMUS terrain in the previous post with some idea of why each node was there, instead of copying a chain and hoping it held together.
The lava biome's split erosion is the technique I think about most, even though EREMUS has no lava, because it taught me erosion is directable and not just destructive For now the desert approach is enough, and I would rather go deep on one biome than spread thin across three
This is the formation groundwork for the terrain strand. The introduction post lays out why EREMUS is procedural at all, and the build post shows the actual network this understanding produced. Next in the series I go from forming the terrain to packaging it, turning the EREMUS heightfield into a tunable, tiling HDA I can reuse.
If you are reading this as part of my Major Study, this post is the learning strand for the terrain: I rebuilt all three of the Terrain Handbook's biomes to understand how terrain forms before building my own, set down in the order I actually learned it.
Why I Spent Part of My Major Study Building a Tutor Instead of My Outpost
I want to be straight about how this part of the semester actually went, because the honest version is more useful for a development blog than a tidy one. This post is about a decision that took me away from building the EREMUS outpost for a while, and why I think it was the right technical-artist call to make.
The problem I kept hitting
Most of what I do (Houdini, Unreal, Substance) I learn from tutorials. And I kept running into the same wall: on a single watch of a tutorial I would retain only a fraction of it. I would rewatch, scrub back, and lose the thread of why a node was there. A video cannot do what a teacher does: it cannot check my work, it cannot take a doubt, and it cannot adapt when I get something wrong. Meanwhile the industry is moving quickly: AI is now part of real production pipelines, and the pressure to skill up fast is real.
I would finish a two-hour Houdini tutorial and realise I could not rebuild half of it without scrubbing back through the video: the steps were in my head, the reasons were not. The pattern was always the same: watch, follow along, feel like I understood it, then hit a blank the moment I tried it on my own scene a week later. It hit hardest on a procedural tutorial where one node's setting changed everything downstream, and the video never paused long enough for me to understand why.
Treating it as a pipeline problem
Before games, I spent two years as a full-stack software engineer. So when I hit a recurring problem, my instinct is not to endure it. I treat it as a pipeline problem and build a tool for it. That is exactly what I did here. The result is an AI tutoring system that turns any DCC tutorial into an actual tutor. It breaks a tutorial into a module-by-module lesson plan, then, while I work live in Houdini or Unreal, it reads my real scene through an automation bridge at each checkpoint and tells me whether I have done the step correctly, answers my doubts grounded in the official documentation, and flags where I have deviated.
The first time it caught me building a node in the wrong order and said so before I had stacked ten more steps on the mistake, I realised it was doing what a teacher does, not what a video does. I asked it why a heightfield mask was not affecting my terrain, and it answered from the actual node documentation instead of leaving me to guess. That was the moment it stopped being a toy. At one checkpoint it read my live Houdini scene and told me my HDA was missing an exposed parameter the tutorial relied on, something I would never have caught on a single watch.
Why this is not a detour away from EREMUS
Crucially, I built and tested it on EREMUS's own skill stack, the exact heightfield, scattering and Houdini-to-Unreal tutorials this project depends on, including the Terrain Handbook and the procedural desert workflow. So it is not a detour away from EREMUS; it is the thing that teaches me EREMUS faster, and with verification instead of guesswork.
The honest evaluation
It took more of the semester than I budgeted for. That is on me, and it is the reason I have had to reduce the scope of the artefact, a decision I am documenting separately as project management. But the learning outcome is real: I now learn these tools with feedback rather than by guessing, and I can point to exactly where I was right and where I was wrong.
Was it worth it? For the artefact, it cost me time I cannot get back. For everything after this project, I think it was. I came out able to learn these tools with feedback instead of guesswork, and that compounds. Also it also expose to what i want to be in this field , "A Technical Artist" from my perspective i resolve many of my real-life problem regarding my course or learning and came up with a technical solution for them.
Where this sits in the field
This is not a niche idea. It is a known problem with recent evidence behind it.
Benjamin Bloom's classic 2-sigma finding (1984) showed that one-to-one tutoring makes students perform about two standard deviations better than standard classroom teaching. The catch has always been that human tutoring does not scale.
A 2025 randomised controlled trial by Kestin et al., published in Scientific Reports, found that students using a well-designed AI tutor achieved over double the median learning gains of in-class active learning, in less time.
And the industry context supports the direction: the GDC 2026 developer survey reports that roughly half of game studios now use AI in development, and 2026 trend reports name the "AI Workflow Specialist" as an emerging role.
Positioning myself
So the thing I built sits exactly on that line, scaling the one form of teaching we know works, aimed at the specific DCC tools I need for game environment art. Positioning myself there, between the craft and the pipeline, is the technical-artist direction I want to move in, and it is the same software-engineer instinct that got me into this field, now pointed at learning art faster.
Sources to cite in Harvard style in the planning folder's references:
In the last post I set the approach for EREMUS's terrain: build it procedurally in Houdini as a reusable, tiling system rather than a hand-sculpted Unreal scene, by combining what three tutorials each do best. This post is the first build, the actual Houdini network that turns that decision into terrain, from the first macro shapes through to a packaged HDA.
Starting with the macro shapes
I started from a HeightField and a distorted ramp heightfield_pattern. A ramp gives me parallel ridges, and turning on Distort curls them into the wind-blown sand lines I was after. I then stacked a few pattern copies with the layer mode set to add, big shapes first, then medium shapes, so the landform carries several scales of structure instead of one flat noise field. Building that macro silhouette before adding any detail was the single discipline the Terrain Handbook drove home across every biome, and it is what stopped the terrain looking like generic procedural noise.
The first version was too uniform, every ridge the same height, which read as noise and not landform. Stacking a second, larger pattern copy on top is what finally broke that up. Getting the number of stacked scales right was the fiddly part: one pattern looked flat, three looked busy; two, big then medium, was the balance.
Adding detail and structure
On top of the macro shapes I layered heightfield_noise, heightfield_slump, and a heightfield_resample pass. The noise and slump give the finer sand structure and settle the slopes so they read as real, gravity-affected material rather than a displacement pattern, and the resample keeps the resolution consistent for everything that comes after it.
Blending the dunes and driving the masks
I used heightfield_layer nodes to blend the dune field into the base, then drove the material breakup with masks rather than by hand. heightfield_maskbyfeature on height, slope and occlusion generates the masks that feed three material layers, sand, rock and worn, into a heightfield_quickshade. Masking off features like peaks, exposed slopes and cavities, instead of painting materials manually, is what keeps the whole thing art-directable: when I change the terrain, the masks follow it automatically. This masking-and-texturing approach is the part the Terrain Handbook goes deepest on, across its dusty, fiery and icy biomes.
Packaging it as a reusable HDA
The entire network is wrapped into a custom HDA, /obj/geo1/desert_terrain, with the parameters I actually tweak exposed at the top level. This covers Modules 1 to 5 of my terrain plan. This is where the procedural desert workflow shaped the decision: the world was always meant to be tiled and streamed into Unreal through Houdini Engine, so the terrain has to be a reusable generator that can also carry the scattering and PDG tiling later, not one hero mesh I can only build once.
I exposed the dune direction and scale, the noise and slump amounts, and the three mask thresholds (sand, rock, worn), the handful of controls I actually reach for when art-directing, so I can retune a tile without opening the network.
Evaluating the process
THE ITERATION WALL: "The slowest part was not any single node; it was iteration speed. Once the resolution was up and the slump and mask passes were stacked, every tweak meant waiting on a recook, so 'try an idea' became a minute-plus round trip, and that quietly shaped how boldly I experimented. Next time I would lock the shapes at low resolution and only crank it for the final look." MASKS LOOKING UNIFORM: "What caught me out is that art-directable masks are not automatically good-looking masks. My first maskbyfeature setup split sand, rock and worn cleanly by height and slope, and it read as three flat bands, exactly the uniform look I was trying to avoid. Breaking it up with occlusion and a little noise in the mask, instead of pure height thresholds, was the difference between 'procedural' and 'believable'."
Where this goes next
That is the first terrain, end to end, the macro shape, the detail and erosion, the feature-mask texturing, and the HDA that packages it all so it can be tuned and reused. The next posts take it further along the pipeline: texturing the terrain in COPs with feature masks instead of hand-painting, scattering the outpost floor across it, and getting it into Unreal through PDG tiling and Houdini Engine.
