PixSpace/src/scene.rs

use bevy::{prelude::*, math::bool, render::primitives::Frustum};
use rand::prelude::*;
use bevy::render::primitives::Plane;


pub struct BuildScenePlugin;

impl Plugin for BuildScenePlugin {
    fn build(&self, app: &mut App) {
        app.add_startup_system(build_scene) // actual scene
            .add_system(print_positions); // debugging
    }
}

#[derive(Component)]
struct Person;

#[derive(Component)]
pub struct Position {
    x: f32,
    y: f32,
}

#[derive(Component)]
pub struct ProjectionScreen {
    bottom_left: Vec3,
    bottom_right: Vec3,
    top_left: Vec3,
    top_right: Vec3,

    dir_right: Vec3,
    dir_up: Vec3,
    dir_normal: Vec3,

    matrix: Mat4

}



fn generalized_projection_stereo(eyePos : Vec3)
{

}


fn generalized_projection (
    projectionScreen: ProjectionScreen,
    eyePos: Vec3,
    mut camera: Camera3dBundle,
    clampNearPlane: bool,
)
{
    let pa = projectionScreen.bottom_left;
    let pb = projectionScreen.bottom_right;
    let pc = projectionScreen.top_left;
    let pd = projectionScreen.top_right;

    let vu = projectionScreen.dir_up;
    let vr = projectionScreen.dir_right;
    let vn = projectionScreen.dir_normal;

    // let m = projectionScreen.matrix;

    //let m = Mat4::from_cols(vu., y_axis, z_axis, w_axis)

    let va = pa - eyePos;
    let vb = pb - eyePos;
    let vc = pc - eyePos;
    let vd = pd - eyePos;

    let viewDir = eyePos + va + vb + vc + vd;

    let d = -va.dot(vn);


    if clampNearPlane {
        _ = 33;
        // camera.frustum.planes[4]. // should be near
    }
}

pub fn build_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // plane
    commands.spawn(PbrBundle {
        mesh: meshes.add(Mesh::from(shape::Plane { size: 5.0 })),
        material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
        ..default()
    });
    // cube
    commands.spawn(PbrBundle {
        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
        transform: Transform::from_xyz(0.0, 0.5, 0.0),
        ..default()
    });
    // light
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            intensity: 1500.0,
            shadows_enabled: true,
            ..default()
        },
        transform: Transform::from_xyz(4.0, 8.0, 4.0),
        ..default()
    });


    // camera

    let mut cam = Camera3dBundle {
        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),

        ..default()
    };



    // commands.spawn(cam);

    // commands.spawn((Person, Position { x: 10.0, y: 10.0 }));
    // commands.spawn()
    // .insert(Person)
    // .insert(Position { x: 10.0, y: 10.0 } );

    // camera
    // commands.spawn_bundle(OffAxisProjection {
    //     transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
    //     ..default()
    // });
}



pub fn modify_frustum(mut query: Query<&Frustum>)
{
    let mut rng = rand::thread_rng();

    for mut q in query.iter() {

        for mut p in q.planes {

            println!("{:?}",p);

            let mut n = p.normal_d();

            n.w += rng.gen::<f32>();

            p = Plane::new(n);

            println!("{:?}",p);



            // p.normal_d() += rng.gen();
        }

        // println!("{:?}",q.frustum.planes.len()); 
    }
}


pub fn modify_projection(mut query: Query<&Projection>)
{
    let mut rng = rand::thread_rng();

    for mut q in query.iter() {
        
        print!("{:?}",q);
    }
}

pub fn print_positions(query: Query<&Position>) {
    for _position in query.iter() {
        _ = 33;
        // println!("position {:?} {:?}", position.x, position.y)
    }
}

// Problem with off-axis
// projection 2401, 240