blackphlox / bevy_dolly Goto Github PK

View Code? Open in Web Editor NEW

126.0 126.0 22.0 9.94 MB

h3r2tic's dolly abstraction layer for the bevy game framework

License: Apache License 2.0

Rust 100.00%

bevy camera rust

bevy_dolly's Introduction

Stats 📊 :

Specs 🖥 :

       Processor: AMD Ryzen 7 5800X 8-Core Processor (16 CPUs), ~3.8GHz
   System Memory: 65536MB RAM DDR4 3600Mhz           
   Graphics Card: NVIDIA GeForce RTX 4070
Dedicated Memory: 12288 MB

Game Jams 🍯 :

Participated - GMTK 2019
Organizing/Hosted & Participated - Level One Jam 2020 - itch.io
Organizing/Hosting - Level One Jam 2022

Hackathon ⚡ :

ITU Creative Coding, Developed a Co-op Mine Detector Game

Projects 🛠 :

See a project you like? Star the repo to increase the chances for me to continue or expand development of said repo.

Click here to show all projects

Bevy Plugins

bevy_config_cam 📹🔧

Plugin containing a suite of configurable cameras

bevy_midi 🎹🎶

Plugin for sending and reciving midi data

bevy_osc 🔣🔢

Plugin for sending and reciving osc data

Potoo 👻🐦

An experimental editor for Bevy

Level One Jam

Level One Jam 2020 & 2022 Website - written using HUGO and Bulma, backend made using JavaScript and Google Sheets API.

Level One Jam Video - made using Adobe After Effects, thanks to @myhairis_blue for the amazing VO.

Level One Jam Lottery - written in Javascript using P5.js and WebGL elements, backend in Dark.

Level One Jam Discord Bot - Achievement Manager - written in Node.js

CryptoGuard

Developed CryptoGuard for Cryptera. SAAS that allows their customers to do secure provisioning remotely as a service without requiring IoT devices to be transported to get firmware loaded.

Logic F Day

Implementing Logic Friday functionailty in a functional language.

CookieMonster

Cross site scripting(XSS) cookie-fetch server, used for educational perpose only. Made using Node.js, P5.js and Matter.js Demo

AsciiEngine 2.5D Topdown Game Engine using Processing and Box2D

Configurations

Below is my configuration for my laptop running WSL. Using X-Server and some enviroment variable configuration, I'm able to startup a linux instance using a single command:

Honeypot system running Debian on a headless server using Digital Ocean Because we had limited storage, continuously serializing the data from a database to CSharp to process the large amount of data for mapping and relation. D3.js to visualize the data and made interactive using Observable.

bevy_dolly's People

Contributors

Stargazers

Watchers

bevy_dolly's Issues

Use new overhauled `bevy_config_cam` as helper functions for examples

leafwing_input_manager
- CursorGrab
- PosCtrl
- Cone?

Start with impl. here and move helpers to bevy_config_cam for more ergonomic example support

bevy main branch

Just found this repo, looking forward to using it.

Thoughts on a bevy main branch? Created a fork that works with main currently.

Notes:

Had to add a wrapper to CameraRig for Component unless I am missing something.
Updated QuerySets, some were not filtered and returning the With<?>, I realize it has no effect really, was it there for reason?

The query state changes lead to code like this, is there a cleaner way to handle E0716

    let mut q2 = query.q2();
    let mut rig = q2.single_mut();
    rig.0.driver_mut.....

Derive Reflect for Rig and the drivers, then place them into type registry

This improves runtime debugging, since reflection is not available for these types right now:

(Screenshot shows bevy_editor_pls)

Use ScanCodes instead of KeyCodes

This is essential for people not using QWERTY keyboard layouts.
Blocked by Leafwing-Studios/leafwing-input-manager#312
I can implement this whenever the next LWIM is released :)

Examples are broken

Getting the following when running fpv on main:

The other examples report similar errors.

Make Rig builder follow Bevy's current paradigm of passing tuples

As Bevy changed the API for bundle and system (and soon plugin) adding to accept tuples instead of multiple calls to a builder function, I think we should follow suit:

Rig::builder()
    .with(Position::new(Vec3::ZERO))
    .with(YawPitch::new().yaw_degrees(45.0).pitch_degrees(-30.0))
    .with(Smooth::new_position(0.3))
    .with(Smooth::new_rotation(0.3))
    .with(Arm::new(Vec3::Z * 4.0))
    .build()

becomes

Rig::builder()
    .with((
		Position::new(Vec3::ZERO),
        YawPitch::new().yaw_degrees(45.0).pitch_degrees(-30.0),
        Smooth::new_position(0.3),
        Smooth::new_rotation(0.3),
        Arm::new(Vec3::Z * 4.0)
	))
    .build()

Change all "2" functionality to From impls

By this I mean functions like transform_2_bevy. Because the numbers 2 and 3 have significant connotations in glam (and by extent Bevy) with the dimensionality, I was confused about this function. The rust ecosystem already provides a trait for exactly this kind of conversion, namely From and the automatically implemented To, so I suggest we use this instead. If you are fine with this change, I volunteer to implement it and setup a PR :)

Update to Bevy 0.10

Seeing as Bevy 0.10 is about to be released, I thought it's time to put this in the room 🙂

Reflect: Serialize and Deserialize rigs

`bevy_pbr` is brought in even if `helpers` is not enabled.

Pretty sure bevy_pbr is only needed for helpers, but bevy_dolly uses it unconditionally, forcing 2d-only dependants to compile a bunch of 3d stuff.

bevy_0.12: crate does not compile without helpers feature

error[E0433]: failed to resolve: could not find `helpers` in the crate root
  --> /Users/me/.cargo/git/checkouts/bevy_dolly-ae7dd05587c8a08d/dcd1f44/src/lib.rs:16:9
   |
16 |         helpers::{cone::*, cursor_grab::*, pos_ctrl::*},
   |         ^^^^^^^ could not find `helpers` in the crate root

error[E0432]: unresolved import `crate::helpers`
  --> /Users/me/.cargo/git/checkouts/bevy_dolly-ae7dd05587c8a08d/dcd1f44/src/lib.rs:15:9
   |
15 |         helpers::*,
   |         ^^^^^^^ could not find `helpers` in the crate root

Also, does not compile with the helpers feature.

error[E0599]: no method named `iter` found for reference `&MoveAction` in the current scope
   --> /Users/me/.cargo/git/checkouts/bevy_dolly-ae7dd05587c8a08d/dcd1f44/src/helpers/pos_ctrl.rs:127:29
    |
127 |             for (i, b) in v.iter().enumerate() {
    |                             ^^^^ method not found in `&MoveAction`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following traits define an item `iter`, perhaps you need to implement one of them:
            candidate #1: `Walker`
            candidate #2: `bevy::reflect::Array`
            candidate #3: `bevy::reflect::List`
            candidate #4: `bevy::reflect::Map`
            candidate #5: `bitflags::traits::Flags`
            candidate #6: `sysinfo::traits::NetworksExt`

error[E0599]: no method named `len` found for reference `&MoveAction` in the current scope
   --> /Users/me/.cargo/git/checkouts/bevy_dolly-ae7dd05587c8a08d/dcd1f44/src/helpers/pos_ctrl.rs:145:22
    |
145 |                 if v.len() > 1 && i != v.len() - 1 {
    |                      ^^^ method not found in `&MoveAction`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following traits define an item `len`, perhaps you need to implement one of them:
            candidate #1: `ExactSizeIterator`
            candidate #2: `bevy::reflect::Array`
            candidate #3: `bevy::reflect::List`
            candidate #4: `bevy::reflect::Map`
            candidate #5: `BufferRef`
            candidate #6: `RuntimeSizedArray`
            candidate #7: `core_graphics::data_provider::CustomData`

error[E0599]: no method named `len` found for reference `&MoveAction` in the current scope
   --> /Users/me/.cargo/git/checkouts/bevy_dolly-ae7dd05587c8a08d/dcd1f44/src/helpers/pos_ctrl.rs:145:42
    |
145 |                 if v.len() > 1 && i != v.len() - 1 {
    |                                          ^^^ method not found in `&MoveAction`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following traits define an item `len`, perhaps you need to implement one of them:
            candidate #1: `ExactSizeIterator`
            candidate #2: `bevy::reflect::Array`
            candidate #3: `bevy::reflect::List`
            candidate #4: `bevy::reflect::Map`
            candidate #5: `BufferRef`
            candidate #6: `RuntimeSizedArray`
            candidate #7: `core_graphics::data_provider::CustomData`

error[E0599]: no method named `len` found for reference `&MoveAction` in the current scope
   --> /Users/me/.cargo/git/checkouts/bevy_dolly-ae7dd05587c8a08d/dcd1f44/src/helpers/pos_ctrl.rs:149:27
    |
149 |                 if i == v.len() - 1 {
    |                           ^^^ method not found in `&MoveAction`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following traits define an item `len`, perhaps you need to implement one of them:
            candidate #1: `ExactSizeIterator`
            candidate #2: `bevy::reflect::Array`
            candidate #3: `bevy::reflect::List`
            candidate #4: `bevy::reflect::Map`
            candidate #5: `BufferRef`
            candidate #6: `RuntimeSizedArray`
            candidate #7: `core_graphics::data_provider::CustomData`

Use same entity for rig and camera

It seems to me that the following kind of code...

    commands.spawn((
        MainCamera,
        Rig::builder()
            .with(Fpv::from_position_target(transform))
            .build(),
    ));

    commands.spawn((
        MainCamera,
        Camera3dBundle {
            transform,
            ..default()
        },
    ));

...could be more easily written as

    commands.spawn((
        MainCamera,
        Rig::builder()
            .with(Fpv::from_position_target(transform))
            .build(),
        Camera3dBundle {
            transform,
            ..default()
        },
    ));

From a quick check, it seems like the examples behave the same way, although this was not an extensive test.
I assume that the design decision of not requiring this in the first place is to mix and match rigs and cameras, right?

Use generic system or system param for ergonomic rig lookup

Generic System:

//App
.add_system(dolly_update_system::<MyRig>)

//Setup
commands
        .spawn()
      //.insert(Some Transform)
        .insert(Rig::builder(/*...*/))
        .insert(MyRig);

//Generic System
fn dolly_update_system<T: Component>(mut query: Query<Rig, With<T>>) {
    for rig in query.iter() {
        rig.update()
    }
}

System Param:

//WIP

#[derive(SystemParam)]
struct CameraUpdater<'w, 's> {
    players: Query<'w, 's, &'static Player>,
    count: ResMut<'w, PlayerCount>,
}

impl<'w, 's> CameraUpdater<'w, 's> {
    fn update(&mut self) {
		self.update()
    }
}

/// The [`SystemParam`] can be used directly in a system argument.
fn update_camera(mut query: Query<Transform, With<Camera3D>>, mut cam_updater: CameraUpdater) {
    let t = cam_updater.update();
	for cams in query.iter() {
        cams = t;
    }
}