mesa: glsl: remove invalid use of f.x syntax where f is a float

1 files changed, 43 insertions, 44 deletions

diff --git a/src/mesa/shader/slang/library/slang_common_builtin.gc b/src/mesa/shader/slang/library/slang_common_builtin.gc
index f41d1fb6037..9f2a4bdd075 100644
--- a/src/mesa/shader/slang/library/slang_common_builtin.gc
+++ b/src/mesa/shader/slang/library/slang_common_builtin.gc
@@ -171,7 +171,7 @@ uniform gl_FogParameters gl_Fog;
 float radians(const float deg)
 {
    const float c = 3.1415926 / 180.0;
-   __asm vec4_multiply __retVal.x, deg, c;
+   __asm vec4_multiply __retVal, deg, c;
 }
 
 vec2 radians(const vec2 deg)
@@ -198,7 +198,7 @@ vec4 radians(const vec4 deg)
 float degrees(const float rad)
 {
    const float c = 180.0 / 3.1415926;
-   __asm vec4_multiply __retVal.x, rad, c;
+   __asm vec4_multiply __retVal, rad, c;
 }
 
 vec2 degrees(const vec2 rad)
@@ -224,7 +224,7 @@ vec4 degrees(const vec4 rad)
 
 float sin(const float radians)
 {
-   __asm float_sine __retVal.x, radians;
+   __asm float_sine __retVal, radians;
 }
 
 vec2 sin(const vec2 radians)
@@ -253,7 +253,7 @@ vec4 sin(const vec4 radians)
 
 float cos(const float radians)
 {
-   __asm float_cosine __retVal.x, radians;
+   __asm float_cosine __retVal, radians;
 }
 
 vec2 cos(const vec2 radians)
@@ -444,7 +444,7 @@ vec4 atan(const vec4 u, const vec4 v)
 
 float pow(const float a, const float b)
 {
-   __asm float_power __retVal.x, a, b;
+   __asm float_power __retVal, a, b;
 }
 
 vec2 pow(const vec2 a, const vec2 b)
@@ -507,7 +507,7 @@ vec4 exp(const vec4 a)
 
 float log2(const float x)
 {
-   __asm float_log2 __retVal.x, x;
+   __asm float_log2 __retVal, x;
 }
 
 vec2 log2(const vec2 v)
@@ -566,7 +566,7 @@ vec4 log(const vec4 v)
 
 float exp2(const float a)
 {
-   __asm float_exp2 __retVal.x, a;
+   __asm float_exp2 __retVal, a;
 }
 
 vec2 exp2(const vec2 a)
@@ -597,7 +597,7 @@ float sqrt(const float x)
 {
    float r;
    __asm float_rsq r, x;
-   __asm float_rcp __retVal.x, r;
+   __asm float_rcp __retVal, r;
 }
 
 vec2 sqrt(const vec2 v)
@@ -667,13 +667,13 @@ vec4 inversesqrt(const vec4 v)
 
 float normalize(const float x)
 {
-   __retVal.x = 1.0;
+   __retVal = 1.0;
 }
 
 vec2 normalize(const vec2 v)
 {
    const float s = inversesqrt(dot(v, v));
-   __asm vec4_multiply __retVal.xy, v, s.xx;
+   __asm vec4_multiply __retVal.xy, v, s;
 }
 
 vec3 normalize(const vec3 v)
@@ -686,7 +686,7 @@ vec3 normalize(const vec3 v)
    float tmp;
    __asm vec3_dot tmp, v, v;
    __asm float_rsq tmp, tmp;
-   __asm vec4_multiply __retVal.xyz, v, tmp.xxx;
+   __asm vec4_multiply __retVal.xyz, v, tmp;
 }
 
 vec4 normalize(const vec4 v)
@@ -694,7 +694,7 @@ vec4 normalize(const vec4 v)
    float tmp;
    __asm vec4_dot tmp, v, v;
    __asm float_rsq tmp, tmp;
-   __asm vec4_multiply __retVal.xyz, v, tmp.xxx;
+   __asm vec4_multiply __retVal.xyz, v, tmp;
 }
 
 
@@ -708,7 +708,7 @@ vec4 normalize(const vec4 v)
 
 float abs(const float a)
 {
-   __asm vec4_abs __retVal.x, a;
+   __asm vec4_abs __retVal, a;
 }
 
 vec2 abs(const vec2 a)
@@ -732,9 +732,9 @@ vec4 abs(const vec4 a)
 float sign(const float x)
 {
    float p, n;
-   __asm vec4_sgt p.x, x, 0.0;            // p = (x > 0)
-   __asm vec4_sgt n.x, 0.0, x;            // n = (x < 0)
-   __asm vec4_subtract __retVal.x, p, n;  // sign = p - n
+   __asm vec4_sgt p, x, 0.0;            // p = (x > 0)
+   __asm vec4_sgt n, 0.0, x;            // n = (x < 0)
+   __asm vec4_subtract __retVal, p, n;  // sign = p - n
 }
 
 vec2 sign(const vec2 v)
@@ -766,7 +766,7 @@ vec4 sign(const vec4 v)
 
 float floor(const float a)
 {
-   __asm vec4_floor __retVal.x, a;
+   __asm vec4_floor __retVal, a;
 }
 
 vec2 floor(const vec2 a)
@@ -792,7 +792,7 @@ float ceil(const float a)
    // XXX this could be improved
    float b = -a;
    __asm vec4_floor b, b;
-   __retVal.x = -b;
+   __retVal = -b;
 }
 
 vec2 ceil(const vec2 a)
@@ -821,7 +821,7 @@ vec4 ceil(const vec4 a)
 
 float fract(const float a)
 {
-   __asm vec4_frac __retVal.x, a;
+   __asm vec4_frac __retVal, a;
 }
 
 vec2 fract(const vec2 a)
@@ -846,7 +846,7 @@ float mod(const float a, const float b)
 {
     float oneOverB;
     __asm float_rcp oneOverB, b;
-    __retVal.x = a - b * floor(a * oneOverB);
+    __retVal = a - b * floor(a * oneOverB);
 }
 
 vec2 mod(const vec2 a, const float b)
@@ -908,7 +908,7 @@ vec4 mod(const vec4 a, const vec4 b)
 
 float min(const float a, const float b)
 {
-   __asm vec4_min __retVal.x, a.x, b.x;
+   __asm vec4_min __retVal, a, b;
 }
 
 vec2 min(const vec2 a, const vec2 b)
@@ -928,17 +928,17 @@ vec4 min(const vec4 a, const vec4 b)
 
 vec2 min(const vec2 a, const float b)
 {
-   __asm vec4_min __retVal, a.xy, b.xx;
+   __asm vec4_min __retVal, a.xy, b;
 }
 
 vec3 min(const vec3 a, const float b)
 {
-   __asm vec4_min __retVal, a.xyz, b.xxx;
+   __asm vec4_min __retVal, a.xyz, b;
 }
 
 vec4 min(const vec4 a, const float b)
 {
-   __asm vec4_min __retVal, a, b.xxxx;
+   __asm vec4_min __retVal, a, b;
 }
 
 
@@ -946,7 +946,7 @@ vec4 min(const vec4 a, const float b)
 
 float max(const float a, const float b)
 {
-   __asm vec4_max __retVal.x, a.x, b.x;
+   __asm vec4_max __retVal, a, b;
 }
 
 vec2 max(const vec2 a, const vec2 b)
@@ -966,17 +966,17 @@ vec4 max(const vec4 a, const vec4 b)
 
 vec2 max(const vec2 a, const float b)
 {
-   __asm vec4_max __retVal, a.xy, b.xx;
+   __asm vec4_max __retVal, a.xy, b;
 }
 
 vec3 max(const vec3 a, const float b)
 {
-   __asm vec4_max __retVal, a.xyz, b.xxx;
+   __asm vec4_max __retVal, a.xyz, b;
 }
 
 vec4 max(const vec4 a, const float b)
 {
-   __asm vec4_max __retVal, a, b.xxxx;
+   __asm vec4_max __retVal, a, b;
 }
 
 
@@ -1165,7 +1165,7 @@ float length(const vec3 v)
    float r;
    const float p = dot(v, v);      // p = v.x * v.x + v.y * v.y + v.z * v.z
    __asm float_rsq r, p;           // r = 1 / sqrt(p)
-   __asm float_rcp __retVal.x, r;  // retVal = 1 / r
+   __asm float_rcp __retVal, r;    // retVal = 1 / r
 }
 
 float length(const vec4 v)
@@ -1173,7 +1173,7 @@ float length(const vec4 v)
    float r;
    const float p = dot(v, v);      // p = v.x * v.x + v.y * v.y + ...
    __asm float_rsq r, p;           // r = 1 / sqrt(p)
-   __asm float_rcp __retVal.x, r;  // retVal = 1 / r
+   __asm float_rcp __retVal, r;    // retVal = 1 / r
 }
 
 
@@ -1219,7 +1219,7 @@ float faceforward(const float N, const float I, const float Nref)
     // this could probably be done better
     const float d = dot(Nref, I);
     float s;
-    __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
+    __asm vec4_sgt s, 0.0, d;  // s = (0.0 > d) ? 1 : 0
     return mix(-N, N, s);
 }
 
@@ -1228,7 +1228,7 @@ vec2 faceforward(const vec2 N, const vec2 I, const vec2 Nref)
     // this could probably be done better
     const float d = dot(Nref, I);
     float s;
-    __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
+    __asm vec4_sgt s, 0.0, d;  // s = (0.0 > d) ? 1 : 0
     return mix(-N, N, s);
 }
 
@@ -1237,7 +1237,7 @@ vec3 faceforward(const vec3 N, const vec3 I, const vec3 Nref)
     // this could probably be done better
     const float d = dot(Nref, I);
     float s;
-    __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
+    __asm vec4_sgt s, 0.0, d;  // s = (0.0 > d) ? 1 : 0
     return mix(-N, N, s);
 }
 
@@ -1246,7 +1246,7 @@ vec4 faceforward(const vec4 N, const vec4 I, const vec4 Nref)
     // this could probably be done better
     const float d = dot(Nref, I);
     float s;
-    __asm vec4_sgt s.x, 0.0, d;  // s = (0.0 > d) ? 1 : 0
+    __asm vec4_sgt s, 0.0, d;  // s = (0.0 > d) ? 1 : 0
     return mix(-N, N, s);
 }
 
@@ -1596,26 +1596,25 @@ bool any(const bvec4 v)
 bool all (const bvec2 v)
 {
    float prod;
-   __asm vec4_multiply prod.x, v.x, v.y;
-   __asm vec4_sne __retVal.x, prod.x, 0.0;
-    return v.x && v.y;
+   __asm vec4_multiply prod, v.x, v.y;
+   __asm vec4_sne __retVal, prod, 0.0;
 }
 
 bool all (const bvec3 v)
 {
    float prod;
-   __asm vec4_multiply prod.x, v.x, v.y;
-   __asm vec4_multiply prod.x, prod.x, v.z;
-   __asm vec4_sne __retVal.x, prod.x, 0.0;
+   __asm vec4_multiply prod, v.x, v.y;
+   __asm vec4_multiply prod, prod, v.z;
+   __asm vec4_sne __retVal, prod, 0.0;
 }
 
 bool all (const bvec4 v)
 {
    float prod;
-   __asm vec4_multiply prod.x, v.x, v.y;
-   __asm vec4_multiply prod.x, prod.x, v.z;
-   __asm vec4_multiply prod.x, prod.x, v.w;
-   __asm vec4_sne __retVal.x, prod.x, 0.0;
+   __asm vec4_multiply prod, v.x, v.y;
+   __asm vec4_multiply prod, prod, v.z;
+   __asm vec4_multiply prod, prod, v.w;
+   __asm vec4_sne __retVal, prod, 0.0;
 }