One thing I love to do is take a trivial game idea and make it scalable to the point where people look at it and wonder how it still runs. Having several thousand things going on in front of you within a fraction of a second. One of the first games of mine to use this style of development was InOut. There are 100 items that you can make with machines called "Operatives". The real computational issues that are usually overlooked come in when you start implementing things like track systems. I had a few tricks up my sleeve for keeping the game performant and interesting and I wanted to show you them!

A simple clock right?

Not really. I wanted each clock to work efficiently since it's one of the items, and there could be thousands of them on screen. The same goal goes for all of the items in InOut, but what makes the clock so different? Let's start with the model. Since each submesh I add would make another draw call or make the existing draw call exponentially slower, I wanted to make each of the item models a single mesh.

The model has a vertex colour map used as a flat colour image similar to an albedo map. The rest is in the two UV channels: "DisplayUV" for the time display and "ShadeUV" for baked ambient occlusion to add some shadows.

Since all of the items are GPU instanced with Unity's Graphics.DrawMeshInstancedIndirect, I made all instances reference that one texture. All the models were a bit static and invariant coming out from the buy tracks. having no rotational randomness was boring until I made some attributes to the shaders so I could rotate them randomly from the vertex shader. This loads the mapping tables from "ClockData.bin". If it's 12:00, array 1 will use index 0, {0,2, 0,3} which are four byte indexes for the display colours which are in array 0. Assets here

            struct InputData {
                float4 vertex : POSITION;
                float4 color : COLOR; //Vertex Color
                float2 uvd : TEXCOORD0; //DisplayUV
                float2 uvs : TEXCOORD1; //ShadeUV
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            
            struct v2f {
                //SV so the Console devs don't complain lol
                float4 vertex : SV_POSITION;
                float4 color : COLOR;
                float2 uvd : TEXCOORD0;
                float2 uvs : TEXCOORD1;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            
            v2f vert(InputData i) {
                v2f o;
                //Use vertex program indexed for this object
                UNITY_SETUP_INSTANCE_ID(i);
                //Get all instanced variables
                float irot = UNITY_ACCESS_INSTANCED_PROP(Props, _ItemRot);
                float ipx = UNITY_ACCESS_INSTANCED_PROP(Props, _ItemPosX);
                float ipy = UNITY_ACCESS_INSTANCED_PROP(Props, _ItemPosY);
                float iscl = UNITY_ACCESS_INSTANCED_PROP(Props, _ItemScale);
                //transfer info from host to GPU as instance
                UNITY_TRANSFER_INSTANCE_ID(i, o);
                float r = radians(irot);
                float s = sin(r);
                float c = cos(r);
                //Rotation matrix (y)
                float3x3 vmat = { c,0,s,0,1,0,-s,0,c };
                i.vertex.xyz = mul(vmat, i.vertex.xyz);
                //Animation offset
                i.vertex.xz += float2(ipx, ipy) - 0.5;
                o.vertex = UnityObjectToClipPos(i.vertex * iscl);
                o.uvd = TRANSFORM_TEX(i.uvd, _DispTex);
                o.uvs = TRANSFORM_TEX(i.uvs, _ShadeTex);
                o.color = i.color;
                return o;
            }