Struct Sphere 

pub struct Sphere {
    pub origin: Vec3,
    pub radius: Float,
    /* private fields */
}

Sphere specified by its radius and origin

Fields

origin: Vec3

Origin of the sphere

radius: Float

Radius of the sphere

Implementations

impl Sphere

pub fn new(origin: Vec3, radius: Float, material: Material) -> Box<Self>

Arguments

• origin - Origin of the sphere
• radius - Radius of the sphere
• material - Material of the sphere

Examples found in repository

examples/fireplace.rs (lines 21-25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let camera = Camera::perspective(
        Vec3::new(4.0, 1.0, -3.0),
        0.5 * Vec3::Y,
        Vec3::Y,
        90.0,
        0.0,
        1.0,
        1024,
        768,
    );

    let mut scene = parser::scene_from_url(SCENE_URL, SCENE_NAME)?;

    scene.add_light(Sphere::new(
        Vec3::new(2.0, 1.5, -2.0),
        0.3,
        Material::Light(Texture::Solid(Color::WHITE)),
    ));

    let renderer = Renderer::new(scene, camera);
    renderer.render().save("fireplace.png")?;

    Ok(())
}

examples/conference.rs (lines 21-25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let camera = Camera::perspective(
        Vec3::new(-50.0, 400.0, -350.0),
        500.0 * Vec3::X + 250.0 * Vec3::Z,
        Vec3::Y,
        90.0,
        0.0,
        1.0,
        1024,
        768,
    );

    let mut scene = parser::scene_from_url(SCENE_URL, SCENE_NAME)?;

    scene.add_light(Sphere::new(
        Vec3::new(-200.0, 40.0, -400.0),
        100.0,
        Material::Light(Texture::Solid(Color::WHITE)),
    ));

    scene.add_light(Sphere::new(
        Vec3::new(900.0, 300.0, -600.0),
        100.0,
        Material::Light(Texture::Solid(Color::WHITE)),
    ));

    let renderer = Renderer::new(scene, camera);
    renderer.render().save("conference.png")?;

    Ok(())
}

examples/hello_sphere.rs (lines 14-18)

fn main() -> Result<(), png::EncodingError> {
    let camera = Camera::default(1280, 720);
    let mut scene = Scene::default();

    scene.add(Plane::new(
        Vec3::NEG_Y,
        Vec3::Y,
        Material::diffuse(Texture::Solid(Color::new(190, 200, 210))),
    ));

    scene.add_light(Sphere::new(
        8.0 * Vec3::Y + 1.5 * Vec3::NEG_Z,
        4.0,
        Material::Light(Texture::Solid(Color::WHITE)),
    ));

    scene.add(
        Sphere::new(
            Vec3::ZERO,
            1.0,
            Material::diffuse(Texture::Solid(Color::new(0, 0, 255))),
        )
        .scale(0.3, 0.3, 0.3)
        .translate(0.0, -0.7, -1.5),
    );

    let mut renderer = Renderer::new(scene, camera);
    renderer.set_samples(36);
    renderer.render().save("hello.png")
}

examples/box.rs (lines 15-22)

fn main() -> Result<(), std::io::Error> {
    let camera = Camera::default(1024, 768);
    let def_color = Color::new(242, 242, 242);
    let mut scene = Scene::empty_box(
        def_color,
        // left
        Material::diffuse(Texture::Solid(Color::new(255, 0, 255))),
        // right
        Material::diffuse(Texture::Solid(Color::new(0, 255, 255))),
    );

    scene.add(Sphere::new(
        Vec3::new(-0.45, -0.5, -1.5),
        0.25,
        Material::metallic(
            Texture::Solid(Color::WHITE),
            0.0,
        )
    ));

    scene.add(Sphere::new(
        Vec3::new(0.45, -0.5, -1.3),
        0.25,
        Material::transparent(
            Texture::Solid(Color::WHITE),
            0.0,
            2.5,
        ),
    ));

    let renderer = Renderer::new(scene, camera);
    renderer.render().save("box.png")?;
    Ok(())
}

examples/circle.rs (lines 39-43)

fn main() -> Result<(), std::io::Error> {
    let camera = Camera::perspective(
        Vec3::new(0.0, 1.5, 1.5),
        Vec3::ZERO,
        Vec3::new(0.0, 1.0, -1.0),
        90.0,
        0.0,
        0.0,
        1024,
        768,
    );

    let mut scene = Scene::default();
    let ground = -0.2;

    // ground
    scene.add(Plane::new(
        ground * Vec3::Y,
        Vec3::Y,
        Material::metallic(Texture::Solid(Color::new(150, 40, 39)), 0.009999),
    ));

    let r = 0.2;
    scene.add_light(Sphere::new(
        Vec3::new(0.0, ground + r + 0.1, 0.0),
        r,
        Material::Light(Texture::Solid(Color::WHITE)),
    ));

    let circle_s = 8;
    let offset = PI / circle_s as Float;

    for i in 0..circle_s {
        let theta = (i as Float / circle_s as Float) * 2.0 * PI + offset;
        let x = theta.cos();
        let y = ground + r;
        let z = theta.sin();

        scene.add(Sphere::new(
            Vec3::new(x, y, z),
            r,
            Material::specular(Texture::Solid(hsv_to_rgb(theta - offset)), 0.2),
        ));
    }

    scene.set_medium(
        Medium::new(
            Vec3::new(0.002, 0.003, 0.0001),
            Vec3::new(0.175, 0.125, 0.11),
            0.9,
        )
    );

    let renderer = Renderer::new(scene, camera);
    renderer.render().save("circle.png")?;

    Ok(())
}

Trait Implementations

impl Bounded for Sphere

fn bounding_box(&self) -> AaBoundingBox

Axis aligned box that contains the object

impl Object for Sphere

fn hit(&self, r: &Ray, t_min: Float, t_max: Float) -> Option<Hit<'_>>

Solve the quadratic

impl Sampleable for Sphere

fn sample_on(&self, rand_sq: DVec2) -> Hit<'_>

Sample on unit sphere and scale

fn sample_towards(&self, xo: Vec3, rand_sq: DVec2) -> Vec3

Visible area from xo forms a cone. Sample a random point on the spherical cap that the visible area forms. Return a ray with direction towards the sampled point.

fn sample_towards_pdf(&self, ri: &Ray) -> (Float, Option<Hit<'_>>)

PDF (w.r.t area) for sampling area of the sphere that is visible from xo (a spherical cap formed by a cone)

fn area(&self) -> Float

Returns surface area of the object

fn sample_leaving(&self, rand_sq0: DVec2, rand_sq1: DVec2) -> (Ray, Hit<'_>)

Samples a ray leaving at random point on the surface of the object. Direction cos weighed on the hemisphere. Returns also normal at ray origin

fn sample_leaving_pdf(&self, r: &Ray, ng: Vec3) -> (Float, Float)

Returns PDF for sampled ray (i) origin and (ii) direction