https://github.com/bsgbryan/roc
A thoroughly-modern real-time simulation engine
https://github.com/bsgbryan/roc
assemblyscript bun entity-component-system game-dev game-development game-engine gamedev simd simd-instructions simd-intrinsics simd-programming simulation typescript webassembly webgpu
Last synced: 17 days ago
JSON representation
A thoroughly-modern real-time simulation engine
- Host: GitHub
- URL: https://github.com/bsgbryan/roc
- Owner: bsgbryan
- Created: 2023-10-02T17:35:45.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2024-08-18T18:19:45.000Z (8 months ago)
- Last Synced: 2025-02-10T03:45:50.877Z (2 months ago)
- Topics: assemblyscript, bun, entity-component-system, game-dev, game-development, game-engine, gamedev, simd, simd-instructions, simd-intrinsics, simd-programming, simulation, typescript, webassembly, webgpu
- Language: TypeScript
- Homepage:
- Size: 326 KB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- awesome - bsgbryan/roc - A thoroughly-modern real-time simulation engine (TypeScript)
README
# Roc welcomes you 😊
Roc is a thoroughly-modern real-time game engine.
What does that mean?
1. Roc is easy to get along with:
_Modern tools and technologies like [Bun](https://bun.sh/), [TypeScript](https://www.typescriptlang.org/), [AssemblyScript](https://www.assemblyscript.org/), [WebAssembly](https://webassembly.org/), [SIMD](https://github.com/WebAssembly/simd), and [WebGPU](https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API) enable Roc to be simple to use & work with while also being incredibly efficient_
1. Roc is smol:
_A long-standing axiom in development is "Smaller things are easier to understand, change, and fix"; Roc follows this axiom by using lots of little pieces, each focused on doing a single thing, to construct nuanced behavior_
1. Roc has strong opinions:
_"Simple" and "flexible" are, often, antithetical; whenever this is the case, Roc simplifies things for you and I by making an opinionated decision - meaning that there absolutely is an "Roc's Way"_
# Roc's Parts
* **[Athenaeum](./src/Athenaeum):** A colleciton of super-useful things
* **[Benzaiten](./src/Benzaiten):** Generates procedural meshes
* **[Eunomia](./src/Eunomia):** Just a little thing that keeps the engine in good running order
* **[Finesse](./src/Finesse):** Flexible, sensible, shockingly-adept input handling
* **[Kali](./src/Kali):** A tiny tool that makes scaling time in the engine as easy as a single method call
* **[Legion](./src/Legion):** An implementation of the [ECS](https://en.wikipedia.org/wiki/Entity_component_system) design pattern
* **[Sunya](./src/Sunya)** A library of helpful mathmatical functions for 3D data structures
* **Strata:** UI tooling. It's all of Roc's buttons, switches, dialogs, and stuff
* **[Xenon](./src/Xenon):** A blisteringly-fast, elegant rendering engine
* **[Yggdrasil](./src/Yggdrasil):** Manages all the FidelityTrees; ensuring the engine is always running at peak perfomance, while hitting the [frame rate](https://www.ign.com/articles/2014/11/05/understanding-frame-rate-and-its-importance) target you specify
# Goals
* **Simplicity:** Using the various pieces of Roc should be straightforward and require very little upfront work
* **Composability:** Roc's pieces should be organized such that using them together is unambiguous and intuitive
* **Efficiency:** Roc strives to make the best use of available resources; including our time as developers/designers
It's important to note that flexibility is _not_ one of Roc's goals. Roc is not intended to render 2D graphics, for example. It is also not designed or intended to load static 3D assets generated using external tools. I understand this will be frustrating and feels limiting. Roc is intended to generate and simulate things. It is also intended to be as self-contained as possible.
# A Personal Note
This is all new to me 😊
I've been a hobbyist game developer for several years, but this is my first time attempting to create my own simulation/game engine. I'm going to make mistakes, bad calls, and change my mind about things - when I learn something I thought was a great idea won't, in fact, work. This already happened, actually; I originally thought Roc could do all instanced *and* indexed rendering. I found out the hard way that that isn't really feasible in the context of purely runtime-generated meshes 😅 I'm sure there will be more situations like that - so if you read design goal or decision and think to yourself "That will *not* work" I'll likely realize that shortly too 👍🏻