ORIGIN ENGINE

version 0.19.3

First ship is coming up soon! Even tho ive been working on really
exciting stuff, i really would like to focus on actually learning and
having a deep enough understanding of vulkan and other stuff like the
best engine’s architecture before actually logging and building
something open and usable, thats why i feel this is a good place to
finally ship this project as it is and maybe come back to it at some
point

Pre-ship checklist!

• I’ve updated the website! now you have a few new sections with new
  information like the game i build using this engine and other cool
  stuff!

• published a new version to the github releases page (0.19.3 i think),
  with the binaries for the demo game and the sandbox for both windows and
  linux! the web build is still there on the website but it is marked as
  legacy tho

Its been super fun to work on this and ive learnt a lot but i really
really really think i could make something so much better with all the
knowledge i now have and with some serious research, this is pretty much
what ive explained in most of all the previous devlogs (the last 2 or
3)

I’ve been working on applying some of the stuff ive been working on to
the engine, like the new renderer class its now pretty much ported
nicely! ive also tested that everything worked cross platform and yay!
the project is very ready to hold any new game or project you might
wanna do with it, although i might wanna make a quick tutorial on how to
work with the engine on a github repo cuz its not very intuitive

Known issue

I’ve been trying to add support to the engine for builtin shaders but
ive realized that its a super deeper problem than what i was expecting,
id honestly do something like making all the shaders be done with
something like slang and then compile them to spirv without any glsl
intermediary

PD: the video you see is a demo scene you can find at
assets/scenes/physics.scene if you wanna try it by yourself!!!

ORIGIN ENGINE

I’ve finally managed to port enough of the original engine to setup an imgui layer to have this little built-in launcher! it currently only works when using opengl, but its completely supported by both the windowing backends (glfw & sdl3) Its hard to make videos like this on a steamdeck so please like lol.

Other stuff

• I completely restructured the new engine architecture to be a layered system, the engine holds a stack of layers and updates them independently! each layer holds stuff like OnAttach OnLateUpdate OnEvent etc, which is a much better approach compared to what we had before!

• I created a completely new custom file system, as the sandbox and games use completely different files and base directories, you can now mount/dismount different “aliases” for each program, so you can find your assets easily with custom virtual paths like sandbox://settings.json or project://scenes/scene.json

• Literally ported the scene/entity system right from the previous version, but it is a lot smaller currently, because the previous one wasnt really good, we now can load scenes from a file but now those get added to a scene stack, which is a lot more efficient if you wanna load them again!

• Overall the project’s code quality is so much better too!!

After these bases are set im gonna be focusing on getting a full render layer working with at least opengl, even tho the vulkan renderer is already setup…

PD: Origin Zero is just the new “protoype” name i gave it, just like with when i started this project i called it Origin “Zeus” lmao

ORIGIN ENGINE

I’m sorry in advance that these and probably the next few devlogs wont have very exiting things or new and awesome information but sometimes you gotta focus on boring structural stuff that its just not really fun…

The new Project-Based System

• The engine is now very dependent on the sandbox editor, sort of like a symbiotic relationship between the sandbox and your code editor, because thats where you will not only handle your assets but also play the game. The previous version just had the sandbox to be a tiny map editor tool that not even i would use half of the time

• The project (also called environment) then would have its own “environment” literally where all your assets would be included, with very little naming restrictions, this would make working on the project super easy and itd be easy too to use git with it (maybe build a builtin git UI??? it could be cool)

I’ve already built the base for it and I’ve already added support for ImGui only for the OpenGL backend, i was thinking of adding a different UI system but this one will do for now :))

ORIGIN ENGINE

A NEW UPDATE!

I’m building a huge update for the origin engine! it might even be considered a new engine all together. The same philosophy is still there but I’m re-writting and refactoring the base structure of the whole engine. For now this refactor is close source tho, ill publish it once its ready for ship!

What we currently have:

I have the structure already though:

• A new project-based system where all the shader compilation and asset handling is done for each project, this + a simple abstraction layer should allow the sandbox to be a hugely more important tool as you will be able to play your game right in the editor!

• Compile time switch between SDL3 or GLFW for windowing, input is not yet “ported” if you consider it that way

What i wanna add but may be difficult

• Runtime api switching between OpenGL, Vulkan and DirectX3D 11. even tho for now i have a super basic abstraction layer and only opengl is even able to initialize so….. maybe too hard i hope i manage to do it tho
  , was thinking of doing a similar thing for switching between physics engines like bullet3, physicsX or Box3D, this is very much in the future of course

• Project export/ editor previews

This is a major step and im learning a lot!! but its very difficult to handle new stuff like vulkan with other new c++ architectural stuff, hope it goes well

ORIGIN ENGINE

Another update to the best game engine there is that starts with the letter “O” (i think). Today’s devlog is small, bust most likely will be start of a new series of very much needed updates to the engine!. It’s important to note that most of the things ive been working on are not yet finished :((

New stuff!

New things that are completely finished:

• Fix the sandbox UI, it was missing imgui flags from previous bug fixes i had to do because the docking branch of imgui was broken, they fixed it so i just rolled back!

• Cleaned up the rendering class, specially important for the new updates im working on, because im gonna need to do a hell lot of abstraction!

Things im working on

Im taking the current base of the engine to make a new “modular” system just for the love of the game, the most basic thing ive done is to allow the user to choose between SDL3 or GLFW for windowing, although input is currently only handled with SDL3 regardless….

There’s a lot of exiting stuff coming SOON^(TM), hope you like them!! (vulkan?, probably not lmfao)

PD: yes! this is the origin engine running nicely in a steamdeck!!!

JSP!

I’m back! and I finally have a new decent version that im probably gonna ship shortly after I publish this devlog. Its been so long since the last devlog because a number of factors, I had some vacations, my main pc is now just a steam deck connected to a monitor and also I’m kind of struggling to continue this project, I hope this isnt the last version but working on the project and adding or fixing things is very complicated and requires a lot of research to do it right, and it is exhausting

What was added??

• Included the new planet models to the halcyon system, you can now correctly explore them by using the new terrain system I added to the engine!

• Added some small help windows/hints for the new stuff before shipping!

• Fixed some audio bugs and added a sound effect for when you close a window

• Fixed the in-helmet HUD UI, the input vectors now correctly show the direction the thrust is being applied to, kinda like in Outer Wilds!!

I’m most likely to be focusing on continuing the engine for a little bit, it really really does require some refactoring and I also need to clean some likely dead code or at least re-understand the code i wrote as it has lines from almost a 10 months ago!

Hopefully someone could help and contribute to the project maybe or make something new out of it too! Im still planing on continuing to develop it but not at this pace considering im about to start college :))

J.S.P.

Very exciting changes to the exploration mode yay !! I’ve been working on precisely TWO (2) things but one of them is way too early for me to be able to show you anything, more on that in the end

Whats new?

I’ve create a custom blender addon that lets me create procedural noise-based planets! It is really powerful and it gets you really good results for how simple it is really. In a way, its nothing but a vertex shader but coded in python lol

• It generates 3D spherical noise and applies it into an icosphere with a variety of parameters. Some of them arent precisely working but they are fine for now (specially the “ridged” option)

• You can try it yourself, its open source too! https://github.com/aloyak/JSP/blob/main/assets_src/blender/addons/planet_generator.py

Terrain System

I’m developing a way for the player to correctly collide with the geometry of these planets, but this is mostly engine-sided changes and I’m not very deep into it yet. I’m currently researching how to handle multi-threading async functions…

• more information about this in my latest engine’s devlog: https://stardance.hackclub.com/projects/1029/devlogs/34738

Known issues

These are not really important right now, but for some reason I’ve realized that the splash screen takes different amounts of time depending on where you run the game?? what?

• A steam deck is around 3 seconds, my computer (the intended duration) is 4 seconds and in a friend’s laptop it is ~0.5 seconds

ORIGIN ENGINE

Yippi another round of improvements to the best and certainty not over engineered game engine out there! Out of all the things ive been working on with the engine ive only really finished one, but it was rather a big change tho

NEW input system

I’ve added a new action-based input system that handles by itself connected devices (because we now support gamepads!!! ), input modes and preferences, keybinds and settings all in one simple system

• The new system instead of reading “raw” input from SDL3 now instead has a wrapper that sets all input to “actions”. All actions have assigned a certain key/button/axis etc…

• It allows you to use keyboard/mouse and gamepad all at the same time

• Games can now have support for handheld devices like your steamdeck!

Support for precompiled shaders (GLSL -> SPV)

This is still work in progress!! The engine itself supports the compiled GLSL files very quickly but the problem is to get those shaders to compile in the first place

• The shader class gets the relative path for the shader, before actually compiling it, it checks if theres a file with the same name but that ends with “.spv”, in that case it uses that one

• Right now theres not an easy utility script that will handle compilation for you, that needs to be done next!!

Dynamically Chunked Terrain Collisions

Very early and of course WIP, I still haven’t done much but i have a pretty good idea of how this will work: You bake the local position of all the vertex of a terrain model and then, when you require it, you get all the triangles close to the player in real time (with a basic “chunked” system), then Bullet3 generates that mesh collider rather quickly as the mesh is not so big (this will probably require multi-threading ). More on this on the next devlog

Other small changes

• Fixed the sandbox not having docking enabled
• Added ImPlot3D to project, might use it at some point

PD: This picture is from my other project that you should check out! It showcases the new terrain system (WIP)

JSP

We are SO back! I thought it would take me weeks to solve this issue but it wasnt that hard, thanks claude lol for helping. It’s not perfect just yet but its honestly crazy how my own engine managed to handle what im about to explain

What took soo long

• The game now handles a transition from a global physics world to a new extra physics world that lives locally when the player enters a new planet (the origin of the new physics world would be the planet’s center), this means that you can perfectly walk on the surface of all the planets while they move around in the orbits without any weird behaviors

• This took a good amount of engine refactoring and a few changes to some systems (specially the floating origin)

I need to fix a couple things like the drag when you are entering a planet, but that should be handled later on when you actually use a spaceship to enter and not just yourself with your spacesuit

Other stuff that is cool

• Added a helmet overlay! (very inspired by outer wilds, id like some suggestions to make it more original honestly, but right now it decent). It is currently work in progress tho, and theres a lot of information missing…

• Small UI improvements: rounded borders, removed window’s transparency, added window close sound effects (need to find a better one tho), little better controller support…

I just this idea to have vehicles but that will take super long, its added to the ideas file but thats certainty not being considered for short term, Any suggestions are welcome tho

PD: video is very bad res bc i had to compress it unfortunately

BAD APPLE!! (NOW PUBLISHED)

the video is published on youtube!!!!!

Check it out: https://youtu.be/a1_1RXaRt74. Please go like it so it get viral!

What was done?

• I’ve improved the performance by only collecting each window information’s only when they are marked as changed, this improved performance so much that i was able to run some games while using it

• Added a simple command line argument parser for quick settings and path changes

• Ive also added some cool C math optimizations like approximating a division by 255 with a cool bit shift trick! (i felt like a genius programmer)

What needs to be improved

• There’s a couple things that still run in the CPU that could be pretty much moved to the GPU if they cause a bottle neck, maybe in the future??

• Need to make sure that new/closed or resized windows are accounted and properly updated, this is the next step, ive tried already but this adds a lot of lag and i didnt like how it was looking, but maybe now ill try again!

PD: PLEASE go watch the final version: https://youtu.be/a1_1RXaRt74

Btw, im probably gonna be shipping shortly, maybe after next devlog?

BAD APPLE!!

This is the first decent version! I still need to fix a couple things but finally using your computer with this on wont give you an epileptic attack. Note that what you see in the video is very simple, this program i made is a lot more powerful (this is not only for bad apple videos but a general postprocessing realtime layer on your screen!!)

New stuff!

• Completely moved the project from GLFW to SDL3!

• Fixed the feeding loop bug: refactored the capturer so instead of taking a screenshot every frame it now loops with X11’s backend through all the windows and reconstructs the screen buffer manually (this took a lot of docs reading time), the result is really good but has limitations that i will list below

• Appart from the effect you see, ive also coded 2 other shaders that also use this video

• Published the github repo and added both a license and a readme file

Current limitations

• This only works on Linux with X11 backend, if you use wayland, windows or mac this should not work at all, adding support to new platforms would be interesting, but before i need to fix the next issue

• The current system that reads all windows and stitches them together to form a screen buffer doesnt take into consideration new or closed windows and doesnt update their position or resizing… this will probably be the next thing to do but ill have to check how the performances doing.

Of course i will be making a video for youtube to showcase this, this was the main goal of the project either way lmao

BAD APPLE!!

the demo video contains flashing colors!!

Huge progress!!!!! i made this work finally! well not quite yet but ive finally have something to show you Theres still some issues you can clearly see but i do know why this is happening

Why it currently looks broken?

In order to get the screen buffer i need to use X11 (currently, maybe ill port it to use other different APIs) which means that this is pretty much like taking a screenshot every frame but very fast because its the GPU. The problem is that we are re-feeding the previous output to the new one, so it breaks the original colors over time

What have i done

• X11 based system to retrieve the screen’s image and pass it to the shader as another texture!

• Performance was improved a bit although it generally doesnt really matter (maybe it will when using videos over 1080p, havent tried tho)

• Fixed A SINGLE memory leak, woops

Next steps!

Port the project to SDL3, i always start my projects with GLFW and always forget how much i dislike GLFW, it has so many tools and features missing that SDL has, so ill probably port it to it, it shouldnt be very hard

BAD APPLE!!

I’ve been adding the basic OpenGL implementations for a very simple texture and shader “classes” (theres no such thing as a class in C of course). This works kind of like a refresher course for me as I already though I was proficent enough with opengl, maybe once i ship this i might try to re do this but using vulkan instead.

What have i added?

• The shader class, which reads the glsl source files (not pre-compiled) and compiles them in real time, not very fancy right now

• A texture class that updates in real time to what frame was given by the video section, correctly set to linear color correction and uses rgb24

Now i will add a super simple quad implementation where the shader will render to, on top of the screen buffer

What i still need to figure out

I dont think that OpenGL can get the screen buffer with the pixel colors of whats behind the screen, even when the glfw window is entirely transparent, I’ll do some more research to see what to do

I’ve thought that this program might actually be a lot more useful that what im currently making it look. In the end you can quickly change the glsl shader to have completely different results and also upload any kind of video you want…

PD: the window you see in the video is green just so you can see it at all, but in the final version it will be completely transparent

Bad Apple!!

Hey!!! I’m making this quick project that i though would be fun to try and have a bit of a rest from my main project, and i think it started nicely!

What is this project?

I’m making one of those fun version for the original Bad Apple! music videoclip that got viral long ago (original: https://www.youtube.com/watch?v=FtutLA63Cp8). I want it to be very original, at least I dont think it has been done already…

I cant really tell you what the video is about yet, but I can tell you that im building it with pure C and openGL…

What have i done so far?

• Project setup: create a basic cmake project that uses glad and glfw to create a special window and render basic stuff on top of it

• Added a video reader that gets each frame of the video at the correct time based on the time elapsed

I started this project making it run in CUDA, but I had a better idea. Then i decided to go with the graphics programming route: i thought about using vulkan but its way too hard to setup for such a small project, even worse considering im using C, not C++. I will have to learn vulkan at some point tho

note: the video is the base for the whole program

JSP!

I’ve finished porting the game to the new action based input system, its not great yet, theres a lot to polish but at least you can play 80% of the game just as good as with a keyboard/mouse (even better sometimes!)

What’s the new input system?

• The game now asks for “actions” callbacks instead of directly asking for raw input. This new layer in the middle allows to make different devices have their own way to control each actions, so it now supports all the gamepads you probably have: xbox, playstation, steam, nintendo, generic ones too

• It is almost steam deck ready! Ive been playing this game on my steam deck and it works great! (you can get around 900 fps when unrestricted) Playing the game with a controller plus a little help from the little mouse trackpad really makes this game fun to play (100% coverage with this setup)

Now i will finally start doing the boring physics stuff that will hopefully not take so long but idk, we’ll have to see

Other stuff that was added

• Improved a bit the gravity based movement mode, it now adds the atmosphere’s drag gradually depending on its density, being the density higher the closer you are to the surface, this makes entering planets feel better

• Fixed some messed up formatting style in my code

I dont know if start a new project for no more than 2 weeks and then go back, ive been having some cool new ideas but for now ill stick to this project

PD: the picture is an old version (0.12.1), latest version with good controller support is 0.14.0

JSP

Omg i need a break! just one more change bro and i will start doing the hard and boring stuff, just one more i swear! This sums up everything ive done for the past few hours, although the new improvements are actually quite important, i feel like im somewhat rushing them instead of focusing on the exploration mode

New things!!

• Simple LOD system for planets, there wasnt a big performance change, but the model swap is very unnoticeable and nice so thats great!

• Added a simple spoiler warning to the exploration mode, the original idea was that you should unlock it after playing the campaign but i guess its fine lol

• I FIXED THE DEPTH BUFFER PRECISION ISSUE!!!! it was such a small change omg, i just dynamically changed the near plane of the camera based on how far you are to a planet, pretty nice

WIP

• Work in progress: I’m porting the whole game to the new action-based input system so that the game supports controllers natively without any kind of steam layer on top, this is till very early and i still dont know how to make some stuff be fun to use with a controller….

I finish this, finish the two major things on the exploration mode that are 100% gonna be quick, make some decent amount of content for it, add the custom spaceship controller and launch system, make the first ~5 minutes of the campaign mode, and then SHIP THIS PROJECT (this will surely go as planned)

PD: the video u see is completely controlled with my gamepad, not the best controls yet but its better than nothing!

JSP

Worked on so many things before getting started with the complicated stuff, ill tell more about that in the bottom section, but for now, im pretty happy with what ive just added, even tho progress is pretty slow!!!

What have i added?

• Full/complete atmospheric effect, it now not only looks good from outside, now from the inside too!!! Its a small trick but when the camera gets close enough to a planet, its atmosphere’s density scales up making the sky blue like here on earth or greatly improving the sunrises and sunsets, they do look beatiful

• Added floating origin: double precision was not enough so ive added a system that teleports all the entities in the scene when the player gets too far from the origin, this works surprisingly good and it was very simple to do, hopefully it wont break physics later on, but so far its great! This allows the solar system to go from ~10000 units wide to over ~3000000!! that is great! This was a engine-level change mostly tho

• You can finally use the planets you discover in the campaign mode in the sandbox mode

• Dynamic settings!!! I made it so that when you first load into the game, the UI scales to your resolution and your target fps are set to your monitor’s refresh rate, might not look like something important but this is actually HUGE

Whats cooking up currently!

• Need a system to allow the player to be placed on top of moving planets (it currently works but breaks sometimes), and also to allow those planets to rotate. This will be achieved with a completely new physics world that will live localy on the closest planet the player is to

• Chunked mesh collider system i really dont know how to this, because of the terrain of my planets (TODO), collisions will be complicated to calculate, if you know about anything that could help, please send it!!!

PD: I wish i could spend more time actually coding than thinking, if that were to be the case id have 300 hours+ in this project already