quad | Generative art project in Elm | Architecture library

Alpha test is a (since ages deprecated) method to only draw fragments when they match some alpha function. Nowadays this can easily be done inside a shader by just discarding the fragments. Alpha testing in itself is also very limited, because it can only decide to draw a fragment or not.

In general, enabling GL_ALPHA_TEST without setting a proper glAlphaFunc will do nothing since the default comparison function is GL_ALWAYS which means that all fragments will pass the test.

Your code doesn't seem to rely on alpha testing, but on blending (I assume that since you are setting the glBlendFunc). Somewhere in your code there's probably also a glEnable(GL_BLEND).

You're in a special case where your fragments are either fully opaque or fully transparent, so it's possible to get depth-testing and blending to work at the same time. The actual problem is, that for depth testing even a fully transparent fragment will store it's depth value. You can prevent the writing by explicitly discarding the fragment in the shader. Something like:

Observations

1. Close to zero (1 - cos(w*t)) / w**2 tends to 0/0. We can take the taylor expansion t**2(1/2 - (w*t)**2/24).

2. Going to the infinity the Lorentzian is a constant and the cosine term will cause the output to oscillate indefinitely, the integral can be approximated by multiplying that term by a slowly decreasing term.

3. You are using a linearly spaced scale with many points. It is easier to visualize with w in log scale.

The plot looks like this before damping the cosine term

I introduced two parameters to tune the attenuation of the oscilations

You can use a dictionary to achieve the behavior you want

Here's a small code snippet -

Not possible. SDL2 does not include a full-fledged rendering engine.

Some options:

• You could adopt Skia (the graphics library used in Chrome, among ohters) and then either stick with a software renderer, or instantiate an OpenGL context and use the hardware backend.

• You could use another 2D drawing library such as Raylib

• Or just bite the bullet and draw your triangles using OpenGL.

Instead of passing a texture handle to glUniform1i(glGetUniformLocation(ID, "textureSampler"), ...), you need to pass a texture slot index.

E.g. if you did glActiveTexture(GL_TEXTUREn) before binding the texture, pass n.

Here's the best explanation I can come up with.

The compiler can evidently do (at least somewhat) an optimization where code that is common to all branches of the if/else tree can be factored out (hoisted or sunk as appropriate). But in the f0 version, this optimization can't be applied because the "default" case has no code at all, and in particular does not either load or store b. So the compiler just optimizes the cases individually as best it can, leaving each one as a single RMW add-memory instruction.

In the f1 version, your __builtin_unreachable has removed the default branch. So now every branch consists, conceptually, of a load of b, an add of some constant, and a store back to b. The compiler seems to notice that they all have the store in common, and thus sinks it out - the store instruction appears just once, and every case jumps to it. Unfortunately, this actually results in worse code overall, because now the individual cases can't use the RMW add; they have to do the load and add as separate instructions. Moreover, the cases can no longer just ret by themselves; they all have to jump to the factored-out store. And the compiler has somehow not realized that the load could be hoisted out, so it is needlessly duplicated across all the cases.

I would guess part of the issue is that the hoisting/sinking is done in a target-independent pass that treats load, add, and store as independent operations. If they remain together, then some later target-specific peephole pass may combine them into the single add-memory instruction; but the earlier pass doesn't seem to consider that leaving them together might be advantageous, and thinks that any hoisting must be good. On a RISC-type load/store machine, where RMW always has to be three instructions, sinking just the store would still be somewhat helpful, maybe, but for x86 it definitely isn't.

So it's maybe two separate missed-optimization problems. The first is not noticing that the load can be hoisted (or maybe noticing but deciding not to do it), and that one seems like a clear bug. The second is not properly evaluating whether sinking the store is worth the cost of the extra jump, and that may be more a matter of applying heuristics that happen to be wrong in this case.

everything was correct except the copy resource call was missing once the new frame arrives.

Seems you want to generate small circles in random positions inside parallelogram.

Take two vectors of parallelogram sides, and generate random points using linear combination of these vectors: