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
104
105
106
107
108

//! In order to get the crate running, you have to copy `msvc` folder and `build.rs` from crates
//! [repository](https://github.com/jakubDoka/rustbatch)
//! and place it into root of your project.
//! # RustBatch
//! This crate provides some performant tools for building big 2D games that deals with huge amount of entities.
//! So far crate contains:
//! - OpenGl abstraction based around batching.
//! - Collision scanner that provides fast collision detection for couple thousand entities
//! - Multithreaded pathfinder that has no problems ewen with 1000 X 1000 tile-maps
//! - Math module that contains structs like Matrix, Vector or Rectangle
//! - Custom per-batch vertex and fragment shader also supported
//! - Sprite packing so you can take advantage of batching as match as you can
//! # Warming
//! Important thing to note is that some functions from render module are calling functions and
//! using enums from gl crate. Functions has to be loaded first witch you achieve by creating
//! window.
//! # Example
//! ```
//!extern crate rustbatch;
//!
//!use rustbatch::{sdl2, image, gl};
//!use rustbatch::debug::FPS;
//!use rustbatch::{Window, Texture, Sprite, Batch};
//!use rustbatch::{Mat, WHITE};
//!
//!
//!fn main() {
//!    // creating window to draw to and event pump to read input. Ignore
//!    // gl var, it cannot be dropped otherwise rendering will not work so just leave it be
//!    let (mut window, mut event_pump, gl) = Window::new(|sys| {
//!        sys.window("rusty batch", 400, 400)
//!            .opengl()
//!            .resizable()
//!            .build()
//!            .unwrap()
//!    });
//!
//!    window.set_background_color(&[0.5f32, 0.5f32, 0.5f32, 1f32]); //gray background
//!
//!    // This is wrapped opengl texture object
//!    let texture = Texture::new(
//!        "C:/Users/jakub/Documents/programming/rust/src/ggl/src/bullets.png",
//!        gl::NEAREST, // So the pixels are drawn with no interpolation
//!        gl::RGBA // Color structure, you would use gl::RGB if your texture does not have alpha channel
//!    ).unwrap();
//!
//!    // Creating sprite. Notice that sprite is just collection of points and it cannot be directly
//!    // drawn to window
//!    let mut sprite = Sprite::new(texture.frame());
//!
//!    // On the other hand batch owns texture witch can be drawn to window
//!    let mut batch = Batch::new(texture);
//!
//!    // this is just a little helper
//!    let mut fps = FPS::new(1f32);
//!
//!    'main: loop {
//!        //polling events
//!        for event in event_pump.poll_iter() {
//!            match event {
//!                // break loop if X button on window is pressed
//!                sdl2::event::Event::Quit { .. } => break 'main,
//!                _ => {}
//!            }
//!        }
//!
//!        // i hope you know how to get delta on your own but fps returns is as bonus if you supply
//!        // 0f32 as delta
//!        let _delta = fps.increase(0f32);
//!
//!        // clearing window
//!        window.clear();
//!
//!        // drawing sprite to batch
//!        // IM is matrix transform. more about matrix in mat module docs
//!        // texture color is multiplied by inputted color
//!        sprite.draw(&mut batch, &Mat::IM, &WHITE);
//!
//!        // drawing batch to window
//!        window.draw(&batch);
//!
//!        // Don't forget to clear batch if you not planning to use it as canvas,
//!        // after all drawing sprites to batch takes some time
//!        batch.clear();
//!
//!        // finishing with window update so you can se it changing
//!        window.update();
//!    }
//!}
//! ```

pub mod images;
pub mod entity;
pub mod render;
pub mod debug;
pub mod math;

pub use sdl2;
pub use image;
pub use gl;
pub use rand;

pub use debug::FPS;
pub use render::{window::Window, texture::Texture, sprite::Sprite, batch::Batch};
pub use math::{mat::Mat, rgba::WHITE};