Handmade Network»VoxelRifts

Recent Activity

A lot of time later, I finally have a hello world program running on my NDS (8x8 Bitmap font)
The program is 142 lines of code total.
Now that I think about it, this should probably be a project for the hmn website, but probably too late now

Finally got something visual to show for the project I've been working on for the past three to four months.

  • Custom language compiling to arm assembly
  • Packed in a .nds file getting loaded on an nds emulator (As well as my DSi)
  • Displaying a blue screen via a bitmap

Finally finished (At least for now) my mini-compiler frontend. https://github.com/PixelRifts/mini-frontend
Took 2 months, we'll see if it was worth it.

Goal of this project was NOT to make yet another language, it was to make a compiler frontend so that I can dive into compiler backends. I'm excited for that to be honest, much of this was just elbow grease, which I am glad to be done with (cough typechecker cough)

Been working on a game/video project for the past month or so. Pretty close to completing a VERY rough demo

Been working on my SoME#3 entry for the past two months and it's finally out now!
It's about the basics of lexing parsing and evaluating mathematical expressions.
https://www.youtube.com/watch?v=myZcNjKcVGw

Made a working Chip-8 emulator
(running the glitch ghost game)

Been working on supporting Linux for my c codebase.
Same Code, different OS-es and graphics api backends, but all of them get same outputs!

I made a video about my two year long journey of using C for various projects!
https://youtu.be/lMvFWKHhVZ0

Been working on my C-Codebase.
It now has swappable backends. Just define a macro and it'll switch the underlying implementations of functions.
So for a demo, I rendered a multicolored triangle with the 3 backends I have implemented currently: OpenGL 3.3, OpenGL 4.6 and D3D11

(You won't see a difference between the 3 multicolored triangles, which is good for my codebase but bad for the demo :kekw:)
Repository: https://github.com/PixelRifts/c-codebase

I've made a repository for a very simple C OpenGL renderer API.
It looks this simple to use:

Render_Begin_Frame(&renderer);
Render_Push_Quad_T(&renderer, rect_init(400, 400, 100, 100), Color_Magenta, white_texture);
Render_Push_String(&renderer, &inconsolata_font, str_lit("Text Rendering!"), vec2_init(500, 100), Color_Yellow);
Render_End_Frame(&renderer);

It fits in precisely 300 Lines of code, and is super easy to extend
https://github.com/PixelRifts/easy-renderer
For a nice demo: I made a little tetris clone... so enjoy my terrible gameplay 😛

&multiedit Just to see how easy it is to convert anything to a multiedit plugin, I ported my old solid state visualizer into a plugin.
Also showcases you can do literally anything with plugins here.

&multiedit a basic particle system plugin in 183 LOC. Yes it's very barebones, but it works!

&multiedit Multiple plugins and Window resizing done. key events, mouse button events and resize events are now accessible through plugins
Now for the fun part (Trying to make a particle system editor as a demonstration)

&multiedit Quite a bit of progress since yesterday, added proper plugins and rendering via them is super easy

&multiedit Had to rescope a bit, panels were causing quite a pain for rendering for plugins. so wasted a day on that.
In other news, I got the file explorer bit working today, with queries!

&multiedit Got basic panels working. Should be easy to attach plugins to them which is the next step

Me and my friend made this game for SoME#2 (Math exposition "competition" by 3blue1brown)
https://voxelrifts.itch.io/graphit

Made a little visualization application for solid state geometry using C/OpenGL

https://github.com/PixelRifts/Rift I've been working on a C-Like Language for the past few months. It aims to be C but a few improvements to it that I would like to have. I'm by no means an expert in making programming languages, rather this was my first actual language that wasn't off a tutorial or book.

Its features:

  • A lot of stuff carried over from C
  • Nested Comment blocks
  • A better syntax for function pointers
  • Lambdas
  • Function overloading and Late-Binding
  • Match-Case statements (so people like me who forget writing breaks after switch cases. don't have to)
  • Operator overloading
  • Namespaces (Like C++)
  • Simple References (Like C++)
  • A Tags system that replaces #define and #ifdef/#ifndef
  • Namespaced Enums
  • Flag Enums (for nicer bitfield declarations)
  • Imports and "Modules"
  • Transpiles to a single c file. You can check the examples folder in the github repo. it has examples for everything in this list that C doesn't have.

For a "demo" I got a triangle up and running with OpenGL in it (with some simple "native" declarations for functions from glad and glfw)