Welcome to Fractal Forums

av = abs(v);
v -= sign(v) * min(av.x,min(av.y,av.z));

vec /= max(x,y,z)

if (abs(x)==1)
 return vec(x,0,0)
if (abs(y)==1)
 return vec(0,y,0)
return vec(0,0,z)

float m = abs(sign(a-b)); // m=0.0 if a==b, m=1.0 otherwise

vec3 paxis(vec3 p)
{
    vec3 a=abs(p),r = vec3(1.0,0.0,0.0);
    if(a.z>=max(a.x,a.y))r=r.yzx;
    else if(a.y>=a.x)r=r.zxy;
    return r*sign(p);
}

vec /= max(abs(vec.x), abs(vec.y), abs(vec.z));

if (abs(vec.x)==1) vec = vector(vec.x,0,0);
else if (abs(vec.y==1) vec = vector(0,vec.y,0);
else vec = vector(0,0,vec.z);

return vec;

av = abs(vec)
vec /= max(av.x, max(av.y,av.z));
return floor(abs(vec))*vec;

av = abs(vec)
vec /= max(av.x, max(av.y,av.z));
av = floor(abs(vec)) * vector(1,0.9,0.8)
av /= max(av.x, max(av.y, av.z));
vec = floor(av) * vec;

vec3 paxis(vec3 vec) {
    vec3 av = abs(vec);
    vec /= max(av.x, max(av.y,av.z));
    av = floor(abs(vec)) * vec3(1.0,0.9,0.8);
    av /= max(av.x, max(av.y, av.z));
    vec = floor(av) * vec;
    return vec;
}

vec3 paxis(vec3 vec) {
    vec3 av = abs(vec);
    vec /= 0.99*max(av.x, max(av.y,av.z));
    av = floor(abs(vec)) * vec3(1.0,0.9,0.8);
    av /= 0.99*max(av.x, max(av.y, av.z));
    vec = floor(av) * vec;
    return vec;
}

  vec3 paxis(vec3 vec) {
    vec3 v = abs(vec);
    float m = max(v.x, max(v.y, v.z));
    v = vec3(float(v.x == m), float(v.y == m), float(v.z == m));

    // disambiguate multiple 1.0 values
    v = v * vec3(1.0, 0.9, 0.8);
    m = max(v.x, max(v.y, v.z));
    v = vec3(float(v.x == m), float(v.y == m), float(v.z == m));

    // restore original sign
    vec3 s = vec3(-float(vec.x < 0.0), -float(vec.y < 0.0), -float(vec.z < 0.0));

    return v*s;
  }

 vec3 paxis(vec3 vec) {
    vec3 v = abs(vec);
    float m = max(v.x, max(v.y, v.z));
    v = vec3(equal(v,vec3(m)));

    // disambiguate multiple 1.0 values
    v = v * vec3(1.0, 0.9, 0.8);
    m = max(v.x, max(v.y, v.z));
    v = vec3(equal(v,vec3(m)));

    // restore original sign
    vec3 s = sign(vec);

    return v*s;
  }

 vec3 paxis(vec3 vec) {
    vec3 v = abs(vec);
    float m = max(v.x, max(v.y, v.z));
    v = vec3(float(v.x == m), float(v.y == m && v.x !=m), float(v.z == m && v.x !=m && v.y !=m));

    // restore original sign
    return v*sign(vec);
  }

vec3 a=abs(p);
a-=max(a.yzx,a.zxy);
return sign(p)*(sign(a)*0.5+0.5);

#include "2D.frag"

// Eiffie
vec3 paxis(vec3 p) {
	vec3 a=abs(p);
	a-=max(a.yzx,a.zxy);
	return sign(p)*(sign(a)*0.5+0.5);
}

// Branched approach
vec3 paxis2(vec3 v) {
	vec3 a = abs(v);
	return normalize(
		(a.x>a.y) ? (a.x>a.z ? vec3(v.x,0,0) : vec3(0,0,v.z))
		:  (a.z>a.y ? vec3(0,0,v.z) : vec3(0,v.y,0)));
}

vec3 color(vec2 c) {
	vec3 v =  vec3(cos(c.x),sin(c.y),sin(c.x*c.y));
	for (int i = 0; i < 2000; i++) {
		v=paxis(v);
	}
	return v;
}

vec3 paxis3(vec3 p)
{
    vec3 a=abs(p),r = vec3(1.0,0.0,0.0);
    if(a.z>=max(a.x,a.y))r=r.yzx;
   else if(a.y>=a.x)r=r.zxy;
   // return r*sign(p);
   return normalize(r*p);
}

av = abs(vec)
vec /= max(av.x, max(av.y,av.z));
return trunc(vec);

av = abs(vec)
vec /= 0.999*max(av.x, max(av.y,av.z));
return trunc(vec);

SLT.F R3.xyz, R1, {0, 0, 0, 0}.x;
SGT.F R1.xyz, R1, {0, 0, 0, 0}.x;
TRUNC.U R3.xyz, R3; // <- Truncate to unsigned integer
TRUNC.U R1.xyz, R1; 
I2F.U R3.xyz, R3; // <- Convert back to float. Really?
I2F.U R1.xyz, R1; 
ADD.F R1.xyz, R1, -R3;

MUL.F R1.xyz, R2, R1;
DP3.F R2.x, R1, R1; // <- a dot product
RSQ.F R2.x, R2.x;  // <- an inverse square root

vec3 v = abs(vec);
float m = max(v.x, max(v.y, v.z));
v = vec3(float(v.x == m), float(v.y == m && v.x !=m), float(v.z == m && v.x !=m && v.y !=m));

// restore original sign
return normalize(v*vec);

MAX.F R2.x, |R1.y|, |R1.z|;
MAX.F R2.x, |R1|, R2;
SNE.F R2.z, |R1.x|, R2.x;
SEQ.F R2.y, |R1|, R2.x;
SEQ.F R3.x, |R1.z|, R2;
SNE.F R3.y, |R1|, R2.x;
SEQ.F R2.x, |R1|, R2;
TRUNC.U R2.x, R2;
TRUNC.U R2.z, R2;
TRUNC.U R2.y, R2;
AND.U R2.y, R2, R2.z;
TRUNC.U R3.x, R3;
AND.U R2.z, R2, R3.x;
TRUNC.U R3.x, R3.y;
AND.U R2.z, R2, R3.x;
I2F.U R2.x, R2;
I2F.U R2.y, R2;
I2F.U R2.z, R2;
MUL.F R1.xyz, R2, R1;
DP3.F R2.x, R1, R1;
RSQ.F R2.x, R2.x;
MUL.F R1.xyz, R2.x, R1;

// Needs #version 330
float fabs(float f) {
return intBitsToFloat(floatBitsToInt(f) & 0x7fffffff);
}

float fastabs(float f) 
{int i=((*(int*)&f)&0x7fffffff);return (*(float*)&i);}

// Notice: returns +1 for 0 as input.
float fastSign(float f) {
   // Bitwise OR of the number '1' with the sign-bit of f
   return intBitsToFloat(0x3F800000 | (0x80000000 & floatBitsToInt(f) ));
}

vec3 fastSign3(vec3 f) {
   return vec3(fastSign(f.x),fastSign(f.y),fastSign(f.z));
}

float fastSign(float f) {
return float((floatBitsToInt(f) >> 31)<<1)+1; // "-1 << 1" is -2
}

float fastSign(float f) { return (floatBitsToInt(f) >> 31) ? -1.0f : 1.0f; }

float fastSignWithZero(float f) { return (f == 0) ? 0 : ((floatBitsToInt(f) >> 31) ? -1.0f : 1.0f); }

      0  y: SETGT       ____,  0.0f,  KC0[0].x      
         z: SETGT       ____,  KC0[0].x,  0.0f      
      1  x: ADD         R0.x,  PV0.z, -PV0.y

      0  y: SETGT_DX10  ____,  KC0[0].x,  0.0f      
      1  x: CNDE_INT    R0.x,  PV0.y,  -1082130432,  1065353216