[Deliverable] Resolve MiniEngine ambiguous intrinsic uses

[V-FEXrt]

MiniEngine has many uses of the following set in intrinsics that are ambiguous under C++'s overload resolution rules.

• clamp
• dot
• lerp
• max
• min
• pow

Other ambiguous cases my arise as used but unimplemented intrinsics are implemented

A similar case was discussed and resolved for select here: llvm/llvm-project#126570

It should be determined if the uses here are intended source breakages requiring migration or if a path similar to select should be forged.

[farzonl]

@spall did some good work here that should have fixed most these cases listed. We will want to know what the other cases are so we can determine if we need source code changes to miniengine or expand our 202X overload resolutions.

[V-FEXrt]

I did some poking around here and this isn't a full list but these seem to be a lot of the missing overloads:

• Binary Vector Scalar Overloads of same element type (float2 fn(float2 a, float b)/float3 fn(float3 a, float b))
  • pow, ldexp (and maybe dot?)
• Binary Vector Scalar Overloads of different element type (float2 fn(float2 a, int b)/float3 fn(float3 a, int b))
  • dot, pow, ldexp, max, (and maybe min)
• Ternary Vector 1 Scalar Overloads (float3 fn(float3 a, float3 b, int c)/float2 fn(float2 a, float2 b, uint c))
  • lerp
• Ternary Vector 2 Scalar Overloads (float3 fn(float3 a, float b, int c)/float2 fn(float2 a, int b, uint c))
  • clamp
• Overloads where one element has the wrong vect size, signedness, or type (fn(int, uint)/fn(uint2, int, uint2)/fn(int, float, float))
  • max, clamp, min
• Matrix overloads
  • mul (and likely others)

The overload analysis also needs to be done for unimplemented intrinsics once they come online

[spall]

@spall did some good work here that should have fixed most these cases listed. We will want to know what the other cases are so we can determine if we need source code changes to miniengine or expand our 202X overload resolutions.

Some of these were likely fixed by hand in the shaders themselves to force the right types, and its likely mini engine will need to have similar changes made to its shaders.

[spall]

I did some poking around here and this isn't a full list but these seem to be a lot of the missing overloads:

* Binary Vector Scalar Overloads of same element type (`float2 fn(float2 a, float b)`/`float3 fn(float3 a, float b)`)
  
  * `pow`, `ldexp` (and maybe `dot`?)

* Binary Vector Scalar Overloads of different element type (`float2 fn(float2 a, int b)`/`float3 fn(float3 a, int b)`)
  
  * `dot`, `pow`, `ldexp`, `max`, (and maybe `min`)

* Ternary Vector 1 Scalar Overloads (`float3 fn(float3 a, float3 b, int c)`/`float2 fn(float2 a, float2 b, uint c)`)
  
  * `lerp`

* Ternary Vector 2 Scalar Overloads (`float3 fn(float3 a, float b, int c)`/`float2 fn(float2 a, int b, uint c)`)
  
  * `clamp`

* Overloads where one element has the wrong vect size, signedness, or type (`fn(int, uint)`/`fn(uint2, int, uint2)`/`fn(int, float, float)`)
  
  * `max`, `clamp`, `min`

* Matrix overloads
  
  * `mul` (and likely others)

The overload analysis also needs to be done for unimplemented intrinsics once they come online

The overloads where you have mixed types, int and float etc will likely need to be fixed by hand. The mixed scalar vector for the same type T overloads can probably be fixed by adding more overloads to clang.