vec3.pi

use raytracepl::utils::*;

pub struct Vec3 {
    pub x:f64;
    pub y:f64;
    pub z:f64;
}

pub fn default() Vec3 {
    
    return Vec3{};
}

pub fn new(x:f64, y:f64, z:f64) Vec3 {
    return Vec3{x:x,y:y,z:z};
}

pub fn random() Vec3 {
    return Vec3{x:random_f64(),y:random_f64(),z:random_f64()};
}

pub fn random_in_unit_sphere() Vec3 {
    while true {
        let p = random_range(-1.0, 1.0);
        if p.length_squared() < 1.0 {
            return p;
        }
    }
    return Vec3{};
}

pub fn ranndom_unit_vector() Vec3 {
    return random_in_unit_sphere().unit_vector();
}

pub fn random_on_hemisphere(normal:Vec3) Vec3 {
    let on_unit_sphere = random_in_unit_sphere();
    if on_unit_sphere.dot(normal) > 0.0 {
        return on_unit_sphere;
    } else {
        return on_unit_sphere.neg();
    }
}

pub fn random_range(min:f64, max:f64) Vec3 {
    return Vec3{
        x:random_f64_range(min,max),
        y:random_f64_range(min,max),
        z:random_f64_range(min,max)
    };
}

pub fn random_in_unit_disk() Vec3 {
    while true {
        let p = Vec3{x:random_f64_range(-1.0, 1.0), y:random_f64_range(-1.0, 1.0), z:0.0};
        if p.length_squared() < 1.0 {
            return p;
        }
    }
    return Vec3{};
}

impl Vec3 {

    pub fn near_zero() bool {
        let s = 1e-8;
        return fabs(self.x) < s && fabs(self.y) < s && fabs(self.z) < s;
    }

    pub fn length_squared() f64 {
        return self.x*self.x + self.y*self.y + self.z*self.z;
    }

    pub fn length() f64 {
        return sqrt_64(self.length_squared());
    }

    pub fn add(other:Vec3) Vec3 {
        return Vec3{x:self.x+other.x, y:self.y+other.y, z:self.z+other.z};
    }

    pub fn sub(other:Vec3) Vec3 {
        return Vec3{x:self.x-other.x, y:self.y-other.y, z:self.z-other.z};
    }

    pub fn neg() Vec3 {
        return Vec3{x:-self.x, y:-self.y, z:-self.z};
    }

    pub fn mul(i:f64) Vec3 {
        return Vec3{x:self.x*i, y:self.y*i, z:self.z*i};
    }

    pub fn div(i:f64) Vec3 {
        return Vec3{x:self.x/i, y:self.y/i, z:self.z/i};
    }

    pub fn eq(other:*Vec3) bool {
        return self.x == other.x && self.y == other.y && self.z == other.z;
    }
    pub fn to_str() string {
        
        let s = itoa_pl(self.x as i64);
        s.append(" ");
        s.append(itoa_pl(self.y as i64));
        s.append(" ");
        s.append(itoa_pl(self.z as i64));
        return s;
    }

    pub fn mul_vec(other:Vec3) Vec3 {
        return Vec3{x:self.x*other.x, y:self.y*other.y, z:self.z*other.z};
    }

    pub fn dot(other:Vec3) f64 {
        return self.x*other.x + self.y*other.y + self.z*other.z;
    }

    pub fn cross(other:Vec3) Vec3 {
        return Vec3{x:self.y*other.z - self.z*other.y, y:self.z*other.x - self.x*other.z, z:self.x*other.y - self.y*other.x};
    }

    pub fn unit_vector() Vec3 {
        return self.div(self.length());
    }

    pub fn reflect(n:Vec3) Vec3 {
        return self.sub(n.mul(2.0*self.dot(n)));
    }

    pub fn refract(n:Vec3, etai_over_etat:f64) Vec3 {
        let cos_theta = fmin(self.neg().dot(n), 1.0);
        let r_out_perp = self.add(n.mul(cos_theta)).mul(etai_over_etat);
        let r_out_parallel = n.mul(sqrt_64(fabs(1.0 - r_out_perp.length_squared()))).neg();
        return r_out_perp.add(r_out_parallel);
    }

}