Add ES 300 built-ins trunc, round, roundEven, modf, isnan, isinf,…

Test/300BuiltIns.frag

+#version 300 es
+
+int imax, imin;
+uint umax, umin;
+
+vec3 x, y;
+bvec3 bv;
+
+uint uy;
+uvec2 uv2c;
+uvec2 uv2y;
+uvec2 uv2x;
+uvec4 uv4y;
+
+ivec3 iv3a;
+ivec3 iv3b;
+
+ivec4 iv4a;
+ivec4 iv4b;
+
+float f;
+
+vec2 v2a, v2b;
+vec4 v4;
+
+void main()
+{
+    // 1.3 int
+    vec3 v = mix(x, y, bv);
+    ivec4 iv10 = abs(iv4a);
+    ivec4 iv11 = sign(iv4a);
+    ivec4 iv12 = min(iv4a, iv4b);
+    ivec4 iv13 = min(iv4a, imin);
+    uvec2 u = min(uv2x, uv2y);
+    uvec4 uv = min(uv4y, uy);
+    ivec3 iv14 = max(iv3a, iv3b);
+    ivec4 iv15 = max(iv4a, imax);
+    uvec2 u10 = max(uv2x, uv2y);
+    uvec2 u11 = max(uv2x, uy);
+    ivec4 iv16 = clamp(iv4a, iv4a, iv4b);
+    ivec4 iv17 = clamp(iv4a, imin, imax);
+    uvec2 u12 = clamp(uv2x, uv2y, uv2c);
+    uvec4 uv10 = clamp(uv4y, umin, umax);
+
+    // 1.3 float
+    vec3 modfOut;
+    vec3 v11 = modf(x, modfOut);
+
+    float t = trunc(f);
+    vec2 v12 = round(v2a);
+    vec2 v13 = roundEven(v2a);
+    bvec2 b10 = isnan(v2a);
+    bvec4 b11 = isinf(v4);
+
+    // 3.3 float
+    int i = floatBitsToInt(f);
+    uvec4 uv11 = floatBitsToUint(v4);
+    vec4 v14 = intBitsToFloat(iv4a);
+    vec2 v15 = uintBitsToFloat(uv2c);
+
+    // 4.0  pack
+    uint u19 = packSnorm2x16(v2a);
+    vec2 v20 = unpackSnorm2x16(uy);
+    uint u15 = packUnorm2x16(v2a);
+    vec2 v16 = unpackUnorm2x16(uy);
+    uint u17 = packHalf2x16(v2b);
+    vec2 v18 = unpackHalf2x16(uy);
+}

Test/precision.frag

@@ -30,6 +30,11 @@ void main()
     precision lowp int;
     int level1_low;
     sum += level1_low;
+    
+    // test maxing precisions of args to get precision of builtin
+    lowp float arg1;
+    mediump float arg2;
+    lowp float d = distance(arg1, arg2);
 
     {
         int level2_low;

Test/testlist

@@ -23,6 +23,7 @@ array100.frag
 comment.frag
 300.vert
 300.frag
+300BuiltIns.frag
 330.frag
 330comp.frag
 constErrors.frag

glslang/Include/intermediate.h

@@ -160,8 +160,12 @@ enum TOperator {
     EOpAbs,
     EOpSign,
     EOpFloor,
+    EOpTrunc,
+    EOpRound,
+    EOpRoundEven,
     EOpCeil,
     EOpFract,
+    EOpModf,
     EOpMin,
     EOpMax,
     EOpClamp,
@@ -169,6 +173,20 @@ enum TOperator {
     EOpStep,
     EOpSmoothStep,
 
+    EOpIsNan,
+    EOpIsInf,
+
+    EOpFloatBitsToInt,
+    EOpFloatBitsToUint,
+    EOpIntBitsToFloat,
+    EOpUintBitsToFloat,
+    EOpPackSnorm2x16,
+    EOpUnpackSnorm2x16,
+    EOpPackUnorm2x16,
+    EOpUnpackUnorm2x16,
+    EOpPackHalf2x16,
+    EOpUnpackHalf2x16,
+
     EOpLength,
     EOpDistance,
     EOpDot,

glslang/MachineIndependent/Constant.cpp

@@ -444,10 +444,27 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType,
 
         case EOpAbs:
         case EOpSign:
-        case EOpFloor:
+        case EOpFloor:            
+        case EOpTrunc:
+        case EOpRound:
+        case EOpRoundEven:
         case EOpCeil:
         case EOpFract:
 
+        case EOpIsNan:
+        case EOpIsInf:
+
+        case EOpFloatBitsToInt:
+        case EOpFloatBitsToUint:
+        case EOpIntBitsToFloat:
+        case EOpUintBitsToFloat:
+        case EOpPackSnorm2x16:
+        case EOpUnpackSnorm2x16:
+        case EOpPackUnorm2x16:
+        case EOpUnpackUnorm2x16:
+        case EOpPackHalf2x16:
+        case EOpUnpackHalf2x16:
+
         case EOpLength:
 
         case EOpDPdx:
@@ -549,6 +566,7 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
 
     case EOpAtan:
     case EOpPow:
+    case EOpModf:
     case EOpClamp:
     case EOpMix:
     case EOpStep:

glslang/MachineIndependent/intermOut.cpp

@@ -216,9 +216,26 @@ bool OutputUnary(bool /* preVisit */, TIntermUnary* node, TIntermTraverser* it)
     case EOpAbs:            out.debug << "Absolute value";       break;
     case EOpSign:           out.debug << "Sign";                 break;
     case EOpFloor:          out.debug << "Floor";                break;
+    case EOpTrunc:          out.debug << "trunc";                break;
+    case EOpRound:          out.debug << "round";                break;
+    case EOpRoundEven:      out.debug << "roundEven";            break;
     case EOpCeil:           out.debug << "Ceiling";              break;
     case EOpFract:          out.debug << "Fraction";             break;
 
+    case EOpIsNan:          out.debug << "isnan";                break;
+    case EOpIsInf:          out.debug << "isinf";                break;
+
+    case EOpFloatBitsToInt: out.debug << "floatBitsToInt";       break;
+    case EOpFloatBitsToUint:out.debug << "floatBitsToUint";      break;
+    case EOpIntBitsToFloat: out.debug << "intBitsToFloat";       break;
+    case EOpUintBitsToFloat:out.debug << "uintBitsToFloat";      break;
+    case EOpPackSnorm2x16:  out.debug << "packSnorm2x16";        break;
+    case EOpUnpackSnorm2x16:out.debug << "unpackSnorm2x16";      break;
+    case EOpPackUnorm2x16:  out.debug << "packUnorm2x16";        break;
+    case EOpUnpackUnorm2x16:out.debug << "unpackUnorm2x16";      break;
+    case EOpPackHalf2x16:   out.debug << "packHalf2x16";         break;
+    case EOpUnpackHalf2x16: out.debug << "unpackHalf2x16";       break;
+
     case EOpLength:         out.debug << "length";               break;
     case EOpNormalize:      out.debug << "normalize";            break;
     case EOpDPdx:           out.debug << "dPdx";                 break;
@@ -304,6 +321,7 @@ bool OutputAggregate(bool /* preVisit */, TIntermAggregate* node, TIntermTravers
     case EOpVectorNotEqual:   out.debug << "NotEqual";                      break;
 
     case EOpMod:           out.debug << "mod";         break;
+    case EOpModf:          out.debug << "modf";        break;
     case EOpPow:           out.debug << "pow";         break;
 
     case EOpAtan:          out.debug << "arc tangent"; break;