Another key trick is to come up with an idea for some image, be too lazy to deal with all the hard stuff like windows and other decoration, then call it “minimalism”

Minimalist skyline.

I think I found a good abstraction for this kind of pseudo-2d effect.
The image is defined as a list of layers, each containing poly-lines,
occluding triangles and a z-index.

The output is a list of poly-lines with the occluded segments removed (shown here in gray).

What happens in the background is messy though, each triangle is converted to it's 3d equivalent,
lines are converted to points,
each checked for visibility by ray tracing, then joined back into lines.

What would be the simplest way of creating a low-polygon flying bird with some adjustable parameters for e.g. the angle of the wings?

Starting with an origami fold pattern is interesting but modeling it leads down a whole rabbit hole.

Not caring about performance / optimization is a game changer.

Instead of defining textures for each of the small triangles that make up the underlying isometric grid, I can just define three large textures for the whole image, then cut out the parts for each triangle using polygon-line clipping and have the line-joining algorithm convert the many short lines back into longer ones.

Sadly this doesn't work for fully vertical or horizontal textures yet due to some uncovered edge cases.

I keep trying to do some form of spaced repetition / incremental reading with foreign language texts.

It's incredibly tedious but I'm collecting tools that should make it easier, the latest being the python module cltk (NLP with classical languages), e.g. for word lemmatization (stemming).

Right now it takes me multiple hours to get through a chapter. Luckily it seems like the number of new words per chapter constantly decreases.

Any ideas how I could generate a 2d grid of random values that is a) continuous in some way, with larger regions of the same value and b) has four values with configurable probabilities and no bias in how these could connect to each other?

Perlin noise would satisfy a)
but if I quantize it into four discrete values, some connections are more likely than others.

Overlaying two black/white grids of noise yields four values but the probabilities get messed up.

Self-similar structure generated by applying a random sequence of axis-swap, mirroring and translate-repeat operations to some seed element.

Previous attempts failed due to problems limiting the length of these sequences, and bounding the number of cuboids in the output.

It's still very unpredictable and slow but produces some interesting results.

I've searched for existing algorithms for this but couldn't find anything besides basic joining of adjacent lines.

The trick is to convert each line to a range along a ray with origin either (x, 0) or (0, y) and group the ranges by their (origin, normal) combination.

For each such combination, joining the 1D ranges is relatively easy and takes care of lines that are adjacent, overlapping or fully contain each other.

Two images for comparison: leonrische.me/pages/line_joini

My line deduplication / joining code is almost working and with that, I should be able to draw isometric outlines and textured isometric faces in O(n^2) time.

The only problem is that a typo produced an image that was broken in a very aesthetic way so once I've dealt with some remaining floating point issues, I'll have to find a way to intentionally replicate that behavior.

One thing that kept me fascinated for the past months is constraint programming.

A nice visual application is defining a set of tiles that can fit together in fixed ways, then use propagation and backtracking to fill the whole grid in a consistent way.

This seems similar to the wave-function-collapse algorithm that made its rounds a few years ago
but is more flexible in that it allows different kinds of constraints,
for example forcing regions of the grid to be equal.

Leon boosted

https://spectra.video/videos/watch/051fef50-a121-40c0-bf3c-ee0730fb4a07

Leon boosted

@neauoire it's working! is this magic?

Leon boosted

Yeah, I run #emacs on my steam deck, ever heard of it?
https://arcology.garden/steam-deck-emacs

Leon boosted

Here's a small demo, the uniform variables in this colouring shader snippet are sequenced in the new zoomasm 4 (unfinished work in progress) timeline editor (along with zoom depth, as was already possible in zoomasm < 4).

```
uniform float Gamma;

uniform float WarpDepth;
uniform float WarpSpeed;
uniform float WarpFreq;

vec3 colour(void)
{
float Time = getTime();
vec2 Coord = getCoord();
vec2 NewCoord = Coord;
NewCoord -= ImageSize / 2.0;
float Distance = length(NewCoord) / length(ImageSize / 2.0);
float Warp = pow(2.0, WarpDepth * sin(2.0 * pi *
( WarpSpeed * Time
+ WarpFreq * Distance
)));
NewCoord *= Warp;
NewCoord += ImageSize / 2.0;
vec2 DE = getDE(vec2(1, -1) * (NewCoord - Coord));
return vec3(pow(clamp(length(DE), 0.0, 1.0), 1.0 / Gamma));
}
```

I should probably get a hi-vis and a brighter front light, the last segment felt a bit unsafe because the few cars on the road were going at 4x my speed.

My new favorite pasttime is racing my road bike through the city at night.

Yesterday I went for a 30km trip, today I wanted to see how far I could push myself without taking a rest day.

10km in one leg starts hurting,
25km in weirdly hasn't gotten worse.

I somehow end up disheartened on a big dark road with a sign saying it's 14km back to my home town,
only to find out that 7 of those are downhill.

After 40km and 2h I'm finally back.
Not a great pace but I'm very happy with it.

Leon boosted

I wanted a place to make virtual art installations so I've started building this flexible exhibition of sorts

Imagine paying for chessable when you can spend months writing 1000 lines of garbage code to have the same thing in the comforts of your favorite text editor.

Not sure how move selection and the spaced-repetition algorithm compare but I think my input format is better than PGN because it doesn't make a distinction between main lines and variations.

To be fair some of chessable is free but many useful features (like limiting the review depth) require a paid subscription.

The final pieces are in place and this could literally be a game changer for me.

Each position where the user is expected to play a move is assigned a recall value (Leitner boxes for now) and engine moves are chosen using modified min-max on these values.

Most importantly the part I couldn't figure out for the longest time: if there are multiple engine moves, the remaining ones are pushed to a queue and reviewed after the current line is over.

Tower of Hanoi in @neauoire's new slideshow program git.sr.ht/~rabbits/adelie.