@lritter@mastodon.gamedev.place
@lritter@mastodon.gamedev.place avatar

lritter

@lritter@mastodon.gamedev.place

Arts, Maths & Metaprogramming; Game Developer at https://mastodon.gamedev.place/@duangle. paniq in the demoscene. Building Frameloop/Tukan, a procedural game engine, maintaining Scopes & gently going NowHere. (he/him)

Migrated from https://mastodon.social/@paniq

My avatar is the logo of the library I'm working on, a stylized toucan with a four-colored beak.

This profile is from a federated server and may be incomplete. Browse more on the original instance.

aeva, to random
@aeva@mastodon.gamedev.place avatar

you ever think about how the standard cartoon bomb (a large blue or black sphere with a big fuse coming out the top) is essentially the "save icon" of destruction, because 1) it's symbolic meaning is widely understood, and 2) it's an anachronism that is widely recognized only for its symbolic meaning as its real life counterpart is long obsolete?

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva mind blown

lritter, to random
@lritter@mastodon.gamedev.place avatar

not sure if quiche or pizza

image/jpeg

seatek, to random
@seatek@hard.blue avatar

This has taken me way, way too long to learn.

lritter,
@lritter@mastodon.gamedev.place avatar

@seatek they are both the same thing from two different perspectives

perhaps it should just say "ship your shoddy half-done crap and keep going"

in OSS dev we say "release early, release often"

aeva, to random
@aeva@mastodon.gamedev.place avatar

ok I got another recording of the thing finally. This was recorded on a faster computer than my laptop, so unfortunately it doesn't have the really cool long convergence artifact thing going on. I really hate what the video encoding is doing here, but such is life.

it's a video of a rotating abstract ring thingy that is light by several lights which create colorful shadows. the video encoding is terrible, but it looks ok I guess

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva very nice. with TAA, you could apply more post-filtering and make the noise disappear entirely. but what's the complexity so far? how do you draw it?

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva i mean runtime complexity. how many iterations, passes, threads, workcount, etc.

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva you do place them on the surface though, right? how do you choose "random"? is it uniformly random?

glassbottommeg, to random
@glassbottommeg@peoplemaking.games avatar

Once again: folks should probably consider switching to Firefox. Especially if you, I don't know, rely on ad-blocking to navigate our glutted-as-shit modern internet, for instance?

https://arstechnica.com/gadgets/2024/05/google-starts-deprecating-older-more-capable-chrome-extensions-next-week/

lritter,
@lritter@mastodon.gamedev.place avatar

@glassbottommeg i did that two months ago. smooth switch.

lritter, to random
@lritter@mastodon.gamedev.place avatar

what does N bit audio sound like? https://www.youtube.com/watch?v=K5jzAqeEoUE

lritter, to random
@lritter@mastodon.gamedev.place avatar

it's odd how many programs i use lately have this weird thing where they start up, and then after a second or so they "reboot". am i the only one noticing this?

the facebook app on android did it first.

then i noticed it in SDL2 after the window has been set up, when i request the render surface.

now vscode did it after i opened the console.

it's a quite irritating trend. and it feels weird, like the phone clicking right after you begin a call.

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva vertigo zoom on my face as it contorts in shock and horror

lritter, to random
@lritter@mastodon.gamedev.place avatar

so what's his punishment? i expect it to be tough considering in the US you can get 1000 years of jailtime for littering or smth

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva what if we give the poor 10000 years of jailtime for littering then won't that improve the justice average

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva what if it's 100,000 years of jailtime

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva @breakin @rygorous bizzaro nelson mandela

lritter, to random
@lritter@mastodon.gamedev.place avatar

wrote a simple runner for a 20 bit state machine which gets 6 bits of input. in addition there's a render function that gets 20 bits of state and outputs a 16x16 4bit sprite index, and a sprite-map function that maps 16 indices to 8x8 sprites using the PICO-8 palette.

the whole thing works. now the next challenge is to write a game with just 20 bits of memory available.

lritter, to random
@lritter@mastodon.gamedev.place avatar

Hypothetically, the simplest perfectly parallel program requiring no operations or instructions at all is a look-up table. The bigger the table, the larger input and output can be. A table of 2^(N+M) bits maps a 2^N bit index to a 2^M bit value.

The main jobs are then figuring out
(1) how to populate the table
(2) what storage format to use
(3) how to access it randomly
(4) how to verify the table

lritter,
@lritter@mastodon.gamedev.place avatar

Above description is a problem shaped in the form of a solution, i.e. an abstraction. This LUT as an abstraction has these combined benefits over other abstractions:

  • It is an algebraic object
  • There are no other dichotomies or types
  • Program and data are the same
  • It has a canonical rectangular shape of fixed size
  • All its problems deal with de-/compression
  • It can theoretically run Doom
lritter,
@lritter@mastodon.gamedev.place avatar

Capturing an arbitrary N bit state machine as a LUT requires N * 2**N bits of storage.

To put this into perspective.

The largest currently available hard drive in 2024 is 30 TB in size (shy of 2 ** 48 bits).

That is just enough to fully capture an arbitrary 42 bit state machine (not even 6 bytes of state).

But size limits are just a practical obstacle, not a theoretical one.

lritter, to random
@lritter@mastodon.gamedev.place avatar

Reordering problems in programming are interesting: Your output doesn't have the same order as your input.

(A) You read in the input sequentially, your opening move is fopen(). The output order differs. Sometimes it's almost parallel, but then flipped here and there (read-ahead). sometimes it's completely backwards. Every time you use some form of buffering to make up for that - in severe cases, this buffer becomes a polymorphic data structure.

lritter,
@lritter@mastodon.gamedev.place avatar

(B) You read in the input in parallel. Your opening move is mmap(). Now the game changes. You often build some form of divide-and-conquer indexing structure. If there is sequential context, then your data is in ambiguous state and you need some form of convolution. Sometimes you gather, sometimes you scatter. Your intermediate buffers mostly look like layered pyramids.

lritter,
@lritter@mastodon.gamedev.place avatar

For me, (A) will always be easier to think about because my day is organized sequentially. It's my existential modus operandi. But we know it's not efficient.

(B) is far more like thinking as a foreman for a godless factory of mindless robots. You put yourself in the shoes of each robot and consider what they're doing. Then you try to see how their interactions mesh up. You organize work in rows and passes. The cost of this efficiency is constant auditory hallucinations of marching jackboots.

lritter,
@lritter@mastodon.gamedev.place avatar

Of course, (A) is always contained somewhere within (B). We have many many units perform the same work on different data, similar to how the RNA sequencers in my body are more like (A) but their collective shape is more like (B). So these are not dichotomies, they are lateral. (B) is layered on top of (A), and then the order of passes in (B) is a new sequence, but now we have a two-dimensional shape and every subsequent reshaping just alters one of the two dimensions.

lritter,
@lritter@mastodon.gamedev.place avatar

The problem with us humans is that we can't help thinking in anything but one dimension, one foot in front of the other, when work is concerned. And hence our programming models keep looking like (A). Our texts are 1D. Our graph topology is visited in 1D. Very often, input structures are deliberately shaped for serial processing - like humans read. And once they're shaped for parallel processing, they become difficult to manage. I wonder if we're not hitting some hard cognitive wall here.

lritter, to random
@lritter@mastodon.gamedev.place avatar

in a time of ubiquitous revolt, obedience is an act of rebellion

lritter, to random
@lritter@mastodon.gamedev.place avatar

noice

video/mp4

lritter,
@lritter@mastodon.gamedev.place avatar

@aeva and wait for the sunset

  • All
  • Subscribed
  • Moderated
  • Favorites
  • •
  • anitta
  • thenastyranch
  • rosin
  • GTA5RPClips
  • osvaldo12
  • love
  • Youngstown
  • slotface
  • khanakhh
  • everett
  • kavyap
  • mdbf
  • DreamBathrooms
  • ngwrru68w68
  • megavids
  • magazineikmin
  • InstantRegret
  • normalnudes
  • tacticalgear
  • cubers
  • ethstaker
  • modclub
  • cisconetworking
  • Durango
  • provamag3
  • tester
  • Leos
  • JUstTest
  • All magazines
    •