Yes splats do reflections

Stop the misinformation, it’s just changing where it’s being done moving from the language to the build system itself: https://ziggit.dev/t/cimport-going-away/5132

It’s also decoupling Zig compiler and C compiler so they’re updated independently.

It’s still a bummer in my view as I just replaced my build pipelines with just a Zig compiler instead of emscripten but that’s fine.

`@cImport` gets moved from the "mainline" language into a separate module -> this example won't compile on future versions of Zig, that's the point

No need to mess with Win32, Godot supports it: https://docs.godotengine.org/en/stable/classes/class_window....

There’s a resurgence of transparent apps and games just because of that.

S4 exists: https://mega.io/objectstorage

SVG path syntax [1] mentioned as being an inspiration in the article is very similar to Turtle graphics (move, lineto, etc.)

[1] https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/E...

Very many vector graphics standards use the idea of a current position. A distinguishing feature of turtle graphics is to have a current direction as well.

It's a shame SVG doesn't. Many shapes can be specified much more concisely.

plotter languages have the same concept.

Which ones? I've just skimmed through docs for HP-GL, DMPL and Gerber, but I can't see anything.

Also called datamoshing, it dates back a few decades already: https://en.wikipedia.org/wiki/Compression_artifact#Artistic_...

Datamoshing or Glitch art. There's even a ffmpeg fork just for glitching: https://github.com/ramiropolla/ffglitch-core

Awesome looking results. As far as I understand it's a "3D" shader in the sense that it looks 3D but it's a prerendered 2D normal map which is then lit using the resulting world space normal.

Here are the frames: https://github.com/nukep/gbshader/tree/main/sequences/gbspin...

It's not that different from "real 3d" renderers. Especially in deferred rendering pipelines the rasterizer creates a bunch of buffers for depth map, normal map, color, etc but main shaders are running on those 2d buffers. That's the beauty of it parts operating with 3d triangles are kept simple simple and the expensive lighting shaders run once on flat 2d images with 0 overdraw. The shaders don't care whether normal map buffer came from 3d geometry which was rasterized just now, prerendered some time ago or the mix of 2. And even in forward rendering pipelines the fragment shader is operating on implicit 2d pixels created by vertex shaders and rasterizer from "real 3d" data.

The way I look at it if the input and math in the shader is working with 3d vectors its a 3d shader. Whether there is also a 3d rasterizer is a separate question.

Modern 3d games are exploiting it in many different ways. Prerendering a 3D model from multiple views might sound like cheating but use of imposters is a real technique used by proper 3d engines.

There's a GBDK demo that actually does something similar (spinning 2D imposters). Does not handle the lighting though, which is quite impressive.

https://github.com/gbdk-2020/gbdk-2020/tree/develop/gbdk-lib...

Unfortunately, the 2D imposter mode has pretty significant difficulties with arbitrarily rotated 3D. The GBDK imposter rotation demo needs a 256k cart just to handle 64 rotation frames in a circle for a single object. Expanding that out to fully 3D views and rotations gets quite prohibitive.

Haven't tried downloading RGDBS to compile this yet. However, suspect the final file is probably similar, and pushing the upper limits on GB cart sizes.

Well, Cannon Fodder for the GBC it's 1 MB big, and the rest such as Metal Gear and Alone in the Dark are pretty sized for the hardware.

It's not that different from how some creative Mac games were doing 3d lighting on 2d textures prior to 3d accelerated hardware being available. The neat part here is that it runs on a Gameboy Colour.

On a device that apparently doesn't even support floating point operations and doesn't support multiplication. Super cool.

It’s a shader, not a renderer. The images are pre-rendered, but the shading is done in real time.

⇒ I think they’re correct in calling this a 3D shader.

The usual way of solving this is to make the voucher responsible as well if any bad actor is banned. That adds a layer of stake in the game.

A practical example of this can be seen in lobsters invite system, where if too many of the invitee accounts post spam, the inviter is also banned.

And another practical observation is that not many people have Lobsters account or even heard about it due to that (way less than people who heard about HN). Their "solution" is to make newcomers beg for invites in some chat. Guess what would a motivated malicious actor would do any times required and a regular internet user won't bother? Yeah, that.

I think this is the inevitable reality for future FOSS. Github will be degraded, but any real development will be moved behind closed doors and invite only walls.

That's putting weight on the other end of the scale. Why would you want to stake your reputation on an internet stranger based on a few PRs?

You are not supposed to vouch for strangers, system working as intended.

It was an issue with the main JPEGXL library being unmaintained and possibly open for security flaws. Some people got together and wrote a new one in Rust which then became an acceptable choice for a secure browser.

Unmaintained? You must be mistaken, libjxl was getting a healthy stream of commits.

The issue was the use of C++ instead of Rust or WUFFS (that Chromium uses for a lot of formats).

It’s largely the same people.

Windows has PIX for Windows, PIX is the name of the GPU debugging since Xbox 360. The Windows version is similar but it relies on debug layers that need to be GPU specific which is usually handled automatically. Although because of that it’s not as deep as the console version but it lets you get by. Most people use RenderDoc on supported platforms though (Linux and Windows). It supports most APIs you can find on these platforms.

Pix predates the XBox.