Published by Jady on 5/18/24, 6:49 PM
The "make a game > make a game engine > make a programming language" pipeline is strong. Here's what I've done
in Cetus Script so far!
extern Void printf(String format, Int... values)
struct Foo
{
Int a
Int b
}
Void main()
{
Foo foo = New
foo.a = 2
printf("Starting at %i\n", foo.a)
While (foo.a < 6)
{
foo.a = foo.a + 1
printf("Loop %i\n", foo.a)
}
printf("Ending at %i\n", foo.a)
Return
}
The first really big feature of Cetus has already been implemented, at least compiler-side. Every single statement
in main is a function! Foo foo = New is secretly just Declare(Foo, foo).
foo.a = 2 is secretly Assign(Get(foo, a), 2). These functions just have patterns
associated with them that let them be used more fluently. Patterns will also eventually be able to be used for types
as well, so you can say Foo? instead of Option.
Another interesting feature is that pointers are handled automatically! foo.a returns Int*
when used in Assign, but it also returns Int when used in printf! You don't
get to handle reference and dereference pointers manually, but it can figure out what's usable on it's own.
Other quirks of the language include using PascalCase for things that public and camelCase for things that are
private, whitespace means nothing and semicolons are optional, etc.
The next thing I'm trying to work on is something like rust's traits, but also allows you to define fields in trait
objects, which you can't do with rust. Other planned features are things like properties being automatic type
definitions instead of just functions.
Published by Jady on 5/6/24, 4:12 PM
When I ended the stream half the text too big or too small or out of place. Turns out I never considered scale when
calculating minimum size! so text size and bounds are fixed now. Here's the grayboxed version of the "Add Component"
window, which is the main tool that will allow users to connect components together into prefabs.
Published by Jady on 5/1/24, 2:54 PM
I've been mainly working on the Echidna Engine editor. Currently everything is very grayboxed, but slowly but surely
we're adding features that will make development way more streamlined than Unity or Godot! One of these features is
"favorite fields", so you have a place to put all your most important data so the display doesn't get all clogged
up!
Published by Jady on 1/30/24, 12:59 PM
If you've been hanging around the server lately, you might've noticed a new SBEPIS channel: Echidna Engine. Echidna
is going to be our in-house engine that SBEPIS will be moved to, off of Unity. I've been struggling a lot with how
Unity's systems operate, between its limited layer and tag systems, its inaccessibility for planetary geometry, and
just how dang slow it is, especially with their physics system. So over the past couple weeks I've been
writing my own game engine from scratch in C# using OpenGL and BepuPhysics, and we're calling it Echidna after the
Denizen of Space.
The primary immediate improvement over Unity is its speed. Unity only runs the majority of its code on one thread at
a time, because it uses Component architecture, which means that entities contains components that do things.
The only place Unity can use multiple threads at once is through its job system, which has Entity Component
System (or ECS) architecture, where entities have components that don't do anything, but the world
contains systems that can run on many components at once. Echidna fully uses ECS architecture to take full
advantage of multithreading, and this can be applied to any system that needs it. The entire engine code only uses 4
files, World, Entity, Component, and System. Everything else is
just sticking components on entities adding systems to the world.
If you're interested in poking through an ECS game engine, all the code is Free and Open Source on my GitHub.
Published by Jady on 5/17/23, 5:34 PM
We have these fancy new outlines now! They appear when an object is still in the process of being captured.
I've been suffering most of the day trying to write my own renderer features, but then I found out that
everything I want to do is actually way easier in the current version of unity than all the old tutorials
I was using. You can just make a shader that runs on the finished image when a camera finishes rendering.
If found a tutorial for this outline shader that takes the difference between the depth of a pixel and the depth
of the surrounding pixels, which gives you an outline. I made a second camera that's parented to the main camera
that uses a separate renderer asset with the new shader on it (set to a specific outlines layer), then hooked that
up to a texture that I load onto the main camera through another shader on the main renderer asset when the game
starts.
Here are those shaders, the outline and the texture overlay. Thanks to Game Dev Guide and this video or the outline shader, although the rest of
the video uses the old bad built-in Unity renderer.
