First parts before closing #5

Features to implement before merging this PR into main

• [x] Keep track of entities
• [x] Store components
• [x] Query for (multiple) components
• [x] Iterate over all entities matching a query
• [x] Resources

Closes #1, #2 This is the first official commit to the project where I added the base crates for the rust development process and GitHub Workflows folder with a base action to check the rust code.

If you have any ideas or opinions, please share them.

Depends on #37

Integrates the ECS with the physics.

The way it currently works is that game_engine::physics_systems::update takes a &mut ecs::World and runs a physics step on all entities with a common::Transform, physics::Rigidbody, and optionally physics::Collider. It also looks for a physics::Gravity and game_engine::Time as a resource.

(Depends on #28)

Add functionality to query for all combinations of tuples of entities.

For example: given the entities A, B, and C, yield (A, B), (A, C), (B, C), allowing for mutable access to them.

I ඞpect this will be needed before integrating the ECS with the physics

Add a way to buffer some actions to be performed on the World at a later stage when possible.

This will make it possible to for example remove certain entities while looping over them.

Todo:

• [x] Command to spawn & despawn entities
• [x] Command to add components to entities
• [x] Add a way to add components to newly spawned entities
• [x] Add a way to get a handle to the new Entity being spawned

This PR partially covers the second part of #5

• [x] Some way of getting access to components in a type safe way from Rust.
• [x] Optionally get handle to Entity with query

Add support for specifying queries that match even entities that don't have a given component, but still get access to it if it does.

Current syntax looks like this:

query_iter!(world, (a: A, b: Option<B>) => {
    // a: &A
    // b: Option<&B>
});
query_iter!(world, (a: mut Option<A>) => {
    // a: Option<&mut A>
});

This PR partially covers the second part of #5

• [x] Some way of getting access to components in a type safe way from Rust.
• [x] Optionally get handle to Entity with query

• Added Phong shading (or at least the ambient/diffuse components of it) using vertex normals.
• Added deferred rendering and proper point light support (with light volumes)
• Added support for a UI-controlled viewport
• Modified Renderer to compartmentalize the actual drawing into its own World struct that can be duplicated etc.
• Changed the ModelManager to instead be effectively a writable "guard" for the backing GPU-buffers, so that on drop all pending changes are automatically flushed to the GPU.
• Fixed a bug where vertex/index buffers were overwritten with new data before the draws were actually performed, resulting in the final draw using vastly wrong vertex and index data.

Closes #18 Closes #30

We could maybe split up workflows so that everything is not in the same file.

Originally posted by @ollisco in https://github.com/inda21plusplus/Project-Delta/issues/17#issuecomment-1069448881

The engine needs a somewhat robust asset management system to allow for streamlined loading/unloading, also to make the rendering inputs easier to handle for the user (i.e. the IDE), exact specifications TBD

I think using webassembly as a target for the scripting language and running it with wasmtime is a nice way to go about it.

They have a short tutorial here https://docs.wasmtime.dev/lang-rust.html and it seems quite nice to use.

Using webassembly would keep the door open to script a game using most modern low-level languages (and then some) while also allowing us to create an own scripting language if we wish (and have the time).

Simple Physics, including:

• Position
• Velocity
• Acceleration
• Colisions (Elastic and inelastic)

Features to implement before merging #25 into main

• [x] Sphere - Sphere
• [x] Box - Sphere
• [x] Box - Box

Features to add later

• [x] Raycast sphere
• [x] Raycast box
• [x] Friction
• [x] Angular velocity
• [x] ECS integration

Features that would be nice to have

• [ ] Convex mesh colliders
• [ ] Concave mesh colliders