starstruck 0.1.0-alpha.3

A game building utility that is made to be simple to use while still providing great performance
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use crate::Starstruck;
use failure::Error;
use futures::Future;
use futures::IntoFuture;
use crate::context::Context;
use std::sync::Arc;
use crate::setup_context::SetupContext;
use crate::allocator::GpuAllocator;
use crate::allocator::DefaultGpuAllocator;
use crate::starstruck::State;
use crate::allocator::DefaultChunk;

/// The main way to construct a starstruck instance
///
/// # Examples
///
/// ```
/// # use failure::Error;
/// #
/// # fn main() -> Result<(), Error> {
/// use starstruck::StarstruckBuilder;
///
/// let starstruck = StarstruckBuilder::new().init()?;
/// # Ok(())
/// # }
/// ```
#[allow(clippy::type_complexity)]
pub struct StarstruckBuilder<
    S: State,
    R,
    A: GpuAllocator<backend::Backend, backend::Device>,
> {
    title: String,
    setup_callback: Box<(FnMut(Arc<SetupContext<A>>) -> R + Send)>,
    render_callback: Box<FnMut(
        (
            &mut S,
            &mut Context<A, backend::Backend, backend::Device, backend::Instance>,
        ),
    ) -> Result<(), Error>>,
    allocator: A
}


impl StarstruckBuilder<(), Result<(), Error>, DefaultGpuAllocator<DefaultChunk<backend::Backend, backend::Device>, backend::Backend, backend::Device>> {
    pub fn new() -> Self {
        Self {
            title: "Starstruck".to_string(),
            setup_callback: Box::new(|_| Ok(())),
            render_callback: Box::new(|_| Ok(())),
            allocator: DefaultGpuAllocator::new()
        }
    }
}

impl<
    S: State,
    F: Future<Item=S, Error=Error> + Send + 'static,
    R: IntoFuture<Future=F, Item=S, Error=Error> + 'static
> StarstruckBuilder<S, R, DefaultGpuAllocator<DefaultChunk<backend::Backend, backend::Device>, backend::Backend, backend::Device>> {

    pub fn new_with_setup<T: 'static + FnMut(Arc<SetupContext>) -> R + Send>(setup_callback: T) -> Self {
        Self {
            title: "Starstruck".to_string(),
            setup_callback: Box::new(setup_callback),
            render_callback: Box::new(|_| Ok(())),
            allocator: DefaultGpuAllocator::new()
        }
    }

    pub fn with_title(mut self, title: &str) -> Self {
        self.title = title.to_string();
        self
    }
}

impl<
    S: State,
    F: Future<Item=S, Error=Error> + Send + 'static,
    R: IntoFuture<Future=F, Item=S, Error=Error> + 'static,
    A: GpuAllocator<backend::Backend, backend::Device>
> StarstruckBuilder<S, R, A> {

    pub fn with_render_callback<T: 'static + FnMut(
        (
            &mut S,
            &mut Context<A, backend::Backend, backend::Device, backend::Instance>,
        ),
    ) -> Result<(), Error>>(mut self, callback: T) -> Self {
        self.render_callback = Box::new(callback);
        self
    }

    pub fn init(self) -> Result<Starstruck<S, A>, Error> {
        Starstruck::init(&self.title, self.setup_callback, self.render_callback, self.allocator)
    }
}

impl Default for StarstruckBuilder<(), Result<(), Error>, DefaultGpuAllocator<DefaultChunk<backend::Backend, backend::Device>, backend::Backend, backend::Device>> {
    fn default() -> Self {
        Self::new()
    }
}