A modular game engine written in Rust
pistondevelopers / piston Goto Github PK
View Code? Open in Web Editor NEWA modular game engine written in Rust
Home Page: https://www.piston.rs
License: MIT License
A modular game engine written in Rust
Home Page: https://www.piston.rs
License: MIT License
A modular game engine written in Rust
What are the default settings?
At the moment, when the user presses Esc
or closes the window, the application does not know the program is being closes and can not resolve from a critical state.
This would simplify the installing for new users.
Then the user does not need to implement all of them.
One object to access all the game sounds, textures, animations etc.
This could provide a very simple interface that hides the complexity of file formats, packing, loading and playing various formats.
Because there is one container for all the assets, one can build higher abstractions reuses the same textures.
Found one error in the documentation. There could be more...
Replay a recorded session of user input as fast as possible.
Can copy from Rust-Snake.
Mouse button + mouse position will suffice.
Needed in order to have consistent physics.
This makes it possible for people to see the test project for Piston.
Just to get textures working without introducing a new dependency.
How this should be organized can be solved later.
I assume all PNG images uses the alpha channel for now.
To make it easier to find it in the code.
http://www.youtube.com/watch?v=k4PVSIShRgM
This is to avoid confusion of which imports are required.
This will allow rendering with a single texture.
Use the one from rust-snake
Because GameSettings
is too generic.
This is to avoid collision with other structured named Settings
in the same app.
When programming games, you often need to fine adjust lot of settings.
It is painful to having to recompile and restart the application for every change.
Is it possible to make this easier and more responsive?
VERTEX_SHADER_TRI_LIST_XY_RGBA_UV
FRAGMENT_SHADER_TRI_LIST_XY_RGBA_UV
Got some problems with borrowing the self as mutable.
The Context
trait in graphics::Context
collides with glfw::Context
.
To solve this, the glfw::Context
can be imported locally were it is used.
Some images that loads RGBA might not use their alpha channel.
extern crate piston;
use piston::*;
fn main() {
...
}
There is a function shader_utils.rs
which does not long belong there. Move it to gl.rs
as part of the implementation.
The Rust-Graphics context has a field base
which could be set to the window coordinates.
Maybe rendering should start in these coordinates?
To make it consistent with the name.
https://github.com/Morgawr/Cloister-Engine/blob/master/src/cloister/physics.clj
fn load_image(name: &str) -> graphics::Image;
Sets up an OpenGL texture which can be used with the Gl back-end for Rust-Graphics.
Allows control over the transformation.
The application does not have to initialize it's own OpenGL context.
The idea is to separate AssetStore
from the app implementing Game
and having Gl
borrow a pointer to it (this could be mutable).
The AssetStore
will not be available under rendering but it will under update
and load
and other events.
Separating the AssetStore
from the application makes it easier to do custom setup like with the window.
It is painful to import everything from separate modules.
Would like to use glob imports.
Make rust-snake use Piston instead of having both library and executable.
Could compute the FPS with floating average and pass it to RenderArgs
.
GameWindow
needs to be created separately from the Game
.
It seems a bit weird to store the game window settings per application.
Game window settings can be stored in the GameWindow
struct.
This is ok since one doesn't need to mutate the application under rendering.
However, it might be a problem with the lifetime.
Perhaps there is a way to work around it.
The back-end should support semi transparent drawing of vector graphics.
On mobile devices an application needs to be able to store the application state and restore it. There should probably be a mechanism for this.
Use make symlink-info
to generate the .symlink-info
file.
Using an existing library in pure Rust?
This is useful for things like editing text.
The latest version contains symlink support, which makes it easier to figure out how to build it.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.