Dynamic Texture Lookups - Sanity check

Unity Engine
1

So reading through this article, I wanted to double check on the following blurb:

Note: It may not seem obvious, but any calculation on the texture coordinates counts as a dependent texture read. For example, packing multiple sets of texture coordinates into a single varying parameter and using a swizzle command to extract the coordinates still causes a dependent texture read.

So that means that instead of having a single float4 texcoord like this:

```csharp
*struct v2f {
float4 vertex : SV_POSITION;
float4 texcoord : TEXCOORD0;
};

   v2f vert (appdata_t v) {
     v2f o;
     UNITY_INITIALIZE_OUTPUT(v2f,o);
     V_CW_TransformPoint(v.vertex); 
     o.vertex = UnityObjectToClipPos(vert);

     o.texcoord.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
     o.texcoord.zw = TRANSFORM_TEX(v.texcoord, _Tex2);

     return o;
   }

   fixed4 frag (v2f i) : SV_Target {
     fixed4 mainTex = tex2D(_MainTex, i.texcoord.xy);
     fixed4 tex2 = tex2D(_Tex2, i.texcoord.zw);

     return mainTex * tex2;
   }*

* *I should break out the float4 texcoord into 2 separate values like this:* *csharp
*struct v2f {
float4 vertex : SV_POSITION;
float2 texcoord : TEXCOORD0;
float2 texcoord2 : TEXCOORD1;
};

   v2f vert (appdata_t v) {
     v2f o;
     UNITY_INITIALIZE_OUTPUT(v2f,o);
     V_CW_TransformPoint(v.vertex); 
     o.vertex = UnityObjectToClipPos(vert);

     o.texcoord= TRANSFORM_TEX(v.texcoord, _MainTex);
     o.texcoord2 = TRANSFORM_TEX(v.texcoord, _Tex2);

     return o;
   }

   fixed4 frag (v2f i) : SV_Target {
     fixed4 mainTex = tex2D(_MainTex, i.texcoord);
     fixed4 tex2 = tex2D(_Tex2, i.texcoord2);

     return mainTex * tex2;
   }*

```

Am I understanding that right?

2

The flip side to this issue that I just discussed with someone, two float2’s at the hardware level mean basically two float4’s because the min size is a float4. So does the extra footprint of double the float4’s outweigh the performance cost of the dynamic texture lookup?

I know this is variable based on the application so there’s probably no right answer. It’s not even really something I’m concerned about for our project, more just me wanting a better understanding and some people’s experiences.

3

It would appear you are. I was about to say “no, that’s ridiculous”, but it is what their documentation says. I think some old desktop hardware had special “.zwxy” swizzles that were fine to use, but mobile may not. It also notes that dependent texture reads aren’t a problem for “OpenGL ES 3.0” capable hardware, so iPhone 5s, iPad Air, and iPad Mini 2 or newer, ie: any Apple hardware made in the last 4 years. As best I understand dependent texture reads aren’t an issue for OpenGL ES 3.0 devices in general.

So for OpenGL ES 2.0 devices the cost of the dependent texture reads is absolutely more than the cost of the wasted space in the float4, I’m not even sure you pay that cost if you don’t use the texture coordinates in the shader anywhere but for the texture read anyway.

In OpenGL ES 3.0, pack them.

4

awesome, thank you bgolus