Coming back to the level editor for Fire Exit that I didn't touch for a long time, I got some undo-redo working. Every one of these sub-editors create their own small snapshot on each action, which is added to a common undo stack. I originally wanted to go for the action/reverse action approach, but for an already existing editor first written without undo-redo in mind, it felt kind of overwhelming to hunt each possible action. Also that's my first attempt at implementing an undo-redo feature from scratch.
I also reworked other parts of the game (not shown here), the format for storing a compiled level or campaign is almost nothing like what it was before (it was full of hand-tweaked micro optimizations that were mostly irrelevant and required a lot of work by hand... Now I leveraged my code generator that can turn a big struct with arrays and pointers into a single block of memory, with relative pointers if needed.)

We added a short point'n'click adventure to Plisitol Jam Collection, our compilation of jam games we made for more than ten years and have been improving ever since.
PsyCam is a short 3D point'n'click adventure game, where you interact with the world as you see it through a bunch of CCTV monitors.
The original "jam" version was made during one week-end in 2022. This version has been improved over the last few months (better controls and tutorial, added lightmapping, even new puzzles and interactions, and overall polish). It takes place in a map made in Trenchbroom, filled with objects made in Blender or directly in Trenchbroom also. The engine is a custom one that supports both OpenGL3 and Direct3D 12 currently, and uses SoLoud for audio.
https://youtu.be/gFj2u45SVz8
https://plisitol.itch.io/jam-collection

After having to stop for some weeks (more details here: https://plisitol.itch.io/jam-collection/devlog/721673/an-update-on-the-coming-update), we finally made some progress on the introduction and menus of our last short point'n'click game.
I could reuse as-is the audio options I made for some previous short games (with a few visual tweaks) as well as the simple localization system. The game itself is a mix of Blender objects in a Trenchbroom map, some of the puzzle/interactions (not shown here) are hard-coded, others (that are just about interacting with the environment with or without an object) are simply "scripted" in the map.

WIP introduction and tutorial improvements for the CCTVs point'n'click game, as well as some other changes: some interactions have been split into several ones (for example, breaking the barricade unlocks the door instead of opening the door with it), new WIP models for the monitors, doors have been animated, and others.

It's starting to look like a game now and not just something thrown together for a jam. Added a static effect when switching cameras (based on https://www.shadertoy.com/view/ft2XRV), some logs that show up on the screens depending on some actions, and scripted camera movement (by adding additional entities using Trenchbroom and linking them, and I took care of making the rotation look like it's simulating two small motors in the camera, and not just interpolate the targets). I also randomized the code you need to type in now. I find it unreasonably fun to find the note with the code on it and type it now. I guess that's why I'm doing this job.

Plisitol Jam Collection is available Now on itch.io!

https://plisitol.itch.io/jam-collection

8 games made in a custom engine for game jams, and then improved for better quality of life. 2 older games made in Java.
Updates are already planned, that will add more games and keep improving the ones already there!

Our trailer for Plisitol Jam Collection, our compilation of jam games made over ten years and improved through time.
All made with an ever-improving handmade C/C++/OpenGL/D3D12 engine, except the 2 oldest which were made in Java.
Soon to be made available on itch.io

https://youtu.be/yjAHX3rLN6U?feature=shared

Been trying to add ands' lightmapper (https://github.com/ands/lightmapper) to my pipeline, here used in a map made in Trenchbroom we made for a game jam in 2022 (and back in the day we just added a simple directional lights and a few point lights to make it look slightly less flat.), with added light sources on the ceiling.
(Oh my, Discord's compression killed it.)

WIP: achieving close to parity with Khronos' Sample Viewer in my model viewer (except I won't go as far as supporting extensions; the differences in the screenshot is I have one directional light going in the camera's forward direction while Khronos' uses a few point lights.)
The only model showcased in that doesn't come from Khronos' sample models is https://sketchfab.com/3d-models/ikea-lillabo-basic-train-set-c09d67bc0d804a1899b82079f836b934

The last jam game I made made me realize how terrible my glb/gltf loader was (in practice I was only getting one mesh and skin from a file, which was enough for some games while I was the only one making models), so I started making a proper model loader and viewer. I'll probably not support all material features and extensions, just enough to make prettier games, and I try to support all kinds of animations as well as possible.
https://streamable.com/u7txk8
The steps after this is advanced enough is figuring out a proper binary custom format for my needs, and make sure my engine can manage materials slightly better.

That's the result (yes, that's a walkthrough of the whole game)

An ongoing game-jam game. One of the themes was "Play with the camera(s)". It will be kind of a point'n'click game, where you can take objects or send them THROUGH security cameras.

Some basic bloom on water ripples.

Trying to get some good-looking depth of field. And now that I can add post-processes relatively easily, I tried adding full-screen blur (which is simpler than DoF) in my menus behind popups, to test if it looks any better.
This is a mostly handmade engine, currently I added this only in my OpenGL renderer, it's just classic several pixel shading passes after forward-rendering the world in a quad.

First try at contact-hardening soft shadows
With a lot of help from http://maxest.gct-game.net/content/chss.pdf, a glance at AMD ShadowFX, and https://developer.download.nvidia.com/shaderlibrary/docs/shadow_PCSS.pdf
And thanks to GLSL for allowing only a single override to texture() for sampler2DShadow, making the HLSL->GLSL conversion complicated for no valid reason. (I'll have to integrate the HLSL version at some point too)

A big part of what I would like to showcase can't really be shown in an exciting way: I created a small builder tool for my projects. It updates a project from svn or checks it out from a repository, compiles it (currently only using MSBuild), maybe bakes some assets, and packages it, filtering files that are useless for a released build. It became even more important to have a quick way to build my games after I decided to create a package showcasing several of my personal projects (10 games until now, going back to 2011), bundled in a nice little launcher shown in the video. The builder is a mostly C tool, with a bit of C++ and additional code taken from my engine, it links to a libsvn.dll (it currently requires the user to have TortoiseSVN installed). The build process (getting project from source control, compiling, baking, packaging) is set up via .json files. I'm thinking about maybe using a scripting language for that instead, so that I can easily customize in which order steps are done, things like that. But for now I'm fine with what it is, and rapidjson is very comfortable to use.

My jam games launcher is coming along slowly. I added a slowly moving background to make it livelier. It looks exactly as I wanted, I'm almost surprised it looks so good. I took a shader from an underwater game of mine currently on hiatus (that displays a directional light and caustic textures), I added specular to it to get the "low-poly glow" feeling I wanted (thanks learnopengl), and I generate a floor mesh procedurally.

Holiday work: I figured I made quite a handful of jam games over the years, so I might as well try to sell them as a pack, along with an improved version of them when possible (which means, at least the same game with the latest version of my engine for better compatibility with present day systems) to add some value, all of it packaged in a nice little launcher. The biggest missing thing from my engine I had to create for the launcher was the text area (you can read a scrollable description of the game, along with the original readme file released at the time of the jam and a list of known issues in the jam version).

Timelapse of creating the path graph, and showcase of the little people's movement at the end. This should be my last post here for a while. https://youtu.be/VvULhPeMmbc

So far all the nodes were on the ground; added some stairs and elevated nodes to give a bit of depth to the people's movement, it looks surprisingly good

Currently making a quick'n'dirty tool inside Surveillance Sphere to link the path nodes with each other so that the little people finally get some proper pathfinding. Previously they were following nodes in the order they appeared in the file (no time to make better in the fil), resulting in them going through buildings pretty often.

Something came out of it: http://lhuillia.iiens.net/wejv11/WE2021_jam_version.zip Not yet the game I had in mind (way too ambitious for a 2-day jam) but it's pleasant. The inhabitants of your town are misbehaving (to respect the jam deadline, that only means "dancing with axes in the hands"), but you can only see it when using a device that lets you see an alternate reality, which also shows your city decayed. The goal is to keep finding criminals to arrest to keep that device funded and keep playing. Reality-shifting effects are made with shaders created for the occasion, both for D3D12 and OpenGL 3.x https://youtu.be/6weYM533W8A Little people graphics (including mayor), intro text and some textures courtesy of Biiscuit.

Some progress: a camera control scheme that gives a bit the feeling of being a surveillance drone hovering a city, and some tweaks to the shaders: now both worlds can have exclusive objects. We can also drop "Spheres", unveiling temporarily the parallel world, which will be one of the main features. For the game itself, I finally settled on something similar to Labyrinth City or Hidden Folks, but where you play as a crazy authoritarian mayor :p

Currently in a game jam that has 2 themes (they're a bit heavy on that): "Schrödinger's cat" and "The universe is made of rounds/circles/spheres". I'm kind of bending them, not sure what will come next. For now I made a shader that unveils a parallel universe inside a sphere. That is in my custom engine, the shader is written both in glsl and hlsl.

For my scenery area stuff in First Plague, I figured I would need to use convex polygons to represent the area and the scenery bits to fit inside; I didn't have real convex polygon handling with collision test, but I already had convex polyhedrons that I already use a lot for my 3D stuff, which share almost all of the same concepts, so I pretty much only had to adapt the code to 2D.

After weeks of coder's block, the way scenery chunks are added is satisfying to me. In the first video, the pink marked tiles represent the tiles seen by the actual in-game camera, chunks are added only if an empty tile becomes visible. A tile "prefab" is picked randomly, depending on the available space. Tile "prefabs" can have varying size (to allow big chunks that contains big monuments and pyramids or complex arrangements, or small bits of forest or town). The heuristic gives a good enough result for me for now, would be better if it could do several passes. https://streamable.com/1y2ta7 The second video shows how it actually looks in game (no empty tile, there's still some popping sometimes because tile visibility doesn't take the chunk's height into account yet). https://streamable.com/6ei8v3 Now I need to be able to fill these chunks with stuff (palm trees, monuments, cities, groups of crocodiles...)

Finally a bit of progress on First Plague: tracks don't have to be strictly on a straight line, and scenery chunks try to follow that. To ease that, the chunks must now fit on a tile grid. There is still a long way to go (the amount of scenery would ideally depend on the camera angle, the camera would smoothly follow the track, and there is not yet objects (trees, houses...) in the scenery tiles). Here is a debug view, way above, that shows track parts and scenery appearing and disappearing. https://streamable.com/t62vwd

Since I wanted to rethink the way scenery is done to make the levels allow freeer layouts, and since by default it's an infinite runner with an infinite procedurally generated level, I figured the less headache-inducing solution would require snapping everything to a grid, so I added a grid visualization in my editor; the way it's drawn is not pretty, but at least it does the job.

I'm several years late to the party, but now I can auto-reload assets by watching modifications on directories/files It currently works with textures, shaders (both shown here), and meshes, and is easy enough to watch game-specific assets (here, chunks created with Trenchbroom for First Plague) https://streamable.com/a20vpn

The water surface is now part of the chunk instead of drawing a single big patch of water, which may allow later to have chunk with water at different heights, or have a pond of water in the scenery that looks different from the river's water. Also, now the chunks don't have to all be the same size. https://streamable.com/zmsf52

Got pretty much all the features I need for a primitive editor for First Plague =>Load/Save/Compile levels =>Edit possible chunk combinations, import new chunks =>Edit the series of chunks that appear mandatorily at the start of each run https://streamable.com/n2aa7e

The sprites and the trigger's translucent meshes are now all drawn in the correct order. The difference is subtle from what I had previously - palm trees were already sorted offline, which was hiding most of the issues - , now for 2D elements it looks always correct, even when turning the camera all around in editor mode. For the trigger's mesh it's an approximation and sometimes some trees close to the limits get drawn in front or behind depending on the camera's position, but I'm going to stick with it, at least for now.

Editor looks a bit cleaner already. https://streamable.com/7ezgx0 File dialogs courtesy of @nakst 's wiki article on handmade.net: https://handmade.network/wiki/7246-file_dialogs

First primitive version of the tool that allows you to choose which chunks are "compatible" with each other for first plague. Also allows to drop new chunks, save, load, and compile the level into a flat-loadable file for the actual game. https://streamable.com/9wxmko

Started the embedded editing tools in First Plague, added a toggleable free camera https://streamable.com/z9c1x0

D3D12 doesn't offer an equivalent to glGenerateMipMap(), so for a while my engine was doing a slow mipmapping process on the CPU. Since I'm a complete noob in compute shader and didn't know where to start, it stuck for a while. (The "GenerateMips()" in Microsoft's MiniEngine was hard to extract because of all the layers.) Then someone on the Discord posted this tutorial: https://www.3dgep.com/learning-directx-12-4 But it was still using a layer on top of D3D12 and d3dx12.h, which makes it hard to port to my existing engine. And I didn't go in-depth with D3D12 for a while, so I forgot how some things worked :p Then I found this one: https://slindev.com/d3d12-texture-mipmap-generation/ Which is not as complete, but at least more readable. In the end, I started something by mixing Microsoft's "D3D12HelloTexture" (loads and display a textured triangle) and "D3D12nBodyGravity" (runs a compute shader) samples (https://github.com/microsoft/DirectX-Graphics-Samples/tree/master/Samples/Desktop) and the 2 tutorials above still helped me, and this is where I am so far. The right set of quads is drawn without mipmaps, for reference.

Just released a new version of First Plague, the jam game I started in the beginning of September, with the improvement of the triggers' visuals and the chunks' assets reorganized: https://lhuillia.iiens.net/wejv10/WEJV10.zip

Made a small effect around trigger, and since I draw them as brushes, it was easy to make them prettier by rounding them a bit. I had to fix an issue with the effect's reflection in the water, fixed it by adding a blend mode that just erases the target color/alpha with the source's (I had the issue in DX, where render textures are drawn upside-down compared to OpenGL, so I add a step when I redraw it upside-down to get it right...)

Among other internal changes to make the game's content more flat-loadable and easily moddable, I made the area where you can pick up people in First Plague more readable. Requires some more work to make it prettier.

The blood stream is now better integrated into my water

A game jam game I made during the week-end, using my same engine as usual, tried to recycle as many things from previous/unfinished projects as I needed https://www.developpez.net/forums/d2090844/applications/developpement-2d-3d-jeux/projets/we-jv10-first-plague/ https://s1.gifyu.com/images/familiarfaces.gif https://s8.gifyu.com/images/losing.gif https://lhuillia.iiens.net/wejv10/WEJV10.zip

I can now place smoke cloud tiles on the map in Fire Exit, and therefore the map's borders don't have to look straight anymore. I also changed the cloud shader I use because the other one wasn't working fast enough on older computers, the new one is based on this: https://www.shadertoy.com/view/lslXRS

The ugliest and most impractical 2D mesh editor you'll see today, embedded in one of my games' editor. All I needed was to make some tile types for clouds and output them as a C struct, and it ended up like this.

I finally made some visual progress on one of my games: with the help of my girlfriend Biiscuit, we decided that the map would be surrounded by the smoke caused by the fires going on all around the planet. I based the smoke on this cloud shader: https://www.shadertoy.com/view/tlBXD3 Enjoy the Twitter compression: https://twitter.com/Guntha_en/status/1264671905589665792 (Before it looked like that:)

Made some small glsl and hlsl syntax highlighters for @rxi 's lite to help myself; since I need to edit both HLSL and GLSL shaders for my games, in each syntax highlighters I added a list of keywords, types and built-in functions from the other language that don't exist in the current language and display them in flashy bright red when used, to avoid common mistakes. In the gif below, copy-pasting a line from an HLSL file to a GLSL file (I know glsl files don't really have standard extensions, that's the one I use in my project...) quickly shows what needs to be adapted.

...And there on a 10-year-old WIndows 7 laptop where it falls back to OpenGL3.0

Here I tested it on Windows 10, where it links to the D3D12 backend by default...

Something that took me weeks to finish in my engine/games: have 1 executable that selects the most adapted rendering backend at launch. For years, I supported both OpenGL3.0 and D3D12, but in separate executables, so the user had to select the right one. Now the implementation of the rendering backends is separated into dlls, and the executable choses the most adapted one at launch (except if the user overriden the "most adapted" one with another one in the options screen) I'm still keeping the ability to build with the renderer embedded in the executable, mostly for the case where, for consoles for example, there is only 1 backend available and it wouldn't make sense to still have the overhead of calling functions from a runtime library. And for easier debug when I want to add a feature to my renderer.

https://store.steampowered.com/app/1202970/Mad_Tracks/ A PC game from 2006 that is getting released again soon on Steam, with some updates (Steam overlay/Steam Cloud, Xbox controller support, a little bit of graphical updates... I was the one who worked on it, and I had about a month to do it