#wolf engine

Wolf v2.4 released

Added the ability to build under CI for Windows. This caused some renames of libraries, due to windows's low MAX_PATH, and caused tags all the way down the stack.

Massive improvements to DI support. Can now construct objects via activation, which provides services automatically.

Start of redoing how Stage components work, allowing them to automatically be able to get and provide services. Will require minimal changes - pay attention to deprecation warnings.

WolfMixerStage: The ability to create a component which will manage the mixer for you, and provide it via DI

Catalyst now allows you to specifically opt in or out of which headers Canis/Okami should be applied to.

CatalystCI now uses symlinks instead of --customSourceDir to put the source tree into HGuild's structure. CustomSourceDir might be removed in the future since symlinks is a cleaner approach.

Upgraded to LLVM14

This month:

StageRunner gained scripting support. As part of getting the ability to create components via scripting, StageRunner now has callbacks that can be ran by scripting.

Much better ruby handling: exceptions and static methods. Also better enum handling for WolfScript in general.

HGuild: Better support on macOS for using the correct brew on arm64

CatalystCI: Start of support for generating CI on Windows. This involves making it powershell compatible, along with its support scripts. Still ongoing.

mruby now has metaprogramming in its default gems

New REPL tool for WolfScript as part of WolfTool. While very basic, its useful to test and check certain canis features.

This month

Starting to design stage runner to be able to load non-cpp applications easily

Catalyst: Reenable mold as an alternate linking. As part of this, linux now builds with PIC all binaries.

WolfUI: Shortcuts for menu items now work, which also redoes a good amount of the input stack.

Wayland: Better support for wayland throughout the stack

Xcode/ARM: Resign tests with the linker, so that tests can run properly in POST_BUILD.

Start of adding wolf specific c++ keywords such as 'let' to simplify code.

Catalyst Build canis dirs at configure time instead of build time, making the build a little nicer.

This Month:

WolfDagger now supports layouts

Hguild/Catalyst: Quite a few speedups to speed up bigger builds (e.g. Wolf itself)

Catalyst now has cleaner support for alternate linkers. Tried using mold, though it has a few issues so its still not enabled by default.

WolfUI: Menus now dont render a garbage frame before rendering the proper menu when first shown.

WolfStage: RectangleRenderComponent now supports a seperate stroke if you want one.

Added support for MessagePack.

This month:

Wolf:

Catalyst: Added official support for VS2022.

CPlusPlus: Extension system now switched to better extension operator ('->*'). This system lets you more cleanly add extensions to any object, regardless if they opt in or opt out (including primitives! e.g. 2->*isEven()).

Canis: Adds extra dependencies on child modules during build, to catch issues when a dependency header changes its size.

Core: Added TextWriter to allow direct access to cout/cerr in a abstract way.

Core: Commandlineparser now supports '--' properly - which stops parsing arguments at the current level. This is useful for tools like WolfTool where you have both high level and low level arguments.

Secret: Start of highlevel tool to access secrets in WolfSecret for debugging.

Windows: Now uses UTF-8 mode for output, preventing the stupid mismatch that windows UTF-16 always had.

Catalyst: Now prefers adding sources directly to targets, instead of the old prepare and add. This fits better with our layout, and simplifies generation for newer features such as...

Catalyst: Now supports automatic registration of things even for.

Catalyst/Canis: Now supports autoregistration with applications. This allows apps to add classes to canis like modules can (useful for tests), or other registration functions they want to add, such as Dagger views.

This month:

HGuild: Now supports source:config:dependenciesInstallPaths --withFile : Returns all paths in all dependencies with the given filename (this is used for merging valgrind supression files)

LLVM/Canis: Now uses LLVM13

Wolf:

CommandLine now can handle array arguments via specifying the argument multiple times (e.g. --file=a --file=b)

WolfRez: Now fails properly if a file fails, instead of trying to run the final output. Added better error handling. Added support for a custom source dir (e.g. WolfCI)

Rendering: Fixed a crash which could occur if the rendering thread intermixes incorrectly with the application thread.

Fix issues with building on macOS under CI

Fix leaking FDs when creating processes

Added support for DebugResourceProfiler: similar to Memory::DebugProfiler, but for arbitrary resources (e.g. FDs)

Rewrote waitForAll to not use recursion for implementation - that way it doesnt crash with thousands of tasks. Endless:

Lua now supports providing logging categories

Fix a bug with FixedAllocator where if it alloacted the last chunk, debug verification would think the allocation chain was broken.

RandomGenerator: Added support for randomizing a boolean

Lojalmn:

Tuah climimwcahg

Ujaramw sil u pnulupmol mi zafeurrw nuzo luhkit fmumf

This month was mostly just straightforward progress. Reorganized some stuff, and have plans for the next project, but nothing too huge.

Wolf v2.2.0-REL

Updated support for GLSLang/SPIRV libs.

Added preliminary support for MSVC22.

Support default textures in material templates.

Tons of emscripten fixes - now runs fine again.

Faster backtrace resolution on linux via an addr2line daemon : gives more capabiltiies to `WolfSystem::Process.

Much easier to allocate an object via Canis if you need to call the constructor seperately.

Endless

Supports loading maps from mods again - was broken due to the Wolfv2 transition.

Bunch of material updates.

Tek::Page is now canis safe so can easily be overridden in future projects.

Lojalmn

This month started slow, but ended up being huge! Endless now runs on top of Wolf2 (with some bugs/quirks/resource changes), which required a huge amount of changes up and down the stack. This opens up some newer projects, just because I can reuse a bunch of the old stack. At least till more of the new system is ready.

Wolf 2.2 Progress

WolfTask: Can now schedule 'then()' callbacks on whatever runloop you want - requiring less thinking, or manually rescheduling it. This also fixes a bug in AudioPlayer where it would crash due to the async loader running on the wrong thread.

WolfRez: Now uses modern Result<> throughout its entire interface, allowing errors to bubble up properly instead of just ABORTing.

Pipewire: Now works completely in Wolf2. Still an experiemental driver since its tricky to test, but works fine.

Logger backends now are required to manually unregister themselves. This is due to a race condition that can happen.

WolfRez: Now will run automatically on build so it can detect resource-only changes

Canis: Added the ability to easily allocate an object, simplifying usage when using non-default constructors.

Endless:

Finished porting to Wolf2! While theirs still some parts that arent working (sampler functions in shaders for example, since its converting WolfV1 (GL3) shaders into proper WolfShaders (Vulkan, which is then specialized to GL3)). Requires a few resource changes, but 90% of it is compatible with existing Tek files.

Tek: Now a Wolf module! This is huge because that means you can have modern systems such as TekTool and Canis working within it.

TekPage: Now split off into its own submodule, so it can be exposed to Canis.

IntroSplashPage: Now takes the name of the class that provides the page - that way Rebirth can provide its own version of it. I'm expecting to follow this pattern with a bunch of other classes - letting Tek's C++ side be replaceable when needed.

EF-Rebirth:

Fmulm is yild. Rim tilo mi pito.