majorstudyfinal

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Unreal Shenanigans

After finishing texturing most of the individual assets inside Substance Painter, I head to Unreal Engine. All of the work left is now in UE which first began with importing all of the texture maps created. I made separate organized files for different textures, meshes and material setups. Please people, organize your UE files. When working in a game studio with other artists, it is very important to ensure that you follow the standard nomenclature and organize files properly so that others don't get muddled up.

Figure 1 (Importing static low poly assets)

Since we are now dealing with individual assets that have individual textures that don't require vertex painting or tiling, we have to create a separate material shader setup for the same. I quickly create a new master material for props that can easily be used with its instances and also allows us to control the full extent of the parameters up for use.

The main thing that stands out here is that I use a new node called MakeMaterialAttributes before the final output node. This node allows you to package all of the final outputs together and returns a single output that can be connected to the master output. Kudos to people over at Epic as they have documented it beautifully in their developer logs on their website.

Figure 2 (Unreal documentation on Material Attributes, (Epic Developer, n.d.))

The other node setups are very similar to the other material setups I have created. It includes all of the material functions minus the foliage and water functions as it is literally not necessary for this material setup.

Figure 3 (Final material setup for the stylized props)

After creating an instance of the master material, I assign it to the wooden logs and start replacing the blockout with the polished final versions of it. It's a fun process when you get to see your old blockouts be replaced with a beautiful latest version of it. I start doing the same for other remaining props; create materials, assign them and replace the blockouts.

Figure 4 (Replacing the blockouts)

I would say this is pretty much the final phase of the set-dressing of the environment art workflow before we head on to lighting and rendering of the scene. Still a lot more to do but I am hopeful and it is turning out to look real good!

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Texturing

In a game environment, textures are easily the most important aspect that easily make or break the immersion apart. If you are not doing hard surface modeling, you do not need to go and make a complex model, but if you make a highly detailed model and do not texture it properly, that's when it all starts to fall apart.

As I am not going for a one to one realistic texture represenation, I have to be very strict with what I use to make sure the stylized assets look stylized and not realistic. Before we can start texturing, I first export a high poly and low poly meshes that we just sculpted. Let's use the wooden log as an example as I believe it would be a very good example on how to properly texture a stylized asset. The low poly mesh can easily be created inside Blender by duplicating the highly sculpted asset and decimating it to a lower polydata.

Figure 1 (Creating a low poly mesh off the high poly wooden logs)

Once it is complete, I import the low poly mesh in blender to quickly UV unwrap it so that I can bake the details of the high poly mesh onto the lower poly mesh. It is very important to note that Substance Painter requires proper unwrapped UVs for us to texture any mesh.

Figure 2 (UV unwrapping a wooden log)

After that ordeal is finally complete, we begin the texturing phase of the mesh. We import the low poly mesh inside Substance Painter and then bake the details of the high poly mesh onto it. If the orientation of both the low poly and the high poly mesh is incorrect or if the UV islands are overlapping each other, then you can expect to be a lot of baking artifacts and errors.

Figure 3 (Baking high poly data onto low poly mesh)

I start by adding a simple base color to my logs with a brownish tint. I continue adding color variations with different grunge masks to get grungy details on the logs. The colors of the grunge masks is completely subjective but I would always suggest to keep rotating it around the base color as it would look really nice and warm.

Figure 4 (Adding stylized grunge details)

If you recall, I kept praising Slope Blur as a wonderful tool to add a bit of stylized brush stroky blur to the grunge masks. I also employ it here as a filter on top of those grunge masks. You also have different blending modes with an opacity slider underneath it for more versatile control.

Figure 5 (Adding edge highlights)

In a stylized asset, you will never have sharp edges unless you are sculpting a very sharp object, like a sword or a knife. In this instance, logs are not very sharp when in fact, they are naturally deformed with interesting shape variations. The edge highlights help pop those details out a lot better. It can be achieved by using a levels node and controlling its dials. It provides beautiful silhouettes that stylized assets often imitate.

I also add Ambient Occlusion using the same principle but I invert the levels node and use a black tint to gain control over its shadows.

Figure 6 (Adding finer details)

After making sure that we include those important details, I also add gradient to make it more interesting. Lighter overlay for its body and a darker overlay for its chipped ends. This is topped with an overlay using a new filter Adobe recently released called Stylization. It adds stylization so to speak. You can select different default presets like watercolor, washed, painterly and so on which you can tweak as it tries its best to replicate said artstyles. I add a bit of handpainted stylization and lower its opacity value so as to not overdo it.

Figure 7 (Handpainted details)

Just so I can get the wooden logs to look a bit handpainted, I add a new layer and in its black mask, I start painting light overlay of its adjacent color at different position on the wooden logs. And as such, I was done with my stylized asset that I textured in Substance Painter. I normally follow this workflow while adding new details necessary or removing redundant layers to texture stylized assets. I then export the texture maps for the stylized wooden logs in an Unreal Engine packed format. This option helps create an automatic ORM map which works perfectly inside UE.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Sculpting

Valorant prides on creating well optimized stylized assets that integrate beautifully with its environment. However, they are very low detailed except for actual sculpts that they use as hero assets or placeholder statues. Of course, since its an actual live service game, they have to cut back A LOT for optimization. But for my project, I was not really limited by the optimization and since it was going to be a small static environment piece, I decided to up the stylization for the meshes.

Figure 1 (Importing blockout into ZBrush)

My choice of software for sculpting stylized assets is ZBrush. Its the most I am confident with and I love utilizing every small secret options at its disposal to elevate its final output. One set of brush packs that I swear my loyalty to is the Orb Brushes released by Michael Vicente. It's a wonderful set of brush presets catered to stylization and I use it in every scultping project of mine.

Figure 2 (Orb brushes from Michael Vicente, (Vicente, n.d.))

I use Dynamesh and Subdivision side by side to increase the pixel count of the imported blockout so that the sculpt is more fluid. I use a couple of alphas to get a quick start on getting a concrete base for my stylized prop.

Figure 3 (Using alphas to sculpt the wooden log)

It is a very quick way to get a base that you can further refine and sculpt on top. You do have to be very careful to prevent from overdoing it and making sure the alpha sculpt actually makes sense. Then, simply inflating or deflating the mesh would extract the alpha sculpt inwards or outwards and you can start sculpting on those.

I start using a couple of different Orb brushes to smoothen the jagged edges and flatten the sharp edges. After I finish sculpting my mesh, I also add a few wooden cracks and chips to the wooden log and create small stylized bumps.

Figure 4 (Sculpting with the Orb Brushes)

No wooden prop is without its own set of imperfections. For my logs, I decided to introduce a bit of deformation to my log so that it appears more organic and stylized. After this, I created another variation of the wooden log and I was done with my stylized wooden props. I will not document any more on this phase as this is literally the same thing I do for any other props that need sculpting. But I can say, I am fully satisfied with how the sculpts turned out and I am very ecstatic to import it to Unreal Engine.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Foliage Layout

I now work on laying out the foliage throughout the environment as identical to the concept art. This will instantly make the foliage pop out more and make it more vibrant and lively.

I decided to use Blender and import those ivy kits. This is where I got to channel my inner kid and be creative with how I lay it all out.

Figure 1 (Laying out the vine kit)

This process tends to get a bit more repetitive as its mostly duplicating different kits, resizing them as seen fit and trying to match the concept art. As such, this entry will be a bit shorter than the others. However, I did have an absolute fun working on this.

Figure 2 (Vine kit on the roof)

After a grueling yet fun process, I finished laying out the ivy kits on my architecture. Variations of those kits allowed for an interesting look that totally fits the Valorant artstyle. Riot is notorious for using beautiful variations of ivy kits and I am glad to have achieved that for my own project.

Figure 3 (Final ivy layout in Blender)

Figure 4 (Importing to UE)

Again, I am working simulatenously between tweaking things in Blender and perfecting details in Unreal Engine. I decided to import the entire ivy layout as a combined mesh as it helped optimize the frame rates of the game environment by a lot.

As it so stands, I needed to create a simple foliage master material that I can apply to any foliage mesh I import to the scene. While creating a material for the foliage, I enable the Two Sided property to make sure its both two sided as it increases the fluffiness for the foliage.

Figure 5 (Master material for the foliage)

The master material setup for the foliage is pretty simple. It's basically plugging the material functions we created earlier into its correct slot with the only unique thing being using a blue color node with a TwoSidedSign to introduce front facing and back facing property for the foliage through the camera lens.

Figure 6 (Importing foliage inside Blender)

It was time to start dressing up other pieces of foliage for my environment. That includes trees, bare trunks and bushes. In the same manner, I start laying out my foliage in my environment and since the material is the same, I only need to create material instances for different foliage types.

Figure 7 (Foliage in UE)

I finish laying it out in Blender and then import it inside UE. The material instances were very handy and I just had to reassign materials to said groups of foliage.

I noticed that the foliage meshes inside my Unreal scene had weird splotchy artifacts and that again was due to nanite being turned on for the meshes. After that, I finished my foliage pass for my environment project and I am really happy with the way it turned out.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Creating the bush foliage

This was probably one of the most confusing phases of my project. This stemmed when I was creating my bush foliage. I have always created bushy foliage by utilizing the hair particle system of Blender. How I would normally do is create stems for the bush using a curve which uses another curve as a point for tapering the original one. I would then apply a hair particle system on the stems and the hair particle would be replaced with the image cards of the leaves.

Figure 1 (Bush foliage created using the hair particle system)

However, you can probably notice that it doesn't look really bushy. I tried my hardest to control its shape by fully tweaking its parameters but alas, I could only get so far! It looks like a plant that would be on a vase rather than bushes that would flood the floor platforms.

While searching for a better alternative to create foliage, I came across an addon named Treebox from a talented artist Justin Wallace who had perfected his foliage generator using geometry nodes in Blender. Since, I am not really well versed in geometry nodes, I decided to give this addon a go to see if it would be a better fit for my project.

Figure 2 (Treebox addon for Blender, (Wallace, n.d.))

I integrated it into my project and my goodness, the difference was clear as day and night. It also allowed for custom texture inputs with smoothen function to export as an fbx mesh that can be imported inside Unreal Engine. I also had A LOT of controls to make sure the bush looks bushy.

Figure 3 (Hair particle generated bush on the left and addon bush on the right)

I was very happy with the result and I created a couple of more variations for the bushes so that they all appear random and spontaneous. With this, the foliage is now ready to be exported as a static mesh inside UE and can be used with the material functions I created earlier.

I wanted to make sure that for the ivy kits I had created initially, they swing low but stay static from where they are hanging. I was talking with Axel Blin about how we went and achieved this effect and he sent me some interesting techniques he employed and some I could potentially employ in my project.

Figure 4 (Axel Blin's tips on wind effect for the ivy kit)

I talked with Eden Anthony about this and he said that the most easy way to go about achieving the wind effect particular for the ivy kit was to weight paint. That way the painted information is stored and when wind is applied to that exported kit mesh inside UE, it follows the rule accordingly.

Figure 5 (Weight painting the vines)

When painting weight, you normally paint it in grayscale. In this instance, the black painted portion of the mesh will receive the wind whereas the white painted portion of the mesh will remain static. That way, I achieve that real life effect of a swinging vine. It is subtle, but it is always the subtle things that count the most in 3D!

Figure 6 (Weight painting the other kits)

With this, I formally conclude my work on foliage completely. I created interesting variations of bushes that would populate the scene as well as adding weight information to the vine kits that would inherit the wind property inside UE accordingly. These are ready to export and I am ready to move to the next phase.

REFERENCES

Wallace, J., n.d. ArtStation Marketplace. [Online] Available at: https://www.artstation.com/marketplace/p/8Gg7y/treebox-for-blender-geometry-node-foliage-for-games [Accessed 16 July 2025].

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

More Vertex Painting

We continue onwards with our vertex painting of the architecture. There is no right or wrong way to do it, but there are a couple of guidelines you can follow to make sure that the vertex paint doesn't look outright horrible. Don't overdo the vertex paint, it might end up entirely covering the texture underneath it unless the art direction calls for it. Always try to mimic the concept art as close as possible and utilize the parameters of the height map to gain better control over your vertex painting.

Figure 1 (Vertex painting on roof tiles)

Similarly to how we vertex painted our wall architecture, I am doing the same for our roof tiles. I wanted to make sure that the foliage which hangs from our roof tiles blend with each other. Again, all of the individual modular pieces of the roofs needed to have their nanites turned off in order to access the Paint tab inside the Mesh Paint mode.

Figure 2 (Basic lighting pass)

I am simulatenously adding a couple of point lights and spot lights here and there to add lighting information to our scene. It was super dull and dark at the beginning, but having a couple of lights in my setup also allows me to precisely set the values of the color tint and the PBR data. As an environment artist, we are to juggle most aspects of 3D ourselves. This would include modelling, texturing, set dressing, lighting and rendering the scene. I would normally advise people to stick to spot lights as they are much more cost efficient than point lights.

Figure 3 (Continuing vertex painting)

In some cases, I had to use my own creative decision on whether to keep the color tint of the bricks as close to the concept art or to maybe try match the color of the plaster texture for visual blending. Valorant does both of it and as such, I decided to replicate both scenarios through my environment project.

Figure 4 (Vertex painting on floor platform)

I do the same for the floor tiles as in the concept art, its evident that there is a lot of moss buildup present. I decided to use the same mossy texture I had used for the roof tiles. I wouldn't consider this necessarily finished as it is always subject to change. I would definitely say I am making a good progress!

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Material Setup and Vertex Painting

I start working on testing the tile textures I created in Substance Designer. I made this my first priority inside UE as I could troubleshoot any errors I run into while working on it.

I first import all of the textures I created inside Substance Designer into Unreal Engine. This would include all of the maps we created like the albedo map, the normal map and the ORM map. Just for extra security, I also imported all of the separate texture maps though I highly doubt I would use those separate texture maps over the ORM maps.

Figure 1 (Importing texture maps inside UE)

It is very important to note that many people forget to set the correct compression settings of the textures they import inside Unreal Engine. This will result in low quality outputs and texture integration errors. The ORM maps will normally be set to a default compression and you need to change it to a Masks compression setting.

Figure 2 (Changing the compression settings of the ORM maps)

I work on creating a master material for the architectural pieces that will utilize vertex painting. It's not really a difficult setup and you can probably find a couple of different vertex painting node setups online.

I made use of reroute nodes which can always be referenced with the data its connected through to organize my graphs and make it look more cleaner. The idea of this setup is to use a Height Lerp node that takes data from the two textures you want to use for your vertex painting (or more, depending on how much you want). It also references the various different material functions we created earlier like ColorControls, RoughSpec and WorldSpacePaint.

Figure 3 (Master material setup for vertex painting)

Here is a more clearer look at one of the graphs that houses the node setup for the color texture for vertex painting. All of the other setups for the normal and the ORM maps follow similar node arrangement. All of them are then fed into the final attributes respectively.

Figure 4 (Clearer look for the color node setup)

Once in the viewport, you can toggle to the Mesh Paint mode to start vertex painting your layers. For some reason, I was not able to select the Paint option inside the Mesh Paint mode. That arose due to my architectural pieces having nanite turned on. Case in point, whenever you want to achieve vertex painting, always turn off nanite for your meshes.

Figure 5 (Mesh Paint Mode for vertex painting)

Using the material functions we created before, we can also actively control the tint, normal and pbr values of the tiles to make sure it looks identical to the concept art. Here, I am trying to match the color of the tiles. I decided to use the plaster material as a base and vertex paint the bricks over.

It is absolutely essential to always create material instances from the master materials for the textures so that we can separately control the parameters of the material setup. We can duplicate those instances which are independent from the other instances and can swap textures out for new textures, allowing for a smoother and faster workflow.

Figure 6 (Controlling the parameters of the material instances)

I am happy knowing that the big setup we initially created for the vertex painting along with the material functions and the texture maps we created inside Substance Designer all integrate properly inside Unreal Engine. It would always look decent inside 3D modeling softwares but the ultimate test is to make sure that it looks beautiful and cohesive inside the game engine of your choice!

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Water Functions

I come to the final stage for the creation of material functions. This is going to be a complex and lengthy function that would serve as the water that covers a lot of the concept art. I didn't want to go and try creating water with the help of particle effects or vfx systems as it would prove to be very costly for our environment map. While I am prioritizing detail over performance, I also am striving to achieve a balance between the two.

I first start by working on the color function for the water. It's a big system that includes a lot of setup for different parameters like foam lines, normal masks, color tints, low foam and the fade distance.

Figure 1 (WaterColor Function)

I now start working on creating a new function for the water material. This is separate from the colors for the water and will act as the opacity function for it. Similar to the water color function, this function also includes a Depth Fade node to control the opacity of the water. This function includes a couple of different parameters like opacity distance, opacity shallow and opacity deep values, strength, refraction and so on.

Figure 2 (WaterOpacity Function)

Finally, I work on the last function for the water material that would control its normal values. Again, just like textures, I am using my own custom normal masks but Unreal Engine also comes with a set of their own default normal maps that can be used for the texture input slots.

This material function includes a couple of different parameters to control the normals for the water material like normal map tiling, normal distortion tiling, normal flatness and so on.

Figure 3 (WaterNormals Function)

With this, I believe I have concluded all of the material functions I need to get started with the main master materials for all of the different meshes I have created for my project. The project is going swimmingly without any big issues or delays and I believe we are ready to move onto our next phase of the project.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Foliage Functions

As I finished my material functions for the basic utility for all meshes, it was time for me to focus on creating certain material functions for the foliage. You really don't need that a very elaborate material setup for foliage, but I like to do it as it makes the parameters more intuitive and looks more organized with a lot more control over the foliage mesh.

Figure 1 (MF_FoliageShadow setup)

Important to note that you might be thinking I came up with the entire setup. However, internet's a very beautiful thing and a couple of those formulas are floating about in the air. I just compiled them and blended between existing formulas to use it for my project.

For the foliage shadow function, it includes parameters like adding a color tint for the shadows, controlling its brightness values, the softness and the strength of the shadows. It's always rerouted to a function output node to close the data chain so that it can be referenced without any missing data links.

After the creation of the foliage shadow function, I created an elaborate function for its wind property. Normally, you can just achieve this by using a SimpleGrassWind node and call it a day. But, I wanted to see if I could refine the function a bit more. I also made a parameter setup to control the branch wind for the trees independent of the leaves.

Figure 2 (FoliageWind setup)

This material function is beautifully executd and includes a lot of parameters. Some of those include controls for billboard scale, inflate, wind intensity, wind speed and so on. Later, when I want to apply wind to my foliage, I just need to plug the data into this function in the master material for foliage and watch the magic happen!

This concludes the material function setups for the foliage meshes. Static foliage kills the immersion of video games and that also goes same for foliage with irratic movements. As such, I took a lot of time in making sure this would work perfectly.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

UE Blockout and Shader Setups

This has been a long time coming, importing my blockout to see if it would work nicely inside Unreal Engine. I first imported the basic blockout meshes as a combined mesh to check if the placement is all correct. Since the orientation was all jumbled up and wrong, I just needed to enter the value of 0 in the X, Y and Z axes to place it correctly.

Again, I would always suggest everyone working in environment art to import your blockouts to UE and work side by side as possible. It helps eliminate and troubleshoot a lot of erros in time.

Figure 1 (Blockout in UE)

When I first imported my blockout to Unreal Engine, I noticed a lot of sharp black artifacts covering all of my meshes. At first, I thought it was due to lighting issues. After adding more lights, the problem still persisted and then I believed it was a UV unwrapping issue. However, they were all properly unwrapped.

I then tried to consult Unreal documentation to no avail. That is when I contacted my leturerer Eden Anthony about this problem. He was aware of this problem and said that it is a raytracing issue that can simply be eliminated by a command that you can enter in console, i.e. r.RayTracing.Shadows.EnableTwoSidedGeometry 0. Once I entered this command inside the console, it went away!

Now, I started focusing on creating material setups inside Unreal Engine. During my early days in Unreal tinkering, I never knew about the existence of Material Functions and what they enable. Material Functions help instance a set of formulas as a single data block that can be used in any appropriate shader setups.

Figure 2 (Material Functions, (Epic Developer, n.d.))

I started working on a simple function to add parameters to control colors at ease. Remember when I said I will be creating a versatile shader to control all the properties of the tile textures inside UE? This is it.

Figure 3 (MF_ColorControls setup)

Material functions take function input as an input data and ends with a function output to reroute nodes from it. Inside this particular function, I added parameters for texture input, color tint, desaturation and hue shift values and the position of the contrast. I also added a brightness parameter simply because there are times when textures that are created in Designer and Painter either look too light or too dark inside Unreal Engine and this simple parameter allows me to tweak its lightness.

Figure 4 (MF_RoughSpec setup)

I created another material function titled RoughSpec. This solely tackles the roughness, specularity, metallic and the ambient occlusion of all the input texture maps it gets. I can normally use this in the main master materials for the meshes itself, but it will be tiresome to keep repeating the same thing whereas with material functions; it shortens the workflow and inherits the entire data set within a single node block structure.

Figure 5 (MF_WorldSpacePaint)

I believe that this function I created next is arguably one of the most important functions within the entire project. Its named WorldSpacePaint and it deals with the majority of the gradient overlay that can be applied using a texture map where we can also control the 3 colors at ease. You can always use more than three colors but I stuck to the standard RGB 3 slot structure.

While I didn't show how to create the texture noise masks, it can be easily done inside Photoshop. It's basically splotches of different colors in a single texture. The way its been brushed will be inherited by this function and the color tints we choose to apply will follow the mask. It also has a lot of parameters like contrast, opacity, tiling scale and so on. It operates using the World Position Offset, meaning if the mesh is moved, the gradient overlay also changes using the texture mask in respect to the WPO, even if you move it by a pixel. This allows for a very flexible and versatile overlay that can be applied to virtually any meshes which looks very identical to the artstyle of Valorant.

Arguably, material functions are one of the most essential building blocks of the main material node setup. It helps shorten the workflow, increases the versatility and introduces the property of inheritance to any mesh you import inside Unreal Engine. I finished the basic utility material functions for the project and now, its time to move onto other important functions.

REFERENCES

Epic Developer, n.d. Epic Developer. [Online] Available at: https://dev.epicgames.com/documentation/en-us/unreal-engine/unreal-engine-material-functions-overview [Accessed 11 July 2025].

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

UV Texture Layout

After creating all of the seamless tile textures in Substance Designer, I wanted to make sure that the meshes, mainly the architectural pieces of our project, will have perfect texel density set so that they appear and tile correctly.

Figure 1 (Archway texture layout)

To add a texture to any mesh inside Blender, you have to plug the albedo texture of the tiles into the Principled BSDF node. It also includes nodes for roughness, specularity, normal, alpha and so on, but now, the albedo base is enough.

The archway consists of the main archway and its small extruding ledge that would require two different textures. To achieve that, I went into the material setup and created two different materials by highlighting the region that demands it. Those two different materials were then assigned accordingly.

Figure 2 (Fixing roof shingles)

I ran into an error while trying to assign tile texture for the roof shingles. As you recall, we only created a plane to act as a modular roof piece for the architecture. Valorant does it quite popularly, using majority of the roof pieces as flat planes and a single layer of roof tiles for volume.

While assigning textures to my flat planes, I noticed a discrepancy as some of the vertices were not really snapped together. Its just a simple fix, turning the snap on and snapping the vertices together to close any holes seen.

Figure 3 (Tiling the normal of the roof planes)

I also decided to go ahead and tile the normal map with the same texel density as the albedo map of the roof tile. Since, it is a flat plane, I wanted to use the normal maps to fake the volume of the tiles. For that, I needed to ensure that the normal and the albedo maps tile accurately as possible.

Figure 4 (Creating side roof plates)

I decided to replicate the diagonal roof plates of the architecture. This was created using a plane. I wanted to go about the non-destructive manner using modifiers. I used a Solidify modifier to add depth to the plane and curved its edges. Then, with the help of an Array modifier, I arrayed the plane mesh to fit the scale of the modular roof pieces. This was then done for every architecture present in the concept art.

Figure 5 (Maintaining similar texel density)

Again, as the scale of individual modular roof pieces differ from each architectural meshes, the texel density also differs by a bit. To make sure that they tile similarly in scale and orientation, I had to spend a bit of time trying to find the perfect texel density for each roof pieces to ensure that they all look similar in scale and tile perfectly without any overlapping artifact errors.

Figure 6 (Applying the modifers)

It's also important to note that I am doing the same thing for the plaster materials of the architecture. Finding a consistent texel density so that the visual quality of the textures for the meshes remain constant and/or similar is key to achieving perfection in environment art. After finishing the roof tiles, I then started applying the meshes as I wanted to import the final polished meshes into Unreal Engine.

I have to say, the pieces are all starting to come around together. The textures look really nice inside Blender, but our main aim is to make them pop in Unreal Engine.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Creating Tile Textures

I feel like I have learnt a lot when being heavily invested in creating stylized tile textures for my project. I have learnt a lot about new nodes that I can use in interesting ways to get beautiful stylized outputs.

Today, I decided to create one last final tile texture for my environment art. As you would recall from the concept art, my environment is completely shrowded in overgrown foliage. Thus, I wanted to also use a vertex tile for the roof shingles from where the ivy vines would hang. That would also apply to the floor platform for the entire environment. Thus, I decided to go and create a mossy grass tile texture that would blend beautifully with the scene.

Figure 1 (Base grass setup)

To create the grassy plain tile, I use a Clouds node (is it even a surprise at this point?). Because of its cloudy pattern, it is very simple to create a grassy texture with different gradient patterns. I used a Crystal node for its sharp mask and used it with a Make it Tile Patch node to create patches of it with variations in its rotation.

At the same time, I also wanted to make sure the texture has grass blades present to introduce volume. I decided to create a single grass blade using a Shape node, pretty versatile for creating a shape you want. After that, I use a Gradient Linear node to introduce gradient to the grass blade. Using a special node called Splatter Circular node, it splatters a bunch of grass blades in a circular rotation and is fed into a Tile Sampler to replicate it seamlessly.

Figure 2 (Creating the color and the roughness maps)

The inputs from the earlier setups are fed into two new setups; one for color and one for roughness. I controlled the roughness of the tile texture pretty easily by using a non-uniform color and blending it with a Subtract blending mode.

I wanted a bit of gradient for the color maps and thus, utilizing uniform colors with gradients and blending them together and using a mask to separate the colors. This was repeated for couple more times and during this pass, the normal and the ambient occlusion maps were also tweaked to get a more direct color for the grass blades.

Figure 3 (Final output setup)

The final setup is exactly as you would imagine. A lot of grass color tweaking with its PBR parameters set which are then plugged into its final output nodes. Again, I create an ORM map and an ORD map if necessary.

This formally concludes the creation of tile textures made in Substance Designer. I chose to omit a couple of textures I created as they literally used the same formulae and it would be a bit boring to reiterate those details on and on again. I will say, I have a deeper appreciation for Substance Designer and would definitely include it a lot more in my 3D workflow. Now, its time to move onto our next phase of the project.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Creating Tile Textures

As commonly seen in Valorant, vertex painting is definitely the name of the game. Lots of different architectures with wall plasters with bricks underneath or overlaying it is very common. I did create a symmetrical brick tile, however, when going through the countless number of pictures I had taken as references, I noticed that Valorant likes their assymetrical brick tile textures for vertex painting a LOT!

Figure 1 (In-game screenshots from Valorant)

My entire project follows around replicating the theme of Valorant's artstyle. Hence, it would be a crucial opportunity missed if I don't try recreating similar brick tile textures for my environment art.

Normally, I would have used a Tile Sampler right off the bat to generate a simple tile that I can work my way up from. But, I noticed smaller details like deformed edges, bumps and irregularities in the brick tiles in Valorant. Thus, I started with a Shape node which is what it basically does; creates a shape for you to use. From there, I use a Crystal node as an alpha mask to control the edges of the shape which I kept reusing in different variations and blended all of them together.

Figure 2 (Creating an irregular brick)

I then plug the data into the Tile Sampler to generate a seamless tile. Note that you can also increase the number of input needs to generate your tile meaning, you can always create a lot of variations if you want even more details for your individual bricks. However, I wanted variations in a non-destructive manner which is where Flood Fill reigns as the king.

I plug the output of the Tile Samplers into a Flood Fill node and then plug that output into a Flood Fill to Random Grayscale to again control variation values of the Flood Fill. This process is repeated over and over again. Think of it simply as scanning individual bricks as its own UV shells and working on creating different variations for each different UV shells in a non-destructive manner.

Figure 3 (Flood Fill node)

I make use of a new node called Distance node. It takes the position of the nearest white pixel in a mask and returns a gradient for an output. This node helped me return certain brick tiles that could easily be extruded non-destructively, allowing for an interesting variation and introducing depth to the brick tiles.

From here on out, I use Warp nodes to introduce deformation to the brick tiles and also make use of the Ambient Occlusion nodes to get a sharper lightness value for the brick tiles that I could use for my color base. The height information was already created and from it, I extracted the final outputs and also created the ORM map from it.

Figure 3 (Warp masks and Distance node)

The color setup is pretty simple. I focused on the left architecture present in the concept art for the base color of the tiles. I would create a shader setup in UE later that would allow me to chnage the tint of the color at will. I was super impressed with the result I obtained and was falling deep in love with the intricacies and the beauty of Designer.

Figure 4 (Final color shader setup)

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Creating Tile Textures

As I have created the leaf cards for the tree created using TreeIt, it makes sense that I also create a tileable bark texture for it. It would look very out of place if the leaves are handpainted but the bark is just a plain brown color.

I decided to see if I could use Substance Designer to create the bark texture for the trees. I started working on the height information of the trees with a horizontal scratch focus. For the scratches, I used a node called Directional Scratches which proved to be just what I needed. With a bit of blur and histogram selection, I extract the information I need from the scratches as the grunge pass on the bark.

Figure 1 (Directional scratch grunge pattern)

I then opt for a vertical leak texture which I want imprinted upon the bark tile texture. I achieve this by using a Directional Noise map and use directional blur with a slop blur to achieve stylization effect. The histogram data is selected and I blend it all together.

Figure 2 (Vertical leak grunge)

Since it was really simple to replicate the scratches on the tree bark, I started working on the color for the tree bark. Again, its gradient with HSL node to slightly change the hue and the saturation values coupled with different uniform colors all blended together to get the final output. After this, they were all plugged into its respective final outputs.

Figure 3 (Color setup for the bark texture)

I believe I have documented almost every thing I do to setup my nodes in Designer. A lot of node setups I use for other tile textures all follow the same pattern. If I need variations, I use Flood Fill. If I need a bit more stylization, I use a Slope Blur node and so on.

For the next few documentations, I will only highlight what I have done unique or interesting as it does get very repetitive and monotonous.

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Creating Tile Textures

I realize that my concept art actually has some metallic pieces that might need some shine. It is a very difficult thing to replicate the stylization of metal while making it look cohesive with other rough assets in a stylized environment. Thus, I had to see if I could replicate a stylized metal tile texture for the project.

As always, I start working on the height map as you can see the shape you want in real time. I start with a Moisture grunge, though you can use any different grunge textures for that matter. I plug with a Clouds node to create a base grunge for the base height information. Clouds map is a beautiful grunge texture, often used for stylization of assets during the texture phase. After controlling its position and the contrast of the moisture map, we blend it together to get a grungy metal visual look.

Figure 1 (Base grungy metal)

I decide to work on adding more grunge textures for the imperfections of the metal tile texture. However, I didn't use new textures; I used a Transformation 2D node to change its orientation and work with the Histogram to control its values. This was then warped and fed to a blend which was fed to a similar setup.

Figure 2 (Extra grunge information)

Rest of the ndoes are pretty similar so I haven't showed it much here. However, for this instance, instead of plugging a black uniform color to the metallic output. A white uniform color with the value of 1 makes the tile texture metallic.

Again, I use the brushstrokes to get a brush pattern for the grunge details before I start adding color to the texture. I am not really that much worried about colors being inaccurate as I will still create a flexible shader setup inside Unreal Engine to control the tint and the pbr values of the textures. However, just for accuracy, I try to maintain a consistency amongst all workflows, which includes making sure I get a similar color output for our textures.

Figure 3 (Metal tile texture)

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Creating Tile Textures

I started working on more complex textures needed for my project. I wanted to create a symmetrical and assymetrical brick tile that could be used in vertex painting setup inside Unreal Engine. My concept art clearly outlines buildings with plaster materials and brick tiles underneath protruding out and I wanted to create a similar effect.

Figure 1 (Symmetrical Brick Tiles)

While specifically working on brick tiles, I wanted slight cuts and cracks to display wear on the bricks. I was racing my mind trying to think of a more intuitive manner to achieve this effect.

Adobe has this wonderful archive on different nodes and what they do and how they can be used up on their website. This is when I found out about this beautiful node called Flood Fill.

Figure 2 (Flood Fill, (Adobe, 2023))

Flood Fill is an effect you can use in your designer setup which allows for interesting variations that would elevate those same boring old tiles. It's a prequel node which you can add to other Flood Fill effects for a more non-destructive workflow.

To create the bumps on the brick tiles, I used a tile sampler to create small rocky bumps which was also blender with voronoi textures created from other tile samplers. it was then fed into the Flood Fill effect.

As mentioned before, Flood Fill is just a starting point for many other Flood Fill effects. Since I wanted variations in the bumps, I decided to use another effect named Flood Fill to Gradient. It transforms the base Flood Fill into gradients and is very useful for creating a height map where tiles are randomly tilted and sloped.

Figure 3 (Flood Fill to Gradient, (Adobe, 2023))

Using the Flood Fill to Gradient, I get a lot of different variations on the bumps which proved helpful to the overall height of the tile. Similarly, when working on the bricks itself, I spam those Flood Fill effects to achieve variations on the brick tile.

Figure 4 (Flood Fill for brick tiles)

The setup looks really complicated but it really isn't. I use a random tile texture and feed it to the flood fill effect and make sure that its rotational values are different so that I achieve a different gradient everytime.

After getting a plethora of gradients, I make sure to blend all of them together into a single height map we can use for our final output nodes. This is achieved by using the Blend node (yep, Blend to blend things) and using a Min (Darken) blending mode to blend the gradients into a single texture.

Figure 5 (Final Color and outputs)

After finally getting the height information, I use that node to extract the roughness, occlusion, normal and height maps for their final outputs. I again use the height node get a base to build my colors upon, similar process with strokes and color gradients which I then plugged into my final color output. I again created an ORM map using the Merge node and finished my brick tile texture.

REFERENCES

Adobe, 2023. Adobe. [Online] Available at: https://helpx.adobe.com/substance-3d-designer/substance-compositing-graphs/nodes-reference-for-substance-compositing-graphs/node-library/filters/effects/flood-fill.html [Accessed 5 July 2025].

Available at: https://helpx.adobe.com/substance-3d-designer/substance-compositing-graphs/nodes-reference-for-substance-compositing-graphs/node-library/filters/effects/flood-fill-to-gradient.html [Accessed 5 July 2025].

[majorstudyfinal]

Artefact, Documentation and Presentation (Aryan Raj Adhikari)

Creating Tile Textures

I started working on the roof shingle tile texture for the roof of the architectures. The roof materials are an interesting thing in Valorant as they are mostly tile textures with simple roof meshes on the edges of the roof to provide volume. They have a very simplistic roof shingle texture and I decided to focus on that inside Designer.

Figure 1 (Base of the roof shingle)

There are different ways to go about creating the roof shingles. The method I opted for was to use a Gradient Linear node which provides a linear gradient node that can then be plugged into a Transformation 2D node to control its transformation values. I then used another Gradient Linear node to control the shape of the roof shingle base by plugging it into a Blend node. Honestly, it sounds complicated but it really isn't and a lot of it boils down to testing different nodes and controlling the parameters to see what you are getting.

Figure 2 (Adding deformations and details to the shingles)

I also wanted to introduce deformations and bumps and whatnot to the shingles. I decided to introduce bumps by transforming the polygon shapes on the shingles and using appropriate blend mode to shave that portion away.

As for the assymetrical roof shingle shape, I used a Perlin Noise texture and added a Blur Slope Grayscale to achieve a stylized look with inherited data from the previous set.

Figure 3 (Tile sampler node)

The Tile Sampler node is one of the most sought after and useful tool in Designer. It allows you to create arrays of anything; input data, or shapes of different kinds. This will prove super helpful especially during the creation of roof shingles. Since, we already have a lot of different variations when it comes to the wear and tear of the shingles, it would be helpful in plugging it all to the Tile Sampler.

The first data set is also plugged into a Tile Sampler to create the base plate below the shingles.

Figure 4 (Roof cracks)

I decided to create cracks for the roof shingles. The beautiful thing about Designer is that you can use different methods to go about achieving the same effect. For my case, I found using a Cell texture with an Edge Detect node to detect edges I want to use as cracks proved useful. I then paired it up with a Crystal node that I used a Directional Warp with to create imperfect cracks.

From here on out, its again the same thing. Plugging the nodes into their corresponding output slots and using the height information from before to create color maps for the roof shingle tiles with the gradient pack will become a norm.

Figure 5 (Mossy overlay)

One thing I did add is to get a mossy overlay on top of the roof shingles which I achieved by inheriting the height information and plugging it into a Height Blend node and then using a Clouds texture map to act as a mossy overlay. The output is also plugged into the color maps whereby I could control its intensity and color at ease.

Figure 6 (Final output setup)