mitchellhansen/flappy-bird-rust
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update project structure, update README, add input handler

Browse Source
This commit is contained in:
Hilmar Wiegand
2019-06-25 01:16:16 +02:00
parent da1cbadfea
commit 988a8f9b57
6 changed files with 287 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
src/main.rs
View File

@@ -1,41 +1,14 @@
use amethyst::{
assets::{AssetStorage, Loader, Processor},
core::transform::{Transform, TransformBundle},
ecs::prelude::{ReadExpect, Resources, SystemData},
assets::Processor,
core::transform::TransformBundle,
prelude::*,
renderer::{
pass::DrawFlat2DDesc,
rendy::{
factory::Factory,
graph::{
render::{RenderGroupDesc, SubpassBuilder},
GraphBuilder,
},
hal::{format::Format, image},
},
types::DefaultBackend,
Camera, GraphCreator, ImageFormat, RenderingSystem, SpriteRender, SpriteSheet,
SpriteSheetFormat, Texture,
},
renderer::{types::DefaultBackend, RenderingSystem, SpriteSheet},
utils::application_root_dir,
window::{ScreenDimensions, Window, WindowBundle},
window::WindowBundle,
};
static WIDTH: u32 = 800;
static HEIGHT: u32 = 600;
struct MyState;
impl SimpleState for MyState {
fn on_start(&mut self, data: StateData<'_, GameData<'_, '_>>) {
let world = data.world;
init_camera(world);
let sprites = load_sprites(world);
init_sprites(world, &sprites);
}
}
mod render;
mod state;
fn main() -> amethyst::Result<()> {
amethyst::start_logger(Default::default());
@@ -45,7 +18,7 @@ fn main() -> amethyst::Result<()> {
let resources = app_root.join("resources");
let display_config = resources.join("display_config.ron");
let render_graph = RenderGraph::default();
let render_graph = render::RenderGraph::default();
let render_system = RenderingSystem::<DefaultBackend, _>::new(render_graph);
let game_data = GameDataBuilder::default()
@@ -58,140 +31,8 @@ fn main() -> amethyst::Result<()> {
)
.with_thread_local(render_system);
let mut game = Application::new(resources, MyState, game_data)?;
let mut game = Application::new(resources, state::MyState, game_data)?;
game.run();
Ok(())
}
fn init_camera(world: &mut World) {
let mut transform = Transform::default();
transform.set_translation_xyz(WIDTH as f32 * 0.5, HEIGHT as f32 * 0.5, 1.);
world
.create_entity()
.with(Camera::standard_2d(WIDTH as f32, HEIGHT as f32))
.with(transform)
.build();
}
fn load_sprites(world: &mut World) -> Vec<SpriteRender> {
let texture_handle = {
let loader = world.read_resource::<Loader>();
let texture_storage = world.read_resource::<AssetStorage<Texture>>();
loader.load(
"sprites/logo.png",
ImageFormat::default(),
(),
&texture_storage,
)
};
let sheet_handle = {
let loader = world.read_resource::<Loader>();
let sheet_storage = world.read_resource::<AssetStorage<SpriteSheet>>();
loader.load(
"sprites/logo.ron",
SpriteSheetFormat(texture_handle),
(),
&sheet_storage,
)
};
(0..3)
.map(|i| SpriteRender {
sprite_sheet: sheet_handle.clone(),
sprite_number: i,
})
.collect()
}
fn init_sprites(world: &mut World, sprites: &[SpriteRender]) {
for (i, sprite) in sprites.iter().enumerate() {
let x = (i as f32 - 1.) * 100. + WIDTH as f32 * 0.5;
let y = (i as f32 - 1.) * 100. + HEIGHT as f32 * 0.5;
let mut transform = Transform::default();
transform.set_translation_xyz(x, y, 0.);
world
.create_entity()
.with(sprite.clone())
.with(transform)
.build();
}
}
// TODO(happens): Can we provide this with a few parameters,
// for the most common cases? The fields could still be exposed
#[derive(Default)]
struct RenderGraph {
dimensions: Option<ScreenDimensions>,
surface_format: Option<Format>,
dirty: bool,
}
// TODO(happens): Add explanations
impl GraphCreator<DefaultBackend> for RenderGraph {
fn rebuild(&mut self, res: &Resources) -> bool {
// Rebuild when dimensions change, but wait until at least two frames have the same.
let new_dimensions = res.try_fetch::<ScreenDimensions>();
use std::ops::Deref;
if self.dimensions.as_ref() != new_dimensions.as_ref().map(|d| d.deref()) {
self.dirty = true;
self.dimensions = new_dimensions.map(|d| d.clone());
return false;
}
self.dirty
}
fn builder(
&mut self,
factory: &mut Factory<DefaultBackend>,
res: &Resources,
) -> GraphBuilder<DefaultBackend, Resources> {
use amethyst::renderer::rendy::{
graph::present::PresentNode,
hal::command::{ClearDepthStencil, ClearValue},
};
self.dirty = false;
let window = <ReadExpect<'_, Window>>::fetch(res);
let surface = factory.create_surface(&window);
// cache surface format to speed things up
let surface_format = *self
.surface_format
.get_or_insert_with(|| factory.get_surface_format(&surface));
let dimensions = self.dimensions.as_ref().unwrap();
let window_kind =
image::Kind::D2(dimensions.width() as u32, dimensions.height() as u32, 1, 1);
let mut graph_builder = GraphBuilder::new();
let color = graph_builder.create_image(
window_kind,
1,
surface_format,
Some(ClearValue::Color([0.34, 0.36, 0.52, 1.0].into())),
);
let depth = graph_builder.create_image(
window_kind,
1,
Format::D32Sfloat,
Some(ClearValue::DepthStencil(ClearDepthStencil(1.0, 0))),
);
let opaque = graph_builder.add_node(
SubpassBuilder::new()
.with_group(DrawFlat2DDesc::new().builder())
.with_color(color)
.with_depth_stencil(depth)
.into_pass(),
);
let _present = graph_builder
.add_node(PresentNode::builder(factory, surface, color).with_dependency(opaque));
graph_builder
}
}