Also check out my uv unwrap modifier. They make a great combo.

How to Use

Select a mesh and add a "Geometry Nodes" modifier.

Select "GN_Texel_Density". Set the texture size, the texel density and the UV map name.

If you check the "apply modifiers" checkbox when exporting to fbx then you can export with texel density without having to apply your modifiers.

Asset Library

If you use the asset library you can find it under the "Enno/uv" folder.

How to get it

Grab it from Gumroad. MIT license.

If you're looking for a texel density addon I recommend Texel Density Checker. If you would like to know more about texel density check out this article by Timothy Dries.

This modifier combined with my uv unwrap modifier makes procedural geometry exportable without applying the modifiers, creating UVs and setting texel density each time you export. Real-time on meshes under around 10k triangles. Requires Blender version 3.5 beta or higher.

How to Use

Select a mesh and add a "Geometry Nodes" modifier.

Select "GN_Unwrapper".

Seams

There are four ways to define uv seams. Sharp edges, edge angle and material border. If you select more than one then they will be combined.

• Sharp Edges - Use sharp edges as uv seams. If you check the "clear sharp edges" checkbox then the sharp edges that you define will be removed by the modifer so that they do not create sharp edges and are only used for uv seams. There is currently no way to get seams in geometry nodes so uv seams cannot be used. Sharp edges can be used as a work-around.

• Edge Angle - Use edge angle for uv seams. The edge angle is in degrees. Unfortuantly this does not work as well as Blender's smart unwrap. Smart unwrap does more than only use edge angle.

• Material Border - Use the border of the defined material as a uv seam.

• Attribute - Used an edge boolean attribute to define uv seams. Geometry nodes do not have access to uv seams. One way to get around this is to use a python script to copy the uv seams into an attribute. A script to do this can be found at https://blender.stackexchange.com/a/269344

Other Settings

• Limit to Material - Use this to limit which faces will be unwrapped. Unwrapping will be limited to faces with the defined material.

• UV Map Name - Set this to the name of the UV map attribute. Default is "UVMap".

Rotate UVs to face up in world space (or any other direction)

If you want all of the uvs to be oriented in the same direction for example you are modeling walls and want drips on the walls to all be vertical then check the "Rotate UVs to World Direction" and set the "UV Rotation World Direction". Set to 0,0,1 for UVs to be vertical.

Pack UVs

Use this to pack UVs into 0 - 1 space. Settings for this can be found in the Blender Docs

Asset Library

If you use the asset library you can find it under the "Enno/uv" folder.

How to get it

Grab it from Gumroad. MIT license.

Also check out my texel density modifier.

I recently read Build by Tony Fadell after seeing him on the Lex Fridman Podcast. In it there is a chapter titled "Three Generations" where he talks about how it usually takes three generations to get a product right. He is responsible for building the iPod, iPhone and Nest Thermostat and uses those as examples.

Why?

I first learned Maya during college in 2000 and after 22 years using Maya I know it quite well. The idea of throwing that built up knowlage away and switching to Blender did not sound appealing to me for a long time. For years co-workers told me how much they liked it (although some warned that it was far from perfect). Finally, a few months ago I made the jump and am very glad that I did.

It's hard to put into words why Blender is better. It is far from perfect. Maybe it's similar to creating an image using oil paint versus using a paint program on a computer. People create amazing images with both but what you can do using paint is vastly limited compared to using a computer. Or maybe a typewriter versus a word processor. Maya has all the tools to create games or movies and some are much better than what is currently in Blender but Blender has tools that breed creativity.

Oh yeah and Blender is also open-source and free.

What is Rust and why is it awesome?

People like Rust

According to Stack Overflow's developer survey Rust has been the most loved programming language since 2016. I made sure to include C# which Unity uses. C and C++ were so far down I had to cut them off.

Rust is FAST

Rust is about as fast as C and C++ and maybe twice as fast as C# in this test.

Rust doesn't crash

One of Rust's main benefits is being memory safe. About 70% of the bugs in Microsft products and Chrome are because of memory errors. Here's an example of one.

int main() 
{ 
   char str1[20]; 
 
   printf("Enter name: "); 
   scanf("%s", str1); 
 
   return(0); 
} 

This C code will blow up if someone enters more than 20 characters. There's no warning or error when you write it and it compiles fine. With Rust however this would not only give you an error it would probably suggest how to fix it.

Another Rust feature is safe concurrency. Here's an example in C that runs with no crash but the result will be... who knows.

int x = 0, y = 0; 
void thread1() {  
  x = 1; 
  if (0 == y) x = 2; 
} 
 
void thread2() { 
  y = 1; 
  if (0 == x) y = 2; 
} 

Rust fixes this problem because of the way it handles ownership and it's borrow checker. Concurrency is much easier in Rust.

There's more

Not only is it possible to write a Rust program that is guarenteed to not leak memory or crash but Rust also has great tools built around it. For example it's errors messages not only tell you what's wrong but in a lot of cases teaches you how to fix it and can even fix it for you.

Other features include a package manager similar to Javascript but better. It can run on just about anything even in browsers faster than Javascript by compiling to WebAssembly.

Some links to learn more about Rust.

• Why the developers who use Rust love it so much.
• Tour of Rust
• The Rust Programming Language Book
• Rust by example
• Rust cheat sheet

I wanted to do it with joinery instead of screws which meant some of the pieces had to be cut into some pretty odd shapes.

My first attempt to make some of the cuts was with a japanese hand saw, some chisels and a mallet. Videos on youtube make it look so easy but trying to get straight cuts was very hard. After a lot of research I bought a Dewalt Table Saw.

With my new table saw I was able to straight complicated cuts pretty easily. Here are most of the pieces.

Test fitting them together. I think it's going to work!

Shots of gluing some pieces together. The holes in the pieces are for dowels which I used instead of screws.

Next step was lots of sanding.

Here's the finished post.

I didn't have a piece of wood wide enough for the mailbox base so I glued two together with dowels in between.

Next I sprayed it all down with some clear sealant, attached the box and numbers.

Done!

Until I finally saw it in the ground I was pretty worried about how it was going to look but I think it turned out great. If I did it over again I would change the design a bit. Maybe for the next house. Time to start the next project!

Figuring out the clouds for Sky Fleet was a journey but I'm pretty happy with the final solution. Here is how it works and the many failures along the way.

My first idea was to use simple meshes for the clouds. I believe I booleaned together some spheres then cleaned them up to get these shapes.

They thought they looked pretty cool but knew I needed a better solution. I stumbled upon a video by Sebastian Lague on youtube about clouds that gave me some ideas. Sebastian's videos are amazing if you've never seen them.

Watching this video led me down a rabbit hole of cloud rendering shaders. My attempt didn't turn out that great and I finally decided that I wanted a styalized look for the clouds.

Instead of focusing on the rendering I decided to try to come up with better shapes for the clouds. In Sebastian's video he talks about using worley noise. I combined worley and simplex noise to come up with the shapes below.

This gave me much better shapes for the clouds but they looked way too solid I thought.

The first thing I tried was duplicating the meshes a couple times and expanding them. The inside mesh is opaque and the outer meshes are transparent.

After watching more youtube videos I tried this technique and was pretty happy with the result.

Looks pretty good I think but a little too crisp. After some research I found alpha-to-coverage which can be used to apply anti-aliasing to alpha test shaders. Here's how the final clouds look in the game.

Since finishing Sky Fleet I got curious about clouds again and made a little cloudy planet shader.

Here's another way to do fake clouds by Oakleaf

Smacked together some quad-based fake #volumetric clouds in a couple of days. Ended up doing a simple depth sort to keep the quads in correct order, at 500 quads a dumb depth sort + vertex buffer reconstruction takes about 2 ms. Buffers are nice. #GameMaker #gamedev pic.twitter.com/gbaRILUs6N

— Oakleaf (@Oakleaff_) August 22, 2022

string $sel[] = `ls -sl`;
if (size($sel) < 2 || size($sel) > 2) {
    error("Select an object, shift-select one material in Hypershade, then run this script");
}
string $object = $sel[0];
string $mat = $sel[1];
string $objects[];
hyperShade -o $mat;

select -tgl $objects;
$objects=`ls -sl`;

select -cl;

for($i=0; $i<size($objects); $i++)
{
    string $temp = `match "^.*\\." $objects[$i]`;
    if (size($temp) > 0) {
        string $check = `substring $temp 1 (size($temp) - 1)`;
        if($check == $object)
        select -tgl $objects[$i];
    }
}

string $listOfObjects[] = `ls -sl`;

int $i;
for( $i = 0; $i < size($listOfObjects); $i++ )
{
	int $eval[] = `polyEvaluate -v`;
	int $numVertices = $eval[0];
	int $v;
	for( $v = 0; $v < $numVertices; $v++ )
	{
	    float $rand = `rand 0.0 1.0`;
		polyColorPerVertex -g $rand ($listOfObjects[$i] + ".vtx[" + $v + "]");
	}
}

• How to RTS
• Terrain Topology Algorithms

Shaders

• Shader Tutorials by Inigo Quilez
• Unity Shaders Cheat Sheet
• Ned Makes Games' Foilage Shader
• From Build-In to URP - Unity
• URP Shader Examples by Filipe Lira
• URP Shader Template by Filipe Lira
• URP Shader Templates by Cyan
• Watercolor Shader for URP by Cyan
• Raymarched Volumetric Lighting in URP
• Skybox Shader by Kelvin van Hoorn
• Harry Alisavakis' Shaders
• Fast Noise Lite
• The Book of Shaders

Clouds

• godot-volumetric-cloud-demo

Trees

• Quick Procedural Bush

Grass

• Grass Bending

Camera Shake

• Math for Game Programmers: Juicing Your Cameras With Math

Math

• Easings.net

Here's a function to dither without using a texture.

float dithering(float2 pos) {
    pos *= _ScreenParams.xy;

    float DITHER_THRESHOLDS[16] =
    {
        1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,
        13.0 / 17.0,  5.0 / 17.0, 15.0 / 17.0,  7.0 / 17.0,
        4.0 / 17.0, 12.0 / 17.0,  2.0 / 17.0, 10.0 / 17.0,
        16.0 / 17.0,  8.0 / 17.0, 14.0 / 17.0,  6.0 / 17.0
    };

    int index = (int(pos.x) % 4) * 4 + int(pos.y) % 4;
    return DITHER_THRESHOLDS[index];
}

Here's a complete unity unlit shader that fades out over a distance. (untested)

Shader "Unlit/NewUnlitShader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;

                // need these
                float4 screenPosition : TEXCOORD1;
                float ditherAmount : TEXCOORD2;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float maxDistance;
            float fadeDistance;

            float dithering(float2 pos) {
                pos *= _ScreenParams.xy;

                float DITHER_THRESHOLDS[16] =
                {
                    1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,
                    13.0 / 17.0,  5.0 / 17.0, 15.0 / 17.0,  7.0 / 17.0,
                    4.0 / 17.0, 12.0 / 17.0,  2.0 / 17.0, 10.0 / 17.0,
                    16.0 / 17.0,  8.0 / 17.0, 14.0 / 17.0,  6.0 / 17.0
                };

                int index = (int(pos.x) % 4) * 4 + int(pos.y) % 4;
                return DITHER_THRESHOLDS[index];
            }

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);

                // pass to fragment shader
                o.screenPosition = ComputeScreenPos(o.vertex);

                float dstToCamera = distance(_WorldSpaceCameraPos, v.vertex);
                float fadeStart = maxDistance - fadeDistance;
                o.ditherAmount = clamp(((dstToCamera - fadeStart) / maxDistance) / (fadeStart / maxDistance), 0, 1);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                // apply fog
                UNITY_APPLY_FOG(i.fogCoord, col);

                // fade by dithering
                float2 screenUV = IN.screenPosition.xy / IN.screenPosition.w;
                clip(dithering(screenUV - i.ditherAmount);

                return col;
            }
            ENDCG
        }
    }
}

using UnityEngine;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;


public class Obj {
    NativeArray<Unity.Mathematics.Random> randomNumberGenerators;

    void Awake() {
        randomNumberGenerators = new NativeArray<Unity.Mathematics.Random>(Unity.Jobs.LowLevel.Unsafe.JobsUtility.MaxJobThreadCount, Allocator.Persistent);

        for (int i = 0; i < randomNumberGenerators.Length; i++) {
            randomNumberGenerators[i] = new Unity.Mathematics.Random((uint)UnityEngine.Random.Range(1, int.MaxValue));
        }
    }

    public void RunJob() {
        NativeArray<float3> positions = new NativeArray<float3>(1000, Allocator.TempJob);

        ObjJob job = new ObjJob {
            randomNumberGenerators = randomNumberGenerators,
            positions = positions
        };

        job.Schedule(positions.Length, 32).Complete();

        // do something with random positions

        positions.Dispose();
    }
}


[BurstCompile]
struct ObjJob : IJobParallelFor
{
    [Unity.Collections.LowLevel.Unsafe.NativeDisableContainerSafetyRestriction] public NativeArray<Unity.Mathematics.Random> randomNumberGenerators;
	[Unity.Collections.LowLevel.Unsafe.NativeSetThreadIndex] int threadId;
    [WriteOnly] public NativeArray<float3> positions;

    public void Execute(int i) {
        Unity.Mathematics.Random random = randomNumberGenerators[threadId];

        positions[i] = new float3(random.NextFloat(), random.NextFloat(), random.NextFloat());

        randomNumberGenerators[threadId] = random;
    }
}

First here's the code for the job.

using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Burst;

[BurstCompile]
struct CullingJob : IJobParallelForFilter
{
    [ReadOnly] public NativeArray<float4> frustumPlanes;
    [ReadOnly] public NativeArray<float3> positions;
    [ReadOnly] public NativeArray<float3> extents;


    public bool Execute(int i) {
        return FrustumContainsBox(positions[i] - extents[i], positions[i] + extents[i]);
    }


    float DistanceToPlane( float4 plane, float3 position )
    {
        return math.dot(plane.xyz, position) + plane.w;
    }

    bool FrustumContainsBox(float3 bboxMin, float3 bboxMax) {
        float3 pos;

        for (int i = 0; i < 6; i++) {
            pos.x = frustumPlanes[i].x > 0 ? bboxMax.x : bboxMin.x;
            pos.y = frustumPlanes[i].y > 0 ? bboxMax.y : bboxMin.y;
            pos.z = frustumPlanes[i].z > 0 ? bboxMax.z : bboxMin.z;

            if (DistanceToPlane(frustumPlanes[i], pos) < 0) {
                return false;
            }
        }

        return true;
    }
}

Here is the code to setup and run the job.

using UnityEngine;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;

public class OjbectCuller : MonoBehaviour {
    Plane[] frustumPlanes;
    NativeArray<float4> frustumPlanesNative;
    public Transform[] objects;
    public Camera playerCamera;


    void Awake() {
        frustumPlanesNative = new NativeArray<float4>(6, Allocator.Persistent);
    }


    void Update() {
        // put object bounds into native arrays
        NativeArray<float3> objectPositions = new NativeArray<float3>(objects.Length, Allocator.TempJob);
        NativeArray<float3> objectExtents = new NativeArray<float3>(objects.Length, Allocator.TempJob);

        for (int i = 0; i < objects.Length; i++) {
            objectPositions[i] = objects[i].bounds.center;
            objectExtents[i] = objects[i].bounds.extents;
        }

        // get camera frustum planes
        frustumPlanes = GeometryUtility.CalculateFrustumPlanes(playerCamera);

        // put planes into native array for job
        for (int i = 0; i < 6; i++) {
            frustumPlanesNative[i] = new float4(frustumPlanes[i].normal.x, frustumPlanes[i].normal.y, frustumPlanes[i].normal.z, frustumPlanes[i].distance);
        }

        // this will hold indexes of visible objects when job is complete
        NativeList<int> visibleIndexes = new NativeList<int>(Allocator.TempJob);

        FoilageCellCulling filterJob = new FoilageCellCulling()
        {        
            frustumPlanes = frustumPlanesNative,
            positions = objectPositions,
            extents = objectExtents
        };

        filterJob.ScheduleAppend(visibleIndexes, numObjects, 32).Complete();

        // do something with visible objects
        for (int i = 0; i < visibleIndexes.Length; i++) {
            // DrawObject(objectPositions[visibleIndexes[i]], objectExtents[visibleIndexes[i]]);
        }

        objectPositions.Dispose();
        objectExtents.Dispose();
    }


    void OnDestroy() {
        frustumPlanesNative.Dispose();
    }
}

Here's how to turn 3d and 2d coordinates into 1d indexes.

int ThreeToOne (int x, int y, int z, int xSize, int ySize, int zSize) {
    return x + y * xSize + z * xSize * ySize;
}

int TwoToOne (int x, int y, int xSize, int ySize) {
    return x + y * xSize;
}

Here's how to turn the 1d indexes back into coordinates.

int3 OneToThree (int index, int xSize, ySize, zSize) {
    int3 result = new int3(0, 0, 0);
    result.x = index % xSize;
    result.y = (index / xSize) % ySize;
    result.z = index / (xSize * ySize);
    return result;
}

int2 OneToTwo (int index, int xSize, ySize) {
    int2 result;
    result.x = index % xSize;
    result.y = index / xSize;
    return result;
}

One example where this is useful is setting pixels in a Unity Texture2D.

void FillTextureWithBlack (Texture2D texture) {
    Color[] colors = new Color[texture.width * texture.height];

    for (int x = 0; x < texture.width; x++) {
        for (int y = 0; y < texture.height; y++) {
            colors[x + y * texture.width] = new Color(0f, 0f, 0f);
        }
    }

    texture.SetPixels(colors);
    texture.Apply();
}

Here's another example where going from indexes to coordinates is useful. Of course this could be made faster with texture.GetPixels()

Color GetAverageColorOfTexture (Texture2D texture) {
    Vector3 averageColor = new Vector3(0f, 0f, 0f);

    for (int i = 0; i < texture.width * texture.height; i++) {
        int x = i % texture.width;
        int y = i / texture.width;

        Color color = texture.GetPixel(x, y);
        averageColor += new Vector3(color.r, color.g, color.b);
    }

    averageColor /= (float)(texture.width * texture.height);
    return new Color(averageColor.x, averageColor.y, averageColor.z, 1f);
}

Bilinear averages the colors of surrounding pixels producing medium quality results. Bicubic is slower but more precise and produces smoother gradations.

Bicubic example.

using UnityEngine;

public class BicubicInterpolator {
    public static float BicubicInterpolated (float x, float y, Texture2D heightmap) {
        int row = Mathf.FloorToInt(x);
        int col = Mathf.FloorToInt(y);

        float remainderX = x - row;
        float remainderY = y - col;

        float[] p0 = new float[4];
        float[] p1 = new float[4];
        float[] p2 = new float[4];
        float[] p3 = new float[4];

        p0[0] = heightmap.GetPixel(row - 1, col - 1).r;
        p0[1] = heightmap.GetPixel(row - 1, col).r;
        p0[2] = heightmap.GetPixel(row - 1, col + 1).r;
        p0[3] = heightmap.GetPixel(row - 1, col + 2).r;

        p1[0] = heightmap.GetPixel(row, col - 1).r;
        p1[1] = heightmap.GetPixel(row, col).r;
        p1[2] = heightmap.GetPixel(row, col + 1).r;
        p1[3] = heightmap.GetPixel(row, col + 2).r;

        p2[0] = heightmap.GetPixel(row + 1, col - 1).r;
        p2[1] = heightmap.GetPixel(row + 1, col).r;
        p2[2] = heightmap.GetPixel(row + 1, col + 1).r;
        p2[3] = heightmap.GetPixel(row + 1, col + 2).r;

        p3[0] = heightmap.GetPixel(row + 2, col - 1).r;
        p3[1] = heightmap.GetPixel(row + 2, col).r;
        p3[2] = heightmap.GetPixel(row + 2, col + 1).r;
        p3[3] = heightmap.GetPixel(row + 2, col + 2).r;

        return BiCubicValue(p0, p1, p2, p3, remainderX, remainderY);
    }

    static float BiCubicValue(float[] p0, float[] p1, float[] p2, float[] p3, float x, float y) {
        float[] arr = new float[4];
        arr[0] = CubicValue(p0, y);
        arr[1] = CubicValue(p1, y);
        arr[2] = CubicValue(p2, y);
        arr[3] = CubicValue(p3, y);
        return CubicValue(arr, x);
    }

    static float CubicValue(float[] p, float x) {
        return p[1] + 0.5f * x * (p[2] - p[0] + x * (2.0f * p[0] - 5.0f * p[1] + 4.0f * p[2] - p[3] + x * (3.0f * (p[1] - p[2]) + p[3] - p[0])));
    }
}

Bilinear example

using UnityEngine;

public class BilinearInterpolator {
    public static float BicubicInterpolated (float x, float y, Texture2D heightmap) {
        int row = Mathf.FloorToInt(x);
        int col = Mathf.FloorToInt(y);

        float remainderX = x - row;
        float remainderY = y - col;

        float x1 = heightmap.GetPixel(row, col).r;
        float x2 = heightmap.GetPixel(row + 1, col).r;

        float y1 = heightmap.GetPixel(row, col + 1).r;
        float y2 = heightmap.GetPixel(row + 1, col + 1).r;

        return Mathf.Lerp(Mathf.Lerp(x1, x2, remainderX), Mathf.Lerp(y1, y2, remainderX), remainderY);
    }
}

If you need to get the height of Unity's terrain from only a heightmap you can use bicubic interpolation.

Vector3 GetPosition (float x, float z, Terrain terrain, Texture2D heightmap) {
    float x1 = x / terrain.terrainData.size.x * heightmap.width;
    float z1 = z / terrain.terrainData.size.z * heightmap.height;

    float y = BicubicInterpolated(x1, z1, heightmap) * terrain.terrainData.heightmapScale.y;

    return new Vector3(x, y, z);
}