Compare commits

..

62 Commits

Author SHA1 Message Date
53d2b5b3f5 wip: timelines 2023-09-08 23:20:27 -07:00
c565120ea7 wip: tickless physics 2023-09-08 20:18:31 -07:00
4f5c9afed3 comments on implementing game mechanics 2023-09-08 20:18:31 -07:00
53605746d4 rename best to collector 2023-09-08 20:18:31 -07:00
cead05b08b rename event.rs to instruction.rs 2023-09-08 20:18:31 -07:00
949897a558 rename EventStruct to TimedInstruction 2023-09-08 20:18:31 -07:00
a4ed50fc38 EventConsumer 2023-09-08 20:15:36 -07:00
846f681648 generic events 2023-09-08 20:15:36 -07:00
ff54a03487 happy compiler happy programmer 2023-09-08 20:15:36 -07:00
8c2dda5205 bad data normalization 2023-09-08 16:06:17 -07:00
addde65caa fix up next_event lsp errors 2023-09-08 16:06:17 -07:00
2c4e6f642b boilerplate 2023-09-08 16:06:17 -07:00
f11742ef3b RelativeCollision concept 2023-09-08 16:06:17 -07:00
e6862b5bad rename Model to ModelGRaphics + move model graphics gen code 2023-09-08 16:06:17 -07:00
e18e8a9a7d walk event 2023-09-08 16:06:17 -07:00
f600092f13 LETS GET RUSTY 2023-09-08 16:06:17 -07:00
1f1ef5d3ad there is no model 2023-09-08 12:28:16 -07:00
54bf0358d6 can't stand the idea of 10 nanoseconds less than 66 ticks per second 2023-09-08 12:27:45 -07:00
6caa273623 jump implementation details 2023-09-08 12:04:30 -07:00
101f0f8d12 localize EventStruct 2023-09-08 12:03:32 -07:00
fc751a9fe8 stage sweep 2023-09-08 11:38:47 -07:00
5391b635fb reorder elements 2023-09-08 11:38:47 -07:00
230469496e brainstorm tickless events 2023-09-08 11:38:47 -07:00
ea3134de51 move physics into its own module 2023-09-08 11:35:40 -07:00
05156d1741 sens way too high 2023-09-06 19:35:43 -07:00
d72e3fcabd use syntactic sugar 2023-09-06 19:08:23 -07:00
99d4e51ee8 use Mat4 in place of Affine3A 2023-09-06 14:47:19 -07:00
7effceff03 convert spaces to tabs 2023-09-06 14:39:44 -07:00
355956e532 change equation for bigger reflectionless area 2023-09-06 14:30:30 -07:00
8aad878d49 texture coordinates + fake fresnel using dot 2023-09-06 14:19:35 -07:00
5fb9f8b1bc tweak matrices 2023-09-06 14:19:35 -07:00
a9977c0bd2 fix cam_pos bug 2023-09-06 14:18:44 -07:00
fd34fbe367 save 1 nanosecond 2023-09-06 14:18:44 -07:00
75695946a0 indexed rendering 2023-09-06 14:18:44 -07:00
2dba9554ea draw teapot 2023-09-06 13:02:48 -07:00
b5880d484a use teapot with normals 2023-09-06 13:01:15 -07:00
0b230b7597 add teapot 2023-09-06 12:09:21 -07:00
988f204358 comment on updating uniforms 2023-09-05 18:51:53 -07:00
abd002e3bf optimize release builds a bit 2023-09-05 15:39:04 -07:00
1776dc4c39 add comments about moving data 2023-09-05 15:39:04 -07:00
946687639a v0.2.0 2023-09-05 15:39:04 -07:00
69c7896011 binding group per model 2023-09-05 14:58:55 -07:00
1a1509f315 try one entity, convert to mat4x4 2023-09-05 14:58:55 -07:00
87f674238d add model_bind_group 2023-09-05 14:58:55 -07:00
cce9800045 no fragment 2023-09-05 14:58:55 -07:00
8792b8e782 add entity CFrames 2023-09-05 14:58:55 -07:00
c9cb22be68 comment on value 2023-09-05 14:58:55 -07:00
d4172f5040 rename uniform_buf to camera_buf 2023-09-05 14:58:55 -07:00
df43dc6f6e add suzanne 2023-09-05 14:58:55 -07:00
c3290e2ce6 macro version into window title 2023-09-05 12:23:26 -07:00
e347d4fd51 vertex index buffer is very cool 2023-09-05 00:18:31 -07:00
ad46418e79 expand baseplate 2023-09-05 00:18:07 -07:00
82da9bf40f why not be accurate 2023-09-01 20:28:37 -07:00
bda898a1f1 struct style init straggler 2023-09-01 20:27:28 -07:00
ce5f6fceb9 modulo is implemented incorrectly by the shader language 2023-09-01 00:10:19 -07:00
7179f20e67 add zoom 2023-08-31 22:48:17 -07:00
e25a2d7a7a use slope fov 2023-08-31 22:47:55 -07:00
7c247b6949 fix strafe bug 2023-08-31 12:37:53 -07:00
49fde16c4f rbhop friction 2023-08-31 12:16:51 -07:00
403910d2d8 rbhop jump power 2023-08-31 12:10:49 -07:00
7a23ef2734 add walking 2023-08-31 12:04:18 -07:00
1e25f71618 brain lol 2023-08-31 02:21:39 -07:00
13 changed files with 7010 additions and 1041 deletions

28
Cargo.lock generated

@ -302,26 +302,6 @@ dependencies = [
"crossbeam-utils",
]
[[package]]
name = "console_error_panic_hook"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
dependencies = [
"cfg-if",
"wasm-bindgen",
]
[[package]]
name = "console_log"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be8aed40e4edbf4d3b4431ab260b63fdc40f5780a4766824329ea0f1eefe3c0f"
dependencies = [
"log",
"web-sys",
]
[[package]]
name = "core-foundation"
version = "0.9.3"
@ -1425,22 +1405,16 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]]
name = "strafe-client"
version = "0.1.0"
version = "0.2.0"
dependencies = [
"async-executor",
"bytemuck",
"console_error_panic_hook",
"console_log",
"ddsfile",
"env_logger",
"glam",
"js-sys",
"log",
"obj",
"pollster",
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
"wgpu",
"winit",
]

@ -1,6 +1,6 @@
[package]
name = "strafe-client"
version = "0.1.0"
version = "0.2.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@ -17,12 +17,7 @@ pollster = "0.3.0"
wgpu = "0.17.0"
winit = "0.28.6"
# https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#platform-specific-dependencies
[target.wasm32-unknown-unknown.dependencies]
console_error_panic_hook = "0.1.7"
console_log = "1.0.0"
js-sys = "0.3.64"
wasm-bindgen = "0.2.87"
wasm-bindgen-futures = "0.4.37"
web-sys = { version = "0.3.64", features = ["Location", "Window"] }
[profile.release]
lto = true
strip = true
codegen-units = 1

@ -1,8 +0,0 @@
<html>
<body>
<script type="module">
import init from "./strafe-client.js";
init();
</script>
</body>
</html>

2580
models/suzanne.obj Normal file

File diff suppressed because it is too large Load Diff

2866
models/teapot.obj Normal file

File diff suppressed because it is too large Load Diff

321
src/body.rs Normal file

@ -0,0 +1,321 @@
use crate::instruction::TimedInstruction;
pub enum PhysicsInstruction {
CollisionStart(RelativeCollision),
CollisionEnd(RelativeCollision),
StrafeTick,
Jump,
SetWalkTargetVelocity(glam::Vec3),
ReachWalkTargetVelocity,
// Water,
// Spawn(
// Option<SpawnId>,
// bool,//true = Trigger; false = teleport
// bool,//true = Force
// )
}
pub struct Body {
pub position: glam::Vec3,//I64 where 2^32 = 1 u
pub velocity: glam::Vec3,//I64 where 2^32 = 1 u/s
pub time: TIME,//nanoseconds x xxxxD!
}
pub enum MoveRestriction {
Air,
Water,
Ground,
Ladder,//multiple ladders how
}
pub struct PhysicsState {
pub body: Body,
pub contacts: Vec<RelativeCollision>,
pub models_cringe_clone: Vec<Model>,
pub time: TIME,
pub strafe_tick_num: TIME,
pub strafe_tick_den: TIME,
pub tick: u32,
pub mv: f32,
pub walkspeed: f32,
pub friction: f32,
pub gravity: glam::Vec3,
pub grounded: bool,
pub jump_trying: bool,
}
#[derive(Clone,Copy)]
pub enum AabbFace{
Right,//+X
Top,
Back,
Left,
Bottom,
Front,
}
pub struct Aabb {
min: glam::Vec3,
max: glam::Vec3,
}
impl Aabb {
// const FACE_DATA: [[f32; 3]; 6] = [
// [0.0f32, 0., 1.],
// [0.0f32, 0., -1.],
// [1.0f32, 0., 0.],
// [-1.0f32, 0., 0.],
// [0.0f32, 1., 0.],
// [0.0f32, -1., 0.],
// ];
const VERTEX_DATA_RIGHT: [glam::Vec3; 4] = [
glam::vec3(1., -1., -1.),
glam::vec3(1., 1., -1.),
glam::vec3(1., 1., 1.),
glam::vec3(1., -1., 1.),
];
const VERTEX_DATA_TOP: [glam::Vec3; 4] = [
glam::vec3(1., 1., -1.),
glam::vec3(-1., 1., -1.),
glam::vec3(-1., 1., 1.),
glam::vec3(1., 1., 1.),
];
const VERTEX_DATA_BACK: [glam::Vec3; 4] = [
glam::vec3(-1., -1., 1.),
glam::vec3(1., -1., 1.),
glam::vec3(1., 1., 1.),
glam::vec3(-1., 1., 1.),
];
const VERTEX_DATA_LEFT: [glam::Vec3; 4] = [
glam::vec3(-1., -1., 1.),
glam::vec3(-1., 1., 1.),
glam::vec3(-1., 1., -1.),
glam::vec3(-1., -1., -1.),
];
const VERTEX_DATA_BOTTOM: [glam::Vec3; 4] = [
glam::vec3(1., -1., 1.),
glam::vec3(-1., -1., 1.),
glam::vec3(-1., -1., -1.),
glam::vec3(1., -1., -1.),
];
const VERTEX_DATA_FRONT: [glam::Vec3; 4] = [
glam::vec3(-1., 1., -1.),
glam::vec3(1., 1., -1.),
glam::vec3(1., -1., -1.),
glam::vec3(-1., -1., -1.),
];
pub fn new() -> Self {
Self {min: glam::Vec3::INFINITY,max: glam::Vec3::NEG_INFINITY}
}
pub fn grow(&mut self, point:glam::Vec3){
self.min=self.min.min(point);
self.max=self.max.max(point);
}
pub fn normal(face:AabbFace) -> glam::Vec3 {
match face {
AabbFace::Right => glam::vec3(1.,0.,0.),
AabbFace::Top => glam::vec3(0.,1.,0.),
AabbFace::Back => glam::vec3(0.,0.,1.),
AabbFace::Left => glam::vec3(-1.,0.,0.),
AabbFace::Bottom => glam::vec3(0.,-1.,0.),
AabbFace::Front => glam::vec3(0.,0.,-1.),
}
}
pub fn face_vertices(face:AabbFace) -> [glam::Vec3;4] {
match face {
AabbFace::Right => Self::VERTEX_DATA_RIGHT,
AabbFace::Top => Self::VERTEX_DATA_TOP,
AabbFace::Back => Self::VERTEX_DATA_BACK,
AabbFace::Left => Self::VERTEX_DATA_LEFT,
AabbFace::Bottom => Self::VERTEX_DATA_BOTTOM,
AabbFace::Front => Self::VERTEX_DATA_FRONT,
}
}
}
type Face = AabbFace;
type TreyMesh = Aabb;
pub struct Model {
//A model is a thing that has a hitbox. can be represented by a list of TreyMesh-es
//in this iteration, all it needs is extents.
transform: glam::Mat4,
}
impl Model {
pub fn new(transform:glam::Mat4) -> Self {
Self{transform}
}
pub fn face_vertices(&self,face:Face) -> [glam::Vec3;4] {
Aabb::face_vertices(face)
}
pub fn face_mesh(&self,face:Face) -> TreyMesh {
let mut aabb=Aabb::new();
for &vertex in self.face_vertices(face).iter() {
aabb.grow(vertex);
}
return aabb;
}
pub fn face_normal(&self,face:Face) -> glam::Vec3 {
let mut n=glam::Vec3Swizzles::xyzz(Aabb::normal(face));
n.w=0.0;//what a man will do to avoid writing out the components
glam::Vec4Swizzles::xyz(self.transform*n)//this is wrong for scale
}
}
pub struct RelativeCollision {
face: Face,//just an id
model: u32,//using id to avoid lifetimes
}
impl RelativeCollision {
pub fn mesh(&self,models:&Vec<Model>) -> TreyMesh {
return models.get(self.model as usize).unwrap().face_mesh(self.face)
}
pub fn normal(&self,models:&Vec<Model>) -> glam::Vec3 {
return models.get(self.model as usize).unwrap().face_normal(self.face)
}
}
pub type TIME = i64;
const CONTROL_JUMP:u32 = 0b01000000;//temp DATA NORMALIZATION!@#$
impl PhysicsState {
//delete this, we are tickless gamers
pub fn run(&mut self, time: TIME){
//prepare is ommitted - everything is done via instructions.
while let Some(instruction) = self.next_instruction() {//collect
if time<instruction.time {
break;
}
//advance
self.advance_time(instruction.time);
//process
self.process_instruction(instruction);
//write hash lol
}
}
//delete this
pub fn extrapolate_position(&self, time: TIME) -> glam::Vec3 {
let dt=(time-self.body.time) as f64/1_000_000_000f64;
self.body.position+self.body.velocity*(dt as f32)+self.gravity*((0.5*dt*dt) as f32)
}
fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
return Some(TimedInstruction{
time:(self.time*self.strafe_tick_num/self.strafe_tick_den+1)*self.strafe_tick_den/self.strafe_tick_num,
//only poll the physics if there is a before and after mouse event
instruction:PhysicsInstruction::StrafeTick
});
}
//state mutated on collision:
//Accelerator
//stair step-up
//state mutated on instruction
//change fly acceleration (fly_sustain)
//change fly velocity
//generic event emmiters
//PlatformStandTime
//walk/swim/air/ladder sounds
//VState?
//falling under the map
// fn next_respawn_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
// if self.body.position<self.world.min_y {
// return Some(TimedInstruction{
// time:self.time,
// instruction:PhysicsInstruction::Trigger(None)
// });
// }
// }
// fn next_water_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
// return Some(TimedInstruction{
// time:(self.time*self.strafe_tick_num/self.strafe_tick_den+1)*self.strafe_tick_den/self.strafe_tick_num,
// //only poll the physics if there is a before and after mouse event
// instruction:PhysicsInstruction::Water
// });
// }
fn next_walk_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
//check if you are accelerating towards a walk target velocity and create an instruction
return None;
}
fn predict_collision_end(&self,model:&Model) -> Option<TimedInstruction<PhysicsInstruction>> {
//must treat cancollide false objects differently: you may not exit through the same face you entered.
None
}
fn predict_collision_start(&self,model:&Model) -> Option<TimedInstruction<PhysicsInstruction>> {
None
}
}
impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState {
//this little next instruction function can cache its return value and invalidate the cached value by watching the State.
fn next_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
//JUST POLLING!!! NO MUTATION
let mut collector = crate::instruction::InstructionCollector::new();
//autohop (already pressing spacebar; the signal to begin trying to jump is different)
if self.grounded&&self.jump_trying {
//scroll will be implemented with InputInstruction::Jump(true) but it blocks setting self.jump_trying=true
collector.collect(Some(TimedInstruction{
time:self.time,
instruction:PhysicsInstruction::Jump
}));
}
//check for collision stop instructions with curent contacts
for collision_data in self.contacts.iter() {
collector.collect(self.predict_collision_end(self.models_cringe_clone.get(collision_data.model as usize).unwrap()));
}
//check for collision start instructions (against every part in the game with no optimization!!)
for model in &self.models_cringe_clone {
collector.collect(self.predict_collision_start(model));
}
if self.grounded {
//walk maintenance
collector.collect(self.next_walk_instruction());
}else{
//check to see when the next strafe tick is
collector.collect(self.next_strafe_instruction());
}
collector.instruction()
}
}
impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
fn process_instruction(&mut self, ins:TimedInstruction<PhysicsInstruction>) {
//mutate position and velocity and time
self.body.advance_time(ins.time);//should this be in a separate function: self.advance_time?
match ins.instruction {
PhysicsInstruction::CollisionStart(_) => todo!(),
PhysicsInstruction::CollisionEnd(_) => todo!(),
PhysicsInstruction::StrafeTick => {
let control_dir=self.get_control_dir();//this respects your mouse interpolation settings
let d=self.body.velocity.dot(control_dir);
if d<self.mv {
self.body.velocity+=(self.mv-d)*control_dir;
}
}
PhysicsInstruction::Jump => {
self.grounded=false;//do I need this?
self.body.velocity+=glam::Vec3::new(0.0,0.715588/2.0*100.0,0.0);
}
PhysicsInstruction::ReachWalkTargetVelocity => {
//precisely set velocity
self.body.velocity=self.walk_target_velocity;
}
PhysicsInstruction::SetWalkTargetVelocity(v) => {
self.walk_target_velocity=v;
//calculate acceleration yada yada
},
}
}
}

37
src/instruction.rs Normal file

@ -0,0 +1,37 @@
pub struct TimedInstruction<I> {
pub time: crate::body::TIME,
pub instruction: I,
}
pub trait InstructionEmitter<I> {
fn next_instruction(&self) -> Option<TimedInstruction<I>>;
}
pub trait InstructionConsumer<I> {
fn process_instruction(&mut self, instruction:TimedInstruction<I>);
}
//PROPER PRIVATE FIELDS!!!
pub struct InstructionCollector<I> {
instruction: Option<TimedInstruction<I>>,
}
impl<I> InstructionCollector<I> {
pub fn new() -> Self {
Self{instruction:None}
}
pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
match &instruction {
Some(unwrap_instruction) => match &self.instruction {
Some(unwrap_best_instruction) => if unwrap_instruction.time<unwrap_best_instruction.time {
self.instruction=instruction;
},
None => self.instruction=instruction,
},
None => (),
}
}
pub fn instruction(self) -> Option<TimedInstruction<I>> {
//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
return self.instruction
}
}

@ -1 +1,4 @@
pub mod framework;
pub mod body;
pub mod instruction;
pub mod timelines;

@ -1,5 +1,5 @@
use bytemuck::{Pod, Zeroable};
use std::{borrow::Cow, f32::consts,time::Instant};
use std::{borrow::Cow, time::Instant};
use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
const IMAGE_SIZE: u32 = 128;
@ -8,28 +8,38 @@ const IMAGE_SIZE: u32 = 128;
#[repr(C)]
struct Vertex {
pos: [f32; 3],
texture: [f32; 2],
normal: [f32; 3],
}
struct Entity {
vertex_count: u32,
index_count: u32,
index_buf: wgpu::Buffer,
}
//temp?
struct ModelData {
transform: glam::Mat4,
vertex_buf: wgpu::Buffer,
entities: Vec<Entity>,
}
struct ModelGraphics {
transform: glam::Mat4,
vertex_buf: wgpu::Buffer,
entities: Vec<Entity>,
bind_group: wgpu::BindGroup,
model_buf: wgpu::Buffer,
}
// Note: we use the Y=up coordinate space in this example.
struct Camera {
time: Instant,
pos: glam::Vec3,
vel: glam::Vec3,
gravity: glam::Vec3,
friction: f32,
screen_size: (u32, u32),
offset: glam::Vec3,
fov: f32,
yaw: f32,
pitch: f32,
controls: u32,
mv: f32,
grounded: bool,
}
const CONTROL_MOVEFORWARD:u32 = 0b00000001;
@ -39,7 +49,7 @@ const CONTROL_MOVELEFT:u32 = 0b00001000;
const CONTROL_MOVEUP:u32 = 0b00010000;
const CONTROL_MOVEDOWN:u32 = 0b00100000;
const CONTROL_JUMP:u32 = 0b01000000;
//const CONTROL_ZOOM:u32 = 0b10000000;
const CONTROL_ZOOM:u32 = 0b10000000;
const FORWARD_DIR:glam::Vec3 = glam::Vec3::new(0.0,0.0,-1.0);
const RIGHT_DIR:glam::Vec3 = glam::Vec3::new(1.0,0.0,0.0);
@ -69,31 +79,50 @@ fn get_control_dir(controls: u32) -> glam::Vec3{
return control_dir
}
#[inline]
fn perspective_rh(fov_y_slope: f32, aspect_ratio: f32, z_near: f32, z_far: f32) -> glam::Mat4 {
//glam_assert!(z_near > 0.0 && z_far > 0.0);
let r = z_far / (z_near - z_far);
glam::Mat4::from_cols(
glam::Vec4::new(1.0/(fov_y_slope * aspect_ratio), 0.0, 0.0, 0.0),
glam::Vec4::new(0.0, 1.0/fov_y_slope, 0.0, 0.0),
glam::Vec4::new(0.0, 0.0, r, -1.0),
glam::Vec4::new(0.0, 0.0, r * z_near, 0.0),
)
}
impl Camera {
fn to_uniform_data(&self) -> [f32; 16 * 3 + 4] {
fn to_uniform_data(&self, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
let aspect = self.screen_size.0 as f32 / self.screen_size.1 as f32;
let proj = glam::Mat4::perspective_rh(consts::FRAC_PI_2, aspect, 1.0, 200.0);
let view = (glam::Mat4::from_translation(self.pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.yaw, self.pitch, 0f32)).inverse();
let fov = if self.controls&CONTROL_ZOOM==0 {
self.fov
}else{
self.fov/5.0
};
let proj = perspective_rh(fov, aspect, 0.5, 1000.0);
let proj_inv = proj.inverse();
let view = glam::Mat4::from_translation(pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.yaw, self.pitch, 0f32);
let view_inv = view.inverse();
let mut raw = [0f32; 16 * 3 + 4];
raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view)[..]);
raw[48..51].copy_from_slice(AsRef::<[f32; 3]>::as_ref(&self.pos));
raw[51] = 1.0;
raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
raw
}
}
pub struct Skybox {
start_time: std::time::Instant,
camera: Camera,
physics: strafe_client::body::PhysicsState,
sky_pipeline: wgpu::RenderPipeline,
entity_pipeline: wgpu::RenderPipeline,
ground_pipeline: wgpu::RenderPipeline,
bind_group: wgpu::BindGroup,
uniform_buf: wgpu::Buffer,
entities: Vec<Entity>,
main_bind_group: wgpu::BindGroup,
camera_buf: wgpu::Buffer,
models: Vec<ModelGraphics>,
depth_view: wgpu::TextureView,
staging_belt: wgpu::util::StagingBelt,
}
@ -124,6 +153,62 @@ impl Skybox {
}
}
fn get_transform_uniform_data(transform:&glam::Mat4) -> [f32; 4*4] {
let mut raw = [0f32; 4*4];
raw[0..16].copy_from_slice(&AsRef::<[f32; 4*4]>::as_ref(transform)[..]);
raw
}
fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
let data = obj::ObjData::load_buf(&source[..]).unwrap();
let mut vertices = Vec::new();
let mut vertex_index = std::collections::HashMap::<obj::IndexTuple,u16>::new();
for object in data.objects {
let mut entities = Vec::<Entity>::new();
for group in object.groups {
let mut indices = Vec::new();
for poly in group.polys {
for end_index in 2..poly.0.len() {
for &index in &[0, end_index - 1, end_index] {
let vert = poly.0[index];
if let Some(&i)=vertex_index.get(&vert){
indices.push(i as u16);
}else{
let i=vertices.len() as u16;
vertices.push(Vertex {
pos: data.position[vert.0],
texture: data.texture[vert.1.unwrap()],
normal: data.normal[vert.2.unwrap()],
});
vertex_index.insert(vert,i);
indices.push(i);
}
}
}
}
let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index"),
contents: bytemuck::cast_slice(&indices),
usage: wgpu::BufferUsages::INDEX,
});
entities.push(Entity {
index_buf,
index_count: indices.len() as u32,
});
}
let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
modeldatas.push(ModelData {
transform: glam::Mat4::default(),
vertex_buf,
entities,
})
}
}
impl strafe_client::framework::Example for Skybox {
fn optional_features() -> wgpu::Features {
wgpu::Features::TEXTURE_COMPRESSION_ASTC
@ -137,45 +222,20 @@ impl strafe_client::framework::Example for Skybox {
device: &wgpu::Device,
queue: &wgpu::Queue,
) -> Self {
let mut entities = Vec::new();
{
let source = include_bytes!("../models/teslacyberv3.0.obj");
let data = obj::ObjData::load_buf(&source[..]).unwrap();
let mut vertices = Vec::new();
for object in data.objects {
for group in object.groups {
vertices.clear();
for poly in group.polys {
for end_index in 2..poly.0.len() {
for &index in &[0, end_index - 1, end_index] {
let obj::IndexTuple(position_id, _texture_id, normal_id) =
poly.0[index];
vertices.push(Vertex {
pos: data.position[position_id],
normal: data.normal[normal_id.unwrap()],
})
}
}
}
let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsages::VERTEX,
});
entities.push(Entity {
vertex_count: vertices.len() as u32,
vertex_buf,
});
}
}
}
let mut modeldatas = Vec::<ModelData>::new();
add_obj(device,& mut modeldatas,include_bytes!("../models/teslacyberv3.0.obj"));
add_obj(device,& mut modeldatas,include_bytes!("../models/suzanne.obj"));
add_obj(device,& mut modeldatas,include_bytes!("../models/teapot.obj"));
println!("models.len = {:?}", modeldatas.len());
modeldatas[1].transform=glam::Mat4::from_translation(glam::vec3(10.,5.,10.));
modeldatas[2].transform=glam::Mat4::from_translation(glam::vec3(-10.,5.,10.));
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
let main_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@ -201,6 +261,21 @@ impl strafe_client::framework::Example for Skybox {
},
],
});
let model_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
],
});
// Create the render pipeline
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
@ -209,29 +284,72 @@ impl strafe_client::framework::Example for Skybox {
});
let camera = Camera {
time: Instant::now(),
pos: glam::Vec3::new(5.0,0.0,5.0),
vel: glam::Vec3::new(0.0,0.0,0.0),
gravity: glam::Vec3 { x: 0.0, y: -100.0, z: 0.0 },
friction: 80.0,
screen_size: (config.width, config.height),
offset: glam::Vec3::new(0.0,4.5,0.0),
fov: 1.0, //fov_slope = tan(fov_y/2)
pitch: 0.0,
yaw: 0.0,
mv: 2.7,
controls:0,
grounded: true,
};
let raw_uniforms = camera.to_uniform_data();
let uniform_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Buffer"),
contents: bytemuck::cast_slice(&raw_uniforms),
let physics = strafe_client::body::PhysicsState {
body: strafe_client::body::Body {
position: glam::Vec3::new(5.0,0.0,5.0),
velocity: glam::Vec3::new(0.0,0.0,0.0),
time: 0,
},
time: 0,
tick: 0,
strafe_tick_num: 100,//100t
strafe_tick_den: 1_000_000_000,
gravity: glam::Vec3::new(0.0,-100.0,0.0),
friction: 90.0,
mv: 2.7,
grounded: true,
jump_trying: false,
walkspeed: 18.0,
contacts: Vec::<strafe_client::body::RelativeCollision>::new(),
models_cringe_clone: modeldatas.iter().map(|m|strafe_client::body::Model::new(m.transform)).collect(),
};
let camera_uniforms = camera.to_uniform_data(physics.extrapolate_position(0));
let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Camera"),
contents: bytemuck::cast_slice(&camera_uniforms),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
//drain the modeldata vec so entities can be /moved/ to models.entities
let mut models = Vec::<ModelGraphics>::with_capacity(modeldatas.len());
for (i,modeldata) in modeldatas.drain(..).enumerate() {
let model_uniforms = get_transform_uniform_data(&modeldata.transform);
let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(format!("ModelGraphics{}",i).as_str()),
contents: bytemuck::cast_slice(&model_uniforms),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &model_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: model_buf.as_entire_binding(),
},
],
label: Some(format!("ModelGraphics{}",i).as_str()),
});
//all of these are being moved here
models.push(ModelGraphics{
transform: modeldata.transform,
vertex_buf:modeldata.vertex_buf,
entities: modeldata.entities,
bind_group: model_bind_group,
model_buf,
})
}
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[&bind_group_layout],
bind_group_layouts: &[&main_bind_group_layout, &model_bind_group_layout],
push_constant_ranges: &[],
});
@ -272,7 +390,7 @@ impl strafe_client::framework::Example for Skybox {
buffers: &[wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3],
attributes: &wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Float32x3],
}],
},
fragment: Some(wgpu::FragmentState {
@ -405,12 +523,12 @@ impl strafe_client::framework::Example for Skybox {
dimension: Some(wgpu::TextureViewDimension::Cube),
..wgpu::TextureViewDescriptor::default()
});
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &bind_group_layout,
let main_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &main_bind_group_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: uniform_buf.as_entire_binding(),
resource: camera_buf.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
@ -421,19 +539,21 @@ impl strafe_client::framework::Example for Skybox {
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
label: None,
label: Some("Camera"),
});
let depth_view = Self::create_depth_texture(config, device);
Skybox {
start_time: Instant::now(),
camera,
physics,
sky_pipeline,
entity_pipeline,
ground_pipeline,
bind_group,
uniform_buf,
entities,
main_bind_group,
camera_buf,
models,
depth_view,
staging_belt: wgpu::util::StagingBelt::new(0x100),
}
@ -480,6 +600,10 @@ impl strafe_client::framework::Example for Skybox {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_JUMP,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_JUMP,
}
(k,winit::event::VirtualKeyCode::Z) => match k {
winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_ZOOM,
winit::event::ElementState::Released => self.camera.controls&=!CONTROL_ZOOM,
}
_ => (),
}
}
@ -488,8 +612,8 @@ impl strafe_client::framework::Example for Skybox {
}
fn move_mouse(&mut self, delta: (f64,f64)) {
self.camera.pitch+=(delta.1/-512.) as f32;
self.camera.yaw+=(delta.0/-512.) as f32;
self.camera.pitch=(self.camera.pitch as f64+delta.1/-2048.) as f32;
self.camera.yaw=(self.camera.yaw as f64+delta.0/-2048.) as f32;
}
fn resize(
@ -509,52 +633,40 @@ impl strafe_client::framework::Example for Skybox {
queue: &wgpu::Queue,
_spawner: &strafe_client::framework::Spawner,
) {
let time = Instant::now();
//physique
let dt=(time-self.camera.time).as_secs_f32();
self.camera.time=time;
let camera_mat=glam::Mat3::from_euler(glam::EulerRot::YXZ,self.camera.yaw,0f32,0f32);
let control_dir=camera_mat*get_control_dir(self.camera.controls&(CONTROL_MOVELEFT|CONTROL_MOVERIGHT|CONTROL_MOVEFORWARD|CONTROL_MOVEBACK));
let d=self.camera.vel.dot(control_dir);
if d<self.camera.mv {
self.camera.vel+=(self.camera.mv-d)*control_dir;
}
self.camera.vel+=self.camera.gravity*dt;
self.camera.pos+=self.camera.vel*dt;
if self.camera.pos.y<0.0{
self.camera.pos.y=0.0;
self.camera.vel.y=0.0;
self.camera.grounded=true;
}
if self.camera.grounded&&(self.camera.controls&CONTROL_JUMP)!=0 {
self.camera.grounded=false;
self.camera.vel+=glam::Vec3::new(0.0,50.0,0.0);
}
if self.camera.grounded {
let applied_friction=self.camera.friction*dt;
if applied_friction*applied_friction<self.camera.vel.length_squared() {
self.camera.vel-=applied_friction*self.camera.vel.normalize();
} else {
self.camera.vel=glam::Vec3::new(0.0,0.0,0.0);
}
}
let control_dir=camera_mat*get_control_dir(self.camera.controls&(CONTROL_MOVELEFT|CONTROL_MOVERIGHT|CONTROL_MOVEFORWARD|CONTROL_MOVEBACK)).normalize_or_zero();
let time=self.start_time.elapsed().as_nanos() as i64;
self.physics.run(time,control_dir,self.camera.controls);
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
// update rotation
let raw_uniforms = self.camera.to_uniform_data();
let camera_uniforms = self.camera.to_uniform_data(self.physics.extrapolate_position(time));
self.staging_belt
.write_buffer(
&mut encoder,
&self.uniform_buf,
&self.camera_buf,
0,
wgpu::BufferSize::new((raw_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
wgpu::BufferSize::new((camera_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
device,
)
.copy_from_slice(bytemuck::cast_slice(&raw_uniforms));
.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
//This code only needs to run when the uniforms change
for model in self.models.iter() {
let model_uniforms = get_transform_uniform_data(&model.transform);
self.staging_belt
.write_buffer(
&mut encoder,
&model.model_buf,//description of where data will be written when command is executed
0,//offset in staging belt?
wgpu::BufferSize::new((model_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
device,
)
.copy_from_slice(bytemuck::cast_slice(&model_uniforms));
}
self.staging_belt.finish();
{
@ -583,15 +695,22 @@ impl strafe_client::framework::Example for Skybox {
}),
});
rpass.set_bind_group(0, &self.bind_group, &[]);
rpass.set_bind_group(0, &self.main_bind_group, &[]);
rpass.set_pipeline(&self.entity_pipeline);
for entity in self.entities.iter() {
rpass.set_vertex_buffer(0, entity.vertex_buf.slice(..));
rpass.draw(0..entity.vertex_count, 0..1);
for model in self.models.iter() {
rpass.set_bind_group(1, &model.bind_group, &[]);
rpass.set_vertex_buffer(0, model.vertex_buf.slice(..));
for entity in model.entities.iter() {
rpass.set_index_buffer(entity.index_buf.slice(..), wgpu::IndexFormat::Uint16);
rpass.draw_indexed(0..entity.index_count, 0, 0..1);
}
}
rpass.set_pipeline(&self.ground_pipeline);
//rpass.set_index_buffer(&[0u16,1,2,1,2,3][..] as wgpu::BufferSlice, wgpu::IndexFormat::Uint16);
//rpass.draw_indexed(0..4, 0, 0..1);
rpass.draw(0..6, 0..1);
rpass.set_pipeline(&self.sky_pipeline);
@ -605,5 +724,9 @@ impl strafe_client::framework::Example for Skybox {
}
fn main() {
strafe_client::framework::run::<Skybox>("Strafe Client v0.1");
strafe_client::framework::run::<Skybox>(
format!("Strafe Client v{}",
env!("CARGO_PKG_VERSION")
).as_str()
);
}

@ -47,13 +47,13 @@ struct GroundOutput {
@vertex
fn vs_ground(@builtin(vertex_index) vertex_index: u32) -> GroundOutput {
// hacky way to draw two triangles that make a square
let tmp1 = (i32(vertex_index)-i32(vertex_index)/3*2) / 2;
let tmp2 = (i32(vertex_index)-i32(vertex_index)/3*2) & 1;
let tmp1 = i32(vertex_index)/2-i32(vertex_index)/3;
let tmp2 = i32(vertex_index)&1;
let pos = vec3<f32>(
f32(tmp1) * 2.0 - 1.0,
0.0,
f32(tmp2) * 2.0 - 1.0
) * 100.0;
) * 160.0;
var result: GroundOutput;
result.pos = pos;
@ -63,19 +63,27 @@ fn vs_ground(@builtin(vertex_index) vertex_index: u32) -> GroundOutput {
struct EntityOutput {
@builtin(position) position: vec4<f32>,
@location(1) normal: vec3<f32>,
@location(1) texture: vec2<f32>,
@location(2) normal: vec3<f32>,
@location(3) view: vec3<f32>,
};
@group(1)
@binding(0)
var<uniform> r_EntityTransform: mat4x4<f32>;
@vertex
fn vs_entity(
@location(0) pos: vec3<f32>,
@location(1) normal: vec3<f32>,
@location(1) texture: vec2<f32>,
@location(2) normal: vec3<f32>,
) -> EntityOutput {
var position: vec4<f32> = r_EntityTransform * vec4<f32>(pos, 1.0);
var result: EntityOutput;
result.normal = normal;
result.view = pos - r_data.cam_pos.xyz;
result.position = r_data.proj * r_data.view * vec4<f32>(pos, 1.0);
result.normal = (r_EntityTransform * vec4<f32>(normal, 0.0)).xyz;
result.texture=texture;
result.view = position.xyz - r_data.cam_pos.xyz;
result.position = r_data.proj * r_data.view * position;
return result;
}
@ -95,14 +103,29 @@ fn fs_sky(vertex: SkyOutput) -> @location(0) vec4<f32> {
fn fs_entity(vertex: EntityOutput) -> @location(0) vec4<f32> {
let incident = normalize(vertex.view);
let normal = normalize(vertex.normal);
let reflected = incident - 2.0 * dot(normal, incident) * normal;
let d = dot(normal, incident);
let reflected = incident - 2.0 * d * normal;
let dir = vec3<f32>(-1.0)+2.0*vec3<f32>(vertex.texture.x,0.0,vertex.texture.y);
let texture_color = textureSample(r_texture, r_sampler, dir).rgb;
let reflected_color = textureSample(r_texture, r_sampler, reflected).rgb;
return vec4<f32>(vec3<f32>(0.1) + 0.5 * reflected_color, 1.0);
return vec4<f32>(mix(vec3<f32>(0.1) + 0.5 * reflected_color,texture_color,1.0-pow(1.0-abs(d),2.0)), 1.0);
}
fn modulo_euclidean (a: f32, b: f32) -> f32 {
var m = a % b;
if (m < 0.0) {
if (b < 0.0) {
m -= b;
} else {
m += b;
}
}
return m;
}
@fragment
fn fs_ground(vertex: GroundOutput) -> @location(0) vec4<f32> {
let dir = vec3<f32>(-1.0)+vec3<f32>(vertex.pos.x/16.%1.0,0.0,vertex.pos.z/16.%1.0)*2.0;
let dir = vec3<f32>(-1.0)+vec3<f32>(modulo_euclidean(vertex.pos.x/16.,1.0),0.0,modulo_euclidean(vertex.pos.z/16.,1.0))*2.0;
return vec4<f32>(textureSample(r_texture, r_sampler, dir).rgb, 1.0);
}

8
src/sweep.rs Normal file

@ -0,0 +1,8 @@
//something that implements body + hitbox + transform can predict collision
impl crate::sweep::PredictCollision for Model {
fn predict_collision(&self,other:&Model) -> Option<crate::event::EventStruct> {
//math!
None
}
}

47
src/timelines.rs Normal file

@ -0,0 +1,47 @@
type ORDER = u32;
pub struct Tracker {
order: ORDER,
}
pub struct TimelineInstruction<I>{
pub order: ORDER,//absolute ordering of instructions which can be used for sorting even when there are multiple simultaneous timestamps
pub instruction: crate::instruction::TimedInstruction<I>,
}
pub struct Timeline<I>{
instructions: std::collections::VecDeque<TimelineInstruction<I>>,
trackers: Vec<Tracker>,//wrong
}
impl<I> Timeline<I>{
pub fn new() -> Self {
Self{
instructions:std::collections::VecDeque::<TimelineInstruction<I>>::new(),
trackers:Vec::<Tracker>::new(),
}
}
pub fn len(&self) -> usize {
return self.instructions.len()
}
pub fn first(&self) -> Option<&TimelineInstruction<I>> {
return self.instructions.get(0)
}
pub fn last(&self) -> Option<&TimelineInstruction<I>> {
return self.instructions.get(self.instructions.len()-1)
}
pub fn append(&mut self,instruction:TimelineInstruction<I>){
let i=self.instructions.len();
self.instructions.push_back(instruction);
for tracker in self.trackers.iter() {
tracker.set_active(true);
}
}
pub fn get_index_after_time(&mut self,time:crate::body::TIME) -> usize{
self.instructions.partition_point(|ins|ins.instruction.time<time)
}
pub fn get_index_after_order(&mut self,order:ORDER) -> usize{
self.instructions.partition_point(|ins|ins.order<order)
}
}