window.rs

extern crate cgmath;
extern crate gfx;
extern crate gfx_device_gl;
extern crate gfx_window_glutin;
extern crate glutin;
extern crate genmesh;
extern crate amethyst_renderer;
extern crate rand;
extern crate amethyst;

use amethyst::engine::{Application, State, Trans};
use amethyst::context::Context;
use amethyst::config::Element;
use amethyst::ecs::{World, Entity};



use std::time::SystemTime;
use rand::Rng;

use gfx::{Device};
use gfx::traits::FactoryExt;


use cgmath::{Point3, Vector3, Matrix4, EuclideanVector};
use cgmath::{Transform, AffineMatrix3};
use genmesh::generators::SphereUV;
use genmesh::{Triangulate, MapToVertices, Vertices};

use amethyst_renderer::VertexPosNormal as Vertex;
use amethyst_renderer::target::{ColorFormat, DepthFormat};
use amethyst_renderer::{Frame, Layer, Texture};

fn build_sphere() -> Vec<Vertex> {
    SphereUV::new(32, 32)
        .vertex(|(x, y, z)| Vertex{
            pos: [x, y, z],
            normal: Vector3::new(x, y, z).normalize().into(),
            tex_coord: [0., 0.]
        })
        .triangulate()
        .vertices()
        .collect()
}

fn layer_gbuffer() -> Layer {
    use amethyst_renderer::pass::*;

    Layer::new("gbuffer",
        vec![
            Clear::new([0., 0., 0., 1.]),
            DrawFlat::new("main", "main")
        ]
    )
}

fn pipeline_deferred() -> Vec<Layer> {
    use amethyst_renderer::pass::*;


    vec![
        layer_gbuffer(),
        Layer::new("main",
            vec![
                BlitLayer::new("gbuffer", "ka"),
                Lighting::new("main", "gbuffer", "main")
            ]
        ),
    ]
}

struct Example;

impl State for Example {
    fn handle_events(&mut self, events: Vec<Entity>, context: &mut Context, _: &mut World) -> Trans {
        use amethyst::context::event::{EngineEvent, Event, VirtualKeyCode};
        let mut trans = Trans::None;
        let storage = context.broadcaster.read::<EngineEvent>();
        for _event in events {
            let event = storage.get(_event).unwrap();
            let event = &event.payload;
            match *event {
                Event::KeyboardInput(_, _, Some(VirtualKeyCode::Escape)) => trans = Trans::Quit,
                Event::Closed => trans = Trans::Quit,
                _ => (),
            }
        }
        trans
    }

    fn on_start(&mut self, context: &mut Context, _: &mut World) {
        use amethyst::context::video_context::VideoContext;
        use amethyst::renderer::pass::*;
        use amethyst::renderer::Layer;



        match context.video_context {
            VideoContext::OpenGL { ref mut frame, ref mut factory,.. } => {
                let mut scene = amethyst_renderer::Scene::new();


                                frame.targets.insert(
                                "gbuffer".into(),
                                Box::new(amethyst_renderer::target::GeometryBuffer::new( factory, (1024, 768)))
                                );
                /*frame.targets.insert(
                    "main".into(),
                    Box::new(amethyst_renderer::target::ColorBuffer{
                        color: ColorFormat,
                        output_depth: main_depth
                    }
                ));
                frame.targets.insert(
                    "gbuffer".into(),
                    Box::new(amethyst_renderer::target::GeometryBuffer::new(&mut factory, (800, 600)))
                );
*/


                let sphere = build_sphere();

                let (buffer, slice) = factory.create_vertex_buffer_with_slice(&sphere, ());
                scene.fragments.push(amethyst_renderer::Fragment{
                    buffer: buffer.clone(),
                    slice: slice.clone(),
                    ka: Texture::Constant([0.1, 0.1, 0.3, 1.]),
                    kd: Texture::Constant([1.0, 0.3, 0.3, 1.]),
                    transform: Matrix4::from_translation(Vector3::new(0.0, 0.0, 0.0)).into()
                });




                                let glayer =  Layer::new("gbuffer",
                                                   vec![
                                                       Clear::new([0., 0., 0., 1.]),
                                                       DrawFlat::new("main", "main")
                                                   ]
                                               );
                                let dlayer =   Layer::new("main",
                                                       vec![
                                                           BlitLayer::new("gbuffer", "ka"),
                                                           Lighting::new("main", "gbuffer", "main")
                                                       ]
                                                   );


                                                   frame.layers.push(glayer);

                                frame.layers.push(dlayer);

                scene.lights.push(amethyst_renderer::Light{
                    color: [1., 1., 1., 1.],
                    radius: 1.,
                    center: [40., 40., 40.],
                    propagation_constant: 0.,
                    propagation_linear: 0.,
                    propagation_r_square: 1.,
                });


                frame.scenes.insert("main".into(), scene);
                let view: AffineMatrix3<f32> = Transform::look_at(
                    Point3::new(0.0 * 6., 1.0, -6.0),
                    Point3::new(0f32, 0.0, 0.0),
                    Vector3::unit_z(),
                );
                let proj = cgmath::perspective(cgmath::deg(60.0f32), 1024 as f32 / 768 as f32, 1.0, 100.0);
                frame.cameras.insert(
                    format!("main"),
                    amethyst_renderer::Camera{projection: proj.into(), view: view.mat.into()}
                );


                /*
                frame.targets.insert(
                    "main".into(),
                    Box::new(amethyst_renderer::target::ColorBuffer{
                        color: main_color,
                        output_depth: main_depth
                    }
                ));*/



            }
            #[cfg(windows)]
            VideoContext::Direct3D {  } => {
                // stub
            },
            VideoContext::Null => (),
        }
    }

    fn update(&mut self, context: &mut Context, _: &mut World) -> Trans {
        use amethyst::context::video_context::VideoContext;
        match context.video_context {
            VideoContext::OpenGL { ref window,
                                   ref mut renderer,
                                   ref frame,
                                   ref mut device,
                                   .. } => {
                renderer.submit(frame, device);
                window.swap_buffers().unwrap();
            }
#[cfg(windows)]
            VideoContext::Direct3D {  } => {
                // stub
            },
            VideoContext::Null => (),
        }
        Trans::None
    }
}

fn main() {
    use amethyst::context::Config;
    let config = Config::from_file("config/window_example_config.yml").unwrap();
    let mut game = Application::build(Example, config).done();
    game.run();
}