Git Product home page Git Product logo

gear's Introduction

Hi there 👋

benny-n's GitHub Stats

gear's People

Contributors

benny-n avatar grishatsuker avatar iliafeldgun avatar orenkoren avatar

Watchers

 avatar  avatar  avatar

gear's Issues

Create code base

At the beginning, the project tree should look close to this:

gear
___| src
_____|MathEngine
_____|PhysicsEngine
_____|RenderingEngine
_____|ECS //or Entity, Component, System as seperate folders, also a possibility

We can start with creating this tree and filling the folders with dummy modules with meaninful names but no functionality yet (maybe consider writing functions with panic!("Not implemented");)

Investigate OpenGL

Learn OpenGL's API and experiment with very small, basic rendering tasks

Physics Engine

As of now, it is not clear for me wether a physics engine is something that can be implemented (even in a very simple way) this early. Personally, I think that the physics engine can be a very good candidate for a module that we can import externally and wrap (by using one or more of the physics crates mentioned in the README, for example), instead of implementing it from scratch.
Please offer your opinions and ideas regarding this matter.
Also, any insights about physics engines in general are extremely valued.

Implement a basic Math Engine

The math engine should contain 2 modules (for now):
Vectors and Matrices.

Vector operations:

  • Vector addition & subtraction: Allows a character to move
  • Dot Product: Determines how much a vector influences another
  • Cross Product: Allows for the creation of a third vector

Matrix operations:

  • Transformation
  • Transpose
  • Inverse
  • Identity

The transformation operation allows a character to rotate.

Math engine related references can be found in the README file.

Naïve skeleton example:

struct Vector{
  x: i64,
  y: i64,
  z: i64,
}
impl Vector{
  fn add(&self,  other : &Vector){
    panic!("Not implemented!");
  }
}

CI pipeline and development branch

Do we maintain a development branch and everyone pushes changes to it or do we open a branch per issue? Maybe something in the middle?
Also, should we add some sort of CI pipeline?
Please share your ideas regarding these questions

Implementing a simple ECS architecture

Creating a simple ECS architecture should be our main concern right now.
This is the core of the game engine.
in TL;DR terms, if we oversimplify it (and we definitely will at the beginning) then it all comes down to:

  • Entities - generic objects with a unique ID.
  • Components - raw data.
  • Systems - functions.

This guide -> https://www.david-colson.com/2020/02/09/making-a-simple-ecs.html
shows how a simple ECS should look like, and gives a lot of code examples in C++.
A good start would be to follow this guide and re-implement some of its examples in Rust.
Naïve skeleton example:

struct Entity<T>{
    id : u64,
}
impl Entity<T>{
    fn get_id(&self) -> u64{
        self.id
    }
}

Side note: this issue is also marked as research because much more investigation is required. Any useful information and insights regarding ECS would be extremely valued.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.