The visuals in the second half made me think of Godot's ambient light, and that it could probably achieve something like this. Unshaded look on illuminated faces, shadowed faces the same but multiplied by ambient color.

Most recently I got a better effect (step) for a hard shadow, but for some reason this also sometimes appears blocky when in front of lit area it isn't in (even if area is not visible). Probably usable at this point (slightly better than basic diffuse), though the ambient effect still doesn't work like I expect (not sure how to fix w/o being able to directly multiply by ambient).

The visuals in the second half made me think of Godot's ambient light, and that it could probably achieve something like this. Unshaded look on illuminated faces, shadowed faces the same but multiplied by ambient color.

I tried to get there with a custom shader using light() but only could really get half of the effect (clamped light color for no over-bright, shadows as full ambient). I couldn't figure out how to multiply by ambient (even leaving diffuse alone), I'd guess that ambient is global post-light() effect. But, I can only pretend to know what I'm doing.

I mean vertex color is already very close and I assume the video itself probably used compositing effects to get the color mix.

This is with higher internal res, of course (as in the original low-res+dithering makes it a lot less obvious). I hope compression doesn't muddy it too much.

Between the vertex-color skyboxes and LoD* (and Universal Interactive) there is overlap here with Spyro. Differing though it doesn't use the extra-loops trick for hard(-ish) edges, instead its skyboxes use multiple** meshes (such as the dump, lake, and power plant).

On top of this, there are a lot of other things using meshes+VC:

• particle-like effects
  • falling snow
  • fancy ribbons fly when you break presents
  • falling leaves after collecting rotten eggs
  • floating numbers (HUD too)
    • and their pop effect, very quick though
  • bees (yellow triangles with a darker corner)
• the loading screen goo effect
• 3D meshes on HUD for eggs
• 2D meshes are often used (with some texture usage)
  • key items, precur nitro eggs (world)
    • these have a pixel-shader (EDIT: or animated texture?) glow effect on a transparent outer ring of polygons
  • gadget UI icons
  • flame effect in junkyard minefield
  • dog icon in ski area (buried timer)
• horns + goo-covered horns in whoville
• puzzle answer painting in bell tower (+normal bell color after solved)

---

3D things in the world are a bit mixed. There are a few things that presumably have no texture (for instance some statues, hooks, parts of the sleigh). Characters do have flat color in textures (face, pocket, belt textures etc) plus vertex shading, so I don't know if they matched the colors there or if characters are entirely done via UV just like the modern trick of UV-color-palettes (or if this distinction even matters that much).

The exception to that might be Max and the ski-area dog that clearly have VC, though I think that's because the textures used (eyes, ear fur) don't actually provide hue like shirts etc.

* just don't play the entire game in widescreen like I did, it messed up the LoD (and the gadget UI element) EDIT: Checking again, not sure how much effect it has on LoD other than messing up the culling on the edges of the screen making it feel worse. I could've sworn there was more mismatch (though I could've also had something else set wrong)

** Oddly, Mt. Crumpit in the picture looks like the verts line up with the skybox perfectly (wireframe view). Though I'd guess that (assuming face-corner VC wasn't a thing) there's a Mt.-Crumpit-shaped-hole in the Skybox. There is however a window in the bell tower that does have a visibly-separate Mt. Crumpit (it's much smaller, like a diorama).

What: 3D meshes (edited in 2D), vertex color.

The simplest example would be to start with something like a triangle or hexagon grid, being able to paint each cell to create a design, then export painted cells as an optimized mesh (glb/obj). I know there are probably a few ways to do this manually, though likely not very smooth. Perhaps even involving SVG conversion (either way, likely involving Blender).

Why: Billboarded characters/projectiles, items, paintings or other environment details, floor/wall/ceiling tile art, UI icons. This would also give a more consistent/stylized look than manual meshes.

How: To me it seems like the newer node-graph applications (Graphite, PixiEditor, or even Blender's geometry nodes) could allow someone to create an editor to do stuff like this (perhaps as an extension).

Other related ideas:

• basic live-unwrapped 3D support (cuboids, revolve/lathe)
• quick patterns (tessellations, spiral vases, futbol)
• semi-freeform cell placement mode (think wooden pattern blocks)
• library tools, particularly indexed color palette+export all
• multi-layer for more flexibility, could be overlapping (obscured verts may not be exported) or not (flat+offset, or multiple extruded parts)

Somewhat similar thing, I did see that Joey Carlino made some character creators (Spore, Mii) in Blender.

I may eventually attempt something, currently stalled (system issues) and the last polygon thing I tried was a text format/loader (via Raylib bindings) that I only sort of completed (really only usable for a very simple project).

Post-video thoughts:

1. What is the situation with this on modern Linux? Something like a community edition, or is it only using the Windows version (lower hardware utilization?) via WINE?

2. Does modern use make any sense (size, performance, registration) beyond sightseeing? I mainly want live rendering (Godot), so I'm guessing that makes it make less sense.

3. Are there any model packs with models like this? Objects (low-poly room decoration etc.), or more particularly the architecture? Textureless is fine for me, vertex color or simple materials works (even if I had to do this myself from a blank model file).

I would've posted to ![email protected] but that's dead.

There's a similar video on Animation Master as well: The 90s CGI software that fell through the cracks

Like how Half-life 2 (etc.?) used a font for weapon icons. I'm guessing TF2 and CSGO (smart way to easily use it wherever supports text). Though it's difficult finding info on this without info about basic text instead.

No-color unicode ( 🛠 ) works everywhere, and can be made with Font Forge*, a bit clunky to me though. I wonder if newer node-based editors like Graphite/PixiEditor are better... or for (M)SDF fonts/textures.

I prefer textmesh** for the look... though color emojis ( 🎈 ) don't work with this (even with a vertex-color-as-albedo material, trying SVG emoji fonts). Plus FontForge doesn't handle color as far as I can see.

Label3D does support color, pixels instead of polygons (high scale or oversampling are options, but M.SignedDistance breaks color emojis). (also modulate_color_glyphs import setting seems to work in only 2D though)

* I've also tried Inkscape, didn't like how glyphs are created/managed (also, text width)

** I want a low-poly font anyway, though even smooth fonts look interesting with a high curve-step

---

---

Not strictly necessary (I'm already using Blender for simple models with vertex colors, and polygons+labels also work for 2D or 3D via canvas layer), but fonts are a more interesting workflow. Easier HUDs or text grid map maybe.

Prompt(s): MURKY (from inktober 2025, item 4).

Medium: created in Blender, rendered in Godot.

Extra info: Vertex fish (from icosphere) painted and unshaded. The murk is material work (plus vertex color transparency) with 3 objects and 2 materials. One is my glass material, the other is alpha_hash.

Challenge details: do-anything-tober. My lowest goal will be at least 12 sessions for the month.

I mentioned session02 (MOON) in the comment of the last post, here's a better image:

It has as much of the parallax effect as I can get without using a separate camera. I probably will do that anyway when I eventually make a vertex skybox.

The Suzanne is just there to show off the chipped (whittled-like) material. Though after 01 I also reworked some things and will likely mostly use a non-textured generic reflective material.

Prompt(s): CROWN (from inktober 2025, item 3) and PUMPKIN (from doodletober week 1, from first post in this comm)

Medium: created in Blender, imported and arranged in Godot.

Extra info: The pumpkin is sculpted and then vertex painted. The branches (and simple materials, environment) are pre-existing.

Challenge details: What-if-I-did-anything-tober. Aiming for 4 entries per-week, likely up-to 12 total (if I stick to it, 16 maybe if it goes well). Using this to refine my workflow, if anything can be rolled into something larger that's good too.

Blender (studio lighting) view:

Finding: Use a grid as a physical palette (save startup file). Neither Blender nor Godot seem to allow specifying a palette width. Eyedropper is another issue*.

In Blender must use unshaded rendering to get accurate colors, if you use color attribute for emission the color is still de-saturated in rendered mode but does sample the correct color with eyedropper.

I do wonder if there are low-poly-oriented options (be it model software or Godot plugins) that handle palettes better.

(older finding: use lambert_wrap diffuse)

Status: I have a custom shader that can use transparent areas to define glow area (glow defined by per-instance shader parameter, similar parameters work for textmesh or csg or custom effect animations etc). Metal and plastic materials are alright too, need to make more models to test more.

Sort of disliking Godot's shadows, but not sure if I want to go fully unshaded. I would be much happier doing so if I could darken it per-object or per-vertex based on lighting conditions (diffuse shadows only), but I don't think there is an easy way to do so. Especially needing to use pixel functions.

Stencil shadows would probably be what I want, haven't tested anything like that though.

In the weeds: Not sure how I want to handle transparency if at all. I was hoping specular/clearcoat could be visible on transparent faces, if that's possible I don't know how.

The fishbowl's flipped-face approach does look better (more like water) as unshaded, though.

* Blender has a shortcut for it but only if your mouse is in the right place

EDIT: If it isn't obvious, this is about vertex colors.

Ideally, modularity would be configured during asset creation. Like how Godot already allows Blender naming to do some stuff like this (even empties into joints/wheels) on import.

For basic use, I assume some of it could be done with an import script to split one scene into multiple variants based on the node tree (and names) with some simple logic/keywords. Likely makes even more sense with component-based code and using the same handling for editing code parameters.

For more advanced capability (particularly up to a character/vehicle editor) I assume it'd involve an add-on as well. At least it'd need a really solid editor script to handle offsets, symmetry/flipping (optionally, more inputs), scaling or other parameters. Something where you could easily create a new variation via a node or function call.

The ultimate form of this would be something that uses a flexible connector system, to the point you could probably assemble characters from 3D-printed parts if not a small scene.

---

---

I have explored multiple options. I know gridmap* could likely handle some of this (smaller grid for static objects, maybe other tricks for semi-static entities), I've been working on a custom shader with parameters to help with dynamic stuff (csg/textmesh color, color replacement for effects like emission or animation).

I assume things like Cyclops (level editor) or SDF modeling (and animations) could be used for an in-engine workflow. Though I am already having freezing/crashing (including some data loss) when editing things with shaders/lighting (4.4.1) so I have not tried those yet.

Also on a more basic level, I assume some rigging can be done just with node visibility and animations (+state?) though I haven't tried Blender animation yet.

* though from what I've seen, it seems like it's missing ways to properly configure bigger cell sizes easily. Sort of necessitating multiple grids (even in addition to walls vs decoration) or having cells that can overlap if you don't place them properly. I assume having multiple grids also does not calculate free grid spaces either (unless you mix grid and non-grid to use the new raycast placement).

This is for models that use vertex colors. I want all faces with the max brightness of the object. So in daytime lighting it should look unshaded, but in a dark environment it should darken (like the thumbnail).

What I've tried:

• using vertex_lighting* and then setting the normal directly (eg NORMAL = vec3(0.0, 1.0, 0.0);)
  • this works, but only if the lighting is perfectly overhead... a slightly wrong angle or even too far into the middle of an omnilight will create a shadow
• attempting to save the original color value, change the normal, and then bring it the old brightness back via max() if the new value is dimmer
  • lots of moving parts/assumptions on my part here
• other math stuff with NORMAL/VERTEX, abs() and normalize() etc
  • on top of the direction failure, there's also failure to keep consistent brightness (with a spinning animation), and darkening across a TextMesh

I also know I could do this with unshaded and just multiply/mix it in the shader, but I don't really like the idea of making a custom lighting/detection system (rather than using actual lights, that is).

I am not totally against diffuse shading, something like a vertex toon shader (2-3 brightness bands) could be interesting aesthetically. If that's even possible, it seems like the vertex light calculation is hardcoded (though it's also possible I just don't understand it).

* this is a relatively re-added feature (4.4)

XFCE note: autohide panel (the clock is not), accessibility WM tweaks turned on (hide title...) as I usually have a window maximized. Raise-on-focus (Window Manager settings, similar setting in tweaks for window cycling) turned off, allowing rolled-up windows to not disappear when unfocused.

System note: I have not maintained it well, broken dependencies right now and have finally got bit by nVidia as my system won't properly wake from suspend. Getting an alternative GPU is somewhat of a mess, especially prices and getting full performance. EDIT: Updated, working fine now

---

---

I made this ultra-minimalist window theme a while ago (this is the second version, with the widget-capable layout and style-based color accent) and have been using it.

The title is 12px tall (the buttons are default 8px, though can get taller with alternate hover/click states).

At this size, XFWM has a design issue with font sizes/baselines so most fonts are cut off (the selected font is Nimbus Mono PS Bold 10, larger has text descenders cut because text can't overlap window contents)

I would try to take this idea further (and fix some of XFWM's other relevant issues) with my own WM but I use a somewhat niche language and couldn't figure out how to render a rectangle the last time I looked into it (the WM I was looking at doesn't have titles/window controls).

Not set on a name as lots of themes have size-based names but are not as minimal.

Personal note: Aside from a software demo (+very small change to other demo) and a basic 3D character controller (which I need to work on again), I really haven't worked with this much.

I have been more focused on vertex color models and their use in Godot. Haven't done much here either... but have started a collection of materials, got billboarded models* working and a simple gridmap.

*=face negative Y in blender, apply rotation. Otherwise it will not export properly.