iceyrazor/rust-vectors
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

very late init

Browse Source
This commit is contained in:
iceyrazor
2026-02-06 04:06:03 -06:00
commit 82f919150b
27 changed files with 3422 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/target

213
Cargo.lock generated Normal file
View File

@@ -0,0 +1,213 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "bitflags"
version = "2.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
[[package]]
name = "c_vec"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fdd7a427adc0135366d99db65b36dae9237130997e560ed61118041fb72be6e8"
[[package]]
name = "cfg-if"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
[[package]]
name = "getrandom"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
dependencies = [
"cfg-if",
"libc",
"r-efi",
"wasi",
]
[[package]]
name = "lazy_static"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
[[package]]
name = "libc"
version = "0.2.174"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
[[package]]
name = "libm"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
[[package]]
name = "ppv-lite86"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
dependencies = [
"zerocopy",
]
[[package]]
name = "proc-macro2"
version = "1.0.95"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
dependencies = [
"proc-macro2",
]
[[package]]
name = "r-efi"
version = "5.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
[[package]]
name = "rand"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
dependencies = [
"rand_chacha",
"rand_core",
]
[[package]]
name = "rand_chacha"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
dependencies = [
"ppv-lite86",
"rand_core",
]
[[package]]
name = "rand_core"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
dependencies = [
"getrandom",
]
[[package]]
name = "sdl2"
version = "0.37.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b498da7d14d1ad6c839729bd4ad6fc11d90a57583605f3b4df2cd709a9cd380"
dependencies = [
"bitflags 1.3.2",
"c_vec",
"lazy_static",
"libc",
"sdl2-sys",
]
[[package]]
name = "sdl2-sys"
version = "0.37.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "951deab27af08ed9c6068b7b0d05a93c91f0a8eb16b6b816a5e73452a43521d3"
dependencies = [
"cfg-if",
"libc",
"version-compare",
]
[[package]]
name = "syn"
version = "2.0.103"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e4307e30089d6fd6aff212f2da3a1f9e32f3223b1f010fb09b7c95f90f3ca1e8"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
[[package]]
name = "vectors"
version = "0.1.0"
dependencies = [
"libm",
"rand",
"sdl2",
]
[[package]]
name = "version-compare"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29"
[[package]]
name = "wasi"
version = "0.14.2+wasi-0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
dependencies = [
"wit-bindgen-rt",
]
[[package]]
name = "wit-bindgen-rt"
version = "0.39.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
dependencies = [
"bitflags 2.9.1",
]
[[package]]
name = "zerocopy"
version = "0.8.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
dependencies = [
"zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
version = "0.8.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
dependencies = [
"proc-macro2",
"quote",
"syn",
]

9
Cargo.toml Normal file
View File

@@ -0,0 +1,9 @@
[package]
name = "vectors"
version = "0.1.0"
edition = "2024"
[dependencies]
libm = "0.2.15"
rand = "0.9.1"
sdl2 = { version = "0.37.0", features = ["gfx"] }

21
LICENSE Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2025 iceyrazor
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

3
README.md Normal file
View File

@@ -0,0 +1,3 @@
# The Nature Of Code Vectors
Me following [The Nature Of Code](https://www.youtube.com/playlist?list=PLRqwX-V7Uu6ZV4yEcW3uDwOgGXKUUsPOM) vectors 1.7 to 3.5 with Rust SDL2

87
src/bin/1-1-walker.rs Normal file
View File

@@ -0,0 +1,87 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use std::time::Duration;
use rand::Rng;
struct ObjectG{
x: i32,
y: i32,
screen_width: i32,
screen_height: i32,
}
impl ObjectG{
fn walk(&mut self) {
let mut rng = rand::rng();
self.x = self.x + rng.random_range(-1..2);
self.y = self.y + rng.random_range(-1..2);
if self.x < 0 { self.x = 0 }
if self.y < 0 { self.y = 0 }
if self.x > self.screen_width { self.x = self.screen_width }
if self.y > self.screen_height{ self.y = self.screen_height }
}
}
fn draw(canvas: &mut sdl2::render::WindowCanvas, obj: &mut ObjectG){
//canvas.set_draw_color(Color::RGB(0,0,0));
//
//canvas.clear();
canvas.set_draw_color(Color::RGB(150,50,255));
obj.walk();
canvas.fill_rect(Rect::new(obj.x, obj.y, 5, 5)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("walker", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj = ObjectG{
x: width as i32 /2,
y: height as i32 /2,
screen_width: width as i32,
screen_height: height as i32,
};
draw(&mut canvas, &mut obj);
let mut event_pump = sdl2_context.event_pump().unwrap();
'running: loop {
draw(&mut canvas, &mut obj);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

51
src/bin/1-2-vector-math.rs Normal file
View File

@@ -0,0 +1,51 @@
// this is just me making a add vec func where
// it retains the order for add or subtracting
// and vec1 and vec2 can be different sizes
fn add_vec(vec1: &Vec<i32>, vec2: &Vec<i32>) -> Vec<i32> {
//return vec![vec1[0]+vec2[0],vec1[1]+vec2[1]];
let mut len=vec1.len();
let mut sumvec: Vec<i32> = vec1.to_vec();
let addvec: Vec<i32> = vec2.to_vec();
if vec1.len() < vec2.len() {
len = vec2.len();
}
for i in 0..len {
if let Some(_) = vec2.get(i) {
if let Some(_) = vec1.get(i) {
sumvec[i] = sumvec[i] + addvec[i]
} else {
sumvec.push(vec2[i])
}
}
}
return sumvec;
}
fn sub_vec(vec1: &Vec<i32>, vec2: &Vec<i32>) -> Vec<i32> {
let mut len=vec1.len();
let mut sumvec: Vec<i32> = vec1.to_vec();
let addvec: Vec<i32> = vec2.to_vec();
if vec1.len() < vec2.len() {
len = vec2.len();
}
for i in 0..len {
if let Some(_) = vec2.get(i) {
if let Some(_) = vec1.get(i) {
sumvec[i] = sumvec[i] - addvec[i]
} else {
sumvec.push(vec2[i])
}
}
}
return sumvec;
}
fn main() {
println!("{:?}", add_vec(&vec![2,4, -1, 4, 10], &vec![1,-1,-4]));
println!("{:?}", add_vec(&vec![1,1], &vec![1,-1,-4,3]));
println!("{:?}", sub_vec(&vec![2, -1], &vec![1,1,-4]));
}

97
src/bin/1-3-random-vec.rs Normal file
View File

@@ -0,0 +1,97 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Point};
use sdl2::render::WindowCanvas;
use std::time::Duration;
use rand::Rng;
struct ObjectG{
x: i32,
y: i32,
screen_width: i32,
screen_height: i32,
points: Vec<Point>,
}
impl ObjectG{
fn walk(&mut self) {
let mut rng = rand::rng();
let rand: f64 = rng.random_range(-100.0..100.0);
let rand_len: f64 = rng.random_range(0.2..1.2);
let x = (rand_len * (rand.cos() * 100.0)) as i32 + self.screen_width / 2;
let y = (rand_len * (rand.sin() * 100.0)) as i32 + self.screen_height / 2;
self.points.push(Point::new(x,y));
if self.x < 0 { self.x = 0 }
if self.y < 0 { self.y = 0 }
if self.x > self.screen_width { self.x = self.screen_width }
if self.y > self.screen_height{ self.y = self.screen_height }
}
}
fn draw(canvas: &mut WindowCanvas, obj: &mut ObjectG){
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
canvas.set_draw_color(Color::RGB(150,50,255));
obj.walk();
//canvas.fill_rect(Rect::new(obj.x, obj.y, 1, 1));
for i in &obj.points {
canvas.draw_line(Point::new(obj.screen_width/2,obj.screen_height/2), *i).err();
}
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("random-vec", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
let mut obj = ObjectG{
x: width as i32 /2,
y: height as i32 /2,
screen_width: width as i32,
screen_height: height as i32,
points: Vec::new(),
};
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
draw(&mut canvas, &mut obj);
let mut event_pump = sdl2_context.event_pump().unwrap();
'running: loop {
draw(&mut canvas, &mut obj);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 120));
}
}

134
src/bin/1-5-1-mover.rs Normal file
View File

@@ -0,0 +1,134 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
use rand::Rng;
fn distance(x: f64,y: f64,x2: f64,y2: f64) -> f64 {
((x2 - x).powi(2) + (y2 - y).powi(2)).sqrt()
}
fn norm_limit(x: &f64,y: &f64, limit: &f64) -> Vec<f64>{
let mag: f64 = distance(0.0, 0.0, *x, *y);
let mut rx: f64 = *x;
let mut ry: f64 = *y;
if mag >= *limit{
rx = *x / mag;
ry = *y / mag;
}
return vec![rx,ry]
}
struct ObjectG{
screen_width: i32,
screen_height: i32,
x: f64,
y: f64,
vx: f64,
vy: f64,
acc_x: f64,
acc_y: f64,
}
impl ObjectG{
fn walk(&mut self) {
//let norm: Vec<i32> = normalize(&self.vx,&self.vy,x,y, &(self.screen_width/2), &(self.screen_height/2));
//self.vx = self.vx + self.screen_width/2;
//self.vy = self.vy + self.screen_height/2;
let mut rng = rand::rng();
self.acc_x = rng.random_range(-1.01..1.01);
self.acc_y = rng.random_range(-1.01..1.01);
self.vx = self.vx + self.acc_x;
self.vy = self.vy + self.acc_y;
let livec: Vec<f64> = norm_limit(&self.vx, &self.vy, &2.0);
self.vx = livec[0];
self.vy = livec[1];
self.x = self.x + self.vx;
self.y = self.y + self.vy;
if self.x < 0.0 { self.x = 0.0 }
if self.y < 0.0 { self.y = 0.0 }
if self.x > self.screen_width as f64 { self.x = self.screen_width as f64 }
if self.y > self.screen_height as f64 { self.y = self.screen_height as f64 }
}
}
fn draw(canvas: &mut WindowCanvas, obj: &mut ObjectG){
//putRectRGB(renderer,i*boxsize,j*boxsize,boxsize-1,150,50,255);
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
canvas.set_draw_color(Color::RGB(150,50,255));
obj.walk();
canvas.fill_rect(Rect::new(obj.x as i32, obj.y as i32, 8, 8)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("mover", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
let mut rng = rand::rng();
let sx = rng.random_range(-1.0..2.0);
let sy = rng.random_range(-1.0..2.0);
let mut obj = ObjectG{
screen_width: width as i32,
screen_height: height as i32,
x: width as f64 /2.0,
y: height as f64 /2.0,
vx: sx,
vy: sy,
acc_x: 0.0,
acc_y: 0.0,
};
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj);
'running: loop {
draw(&mut canvas, &mut obj);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 120));
}
}

107
src/bin/1-5-normalize.rs Normal file
View File

@@ -0,0 +1,107 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
struct ObjectG{
x: i32,
y: i32,
screen_width: i32,
screen_height: i32,
vx: i32,
vy: i32,
}
fn distance(x: f64,y: f64,x2: f64,y2: f64) -> f64 {
((x2 - x).powi(2) + (y2 - y).powi(2)).sqrt()
}
impl ObjectG{
fn walk(&mut self, x: &i32, y: &i32) {
self.vx = x - self.x;
self.vy = y - self.y;
// normalize is vec / mag
// this normalize is a bit more complicated because of me using screen / 2
// normally you use the first 2 of distance at 0,0
//get the distance
let mag: f64 = distance((self.screen_width/2) as f64, (self.screen_height/2) as f64,*x as f64,*y as f64);
//normalize
self.vx = ((self.vx as f64 / mag ) * 50.0) as i32;
self.vy = ((self.vy as f64 / mag ) * 50.0) as i32;
self.vx = self.vx + self.screen_width/2;
self.vy = self.vy + self.screen_height/2;
if self.x < 0 { self.x = 0 }
if self.y < 0 { self.y = 0 }
if self.x > self.screen_width { self.x = self.screen_width }
if self.y > self.screen_height{ self.y = self.screen_height }
}
}
fn draw(canvas: &mut WindowCanvas, obj: &mut ObjectG, mx: &i32, my: &i32){
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
canvas.set_draw_color(Color::RGB(150,50,255));
obj.walk(mx,my);
canvas.fill_rect(Rect::new(obj.vx, obj.vy, 8, 8)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("normalize", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
let mut obj = ObjectG{
x: width as i32 /2,
y: height as i32 /2,
screen_width: width as i32,
screen_height: height as i32,
vx: 0,
vy: 0,
};
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj, &0, &0);
'running: loop {
let state = event_pump.mouse_state();
draw(&mut canvas, &mut obj, &state.x(), &state.y());
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 120));
}
}

122
src/bin/1-6-mover-mouse.rs Normal file
View File

@@ -0,0 +1,122 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
fn distance(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = distance(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
fn norm_limit(x: &f64,y: &f64, limit: &f64) -> Vec<f64>{
let mag: f64 = distance(*x, *y);
let mut rx: f64 = *x;
let mut ry: f64 = *y;
if mag >= *limit{
rx = (*x / mag) * *limit;
ry = (*y / mag) * *limit;
}
return vec![rx,ry]
}
struct ObjectG{
x: f64,
y: f64,
vx: f64,
vy: f64,
acc_x: f64,
acc_y: f64,
}
impl ObjectG{
fn walk(&mut self, x: &i32, y: &i32) {
self.acc_x = *x as f64 - self.x;
self.acc_y = *y as f64 - self.y;
let smag: Vec<f64> = set_mag(&self.acc_x,&self.acc_y,&1.0);
self.acc_x = smag[0];
self.acc_y = smag[1];
self.vx = self.vx + self.acc_x;
self.vy = self.vy + self.acc_y;
let vel_lim: Vec<f64> = norm_limit(&self.vx, &self.vy, &5.0);
self.vx = vel_lim[0];
self.vy = vel_lim[1];
self.x = self.x + self.vx;
self.y = self.y + self.vy;
}
}
fn draw(canvas: &mut WindowCanvas, obj: &mut ObjectG, mx: &i32, my: &i32){
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
canvas.set_draw_color(Color::RGB(150,50,255));
obj.walk(mx,my);
canvas.fill_rect(Rect::new(obj.x as i32, obj.y as i32, 8, 8)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("mover-mouse", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
let mut obj = ObjectG{
x: width as f64 /2.0,
y: height as f64 /2.0,
vx: 0.0,
vy: 0.0,
acc_x: 0.0,
acc_y: 0.0,
};
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj, &0, &0);
'running: loop {
let state = event_pump.mouse_state();
draw(&mut canvas, &mut obj, &state.x(), &state.y());
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

127
src/bin/2-1-gravity-wind.rs Normal file
View File

@@ -0,0 +1,127 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
struct ObjectG{
screen_width: i32,
screen_height: i32,
x: f64,
y: f64,
vx: f64,
vy: f64,
acc_x: f64,
acc_y: f64,
size: i32,
}
impl ObjectG{
fn apply_force(&mut self, for_x: &f64, for_y: &f64){
self.acc_x = self.acc_x + *for_x;
self.acc_y = self.acc_y + *for_y;
}
fn edges(&mut self){
if self.y >= (self.screen_height-self.size) as f64 {
self.y = (self.screen_height-self.size) as f64;
self.vy = self.vy * -1.0;
}
if self.x >= (self.screen_width-self.size) as f64 {
self.x = (self.screen_width-self.size) as f64;
self.vx = self.vx * -1.0;
} else if self.x <= self.size as f64 {
self.x = self.size as f64;
self.vx = self.vx * -1.0;
}
}
fn walk(&mut self) {
self.vx = self.vx + self.acc_x;
self.vy = self.vy + self.acc_y;
self.x = self.x + self.vx;
self.y = self.y + self.vy;
self.acc_x = 0.0;
self.acc_y = 0.0;
}
}
fn draw(canvas: &mut WindowCanvas, obj: &mut ObjectG, g_button: &bool){
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
canvas.set_draw_color(Color::RGB(150,50,255));
//gravity
obj.apply_force(&0.0, &0.2);
if *g_button==true {
//wind
obj.apply_force(&0.1, &0.0);
}
obj.edges();
obj.walk();
canvas.fill_rect(Rect::new(obj.x as i32 - obj.size, obj.y as i32 - obj.size, (obj.size*2) as u32, (obj.size*2) as u32)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("gravity-wind", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
let mut obj = ObjectG{
screen_width: width as i32,
screen_height: height as i32,
x: width as f64 /2.0,
y: height as f64 /2.0,
vx: 0.0,
vy: 0.0,
acc_x: 0.0,
acc_y: 0.0,
size: 10,
};
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj, &false);
'running: loop {
let mut g_button = false;
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
Event::KeyDown { keycode: Some(Keycode::G), .. } => {
g_button = !g_button;
},
_ => {}
}
}
draw(&mut canvas, &mut obj, &g_button);
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

160
src/bin/2-2-mass-accel.rs Normal file
View File

@@ -0,0 +1,160 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
struct ObjectG{
screen_width: i32,
screen_height: i32,
x: f64,
y: f64,
vx: f64,
vy: f64,
acc_x: f64,
acc_y: f64,
size: i32,
mass: f64,
}
impl ObjectG{
fn apply_force(&mut self, for_x: &f64, for_y: &f64){
let for_x: f64 = *for_x / self.mass;
let for_y: f64 = *for_y / self.mass;
self.acc_x = self.acc_x + for_x;
self.acc_y = self.acc_y + for_y;
}
fn edges(&mut self){
if self.y >= (self.screen_height-self.size) as f64 {
self.y = (self.screen_height-self.size) as f64;
self.vy = self.vy * -1.0;
}
if self.x >= (self.screen_width-self.size) as f64 {
self.x = (self.screen_width-self.size) as f64;
self.vx = self.vx * -1.0;
} else if self.x <= self.size as f64 {
self.x = self.size as f64;
self.vx = self.vx * -1.0;
}
}
fn walk(&mut self) {
self.vx = self.vx + self.acc_x;
self.vy = self.vy + self.acc_y;
self.x = self.x + self.vx;
self.y = self.y + self.vy;
self.acc_x = 0.0;
self.acc_y = 0.0;
}
fn show(&mut self, canvas: &mut WindowCanvas){
canvas.fill_rect(Rect::new(self.x as i32 - self.size, self.y as i32 - self.size, (self.size*2) as u32, (self.size*2) as u32)).err();
}
}
fn draw(canvas: &mut WindowCanvas, obj: &mut ObjectG, obj2: &mut ObjectG, g_button: &bool){
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
//gravity
let grav = 0.2;
obj.apply_force(&0.0, &(grav * obj.mass));
obj2.apply_force(&0.0, &(grav * obj2.mass));
if *g_button==true {
//wind
obj.apply_force(&0.1, &0.0);
obj2.apply_force(&0.1, &0.0);
}
obj.edges();
obj.walk();
canvas.set_draw_color(Color::RGB(150,50,255));
obj.show(canvas);
obj2.edges();
obj2.walk();
canvas.set_draw_color(Color::RGB(255,50,150));
obj2.show(canvas);
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("mass-accel", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
let mut obj = ObjectG{
screen_width: width as i32,
screen_height: height as i32,
x: width as f64 /2.0 + 80.0,
y: height as f64 /2.0,
vx: 0.0,
vy: 0.0,
acc_x: 0.0,
acc_y: 0.0,
size: 10,
mass: 2.0,
};
obj.size = (obj.mass.sqrt() * 10.0) as i32;
let mut obj2 = ObjectG{
screen_width: width as i32,
screen_height: height as i32,
x: width as f64 /2.0 - 80.0,
y: height as f64 /2.0,
vx: 0.0,
vy: 0.0,
acc_x: 0.0,
acc_y: 0.0,
size: 10,
mass: 4.0,
};
obj2.size = (obj2.mass.sqrt() * 10.0) as i32;
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj, &mut obj2, &false);
'running: loop {
let mut g_button = false;
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
Event::KeyDown { keycode: Some(Keycode::G), .. } => {
g_button = !g_button;
},
_ => {}
}
}
draw(&mut canvas, &mut obj, &mut obj2, &g_button);
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

194
src/bin/2-3-friction.rs Normal file
View File

@@ -0,0 +1,194 @@
extern crate sdl2;
use rand::Rng;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn normalize(x: &f64,y: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = *x / getmag;
let ry = *y / getmag;
return vec![rx,ry]
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
struct ObjectG{
screen_width: i32,
screen_height: i32,
x: f64,
y: f64,
vx: f64,
vy: f64,
acc_x: f64,
acc_y: f64,
size: i32,
mass: f64,
}
impl ObjectG{
fn apply_force(&mut self, for_x: &f64, for_y: &f64){
let for_x: f64 = *for_x / self.mass;
let for_y: f64 = *for_y / self.mass;
self.acc_x = self.acc_x + for_x;
self.acc_y = self.acc_y + for_y;
}
fn friction(&mut self){
let diff = self.screen_height - (self.y as i32 + self.size);
if diff < 1 {
//self.vx = self.vx * 0.95;
//self.vy = self.vy * 0.95;
let friction = normalize(&self.vx, &self.vy);
let friction = vec![friction[0] * -1.0, friction[1] * -1.0];
let mu = 0.05;
let normal = self.mass;
let force = set_mag(&friction[0], &friction[1], &(mu * normal));
self.apply_force(&force[0], &force[1]);
}
}
fn edges(&mut self){
if self.y >= (self.screen_height-self.size) as f64 {
self.y = (self.screen_height-self.size) as f64;
self.vy = self.vy * -1.0;
}
if self.x >= (self.screen_width-self.size) as f64 {
self.x = (self.screen_width-self.size) as f64;
self.vx = self.vx * -1.0;
} else if self.x <= self.size as f64 {
self.x = self.size as f64;
self.vx = self.vx * -1.0;
}
}
fn walk(&mut self) {
self.vx = self.vx + self.acc_x;
self.vy = self.vy + self.acc_y;
self.x = self.x + self.vx;
self.y = self.y + self.vy;
self.acc_x = 0.0;
self.acc_y = 0.0;
}
fn show(&mut self, canvas: &mut WindowCanvas){
canvas.set_draw_color(Color::RGBA(150,50,255,100));
canvas.fill_rect(Rect::new(self.x as i32 - self.size, self.y as i32 - self.size, (self.size*2) as u32, (self.size*2) as u32)).err();
canvas.set_draw_color(Color::RGBA(150,50,255,255));
canvas.draw_rect(Rect::new(self.x as i32 - self.size, self.y as i32 - self.size, (self.size*2) as u32, (self.size*2) as u32)).err();
}
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, g_button: &bool){
canvas.set_draw_color(Color::RGBA(0,0,0,255));
canvas.clear();
//gravity
let grav = 8.2;
for obj in obj_arr{
obj.apply_force(&0.0, &(grav * obj.mass));
if *g_button==true {
//wind
obj.apply_force(&0.1, &0.0);
}
obj.friction();
obj.walk();
obj.edges();
obj.show(canvas);
}
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("friction", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
for _ in 0..10{
let mut rng = rand::rng();
let mut obj = ObjectG{
screen_width: width as i32,
screen_height: height as i32,
x: width as f64 /2.0,
y: height as f64 /2.0,
vx: rng.random_range(-10.0..10.0),
vy: rng.random_range(-10.0..10.0),
acc_x: 0.0,
acc_y: 0.0,
size: 0,
mass: rng.random_range(2.0..8.0),
};
obj.size = (obj.mass.sqrt() * 10.0) as i32;
obj_arr.push(obj);
}
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr, &false);
'running: loop {
let mut g_button = false;
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
Event::KeyDown { keycode: Some(Keycode::G), .. } => {
g_button = !g_button;
},
_ => {}
}
}
draw(&mut canvas, &mut obj_arr, &g_button);
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

193
src/bin/2-4-drag.rs Normal file
View File

@@ -0,0 +1,193 @@
extern crate sdl2;
use rand::Rng;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn normalize(x: &f64,y: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = *x / getmag;
let ry = *y / getmag;
return vec![rx,ry]
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
struct ObjectG{
screen_width: i32,
screen_height: i32,
x: f64,
y: f64,
vx: f64,
vy: f64,
acc_x: f64,
acc_y: f64,
size: i32,
mass: f64,
}
const DRAG_C: f64 = 0.3;
impl ObjectG{
fn apply_force(&mut self, for_x: &f64, for_y: &f64){
let for_x: f64 = *for_x / self.mass;
let for_y: f64 = *for_y / self.mass;
self.acc_x = self.acc_x + for_x;
self.acc_y = self.acc_y + for_y;
}
fn drag(&mut self){
let drag = normalize(&self.vx, &self.vy);
let drag = vec![drag[0] * -1.0, drag[1] * -1.0];
let speed = magnitude(self.vx, self.vy);
let drag = set_mag(&drag[0], &drag[1], &(DRAG_C * speed * speed));
self.apply_force(&drag[0], &drag[1]);
}
fn edges(&mut self){
if self.y >= (self.screen_height-self.size) as f64 {
self.y = (self.screen_height-self.size) as f64;
self.vy = self.vy * -1.0;
}
if self.x >= (self.screen_width-self.size) as f64 {
self.x = (self.screen_width-self.size) as f64;
self.vx = self.vx * -1.0;
} else if self.x <= self.size as f64 {
self.x = self.size as f64;
self.vx = self.vx * -1.0;
}
}
fn walk(&mut self) {
self.vx = self.vx + self.acc_x;
self.vy = self.vy + self.acc_y;
self.x = self.x + self.vx;
self.y = self.y + self.vy;
self.acc_x = 0.0;
self.acc_y = 0.0;
}
fn show(&mut self, canvas: &mut WindowCanvas){
canvas.set_draw_color(Color::RGBA(150,50,255,100));
canvas.fill_rect(Rect::new(self.x as i32 - self.size, self.y as i32 - self.size, (self.size*2) as u32, (self.size*2) as u32)).err();
canvas.set_draw_color(Color::RGBA(150,50,255,255));
canvas.draw_rect(Rect::new(self.x as i32 - self.size, self.y as i32 - self.size, (self.size*2) as u32, (self.size*2) as u32)).err();
}
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, g_button: &bool){
canvas.set_draw_color(Color::RGBA(0,0,0,255));
canvas.clear();
canvas.set_draw_color(Color::RGBA(255,255,255,50));
canvas.fill_rect(Rect::new(0,obj_arr[0].screen_height/2,obj_arr[0].screen_width as u32,(obj_arr[0].screen_height/2) as u32)).err();
//gravity
let grav = 0.2;
for obj in obj_arr{
obj.apply_force(&0.0, &(grav * obj.mass));
if *g_button==true {
//wind
obj.apply_force(&0.1, &0.0);
}
if obj.y > (obj.screen_height / 2) as f64 {
obj.drag();
}
obj.walk();
obj.edges();
obj.show(canvas);
}
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("drag", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
for _ in 0..10{
let mut rng = rand::rng();
let mut obj = ObjectG{
screen_width: width as i32,
screen_height: height as i32,
x: rng.random_range(10.0..width as f64),
y: 20.0,
vx: 0.0,
vy: 1.0,
acc_x: 0.0,
acc_y: 0.0,
size: 0,
mass: rng.random_range(1.0..8.0),
};
obj.size = (obj.mass.sqrt() * 10.0) as i32;
obj_arr.push(obj);
}
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr, &false);
'running: loop {
let mut g_button = false;
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
Event::KeyDown { keycode: Some(Keycode::G), .. } => {
g_button = !g_button;
},
_ => {}
}
}
draw(&mut canvas, &mut obj_arr, &g_button);
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

182
src/bin/2-5-grav-attraction-point.rs Normal file
View File

@@ -0,0 +1,182 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
use rand::Rng;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
//i know i can use sdl points but i wanna make my own thing.
//plus this is more independant.
struct Point{
x: f64,
y: f64,
}
impl Point{
fn add(&mut self, addvec: &Point){
self.x = self.x + addvec.x;
self.y = self.y + addvec.y;
}
fn sub(&mut self, subvec: &Point){
self.x = self.x - subvec.x;
self.y = self.y - subvec.y;
}
fn set_mag(&mut self, mag: &f64) {
let smag = set_mag(&self.x, &self.y, &mag);
self.x = smag[0];
self.y = smag[1];
}
}
struct ObjectG{
pos: Point,
vel: Point,
acc: Point,
size: i32,
mass: f64,
}
impl ObjectG{
fn apply_force(&mut self, force: &Point){
let force = Point { x: force.x / self.mass, y: force.y / self.mass };
self.acc.add(&force);
}
fn walk(&mut self) {
self.vel.add(&self.acc);
self.pos.add(&self.vel);
self.acc=Point{x:0.0, y:0.0}
}
}
struct Attractor{
pos: Point,
size: i32,
mass: f64,
}
impl Attractor{
fn attract(&mut self, obj: &mut ObjectG){
let mut force = Point{x: self.pos.x, y: self.pos.y};
force.sub(&obj.pos);
let dist = magnitude(force.x, force.y);
let mut dist = dist * dist;
if dist < 100.0 { dist = 100.0 }
if dist > 1000.0 { dist = 1000.0 }
let g = 5.0;
let strength = g * (self.mass * obj.mass) / dist;
force.set_mag(&strength);
obj.apply_force(&force);
}
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, atr: &mut Attractor){
canvas.set_draw_color(Color::RGBA(0,0,0,50));
canvas.fill_rect(Rect::new(0,0,600,600)).err();
//canvas.clear();
for obj in obj_arr{
obj.walk();
canvas.set_draw_color(Color::RGBA(150,50,255,150));
canvas.fill_rect(Rect::new(obj.pos.x as i32 - obj.size, obj.pos.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
canvas.set_draw_color(Color::RGB(150,50,255));
canvas.draw_rect(Rect::new(obj.pos.x as i32 - obj.size, obj.pos.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
atr.attract(obj);
}
canvas.set_draw_color(Color::RGB(255,50,150));
canvas.fill_rect(Rect::new(atr.pos.x as i32 - atr.size, atr.pos.y as i32 - atr.size, (atr.size * 2) as u32, (atr.size * 2) as u32)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=600;
let height: u32=600;
let window = video_subsystem.window("grav-attraction-point", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
for _ in 0..10{
let mut rng = rand::rng();
let mut obj = ObjectG{
pos: Point { x: rng.random_range(6.0..width as f64 -1.0), y: rng.random_range(6.0..width as f64 -1.0)},
vel: Point { x: rng.random_range(-11.0..10.0), y: rng.random_range(-11.0..10.0)},
acc: Point { x: 0.0, y: 0.0 },
size: 0,
mass: rng.random_range(50.0..150.0),
};
obj.size = (obj.mass.sqrt() * 2.0) as i32;
obj_arr.push(obj);
}
let mut atr = Attractor{
pos: Point{x: width as f64 /2.0, y: height as f64 /2.0},
size: 0,
mass: 100.0,
};
atr.size = (atr.mass.sqrt() * 2.0) as i32;
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr, &mut atr);
'running: loop {
draw(&mut canvas, &mut obj_arr, &mut atr);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

171
src/bin/2-5-grav-attraction.rs Normal file
View File

@@ -0,0 +1,171 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
use rand::Rng;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
struct ObjectG{
x: f64,
y: f64,
vx: f64,
vy: f64,
acc_x: f64,
acc_y: f64,
size: i32,
mass: f64,
}
impl ObjectG{
fn apply_force(&mut self, force_x: &f64, force_y: &f64){
let fx = force_x / self.mass;
let fy = force_y / self.mass;
self.acc_x = self.acc_x + fx;
self.acc_y = self.acc_y + fy;
}
fn walk(&mut self) {
self.vx = self.vx + self.acc_x;
self.vy = self.vy + self.acc_y;
self.x = self.x + self.vx;
self.y = self.y + self.vy;
self.acc_x = 0.0;
self.acc_y = 0.0;
}
}
struct Attractor{
x: f64,
y: f64,
size: i32,
mass: f64,
}
impl Attractor{
fn attract(&mut self, obj: &mut ObjectG){
let force_x = self.x - obj.x;
let force_y = self.y - obj.y;
let dist = magnitude(force_x, force_y);
let mut dist = dist * dist;
if dist < 100.0 { dist = 100.0 }
if dist > 1000.0 { dist = 1000.0 }
let g = 5.0;
let strength = g * (self.mass * obj.mass) / dist;
let force = set_mag(&force_x, &force_y, &strength);
obj.apply_force(&force[0], &force[1]);
}
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, atr: &mut Attractor){
canvas.set_draw_color(Color::RGBA(0,0,0,50));
canvas.fill_rect(Rect::new(0,0,600,600)).err();
//canvas.clear();
for obj in obj_arr{
obj.walk();
canvas.set_draw_color(Color::RGBA(150,50,255,150));
canvas.fill_rect(Rect::new(obj.x as i32 - obj.size, obj.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
canvas.set_draw_color(Color::RGB(150,50,255));
canvas.draw_rect(Rect::new(obj.x as i32 - obj.size, obj.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
atr.attract(obj);
}
canvas.set_draw_color(Color::RGB(255,50,150));
canvas.fill_rect(Rect::new(atr.x as i32 - atr.size, atr.y as i32 - atr.size, (atr.size * 2) as u32, (atr.size * 2) as u32)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=600;
let height: u32=600;
let window = video_subsystem.window("grav-attraction", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
for _ in 0..10{
let mut rng = rand::rng();
let mut obj = ObjectG{
x: rng.random_range(6.0..width as f64 -1.0),
y: rng.random_range(6.0..height as f64 -1.0),
vx: rng.random_range(-11.0..10.0),
vy: rng.random_range(-11.0..10.0),
acc_x: 0.0,
acc_y: 0.0,
size: 0,
mass: rng.random_range(50.0..150.0),
};
obj.size = (obj.mass.sqrt() * 2.0) as i32;
obj_arr.push(obj);
}
let mut atr = Attractor{
x: width as f64 /2.0,
y: height as f64 /2.0,
size: 0,
mass: 100.0,
};
atr.size = (atr.mass.sqrt() * 2.0) as i32;
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr, &mut atr);
'running: loop {
draw(&mut canvas, &mut obj_arr, &mut atr);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

252
src/bin/2-6-mutual-attraction.rs Normal file
View File

@@ -0,0 +1,252 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
use rand::Rng;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
//i know i can use sdl points but i wanna make my own thing.
//plus this is more independant.
#[derive(Clone)]
struct Point{
x: f64,
y: f64,
}
impl Point{
fn add(&mut self, addvec: &Point){
self.x = self.x + addvec.x;
self.y = self.y + addvec.y;
}
fn sub(&mut self, subvec: &Point){
self.x = self.x - subvec.x;
self.y = self.y - subvec.y;
}
fn set_mag(&mut self, mag: &f64) {
let smag = set_mag(&self.x, &self.y, &mag);
self.x = smag[0];
self.y = smag[1];
}
fn rotate(&mut self, angle: &f64){
let cos_theta = angle.cos();
let sin_theta = angle.sin();
let x = self.x * cos_theta - self.y * sin_theta;
let y = self.x * sin_theta + self.y * cos_theta;
self.x = x;
self.y = y;
}
}
struct ObjectG{
pos: Point,
vel: Point,
acc: Point,
size: i32,
mass: f64,
}
impl ObjectG{
fn new(x: f64, y: f64, vx: f64, vy: f64, mass: f64) -> Self{
Self {
pos: Point{x: x, y: y},
vel: Point { x: vx, y: vy},
acc: Point { x: 0.0, y: 0.0},
size: (mass.sqrt() * 2.0) as i32,
mass: mass,
}
}
fn apply_force(&mut self, force: &Point){
let force = Point { x: force.x / self.mass, y: force.y / self.mass };
self.acc.add(&force);
}
fn walk(&mut self) {
self.vel.add(&self.acc);
self.pos.add(&self.vel);
self.acc=Point{x:0.0, y:0.0}
}
fn attract(&mut self, obj: &mut ObjectG){
let mut force = Point{x: self.pos.x, y: self.pos.y};
force.sub(&obj.pos);
let dist = magnitude(force.x, force.y);
let mut dist = dist * dist;
if dist < 100.0 { dist = 100.0 }
if dist > 1000.0 { dist = 1000.0 }
let g = 0.5;
let strength = g * (self.mass * obj.mass) / dist;
force.set_mag(&strength);
obj.apply_force(&force);
}
fn show(&mut self, canvas: &mut WindowCanvas){
canvas.set_draw_color(Color::RGBA(150,50,255,150));
canvas.fill_rect(Rect::new(self.pos.x as i32 - self.size, self.pos.y as i32 - self.size, (self.size * 2) as u32, (self.size * 2) as u32)).err();
canvas.set_draw_color(Color::RGB(150,50,255));
canvas.draw_rect(Rect::new(self.pos.x as i32 - self.size, self.pos.y as i32 - self.size, (self.size * 2) as u32, (self.size * 2) as u32)).err();
}
}
//ngl these 2 are chatgpt.
fn get_pair_mut<T>(slice: &mut [T], i: usize, j: usize) -> Option<(&mut T, &mut T)> {
if i == j || i >= slice.len() || j >= slice.len() {
return None;
}
if i < j {
let (left, right) = slice.split_at_mut(j);
Some((&mut left[i], &mut right[0]))
} else {
let (left, right) = slice.split_at_mut(i);
Some((&mut right[0], &mut left[j]))
}
}
fn attract_all(obj_arr: &mut [ObjectG]) {
let len = obj_arr.len();
for i in 0..len {
for j in (i + 1)..len {
let (a, b) = get_pair_mut(obj_arr, i, j).unwrap();
a.attract(b);
b.attract(a);
}
}
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, sun: &mut ObjectG){
canvas.set_draw_color(Color::RGBA(0,0,0,80));
canvas.fill_rect(Rect::new(0,0,800,800)).err();
//canvas.clear();
attract_all(obj_arr);
for obj in obj_arr{
obj.walk();
sun.attract(obj);
obj.show(canvas);
}
canvas.set_draw_color(Color::RGBA(255,50,100,100));
canvas.fill_rect(Rect::new(sun.pos.x as i32 - sun.size, sun.pos.y as i32 - sun.size, (sun.size * 2) as u32, (sun.size * 2) as u32)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=800;
let height: u32=800;
let window = video_subsystem.window("mutual-attraction", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
for _ in 0..250{
let mut rng = rand::rng();
let mut pos = Point{x: rng.random_range(-1.0..1.0), y: rng.random_range(-1.0..1.0)};
let mut vel = pos.clone();
vel.set_mag(&rng.random_range(5.0..15.0));
pos.set_mag(&rng.random_range(200.0..300.0));
vel.rotate(&(3.14192/2.0));
pos.add(&Point { x: width as f64 /2.0, y: height as f64 /2.0 });
//let vel = Point{ x:rng.random_range(-1.0..1.0), y: rng.random_range(-1.0..1.0)};
let m = rng.random_range(5.0..15.0);
let obj = ObjectG::new(pos.x,pos.y,vel.x,vel.y,m);
obj_arr.push(obj);
}
/*
let obj = ObjectG::new(300.0, 200.0, 0.0, 5.0, 10.0);
obj_arr.push(obj);
let obj2 = ObjectG::new(100.0,200.0,0.0,-5.0,10.0);
obj_arr.push(obj2);
let obj3 = ObjectG::new(200.0,300.0,-5.0,-0.0,10.0);
obj_arr.push(obj3);
let obj4 = ObjectG::new(200.0,100.0,5.0,-0.0,10.0);
obj_arr.push(obj4);
*/
let mut sun = ObjectG::new(width as f64 /2.0, height as f64 /2.0,0.0,0.0,500.0);
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr, &mut sun);
'running: loop {
draw(&mut canvas, &mut obj_arr, &mut sun);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
}
}
// optimizations
// barnes hut simulation
// quad tree

120
src/bin/3-1-angles-and-rotation.rs Normal file
View File

@@ -0,0 +1,120 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Point, Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
struct PointG{
x: f64,
y: f64,
}
impl PointG{
fn rotate(&mut self, angle: &f64){
let cos_theta = angle.cos();
let sin_theta = angle.sin();
let x = self.x * cos_theta - self.y * sin_theta;
let y = self.x * sin_theta + self.y * cos_theta;
self.x = x;
self.y = y;
}
}
struct ObjectG{
pos: PointG,
screen_size: PointG,
}
impl ObjectG{
fn new(x: f64, y: f64, sw: f64, sh: f64) -> Self{
Self {
pos: PointG{x: x, y: y},
screen_size: PointG { x: sw, y: sh },
}
}
}
fn draw_line(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, a: &usize, b: &usize){
let pos = PointG{x: obj_arr[*a].pos.x + obj_arr[*a].screen_size.x / 2.0, y: obj_arr[*a].pos.y + obj_arr[*a].screen_size.y / 2.0};
let pos2 = PointG{x: obj_arr[*b].pos.x + obj_arr[*b].screen_size.x / 2.0, y: obj_arr[*b].pos.y + obj_arr[*b].screen_size.y / 2.0};
canvas.set_draw_color(Color::RGB(150,50,255));
canvas.draw_line(Point::new(pos.x as i32,pos.y as i32), Point::new(pos2.x as i32,pos2.y as i32)).err();
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>){
canvas.set_draw_color(Color::RGBA(0,0,0,80));
canvas.fill_rect(Rect::new(0,0,800,800)).err();
canvas.clear();
draw_line(canvas, obj_arr, &0, &1);
draw_line(canvas, obj_arr, &1, &2);
draw_line(canvas, obj_arr, &2, &3);
draw_line(canvas, obj_arr, &3, &0);
for obj in obj_arr{
obj.pos.rotate(&0.05);
}
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("angles-and-rot", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
let obj = ObjectG::new(128.0,64.0,width as f64, height as f64);
obj_arr.push(obj);
let obj = ObjectG::new(-128.0,64.0,width as f64, height as f64);
obj_arr.push(obj);
let obj = ObjectG::new(-128.0,-64.0,width as f64, height as f64);
obj_arr.push(obj);
let obj = ObjectG::new(128.0,-64.0,width as f64, height as f64);
obj_arr.push(obj);
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr);
'running: loop {
draw(&mut canvas, &mut obj_arr);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
}
}

163
src/bin/3-2-0-angular-motion.rs Normal file
View File

@@ -0,0 +1,163 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Point, Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
struct PointG{
x: f64,
y: f64,
start_x: f64,
start_y: f64,
mx: f64,
my: f64,
}
impl PointG{
fn new(x: f64, y: f64) -> Self {
Self{
x: x,
y: y,
start_x: x,
start_y: y,
mx: 0.0,
my: 0.0,
}
}
fn set_angle(&mut self, angle: &f64){
let angle = angle % (3.14192 * 2.0);
let cos_theta = angle.cos();
let sin_theta = angle.sin();
let x = self.start_x * cos_theta - self.start_y * sin_theta;
let y = self.start_x * sin_theta + self.start_y * cos_theta;
self.x = x;
self.y = y;
}
}
struct ObjectG{
pos: PointG,
screen_size: PointG,
ang: f64,
a_vel: f64,
a_acc: f64,
}
impl ObjectG{
fn new(x: f64, y: f64, sw: f64, sh: f64) -> Self{
Self {
pos: PointG::new(x,y),
screen_size: PointG::new(sw,sh),
ang: 0.0,
a_vel: 0.0,
a_acc: 0.001,
}
}
fn update(&mut self){
let map = ((self.pos.mx / self.screen_size.x) - 0.5) / 0.5 / 10.0;
if self.a_vel > 0.2 { self.a_vel = 0.2 }
if self.a_vel < -0.2 { self.a_vel = -0.2 }
self.a_acc = map;
self.ang = self.ang + self.a_vel;
self.a_vel = self.a_vel + self.a_acc;
self.pos.set_angle(&self.ang);
}
}
fn draw_line(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, a: &usize, b: &usize){
let pos = PointG::new(obj_arr[*a].pos.x + obj_arr[*a].screen_size.x / 2.0, obj_arr[*a].pos.y + obj_arr[*a].screen_size.y / 2.0);
let pos2 = PointG::new(obj_arr[*b].pos.x + obj_arr[*b].screen_size.x / 2.0, obj_arr[*b].pos.y + obj_arr[*b].screen_size.y / 2.0);
canvas.set_draw_color(Color::RGB(150,50,255));
canvas.draw_line(Point::new(pos.x as i32,pos.y as i32), Point::new(pos2.x as i32,pos2.y as i32)).err();
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>){
canvas.set_draw_color(Color::RGBA(0,0,0,80));
canvas.fill_rect(Rect::new(0,0,800,800)).err();
canvas.clear();
draw_line(canvas, obj_arr, &0, &1);
draw_line(canvas, obj_arr, &1, &2);
draw_line(canvas, obj_arr, &2, &3);
draw_line(canvas, obj_arr, &3, &0);
for obj in obj_arr{
obj.update();
}
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("angular-motion", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
let obj = ObjectG::new(128.0,64.0,width as f64, height as f64);
obj_arr.push(obj);
let obj = ObjectG::new(-128.0,64.0,width as f64, height as f64);
obj_arr.push(obj);
let obj = ObjectG::new(-128.0,-64.0,width as f64, height as f64);
obj_arr.push(obj);
let obj = ObjectG::new(128.0,-64.0,width as f64, height as f64);
obj_arr.push(obj);
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr);
'running: loop {
draw(&mut canvas, &mut obj_arr);
let state = event_pump.mouse_state();
for obj in &mut obj_arr{
obj.pos.mx=state.x() as f64;
obj.pos.my=state.y() as f64;
}
//draw(&mut canvas, &mut obj, &state.x(), &state.y());
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
}
}
// *~challenges
// when you click you grab the rect and then rotate it
// releasing it at a velocity will maintain its velocity

224
src/bin/3-2-1-grav-rot.rs Normal file
View File

@@ -0,0 +1,224 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Point, Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
use rand::Rng;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
//i know i can use sdl points but i wanna make my own thing.
//plus this is more independant.
struct PointG{
x: f64,
y: f64,
start_x: f64,
start_y: f64,
}
impl PointG{
fn new(x: &f64, y: &f64)->Self{
Self{
x: *x,
y: *y,
start_x: *x,
start_y: *y,
}
}
fn add(&mut self, addvec: &PointG){
self.x = self.x + addvec.x;
self.y = self.y + addvec.y;
}
fn sub(&mut self, subvec: &PointG){
self.x = self.x - subvec.x;
self.y = self.y - subvec.y;
}
fn set_mag(&mut self, mag: &f64) {
let smag = set_mag(&self.x, &self.y, &mag);
self.x = smag[0];
self.y = smag[1];
}
fn set_angle(&mut self, angle: &f64){
let angle = angle % (3.14192 * 2.0);
let cos_theta = angle.cos();
let sin_theta = angle.sin();
let x = self.start_x * cos_theta - self.start_y * sin_theta;
let y = self.start_x * sin_theta + self.start_y * cos_theta;
self.x = x;
self.y = y;
}
}
struct ObjectG{
pos: PointG,
vel: PointG,
acc: PointG,
size: i32,
mass: f64,
ang: f64,
a_vel: f64,
a_acc: f64,
line_end: PointG,
}
impl ObjectG{
fn apply_force(&mut self, force: &PointG){
let force = PointG::new( &(force.x / self.mass), &(force.y / self.mass) );
self.acc.add(&force);
}
fn walk(&mut self) {
self.vel.add(&self.acc);
self.pos.add(&self.vel);
self.a_acc = self.acc.x / 50.0;
self.a_vel = self.a_vel + self.a_acc;
self.ang = self.ang + self.a_vel;
self.acc=PointG::new(&0.0, &0.0);
}
}
struct Attractor{
pos: PointG,
size: i32,
mass: f64,
}
impl Attractor{
fn attract(&mut self, obj: &mut ObjectG){
let mut force = PointG::new(&self.pos.x, &self.pos.y);
force.sub(&obj.pos);
let dist = magnitude(force.x, force.y);
let mut dist = dist * dist;
if dist < 100.0 { dist = 100.0 }
if dist > 1000.0 { dist = 1000.0 }
let g = 5.0;
let strength = g * (self.mass * obj.mass) / dist;
force.set_mag(&strength);
obj.apply_force(&force);
}
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, atr: &mut Attractor){
canvas.set_draw_color(Color::RGBA(0,0,0,50));
canvas.fill_rect(Rect::new(0,0,600,600)).err();
//canvas.clear();
for obj in obj_arr{
obj.walk();
canvas.set_draw_color(Color::RGBA(150,50,255,150));
canvas.fill_rect(Rect::new(obj.pos.x as i32 - obj.size, obj.pos.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
canvas.set_draw_color(Color::RGB(150,50,255));
canvas.draw_rect(Rect::new(obj.pos.x as i32 - obj.size, obj.pos.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
obj.line_end.set_angle(&obj.ang);
canvas.set_draw_color(Color::RGB(255,80,150));
canvas.draw_line(Point::new(obj.pos.x as i32,obj.pos.y as i32),Point::new((obj.pos.x + obj.line_end.x) as i32, (obj.pos.y + obj.line_end.y) as i32)).err();
atr.attract(obj);
}
canvas.set_draw_color(Color::RGB(255,50,150));
canvas.fill_rect(Rect::new(atr.pos.x as i32 - atr.size, atr.pos.y as i32 - atr.size, (atr.size * 2) as u32, (atr.size * 2) as u32)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=600;
let height: u32=600;
let window = video_subsystem.window("grav-attraction-point", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
for _ in 0..10{
let mut rng = rand::rng();
let mut obj = ObjectG{
pos: PointG::new( &rng.random_range(6.0..width as f64 -1.0), &rng.random_range(6.0..width as f64 -1.0)),
vel: PointG::new( &rng.random_range(-11.0..10.0), &rng.random_range(-11.0..10.0)),
acc: PointG::new( &0.0, &0.0 ),
size: 0,
mass: rng.random_range(50.0..150.0),
ang: 0.0,
a_vel: 0.02,
a_acc: 0.0,
line_end: PointG::new(&0.0,&0.0),
};
obj.size = (obj.mass.sqrt() * 2.0) as i32;
obj.line_end = PointG::new(&(obj.size as f64),&0.0);
obj_arr.push(obj);
}
let mut atr = Attractor{
pos: PointG::new(&(width as f64 /2.0), &(height as f64 /2.0)),
size: 0,
mass: 100.0,
};
atr.size = (atr.mass.sqrt() * 2.0) as i32;
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr, &mut atr);
'running: loop {
draw(&mut canvas, &mut obj_arr, &mut atr);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
}
}

231
src/bin/3-3-angles-and-vectors.rs Normal file
View File

@@ -0,0 +1,231 @@
extern crate sdl2;
use libm::atan2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Point, Rect};
use sdl2::render::WindowCanvas;
use std::time::Duration;
use rand::Rng;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
//i know i can use sdl points but i wanna make my own thing.
//plus this is more independant.
struct PointG{
x: f64,
y: f64,
start_x: f64,
start_y: f64,
}
impl PointG{
fn new(x: &f64, y: &f64)->Self{
Self{
x: *x,
y: *y,
start_x: *x,
start_y: *y,
}
}
fn add(&mut self, addvec: &PointG){
self.x = self.x + addvec.x;
self.y = self.y + addvec.y;
}
fn sub(&mut self, subvec: &PointG){
self.x = self.x - subvec.x;
self.y = self.y - subvec.y;
}
fn set_mag(&mut self, mag: &f64) {
let smag = set_mag(&self.x, &self.y, &mag);
self.x = smag[0];
self.y = smag[1];
}
fn set_angle(&mut self, angle: &f64){
let angle = angle % (3.14192 * 2.0);
let cos_theta = angle.cos();
let sin_theta = angle.sin();
let x = self.start_x * cos_theta - self.start_y * sin_theta;
let y = self.start_x * sin_theta + self.start_y * cos_theta;
self.x = x;
self.y = y;
}
fn heading(&mut self) -> f64{
let angle = atan2(self.y, self.x);
angle
}
}
struct ObjectG{
pos: PointG,
vel: PointG,
acc: PointG,
size: i32,
mass: f64,
ang: f64,
line_end: PointG,
}
impl ObjectG{
fn apply_force(&mut self, force: &PointG){
let force = PointG::new( &(force.x / self.mass), &(force.y / self.mass) );
self.acc.add(&force);
}
fn walk(&mut self) {
self.vel.add(&self.acc);
self.pos.add(&self.vel);
//self.a_acc = self.acc.x / 50.0;
//self.a_vel = self.a_vel + self.a_acc;
//self.ang = self.ang + self.a_vel;
self.acc=PointG::new(&0.0, &0.0);
}
}
struct Attractor{
pos: PointG,
size: i32,
mass: f64,
}
impl Attractor{
fn attract(&mut self, obj: &mut ObjectG){
let mut force = PointG::new(&self.pos.x, &self.pos.y);
force.sub(&obj.pos);
let dist = magnitude(force.x, force.y);
let mut dist = dist * dist;
if dist < 100.0 { dist = 100.0 }
if dist > 1000.0 { dist = 1000.0 }
let g = 5.0;
let strength = g * (self.mass * obj.mass) / dist;
force.set_mag(&strength);
obj.apply_force(&force);
}
}
fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, atr: &mut Attractor){
canvas.set_draw_color(Color::RGBA(0,0,0,50));
canvas.fill_rect(Rect::new(0,0,600,600)).err();
canvas.clear();
for obj in obj_arr{
obj.walk();
canvas.set_draw_color(Color::RGBA(150,50,255,150));
canvas.fill_rect(Rect::new(obj.pos.x as i32 - obj.size, obj.pos.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
canvas.set_draw_color(Color::RGB(150,50,255));
canvas.draw_rect(Rect::new(obj.pos.x as i32 - obj.size, obj.pos.y as i32 - obj.size, (obj.size * 2) as u32, (obj.size * 2) as u32)).err();
obj.ang = obj.vel.heading();
obj.line_end.set_angle(&obj.ang);
canvas.set_draw_color(Color::RGB(255,80,0));
canvas.draw_line(Point::new(obj.pos.x as i32,obj.pos.y as i32),Point::new((obj.pos.x + obj.line_end.x) as i32, (obj.pos.y + obj.line_end.y) as i32)).err();
atr.attract(obj);
}
canvas.set_draw_color(Color::RGB(255,50,150));
canvas.fill_rect(Rect::new(atr.pos.x as i32 - atr.size, atr.pos.y as i32 - atr.size, (atr.size * 2) as u32, (atr.size * 2) as u32)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=600;
let height: u32=600;
let window = video_subsystem.window("grav-attraction-point", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj_arr: Vec<ObjectG> = Vec::new();
for _ in 0..10{
let mut rng = rand::rng();
let mut obj = ObjectG{
pos: PointG::new( &rng.random_range(6.0..width as f64 -1.0), &rng.random_range(6.0..width as f64 -1.0)),
vel: PointG::new( &rng.random_range(-11.0..10.0), &rng.random_range(-11.0..10.0)),
acc: PointG::new( &0.0, &0.0 ),
size: 0,
mass: rng.random_range(50.0..150.0),
ang: 0.0,
line_end: PointG::new(&0.0,&0.0),
};
obj.size = (obj.mass.sqrt() * 2.0) as i32;
obj.line_end = PointG::new(&(obj.size as f64),&0.0);
obj_arr.push(obj);
}
let mut atr = Attractor{
pos: PointG::new(&(width as f64 /2.0), &(height as f64 /2.0)),
size: 0,
mass: 100.0,
};
atr.size = (atr.mass.sqrt() * 2.0) as i32;
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
let mut event_pump = sdl2_context.event_pump().unwrap();
draw(&mut canvas, &mut obj_arr, &mut atr);
'running: loop {
draw(&mut canvas, &mut obj_arr, &mut atr);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
}
}
// *~challenges
// force a object forward based on its angle

129
src/bin/3-4-polar-cords.rs Normal file
View File

@@ -0,0 +1,129 @@
extern crate sdl2;
use sdl2::gfx::primitives::DrawRenderer;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use std::time::Duration;
use std::f64::consts::PI;
use rand::{rng, Rng};
struct PointG{
x: f64,
y: f64,
}
impl PointG{
fn new(x: &f64, y: &f64) -> Self{
Self{
x: *x,
y: *y,
}
}
}
struct ObjectG{
pos: PointG,
mouse: PointG,
ang: f64,
r: f64,
}
impl ObjectG{
fn new(x: &f64, y: &f64) -> Self{
Self{
pos: PointG::new(x,y),
//ang: -3.14192 / 4.0,
mouse: PointG::new(&0.0,&0.0),
ang: 0.0,
r: 150.0,
}
}
}
fn draw_circle(canvas: &mut sdl2::render::WindowCanvas, obj: &mut ObjectG){
let mut i = 0.0;
let mut inc = 0.1;
//let mut inc = (obj.mouse.x / PI)/30.0;
if inc < 0.01 { inc = 0.01 }
let mut vx: Vec<i16> = Vec::new();
let mut vy: Vec<i16> = Vec::new();
while i < (PI*2.0) {
obj.ang = i;
let r1 = obj.r + rng().random_range(-10.0..10.0);
obj.pos.x = r1 * obj.ang.cos();
obj.pos.y = r1 * obj.ang.sin();
//let nx = obj.r * (obj.ang - inc).cos();
//let ny = obj.r * (obj.ang - inc).sin();
//canvas.fill_rect(Rect::new(obj.pos.x as i32 + 200, obj.pos.y as i32 + 200, 5, 5)).err();
//canvas.draw_line(Point::new((obj.pos.x + 200.0) as i32, (obj.pos.y + 200.0) as i32),Point::new((nx as i32) + 200, (ny as i32) + 200)).err();
vx.push((obj.pos.x + 200.0) as i16);
vy.push((obj.pos.y + 200.0) as i16);
i = i + inc;
}
canvas.polygon(&vx, &vy, Color::RGB(150,50,255)).err();
}
fn draw(canvas: &mut sdl2::render::WindowCanvas, obj: &mut ObjectG){
canvas.set_draw_color(Color::RGBA(0,0,0,50));
canvas.clear();
draw_circle(canvas, obj);
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("polar-cords", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj = ObjectG::new(&0.0, &0.0);
canvas.set_draw_color(Color::RGBA(0,0,0,0));
canvas.fill_rect(Rect::new(0,0,width,height)).err();
draw(&mut canvas, &mut obj);
let mut event_pump = sdl2_context.event_pump().unwrap();
'running: loop {
let state = event_pump.mouse_state();
obj.mouse.x = state.x() as f64;
obj.mouse.y = state.y() as f64;
draw(&mut canvas, &mut obj);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
}
}
// *~challenges
// make some shapes and shit.
// perlin noise???

144
src/bin/3-5-harmonic-motion.rs Normal file
View File

@@ -0,0 +1,144 @@
extern crate sdl2;
use sdl2::gfx::primitives::DrawRenderer;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use std::time::Duration;
use std::f64::consts::PI;
use rand::{rng, Rng};
struct PointG{
x: f64,
y: f64,
}
impl PointG{
fn new(x: &f64, y: &f64) -> Self{
Self{
x: *x,
y: *y,
}
}
}
struct ObjectG{
pos: PointG,
mouse: PointG,
ang: f64,
a_vel: f64,
r: f64,
}
impl ObjectG{
fn new(x: &f64, y: &f64) -> Self{
Self{
pos: PointG::new(x,y),
mouse: PointG::new(&0.0,&0.0),
ang: 0.0,
a_vel: 0.1,
r: 150.0,
}
}
}
fn draw_circle(canvas: &mut sdl2::render::WindowCanvas, obj: &mut ObjectG){
let mut i = 0.0;
let mut inc = 0.1;
//let mut inc = (obj.mouse.x / PI)/30.0;
if inc < 0.01 { inc = 0.01 }
let mut vx: Vec<i16> = Vec::new();
let mut vy: Vec<i16> = Vec::new();
while i < (PI*2.0) {
obj.ang = i;
let r1 = obj.r + rng().random_range(-10.0..10.0);
obj.pos.x = r1 * obj.ang.cos();
obj.pos.y = r1 * obj.ang.sin();
//let nx = obj.r * (obj.ang - inc).cos();
//let ny = obj.r * (obj.ang - inc).sin();
//canvas.fill_rect(Rect::new(obj.pos.x as i32 + 200, obj.pos.y as i32 + 200, 5, 5)).err();
//canvas.draw_line(Point::new((obj.pos.x + 200.0) as i32, (obj.pos.y + 200.0) as i32),Point::new((nx as i32) + 200, (ny as i32) + 200)).err();
vx.push((obj.pos.x + 200.0) as i16);
vy.push((obj.pos.y + 200.0) as i16);
i = i + inc;
}
canvas.polygon(&vx, &vy, Color::RGB(150,50,255)).err();
}
fn draw(canvas: &mut sdl2::render::WindowCanvas, obj: &mut ObjectG){
canvas.set_draw_color(Color::RGBA(0,0,0,50));
//canvas.fill_rect(Rect::new(0,0,400,400)).err();
//canvas.rectangle(0, 0, 400, 400, Color::RGB(0,50,0)).err();
canvas.clear();
//obj.r = (obj.ang.sin() + 1.0) * 100.0;
//canvas.filled_circle(200, 200, (obj.r) as i16, Color::RGBA(150,50,255,254)).err();
obj.pos.y = obj.ang.sin() * 200.0;
canvas.filled_circle(200, (obj.pos.y + 200.0) as i16, 16 , Color::RGBA(150,50,255,254)).err();
canvas.line(200, 200, 200, (obj.pos.y + 200.0) as i16, Color::RGBA(150,50,255,254)).err();
//let inc = (PI * 2.0) / 60.0;
obj.ang = obj.ang + obj.a_vel;
//obj.a_vel = obj.a_vel + 0.0001;
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("harmonic-motion", width, height)
.position_centered()
.opengl()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj = ObjectG::new(&0.0, &0.0);
canvas.set_draw_color(Color::RGBA(0,0,0,0));
canvas.fill_rect(Rect::new(0,0,width,height)).err();
draw(&mut canvas, &mut obj);
let mut event_pump = sdl2_context.event_pump().unwrap();
'running: loop {
let state = event_pump.mouse_state();
obj.mouse.x = state.x() as f64;
obj.mouse.y = state.y() as f64;
draw(&mut canvas, &mut obj);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}
// *~challenges
// x and y ocillation

89
src/bin/cos-sin.rs Normal file
View File

@@ -0,0 +1,89 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use std::time::Duration;
struct ObjectG{
x: i32,
y: i32,
screen_width: i32,
screen_height: i32,
frame: i32,
}
impl ObjectG{
fn walk(&mut self) {
self.frame = self.frame + 1;
let speed = 50.0;
self.x = (((self.frame as f64) / speed).sin() * (self.screen_width as f64) / 2.1) as i32 + (self.screen_width / 2);
self.y = (((self.frame as f64) / speed).cos() * (self.screen_height as f64) / 2.1) as i32 + (self.screen_height / 2);
if self.x < 0 { self.x = 0 }
if self.y < 0 { self.y = 0 }
if self.x > self.screen_width { self.x = self.screen_width }
if self.y > self.screen_height{ self.y = self.screen_height }
}
}
fn draw(canvas: &mut sdl2::render::WindowCanvas, obj: &mut ObjectG){
canvas.set_draw_color(Color::RGB(0,0,0));
canvas.clear();
//putRectRGB(renderer,i*boxsize,j*boxsize,boxsize-1,150,50,255);
canvas.set_draw_color(Color::RGB(150,50,255));
obj.walk();
canvas.fill_rect(Rect::new(obj.x-5/2, obj.y-5/2, 5, 5)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("cos-sin", width, height)
.position_centered()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
let mut obj = ObjectG{
x: width as i32 /2,
y: height as i32 /2,
screen_width: width as i32,
screen_height: height as i32,
frame: 0,
};
draw(&mut canvas, &mut obj);
let mut event_pump = sdl2_context.event_pump().unwrap();
'running: loop {
draw(&mut canvas, &mut obj);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
// The rest of the game loop goes here...
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}

63
src/bin/transparency-test-a.rs Normal file
View File

@@ -0,0 +1,63 @@
extern crate sdl2;
//use sdl2::gfx::primitives::DrawRenderer;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Rect};
use std::time::Duration;
fn draw(canvas: &mut sdl2::render::WindowCanvas){
canvas.set_draw_color(Color::RGBA(200,0,0,50));
canvas.fill_rect(Rect::new(200,200,100,100)).err();
//canvas.clear();
canvas.set_draw_color(Color::RGBA(200,0,0,255));
canvas.fill_rect(Rect::new(100,100,50,50)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let mut window = video_subsystem.window("transparency-test-a", width, height)
.opengl()
.position_centered()
.build()
.unwrap();
window.set_opacity(0.5).expect("cant set opa :<");
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
canvas.set_draw_color(Color::RGBA(0,0,0,0));
canvas.fill_rect(Rect::new(0,0,width,height)).err();
draw(&mut canvas);
let mut event_pump = sdl2_context.event_pump().unwrap();
'running: loop {
draw(&mut canvas);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
}
}

135
src/bin/walker-levy-flight.rs Normal file
View File

@@ -0,0 +1,135 @@
extern crate sdl2;
use sdl2::pixels::Color;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::rect::{Point, Rect};
use std::time::Duration;
use rand::Rng;
fn magnitude(x: f64,y: f64) -> f64 {
((x).powi(2) + (y).powi(2)).sqrt()
}
fn set_mag(x: &f64,y: &f64, mag: &f64) -> Vec<f64>{
let getmag: f64 = magnitude(*x, *y);
let rx = (*x / getmag) * mag;
let ry = (*y / getmag) * mag;
return vec![rx,ry]
}
#[derive(Clone)]
struct PointG{
x: f64,
y: f64,
}
impl PointG{
fn add(&mut self, addvec: &PointG){
self.x = self.x + addvec.x;
self.y = self.y + addvec.y;
}
fn mul(&mut self, mult: &f64){
self.x = self.x * mult;
self.y = self.y * mult;
}
fn set_mag(&mut self, mag: &f64) {
let smag = set_mag(&self.x, &self.y, &mag);
self.x = smag[0];
self.y = smag[1];
}
}
struct ObjectG{
pos: PointG,
prev: PointG,
screen_width: i32,
screen_height: i32,
}
impl ObjectG{
fn walk(&mut self) {
let mut rng = rand::rng();
self.prev = self.pos.clone();
let mut step = PointG{x: rng.random_range(-1.0..1.0), y: rng.random_range(-1.0..1.0)};
let r = rng.random_range(0.0..100.0);
if r < 1.0 {
step.mul(&rng.random_range(25.0..100.0));
} else {
step.set_mag(&2.0);
}
self.pos.add(&step);
if self.pos.x < 0.0 { self.pos.x = 0.0 }
if self.pos.y < 0.0 { self.pos.y = 0.0 }
if self.pos.x > self.screen_width as f64{ self.pos.x = self.screen_width as f64}
if self.pos.y > self.screen_height as f64{ self.pos.y = self.screen_height as f64}
}
}
fn draw(canvas: &mut sdl2::render::WindowCanvas, obj: &mut ObjectG){
canvas.set_draw_color(Color::RGBA(0,0,0,20));
//canvas.clear();
canvas.fill_rect(Rect::new(0,0,obj.screen_width as u32,obj.screen_height as u32)).err();
canvas.set_draw_color(Color::RGB(150,50,255));
obj.walk();
canvas.fill_rect(Rect::new(obj.pos.x as i32, obj.pos.y as i32, 5, 5)).err();
canvas.draw_line(Point::new(obj.pos.x as i32, obj.pos.y as i32),Point::new(obj.prev.x as i32, obj.prev.y as i32)).err();
canvas.present();
}
fn main() {
let sdl2_context = sdl2::init().unwrap();
let video_subsystem = sdl2_context.video().unwrap();
let width: u32=400;
let height: u32=400;
let window = video_subsystem.window("walker-levy-flight", width, height)
.position_centered()
.opengl()
.build()
.unwrap();
let mut canvas = window.into_canvas().build().unwrap();
canvas.default_pixel_format();
canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
let mut obj = ObjectG{
pos: PointG{x: width as f64/2.0,y: height as f64 /2.0},
prev: PointG{x: width as f64/2.0,y: height as f64 /2.0},
screen_width: width as i32,
screen_height: height as i32,
};
draw(&mut canvas, &mut obj);
let mut event_pump = sdl2_context.event_pump().unwrap();
'running: loop {
draw(&mut canvas, &mut obj);
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} |
Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
break 'running
},
_ => {}
}
}
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
}