Explaining Discrete Mathematics with Lara Croft's Evolution

Description

A two-panel meme used to explain the concept of discrete mathematics. The top text reads, 'My best example when explaining what discrete mathematics is to people who don't know it:'. Below, two images of the video game character Lara Croft are shown side-by-side. The left image, labeled '1996', shows the original, highly angular and low-polygon version of the character, famous for its blocky, geometric construction. The right image, labeled '2018', displays a modern, photorealistic, and smoothly rendered version of the same character. The humor and educational value come from the visual analogy: the 1996 Lara is a clear representation of a 3D model built from a small number of discrete geometric shapes (polygons), the fundamental building blocks of computer graphics. The 2018 version, while appearing smooth and continuous, is still composed of a vastly larger number of discrete polygons. It cleverly illustrates how complex, continuous-looking surfaces in the digital world are approximations made from a finite number of distinct, countable units - the core idea of discrete mathematics

Common Tags

CSFundamentals GamingReference TechHumor GraphicsProgramming GeekHumor

Comments

Anonymous ★ Top Pick Modern frameworks are like the 2018 Lara Croft - smooth, high-level abstractions. But every senior engineer knows that when you're debugging a performance issue, you're just staring at the pointy, low-poly 1996 version written in raw SQL

Anonymous ★ Top Pick

Modern frameworks are like the 2018 Lara Croft - smooth, high-level abstractions. But every senior engineer knows that when you're debugging a performance issue, you're just staring at the pointy, low-poly 1996 version written in raw SQL
Anonymous

1996 Lara: 540 ints in an index buffer; 2018 Lara: 60 000 ints in an index buffer with better normal maps - proof that under all the photoreal hype, it’s still just the same adjacency matrix your discrete math prof made you hand-draw
Anonymous

The real discrete mathematics lesson here is calculating how many triangles you can render before your PM discretely asks why the frame rate dropped to single digits in production
Anonymous

This is actually a brilliant pedagogical example: discrete math is like 1996 Lara - you can literally count the vertices and see the distinct states. Continuous functions are 2018 Lara - smooth interpolation everywhere, but under the hood it's still discrete vertices with enough tessellation to fool the eye. The real irony? Both are discrete at the hardware level; we just got better at lying about it with more triangles and fragment shaders
Anonymous

As the triangle count approaches ‘photorealistic,’ marketing calls it reality, SRE calls it a thermal incident, and the math still calls it discrete
Anonymous

Discrete math: curves are just marketing’s word for “more triangles” - 1996 shipped at eight, 2018 ships at two million, and your render loop still only gets 16 ms to pretend calculus
Anonymous

Low-poly Lara to photoreal: discrete math proving finite triangles approximate any curve - if your GPU budget converges
@yoyatayo 3y

I didnt get it
1. @RiedleroD 3y
  
  I'm sure that joke is somehow about her four-polygon breasts
  
  @qwnick 3y
  
  That's exactly wrong, by the way. Vertices in polygons stored in float, which is not discrete mathematics. Also mesh is not a graph, it's just oner array of vertices, and another array of of indexes. 3 index = polygon. Meaning it's doesn't explained by discrete mathematics.
  
  @RiedleroD 3y
  
  floats, as defined by IEEE754, are discrete values, and therefore fall under the umbrella of discrete math ALSO, the ps1, which is where this game ran iirc, used whole numbers for vertexes (that's where the awful vertex jittering comes from)
  
  @qwnick 3y
  
  where is in IEE754 float defined as discrete number? It may be stored as discrete number, but that is far abstraction level from mesh storage
  
  @RiedleroD 3y
  
  → it's stored as a discrete number there is the definition. If you abstract that away, that's on you. 2^16 might be a lot of values, but they're still finite.
  
  @qwnick 3y
  
  well that's stupid. First of all ps1 supported fixed-point data type, which is not integer. Second - polygons where cut cause of rendering limitations, not because non-decimal data types where not supported (which were supported, anyhow). I'm pretty sure rendering process doesn't include graph search.
  
  @RiedleroD 3y
  
  integers and fixed point numbers are one and the same in how you handle them. The only difference is if you have a little dot somewhere imagined in the number. in other words, 1.2/3.4 is the same as 12/34. both are equally discrete, anyway. you're right about the second point, but nobody claimed something else, so you really just made an obvious statement. graph search is part of discrete math, but not required if you want to make a joke referencing it. keep in mind that I do agree that the joke is kinda bad
  
  @qwnick 3y
  
  The only difference is if you have a little dot somewhere imagined in the number. Yes, that's the point.
  
  @RiedleroD 3y
  
  doesn't matter for the argument
  
  @qwnick 3y
  
  What's the main difference between float and integer as data interfaces? Not the floating point?
  
  @RiedleroD 3y
  
  integers and fixed-point numbers just count from the lowest to the highest value in equal sized steps (ignoring two's complement) and if you hit the highest or lowest number, you're out of luck. floating point numbers have variable sized steps, which makes them good for general application, no matter how small or large numbers get (to an extent) - also, there's infinity, negative infinity, NaN and all sorts of black magic included. actual non-discrete fractions can store any number, not just a finite amount of them. That's often represented by higher-level objects instead. While technically still limited by the amount of RAM and the address size of the cpu architecture, in theory those objects are meant to be infinite.
  
  @qwnick 3y
  
  Otherwise, if we agreed on your defenition, then everything is descrete mathematics, meaning term will lose any sense.
  
  @RiedleroD 3y
  
  no, everything in digital computing is discrete mathematics, which is inherent, since digital means only being able to store a finite amount of information, unlike analogue systems.
  
  @qwnick 3y
  
  That's what I meant. That you can post any computer related image and paste "My best example when explaining what discrete mathematics". More, applying your definition on planck units - everything is descrete mathematics, cause on planck scale everything is integral. Which is again, stupid, ad ruin purpose of any terminology - specific contexts is given specific meaning
  
  @RiedleroD 3y
  
  planck units are a theory, and, if correct, would mean that physics is discrete math, yes. However, much like gravity not actually being 9.82m/s everywhere, or for everything, we can usually model physics much easier with non-discrete math. All math is just knowing where and how to approximate effectively.
  
  dev_meme 3y
  
  >> ad ruin purpose of any terminology - specific contexts is given specific meaning It doesnt. Main context we have here is CS and jokes should be perceived (first of all) through this context
  
  @qwnick 3y
  
  So the joke is that in both cases meshes stored in non integral data. But non integral data is stored in integral view in raw memory binary, hence it's discrete math? That's just great, isn't it? (no, it's obviously bad, and doesn't fit)
  
  dev_meme 3y
  
  The joke here is that (in most cases) for purpose of computational science we would consider all FP operations as done over finite number and in wide range of tasks (on theoretical level) you can just remove dot and on those numbers as with integers This is answer if your main problem is about discrete math to work specifically over field of 𝐙
  
  dev_meme 3y
  
  @qwnick and another fun fact: many game engines of old time heavily relied on CPUs for grapphical tasks and not solely on GPUs (partially) because GPUs alghs were targeting approximate solution instead of exact solution possible with CPUs
  
  @qwnick 3y
  
  So joke is not related to the picture, from your words. Cause you said nothing about breast low poly count.
  
  @RiedleroD 3y
  
  I did some more research. The CPU had fixed-point data, but the GPU only had integers; one pixel on screen got exactly one number. That's it. The ps1 didn't even support subpixel verteces.
  
  @qwnick 3y
  
  Wtf is not sub-pixel vertex?
  
  @RiedleroD 3y
  
  subpixel vertex as in e.g. a triangle that has its points defined somewhere between pixel positions.
  
  @qwnick 3y
  
  But polygons are not defined in pixel space
  
  @RiedleroD 3y
  
  I assume they convert the numbers somewhere between cpu->gpu interaction and rasterization.
  
  @qwnick 3y
  
  So they are not stored in pixel space? They just rasterized in pixel space, same as now without AA?
  
  @RiedleroD 3y
  
  they're stored in multiple places, in multiple ways, as most things in computation. AA is something else entirely
  
  @RiedleroD 3y
  
  but yes, I assume they don't have a dedicated cache for verteces between the 3d transformation step and the rasterization step
  
  @qwnick 3y
  
  wdym stored in multiple places? Mesh is not stored in multiple places. Mesh is stored in 2 arrays, one is vertex, other is index. Index taken in a loop by 3 points. 3 index = 1 polygon. Rendering direction is defined by indexes order in polygon.
  
  @RiedleroD 3y
  
  you need to store 3d models at least once in ROM, once in RAM, and once inside the GPU, unless the CPU and GPU share RAM, which might be possible inside the ps1, but idk tbh
  
  @qwnick 3y
  
  it's just how data is transfered to vram, it doesn't change fact that meshes are not stored in pixel space. They are rasterized in pixel space, but after this they are not meshes, but frame (or draw call result).
  
  @RiedleroD 3y
  
  now that I think of it, I think the ps1 didn't even have vertex transformations on the GPU, since programmers needed to pre-sort verteces anyway because of the lack of z-buffer, so they also had to apply camera angle transformations in CPU to know the correct order… or maybe the had a chip dedicated to 3D transforms that supplied the transformed positions to CPU RAM?
  
  @RiedleroD 3y
  
  plus, the way they implement shading is also completely CPU-controlled - basically, you have to define light levels per vertex. no "oh, there's a light over there, let me compute the shading for each model", no, you had to find that out yourself and tell the GPU which vertex is how bright
  
  @RiedleroD 3y
  
  I'm getting this info from here btw → https://www.copetti.org/writings/consoles/playstation/ check it out, it's interesting
  
  @qwnick 3y
  
  If you don't have z-buffer, you need to make draw calls in correct order. Any mesh is stored subpixel space and rasterized into pixel space. It worked same way on ps1, and it working same way now. Wobble on ps1 was caused not by vertex logic, but that in order to rasterize mesh you need to check every pixel, and then take texture by UV and apply to this pixel. PS1 didn't did divides (cause they are pricey) and instead of deciding on each pixel color based on UV, squeezed whole texture in this polygon. Which is, again, doesn't include discrete mathematics. And also, does not related to small polygon count
  
  @RiedleroD 3y
  
  yes, they did have to do that. ps1-era GPUs and modern GPUs are so far apart in terms of how they do things that they're basically incomparable. Again, they didn't even have vertex shaders on the ps1. no depth buffer. no perspective. no, that is the texture wobble, not the vertex wobble. And they had to do that because they lacked perspective (haha, but yes, very literally, no vertex transforms→no perspective info) nobody was talking about small polygon count, except for my initial guess about "haha boob pointy" being the go-to joke for tomb raider
  
  @RiedleroD 3y
  
  basically, as I understand it, the ps1 GPU literally only rasterized.
  
  @RiedleroD 3y
  
  yep, they had a coprocessor for that lol
  
  @RiedleroD 3y
  
  they also didn't have z-buffer, as an aside. They really cut corners whereever possible. The N64, its competitor at the time, had not only floating point numbers, but a z-buffer and mipmapping.
  
  @RiedleroD 3y
  
  they also hat better games, har har
  
  @qwnick 3y
  
  What is not sub-pixel vertex?
  
  @RiedleroD 3y
  
  hm I guess that's what the joke is about, isn't it? The ps1 integer verteces
  
  dev_meme 3y
  
  All those memes about 0.1 + 0.2 are not wasted 🎉
  
  @ZgGPuo8dZef58K6hxxGVj3Z2 3y
  
  This is a good one too: let a = 9999999999999999; let b = 1; if (a - b == a) { alert(‘wtf?’); } else { alert(‘everything is fine’); }
@HellAbyss 3y

🤓🤓 moment
@qwnick 3y

Pun intended
@dsmagikswsa 3y

Wow the debate on top 👍🏼
@karim_mahyari 3y

BREAKING: Guy's humor is not tingled by meme, decides to make it a big deal
@MrStaudinger 2y

I didn't get it

Use J and K for navigation

Explaining Discrete Mathematics with Lara Croft's Evolution

Description

Categories

Common Tags

Comments

More like this

Calvin's Dad's Taxonomy: All Programming Projects Are Either Math or Files

Your Skin Has Triangles Because You're a Low-Poly Mesh

The Infinite Recursion of Problems: A Mandelbrot Set Metaphor