Josh Barczak

"'Premature optimization is the root of all evil' is the root of evil"

https://medium.com/@okaleniuk/premature-optimization-is-the-root-of-all-evil-is-the-root-of-evil-a8ab8056c6b

http://ubiquity.acm.org/article.cfm?id=1513451

http://www.joshbarczak.com/blog/?p=580

http://scottdorman.github.io/2009/08/28/premature-optimization-is-the-root-of-all-evil/

It's basically an excuse to not think about the performance or implementation of your entire product until the end and then, when you use a profiler and chop away "10%" here and "20%" there, you still end up with a slow-as-piss program with every function taking less than 1% total time. Then what do you do?

Oh yeah, what you should have done in the first place. _Think_ about how your program actually functions so you can remove all of the insane systemic, architecture decisions you made that all bleed a fixed amount of time every single function call. That's the difference between an engineer, and script kid. If you're not reasoning about _the entire platform_ (all the way down to the cache lines), you're not engineering. You can abstract all you want, but those abstractions don't magically prevent the underlying hardware and architectural decisions from affecting the product. Abstractions tools (read: approximations!) for high-level reasoning. They're not magic "you don't have to think [about low level implementation]" spells.

Actual experts keep trying to warn you guys about abusing that quote, but nobody apparently…

It sounds like you've got something specific in mind when you say, "modeling". The term modeling is used in a lot of different situations to mean different things. For example, it could mean to make a 3d model in Blender, it could mean to pose for someone to paint you or to take a photo, with databases it's used to mean modeling the data, with statistics it's used to mean finding a way to simply represent and reason about the data (create a model of it).

The things you've listed out make me guess you want to write 2d or 3d image rendering software. Is that right?

If that's the case, there's no substitute for trying to recreate certain algorithms or curves using a language or tool that you're comfortable with. It'll help you build an intuition about how the mathematical object behaves and what problems it solves (and doesn't). All of these approaches were created to solve problems, understanding the theory of it doesn't quite get you there. If you don't have a good place to try out functions, I recommend https://thebookofshaders.com/05/ , https://www.desmos.com/calculator , or https://www.geogebra.org/calculator .

A good place to start is linear interpolation (lerp). It seems dead simple, but it's used extensively to blend two things together (say positions or colors) and the other things you listed are mostly fancier things built on top of linear interpolation.

https://en.wikipedia.org/wiki/Linear_interpolation

For bezier curves and surfaces here are some links I've…

> We dispatch instanced draw calls where each instance corresponds to a segment’s quad. The vertex shader finds all of the information it needs from the primitive offset and segment id of the quad it is working on.

Hm, any reason you're using instanced quads? From my understanding of how GPUs work, instancing only has big gains when you have a lot of vertex data in the draw call [0]. Instead of the instanced quads, have you considered making a vertex buffer containing two shapes: a + for the center/edges, and four quads for the corners. That way you could still do the whole thing in two draw calls, and you're not going through the slow instancing path. And if you have to blend the bg anyway (e.g. rgba background-color), you can just draw the whole vertex buffer in one go to skip the extra draw call.

[0] http://www.joshbarczak.com/blog/?p=667

Any shader.

You can render a single quad and calculate UV in the pixel shader. Geometrically, this is the most accurate method.

You can do without any shaders, write a CPU code that builds a reasonably dense (about 8x8 pixels/triangle) static geosphere mesh with position and texcoord channels.

You can also build a reasonably dense grid mesh occupying just the screen with just the positions in clip space, and calculate UV channel in the VS based on the rotation.

GS will work too but I’m not sure it makes sense performance-wise. People normally use GS-es to implement small dynamic objects. For static geometry I won’t be surprised an immutable buffer will be faster, just because that’s what hardware & drivers are optimized for. See e.g. this http://www.joshbarczak.com/blog/?p=667