//For more Vectron fractals visit www.machina-infinitum.com
//General-IFS Fractal - 2024
#include "octane-oslintrin.h"
#define mat4 matrix
#define inout output
// ----------------------------------------- scalars -------------------------------------------------
float fract(float x) { return x - floor(x); }

vector wn_sine_mul(vector a, vector b) { float r1 = sqrt(a[0]*a[0] + a[1]*a[1]); float r2 = sqrt(b[0]*b[0] + b[1]*b[1]);
    float aa = 1. - a[2]*b[2] / (r1*r2);
    return vector(aa * (a[0]*b[0] - a[1]*b[1]) , aa * (a[0]*b[1] + a[1]*b[0]) , a[2]*r2+b[2]*r1 ) ; }
// ------------------------------------------ vec2 ---------------------------------------------------
struct vec2{ float x, y; };
vec2 __operator__add__(vec2 a, vec2 b) { return vec2(a.x+b.x, a.y+b.y); }
vec2 __operator__sub__(vec2 a, vec2 b) { return vec2(a.x-b.x, a.y-b.y); }
vec2 abs(vec2 a) { return vec2(fabs(a.x), fabs(a.y) ); }
float length(vec2 a) { return sqrt(a.x*a.x + a.y*a.y); }
vec2 clamp(vec2 x, float minVal, float maxVal) { return vec2( clamp(x.x, minVal, maxVal), clamp(x.y, minVal, maxVal) ); }
vec2 __operator__mul__(float val, vec2 v) { return vec2(val*v.x, val*v.y); }
vec2 __operator__mul__(vec2 a, float b) { return vec2(a.x*b, a.y*b); }
vec2 __operator__div__(vec2 a, float b) { return vec2(a.x/b, a.y/b); }
vec2 termbyterm(vec2 a, vec2 b) { return vec2(a.x*b.x , a.y*b.y); }
vec2 termbyterm_div(vec2 a, vec2 b) { return vec2(a.x/b.x , a.y/b.y); }
float dot(vec2 a, vec2 b) { return a.x*b.x + a.y*b.y; }
vec2 floor(vec2 a) { return vec2(floor(a.x), floor(a.y) ); }
vec2 flip(vec2 a) { return vec2(a.y, a.x ); }
// ------------------------------------------ vec3 ---------------------------------------------------
struct vec3{ float x, y, z; };
vec3 __operator__add__(vec3 a, vec3 b) { return vec3(a.x+b.x, a.y+b.y, a.z+b.z); }
vec3 __operator__mul__(float val, vec3 v) { return vec3(val*v.x, val*v.y, val*v.z); }
vec3 __operator__div__(vec3 a, float b) { return vec3(a.x/b, a.y/b, a.z/b); }

vec3 __operator__add__(vec3 a, float b) { return vec3(a.x+b, a.y+b, a.z+b); }
vec3 __operator__add__(float b, vec3 a) { return vec3(a.x+b, a.y+b, a.z+b); }
vec3 __operator__sub__(vec3 a, float b) { return vec3(a.x-b, a.y-b, a.z-b); }
vec3 __operator__sub__(float b, vec3 a) { return vec3(a.x-b, a.y-b, a.z-b); }
vec3 __operator__sub__(vec3 a, vec3 b) { return vec3(a.x-b.x, a.y-b.y, a.z-b.z); }
vec3 __operator__mul__(vec3 a, float b) { return vec3(a.x*b, a.y*b, a.z*b); }
float length(vec3 v) { return length(vector(v.x,v.y,v.z)); }
vec3 normalize(vec3 a) { return a/length(a); }
vec3 toVec3(vector v) { return vec3(v[0], v[1], v[2]); }
vec3 toVec3(float v) { return vec3(v, v, v); }
float dot(vec3 a, vec3 b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
vec3 termbyterm(vec3 a, vec3 b) { return vec3(a.x*b.x , a.y*b.y , a.z*b.z); }
vec3 termbyterm_div(vec3 a, vec3 b) { return vec3(a.x/b.x , a.y/b.y , a.z/b.z); }
vec3 wn_sine_mul(vec3 a, vec3 b) { float r1 = sqrt(a.x*a.x + a.y*a.y); float r2 = sqrt(b.x*b.x + b.y*b.y);
    float aa = 1. - a.z*b.z / (r1*r2);
    return vec3(aa * (a.x*b.x - a.y*b.y) , aa * (a.x*b.y + a.y*b.x) , (a.z*r2+b.z*r1) ) ; }
vec3 cross(vec3 a, vec3 b) { return vec3(a.y*b.z - a.z * b.y, a.x*b.z-a.z*b.x, a.y*b.x - a.x*b.y  ); }
vec3 fract(vec3 a) { return vec3( fract(a.x), fract(a.y), fract(a.z) ); }
vec3 mod(vec3 a, float j) { return vec3( mod(a.x,j), mod(a.y,j), mod(a.z,j) ); }
vec3 clamp(vec3 x, vec3 minVal, vec3 maxVal) { return vec3( clamp(x.x, minVal.x, maxVal.x), clamp(x.y, minVal.y, maxVal.y), clamp(x.z, minVal.z, maxVal.z) ); }
vec3 clamp(vec3 x, float minVal, float maxVal) { return vec3( clamp(x.x, minVal, maxVal), clamp(x.y, minVal, maxVal), clamp(x.z, minVal, maxVal) ); }
vec3 sign(vec3 x) { return vec3( sign(x.x), sign(x.y), sign(x.z) ); }
vec3 abs(vec3 a) { return vec3(fabs(a.x), fabs(a.y), fabs(a.z) ); }
vec3 sqrt(vec3 a) { return vec3(sqrt(fabs(a.x)), sqrt(fabs(a.y)), sqrt(fabs(a.z)) ); }
vec3 floor(vec3 a) { return vec3(floor(a.x), floor(a.y), floor(a.z) ); }
vec3 swap_xy(vec3 a) { return vec3(a.y, a.x, a.z ); }
vec3 swap_xz(vec3 a) { return vec3(a.z, a.y, a.x ); }
vec3 swap_yz(vec3 a) { return vec3(a.x, a.z, a.y ); }
void set_xy(vec2 src, output vec3 dest) { dest = vec3(src.x, src.y, dest.z ); return; }
void set_xz(vec2 src, output vec3 dest) { dest = vec3(src.x, dest.y, src.y ); return; }
void set_yz(vec2 src, output vec3 dest) { dest = vec3(dest.x, src.x, src.y ); return; }
void set_xy(vec3 src, output vec3 dest) { dest = vec3(src.x, src.y, dest.z ); return; }
void set_xz(vec3 src, output vec3 dest) { dest = vec3(src.x, dest.y, src.z ); return; }
void set_yz(vec3 src, output vec3 dest) { dest = vec3(dest.x, src.x, src.z ); return; }
vec3 min(vec3 x, float v) { return vec3( min(x.x, v), min(x.y, v), min(x.z, v) ); }
vec3 min(vec3 a, vec3 b) { return vec3( min(a.x, b.x), min(a.y, b.y), min(a.z, b.z) ); }
vec3 max(vec3 x, float v) { return vec3( max(x.x, v), max(x.y, v), max(x.z, v) ); }
vec3 max(vec3 a, vec3 b) { return vec3( max(a.x, b.x), max(a.y, b.y), max(a.z, b.z) ); }
vec3 mix(vec3 a, vec3 b, float amount) { return vec3( mix(a.x, b.x,amount), mix(a.y, b.y,amount), mix(a.z, b.z,amount) ); }
float maxcoord(vec3 a) {
    float ax = abs(a.x); float ay = abs(a.y); float az = abs(a.z);
    return  max(max(ax, ay), az);
    }
float mincoord(vec3 a) {
    float ax = abs(a.x); float ay = abs(a.y); float az = abs(a.z);
    return min(min(ax, ay), az);
    }

vec2 xy(vec3 v) { return vec2(v.x, v.y); }
vec3 zero_3() { return vec3( 0, 0, 0 ); }
vec2 get_xy(vec3 src) { return vec2(src.x, src.y); }
vec2 get_xz(vec3 src) { return vec2(src.x, src.z); }
vec2 get_yz(vec3 src) { return vec2(src.y, src.z); }
vec2 get_yx(vec3 src) { return vec2(src.y, src.x); }
vec2 get_zx(vec3 src) { return vec2(src.z, src.x); }
vec2 get_zy(vec3 src) { return vec2(src.z, src.y); }
// ------------------------------------------ vec4 ---------------------------------------------------
struct vec4{ float x, y, z, w; };

float length(vec4 a) { return sqrt(a.x*a.x + a.y*a.y + a.z*a.z + a.w*a.w); }
float dot(vec4 a, vec4 b) { return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w; }
vec4 __operator__div__(vec4 a, float b) { return vec4(a.x/b, a.y/b, a.z/b, a.w/b); }
vec4 __operator__mul__(vec4 a, float b) { return vec4(a.x*b, a.y*b, a.z*b, a.w*b); }
vec4 __operator__mul__(vec4 a, vec4 b) { return vec4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); }
vec4 __operator__add__(vec4 a, vec4 b) { return vec4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); }
vec4 __operator__sub__(vec4 a, vec4 b) { return vec4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); }
vec3 xyz(vec4 v) { return vec3(v.x, v.y, v.z); }
vec4 __operator__sub__(vec4 a, float b) { return vec4(a.x-b, a.y-b, a.z-b,a.w-b); }
vec3 yzw(vec4 v) { return vec3(v.y, v.z, v.w); }
vec2 xy(vec4 v) { return vec2(v.x, v.y); }
vec4 setXy(vec4 src, vec2 v) { return vec4(v.x, v.y, src.z, src.w ); }
vec4 setXyz(vec4 src, vec3 v) { return vec4(v.x, v.y, v.z, src.w ); }
vec4 setXyz(vec4 src, vector v) { return vec4(v[0], v[1], v[2], src.w ); }

vec4 __operator__mul__(float val, vec4 v) { return vec4(val*v.x, val*v.y, val*v.z, val*v.w); }
vec3 clamp(vec3 x, vec4 minVal, vec4 maxVal) { return vec3( clamp(x.x, minVal.x, maxVal.x), clamp(x.y, minVal.y, maxVal.y), clamp(x.z, minVal.z, maxVal.z) ); }
vec4 abs(vec4 a) { return vec4(fabs(a.x), fabs(a.y), fabs(a.z), fabs(a.w) ); }
vec4 min(vec4 x, float v) { return vec4( min(x.x, v), min(x.y, v), min(x.z, v), min(x.w, v) ); }
vec4 max(vec4 x, float v) { return vec4( max(x.x, v), max(x.y, v), max(x.z, v), max(x.w, v) ); }
vec4 min(vec4 x, vec4 y) { return vec4( min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w) ); }
vec4 toVec4(vector v, float s) { return vec4(v[0], v[1], v[2], s); }
vec4 toVec4(vec3 v3, float s) { return vec4(v3.x, v3.y, v3.z, s); }
vec4 toVec4(float s, vec3 v3) { return vec4(s, v3.x, v3.y, v3.z); }
vec4 toVec4(float s, vector v) { return vec4(s, v[0], v[1], v[2]); }
vec4 toVec4(float s) { return vec4(s, s, s, s); }
vec4 zero_4() { return vec4( 0, 0, 0, 0 ); }
// ------------------------------------------ mat3 ---------------------------------------------------
struct mat3{ float m00, m01, m02, m10, m11, m12, m20, m21, m22; };
mat3 __operator__mul__(float val, mat3 m) { return mat3(val*m.m00, m.m01, m.m02, m.m10, val*m.m11, m.m12, m.m20, m.m21, val * m.m22); }
mat3  rotationMatrix3(vec3 v, float angle){ float c = cos(radians(angle)), s = sin(radians(angle)); return mat3(c+(1.0-c)*v.x*v.x, (1.0-c)*v.x*v.y-s*v.z, (1.0-c)*v.x*v.z+s*v.y,  (1.0-c)*v.x*v.y+s*v.z, c+(1.0-c)*v.y*v.y, (1.0-c)*v.y*v.z-s*v.x,  (1.0-c)*v.x*v.z-s*v.y, (1.0-c)*v.y*v.z+s*v.x, c+(1.0-c)*v.z*v.z); }
mat3 __operator__mul__(mat3 A, mat3 B) { return mat3(A.m00*B.m00+A.m01*B.m10+A.m02*B.m20, A.m00*B.m01+A.m01*B.m11+A.m02*B.m21, A.m00*B.m02+A.m01*B.m12+A.m02*B.m22, A.m10*B.m00+A.m11*B.m10+A.m12*B.m20, A.m10*B.m01+A.m11*B.m11+A.m12*B.m21, A.m10*B.m02+A.m11*B.m12+A.m12*B.m22, A.m20*B.m00+A.m21*B.m10+A.m22*B.m20, A.m20*B.m01+A.m21*B.m11+A.m22*B.m21, A.m20*B.m02+A.m21*B.m12+A.m22*B.m22); }
vec3 __operator__mul__(vec3 v, mat3 m) { return vec3(v.x*m.m00+v.y*m.m01+v.z*m.m02, v.x*m.m10+v.y*m.m11+v.z*m.m12, v.x*m.m20+v.y*m.m21+v.z*m.m22); }
// ------------------------------------------ misc ---------------------------------------------------
	vec4 sin(vec4 a) {return vec4(sin(a.x),sin(a.y),sin(a.z),sin(a.w));}
	vec4 __operator__add__(vec4 a, float b) { return vec4(a.x+b, a.y+b, a.z+b,a.w+b); }
vec3 Rotate(vec3 z,float AngPFXY,float AngPFYZ,float AngPFXZ)
{
		float sPFXY = sin(radians(AngPFXY)); float cPFXY = cos(radians(AngPFXY));
        float sPFYZ = sin(radians(AngPFYZ)); float cPFYZ = cos(radians(AngPFYZ));
        float sPFXZ = sin(radians(AngPFXZ)); float cPFXZ = cos(radians(AngPFXZ));

        float zx = z.x; float zy = z.y; float zz = z.z; float t;

        // rotate BACK
        t = zx; // XY
        zx = cPFXY * t - sPFXY * zy; zy = sPFXY * t + cPFXY * zy;
        t = zx; // XZ
        zx = cPFXZ * t + sPFXZ * zz; zz = -sPFXZ * t + cPFXZ * zz;
        t = zy; // YZ
        zy = cPFYZ * t - sPFYZ * zz; zz = sPFYZ * t + cPFYZ * zz;
		return vec3(zx,zy,zz);
}

shader OslGeometry(
	float Scale = 1.34[[float min=0.001, float max=4]],
	float FoldY = 1.025709[[float min=0.001, float max=4]],
	float FoldX = 1.025709[[float min=0.001, float max=4]],
	float FoldZ = 0.035271[[float min=0.001, float max=4]],
	float JuliaX = -1.763517[[float min=-5, float max=5]],
	float JuliaY = 0.392486[[float min=-5, float max=5]],
	float JuliaZ = -1.734913[[float min=-5, float max=5]],
	float AngX = -51.080209 [[float min=-360, float max=360]],
	float AngY = 0 [[float min=-360, float max=360]],
	float AngZ = -29.096322 [[float min=-360, float max=360]],
	float Offset = -3.036726[[float min=-5, float max=5]],
	int EnableOffset =1[[string label = "Enable Offset mirroring", string widget = "boolean"]],
	int Iterations = 80[[int min=0, int max=80]],
	float ColorPeriod = 0.59646 [[float min=-1, float max=10]],
	float ColorOffset = -0.764706 [[float min=-2, float max=2]],
	int MinColorIteration = 9[[int min=0, int max=60]],
	int MaxColorIteration = 41[[int min=0, int max=60]],
	float LoopUV = 0.0[[float min=0, float max=10]], // New parameter for UV loop
	int OrbitMethod = 0[[int min=0, int max=15]],
	float Precision = 1,
	int Auto_Fix_Octane_2022 = 1 [[string label = "Auto Fix Vectron rendering in Octane 2022", string widget = "boolean"]],
	float Auto_Fix_Ray_Epsilon = 0.0001[[float min=0, float max=0.01]],
    output _sdf c = _SDFDEF)
{
	vec3 p = toVec3(P);
		vec4 OrbitTrap = vec4(1,1,1,1);
	float u2 = 1;
    float v2 = 1;
	if(EnableOffset)p = Offset+abs(vec3(p.x,p.y,p.z));

	vec3 p0 = vec3(JuliaX,JuliaY,JuliaZ);
	float l = 0.0;
	int i=0;
	for (i=0; i<Iterations; i++) {

		p = Rotate(p,AngX,AngY,AngZ);

		p.x=abs(p.x+FoldX)-FoldX;
		p.y=abs(p.y+FoldY)-FoldY;
		p.z=abs(p.z+FoldZ)-FoldZ;
		p=p*Scale+p0;
		l=length(p);
		float rr = dot(p,p);
	if (i >= MinColorIteration && i <= MaxColorIteration)
	{
		OrbitTrap = min(OrbitTrap, vec4(abs(p.x),abs(p.y),abs(p.z), rr));
	}
	}
	OrbitTrap = sin(OrbitTrap * ColorPeriod - ColorOffset * 3.14159265359) * 0.5 + 0.5;
	if (OrbitMethod == 0)
    {
        u2 = OrbitTrap.x;
        v2 = OrbitTrap.x;
    }
    else if (OrbitMethod == 1)
    {
        u2 = OrbitTrap.z;
        v2 = OrbitTrap.z;
    }
    else if (OrbitMethod == 2)
    {
        u2 = OrbitTrap.w;
        v2 = OrbitTrap.w;
    }
    else if (OrbitMethod == 3)
    {
        u2 = OrbitTrap.x;
        v2 = OrbitTrap.y;
    }

    else if (OrbitMethod == 4)
    {
        u2 = OrbitTrap.x;
        v2 = OrbitTrap.z;
    }
    else if (OrbitMethod == 5)
    {
        u2 = OrbitTrap.x;
        v2 = OrbitTrap.w;
    }
    else if (OrbitMethod == 6)
    {
        u2 = OrbitTrap.y;
        v2 = OrbitTrap.x;
    }
    else if (OrbitMethod == 7)
    {
        u2 = OrbitTrap.y;
        v2 = OrbitTrap.z;
    }
    else if (OrbitMethod == 8)
    {
        u2 = OrbitTrap.y;
        v2 = OrbitTrap.w;
    }
    else if (OrbitMethod == 9)
    {
        u2 = OrbitTrap.z;
        v2 = OrbitTrap.x;
    }
    else if (OrbitMethod == 10)
    {
        u2 = OrbitTrap.z;
        v2 = OrbitTrap.y;
    }
    else if (OrbitMethod == 11)
    {
        u2 = OrbitTrap.z;
        v2 = OrbitTrap.w;
    }
    else if (OrbitMethod == 12)
    {
        u2 = OrbitTrap.w;
        v2 = OrbitTrap.x;
    }
    else if (OrbitMethod == 13)
    {
        u2 = OrbitTrap.w;
        v2 = OrbitTrap.y;
    }
    else if (OrbitMethod == 14)
    {
        u2 = OrbitTrap.w;
        v2 = OrbitTrap.z;
    }
    else if (OrbitMethod == 15)
    {
        u2 = OrbitTrap.w;
        v2 = OrbitTrap.w;
    }
	u2 = mod(u2 + LoopUV, 1.0);
	v2 = mod(v2 + LoopUV, 1.0);
    c.u = u2;
    c.v = v2;
	float OutFractal  = Precision*(l)*pow(Scale, -float(i));
	#ifdef __OCTANE_VERSION__
    #if __OCTANE_VERSION__ > 12000000
        if(Auto_Fix_Octane_2022 == 1) {
            OutFractal -= Auto_Fix_Ray_Epsilon;
        }
	#endif
    #endif
    c.dist = OutFractal;
}