An Alignment Chart of Game Development Reflection Techniques

Level 1: Funhouse Mirror

Imagine you’re at a carnival funhouse and there’s a whole bunch of “mirrors”, each doing something different and wacky. One mirror is absolutely perfect – you see yourself exactly as you are, crystal clear (that’s like the super high-tech way the game could do it, but it’s very hard to pull off all the time). Another “mirror” isn’t a mirror at all: it’s actually a window into another room that looks just like yours, where a twin copies your every move! It sounds silly, but from where you’re standing, it kind of looks like a reflection – until the twin messes up or a stranger walks into that other room, then you realize something’s off. Yet another mirror is really just a TV screen showing a live video of you from a camera – you can see yourself, but it feels like when you’re on those jumbotron screens at sports events: it’s you, but it’s more like watching a TV show of you rather than a true mirror image. Some mirrors are so dusty or cracked that you basically can’t see yourself, just vague shapes or broken pieces – the haunted house approach. And the silliest of all: imagine a “mirror” that’s literally just a printed photograph taped onto the wall. You walk up and see a static, totally wrong image (maybe it’s someone else or you from yesterday), and you’d probably laugh and say “What the… this isn’t a mirror!”

This meme is joking that game developers use tricks like these when making mirrors in a video game. A real mirror effect can be like a huge, complicated magic trick for the computer, so sometimes they cheat a little. Some try to be clever so you won’t notice (like the camera or the duplicate room idea), and some just say “forget it” and dirty up the mirror or use a placeholder. It’s funny because it’s like a morality chart of mirrors from “the right way” to “the hilariously wrong way”. The right way (good) is doing the mirror properly even if it’s hard, and the wrong way (evil) is totally faking it in a lazy or goofy manner. Seeing all those side by side is like walking through a funhouse of mirrors, from the really accurate one to the one that’s basically a joke. Even if you’re not a programmer, you can appreciate how creative (or desperate) these solutions are. It’s amusing because it shows how far game makers will go to give you something that looks like a mirror – sometimes even pulling pranks like that fake photo – just to save the poor game from working too hard! So next time you’re playing a game and see a mirror, you might wonder: is it a real “mirror” mirror, or is there some funhouse trick behind it?

Level 2: Reflection Tricks 101

So, what’s going on with all these different “mirror” techniques? In game development, especially in graphics programming, creating a mirror effect is actually pretty challenging. A real mirror in life just bounces light rays, but in a game, the computer has to do extra work to simulate that. Developers have come up with a bunch of tricks (some high-tech, some downright cheeky) to show something like a reflection without breaking the game’s performance. Let’s demystify some of the terms and ideas shown:

• Ray Tracing: This is the straightforward but computationally heavy method. Imagine the game literally simulating light rays from the camera: when a ray hits a mirror, it spawns a new ray going off in the mirrored direction to find what’s there, just like real light would. The game then draws whatever that secondary ray “sees” in the mirror. This gives the most accurate reflection (you’ll see exactly what you should), but it’s super expensive for the computer. It’s like doing the work of rendering the scene all over again for each reflective pixel. Until recently, games couldn’t really afford this in real-time except maybe for small reflections. With modern hardware (like those fancy RTX graphics cards), some games now use raytraced reflections sparingly, but it’s still a luxury feature because it can slow things down a lot.

• Planar Reflections (Rendering the Scene Twice): This is a bit like a manual version of what ray tracing would do for a flat mirror. The developer sets up a second camera in the game world that looks out from the mirror’s position. In essence, the game draws the whole room again from that camera onto the mirror surface. It’s called “planar” because it works for flat surfaces. This method gives a correct reflection (you see moving characters, yourself, everything, because it’s literally rendering those things a second time), but the obvious drawback is performance: you’ve almost doubled the rendering work for scenes with mirrors. It’s often used in games in a limited way – like maybe only a small mirror or a calm water surface uses it – because you can’t do it on every surface without the game chugging. It’s the simpler “old-school” solution: reliable, but costly.

• Cubemap Reflections: A cubemap is basically a collection of pictures (textures) that represent the view of the environment in all directions (imagine standing at one point in a room and taking 6 photos: front, back, left, right, up, down – that’s a cubemap). Games often pre-create cubemaps for different areas and use them to fake reflections. When something in the game is shiny or mirror-like, instead of calculating what it should reflect on the fly, the game just looks up the corresponding direction in the cubemap image. This is really fast because it’s just a texture lookup, and GPUs handle that easily. The downside: it’s not specific to the player’s current viewpoint. If you move, the reflection in a cubemap doesn’t shift correctly (thus things can look a bit off, especially for near objects), and the cubemap might not include moving objects. It might just be a static snapshot of the room. That’s why, for example, in some older games, mirrors or shiny floors felt a bit like a vague, blurry version of the room and wouldn’t show your character. A low-res cubemap is just doing this with lower quality images, making the reflection extra blurry (sometimes intentionally to hide seams or the fact that it’s static). In the meme, that’s the “foggy” look – like when a bathroom mirror is steamed up: you can tell something’s reflected, but it’s not clear.

• Parallax-Corrected Cubemap: This is an improved version of the above. One big issue with a basic cubemap is that it assumes the reflection origin is at a single point in space (usually where the cubemap was captured). For large mirrors or ones not at that exact capture point, the reflection looks wrong because of parallax (objects might appear in the wrong place on the mirror if you move around). “Parallax-corrected” means the game tries to adjust the way it samples the cubemap so that as you move, the reflection shifts a bit more realistically, as if the reflection is coming from the mirror’s surface where it should. It’s a hack that can involve some math to offset or warp the coordinates used to fetch from the cubemap. It’s definitely better than a plain cubemap if done right – the reflection will “stick” more realistically to the mirror as you move past it. But it’s still, at its core, using an environment texture, so it won’t show dynamic things like the player model unless that cubemap is being updated in real-time (which is rare or done at low frequency because that gets expensive too). So parallax-corrected cubemaps make static scenes look much more convincing in mirrors, but you still might be the vampire with no reflection, as the meme joke implies.

• Screen-Space Reflections (SSR): This technique is kind of ingenious. The idea is to reuse what has already been drawn on the screen to create reflections, rather than rendering the world again or using a static image. After the main scene is drawn, the game knows the color of each pixel and the depth (distance) of each pixel (from the depth buffer). For a pixel on a reflective surface, the shader can basically simulate a ray bounce in screen space: it knows the view angle and surface normal, so it traces along that direction into the screen’s depth texture to find where it intersects something that was rendered. If it hits, say, another pixel’s depth, it knows that’s the thing which would be seen in the reflection. It then grabs the color from that pixel and uses it for the reflection. This way, you get dynamic reflections of stuff that’s in view with relatively little overhead (mostly math per pixel and some clever sampling). But, as mentioned, if the thing you need to reflect isn’t on the screen, this method can’t find it. For example, if the mirror should show a monster that’s actually behind the player (not visible in the current camera view), SSR will come up empty – it literally has no data for that. So games often fade out SSR reflections or fill with generic filler if the ray goes beyond the screen. This can make mirrors look weird: parts of it might look perfect while parts might be kind of blank or filled with a blurry smear of the nearest edge. Also SSR can struggle with reflecting objects against complex depth (it might catch the wrong depth or do funky stretching under some conditions). It’s basically a best-effort cheat. Many modern games use SSR for things like shiny floors or wet pavement because it works well enough there (you usually are looking downward so what needs reflecting – the sky, buildings, etc. – are in view). But it’s quite noticeable if you deliberately angle the camera to catch the limits, like in a big wall mirror scenario.

• Render-To-Texture (Camera feed): This is similar to the planar reflection method but is often done via an engine’s render-to-texture feature. Essentially, you set up a camera and have it draw its view onto a texture that’s applied to a surface (the mirror). It’s literally like how a live security camera feed in a game works, where you see on a monitor what another camera sees. If you position that camera exactly where a mirror’s reflection camera should be, you’ve basically implemented planar reflections via the engine’s API. This might be done instead of custom planar reflection code because an engine might make it easy to drop a camera and target a texture. The effect is the same – you get a dynamic reflection – and the costs are similar (that camera rendering is extra work). Sometimes, to save frames, a game might not update that camera-texture every single frame (maybe every other frame, or a lower framerate update, etc.), which could make the mirror look a tad laggy or not perfectly smooth. In the meme they joked “look ma I’m on TV” because if the perspective isn’t perfectly matched (or the refresh is off), it’s like seeing yourself on a TV screen rather than an instantaneous mirror.

• Using Trickery or Art: The last category of “techniques” isn’t really graphics programming at all – it’s design tricks. If doing a real mirror is too costly or complicated, a developer might simply avoid it. Two common avoids: make the mirror dirty/broken, or just remove it. A shattered mirror texture means the mirror in the game is cracked so badly you can’t see a proper reflection, only shards of warped whatever or just white cracks. This is done so the player’s expectation is managed – “oh, it’s broken, of course I can’t see myself.” Similarly, a very dirty mirror might just reflect a vague muddy shape (which could be some cheap cubemap or just a generic grey). In both cases, the game isn’t rendering a true reflection of the scene at all. It’s just a static texture simulating a damaged mirror. And then there’s the extreme “bad photo texture” – literally slapping an image onto the mirror. That’s more a joke than a serious technique; it would look obviously wrong if the photo doesn’t move. But it exemplifies the idea of completely faking it with artwork. For instance, some older games might have done something like use a static image as a “mirror” in the background, hoping you wouldn’t notice it never changes. These are basically the “we give up” or “we’ll solve it in art” solutions for reflections.

All these methods reflect (ha!) the core issue: real reflections are computationally expensive, so games must compromise. This meme is listing those compromises in a fun way. The terms like “screenspace_reflections” or “cubemap” might sound fancy, but as you can see, they each have a simple concept:

• Ray tracing = do it for real with math (beautiful but slow).
• Render twice = draw it again from another angle (accurate but double work).
• Cubemap = use a stored picture of the environment (fast but can be wrong or outdated).
• Parallax correction = tweak the stored picture to fit better (helps a bit, not perfect).
• Screen-space = reuse what’s on screen to fake it (great for some cases, fails for off-screen stuff).
• No reflection (broken/dirty) = avoid the problem creatively.
• Random texture = a placeholder or joke, basically not a real reflection at all.

The alignment chart format (the whole lawful/chaotic good/evil thing) is just a humorous framework borrowed from tabletop RPGs like Dungeons & Dragons. It doesn’t have a technical meaning by itself; it’s being used metaphorically. “Good” in this context loosely means the result looks correct or is a respectable solution, whereas “evil” means it’s a naughty or poor solution (looks wrong or is a hack). “Lawful” means it’s a proper, established method or follows expected rules (like physics or industry-standard practice), and “Chaotic” means it’s an unorthodox, wild approach outside normal bounds. It’s a fun way to classify these tricks by their vibe more than their actual function.

In game development, choosing how to do reflections is a classic case of performance trade-offs. If you want it to look perfect, you’ll pay a high cost (maybe too high to be practical). So developers often choose something in between or clever. For a newbie developer, the big takeaway is: there isn’t a single “mirror function” that solves this cheaply; you either do extra work (render more, do ray calculations) or you fake it and accept some visual inaccuracies. This meme just presents that reality in a jokey way that also nods to gamer culture (like the vampire reference, because characters not appearing in mirrors is a common trope, intentional or not!).

If you ever play a game and notice you can’t see yourself in a mirror, or the reflection is oddly blurry, now you know why! It’s not a ghost 👻 – it’s the developers making a practical choice. And if you do see a perfect reflection and the game still runs smoothly, appreciate the tech or hardware making that possible, because a lot of clever work (or brute force) went into it.

Level 3: Mirrors on a Budget

For seasoned game developers and graphics engineers, this meme hits home because it humorously charts the spectrum of reflection techniques by “morality” (good/evil) and “order” (lawful/chaotic). It’s essentially a big inside joke about how we fake mirrors in games. Each of the nine panels corresponds to a known approach, ranging from the gold standard to the outright ludicrous. The humor comes from exaggerating each method’s reputation: the more of a hack or corner-cutting it is, the more toward chaotic/evil it slides. Let’s break down those alignments and why they’re funny and relatable:

• Lawful Good – Raytracing: “Expensive, but mostly accurate.” This is the virtuous paladin of mirror rendering. It follows the rules of physics to a tee, producing beautiful accurate reflections. Every graphics dev knows ray tracing is the real deal: you cast rays, bounce them off surfaces, and get correct reflections and even multiple bounces if needed. The meme calls it expensive because, indeed, in a real-time game, doing raytraced reflections is computationally costly (historically borderline unfeasible until recent hardware advances). But it’s “mostly accurate” — it’s effectively as accurate as real life for a single reflection bounce (lawful good doesn’t necessarily mean perfect if you limit recursion, but it’s the highest fidelity on this chart). We chuckle because we aspire to this technique, yet most of us have spent our careers avoiding it due to performance constraints. It’s the noble hero we often can’t afford in a 16ms frame. Seeing it labeled Lawful Good is apt: it’s the proper way, bringing order and correctness to reflections, at great personal (CPU/GPU) cost.

• Neutral Good – Rendering the Room Twice: “ol reliable.” This panel refers to the tried-and-true method of planar reflections via a second render pass. It’s called “old reliable” because any graphics veteran has done this at least once: you place a mirror, and you just brute-force render the scene from the mirror’s perspective onto it. No fancy math beyond setting up a mirrored camera. It’s good because the result is still accurate (you see what you should see in the mirror), and it’s neutral because it’s not as theoretically elegant as ray tracing, but it’s not wildly hacky either – it’s a straightforward solution within standard engine capabilities. We grin at this one because it’s indeed reliable and commonly taught in graphics programming, yet it’s very literal (like, “okay fine, just draw everything again”). It doubles your draw workload, so performance-wise you pay a lot, but it’s predictable: if you budget for it, it works. The phrase “ol’ reliable” is meme-speak acknowledging its long-standing use. It’s neutral good: doesn’t break any rules or expectations, but also doesn’t try to optimize or cheat much – just an honest if somewhat brute-force approach.

• Chaotic Good – “Window to Adjacent Bathroom”: “funny in multiplayer games.” This one always gets a laugh from devs because it’s a ridiculous yet real tactic: literally fake the mirror as a window. The caption imagines a scenario (likely a jokey reference to some anecdote) where instead of actually reflecting the room, the dev built a second copy of the room on the other side of the “mirror” wall. So the mirror is effectively a window into that duplicated space. If you’re alone, it might convincingly look like a reflection (especially if a duplicate of your character is in there mimicking you). But as soon as something unpredictable happens – say another player walks into that hidden room – it becomes obvious it’s not a mirror. The alignment Chaotic Good fits because it’s a wild, rule-bending solution done with good intentions (maintaining performance or just having fun). It’s a clever level design hack rather than a rendering technique. In a multiplayer setting, two players could conceivably see each other through what’s supposed to be a mirror and realize “Wait a second… that’s not me!” We call this out as “funny in multiplayer” because it turns a graphics shortcut into a potential gameplay quirk or glitch. Devs find it hilarious because it’s so hacky: imagine explaining to QA “the mirror works by having a duplicate bathroom on the other side.” It’s chaotic (throwing proper techniques out the window, no pun intended) yet good in that it at least gives players something mirror-like without killing performance.

• Lawful Neutral – Parallax Corrected Cubemaps: “guess I’m a vampire now.” Here we’re looking at a standard industry technique tinted with a bit of irony. Cubemaps are widely used for reflections (think shiny chrome on cars, water reflections, etc.). A parallax-corrected cubemap is an attempt to improve basic cubemaps for use on flat mirrors or surfaces where the viewpoint moves. “Lawful neutral” because this is an officially sanctioned trick – many game engines (like Unreal Engine) support parallax-corrected reflections: it’s in the graphics programmer’s handbook of acceptable hacks. It’s neutral in morality since it doesn’t aim to be perfectly honest (it’s still faking the reflection with pre-baked images), but it follows a rigorous method to make it as plausible as possible given constraints. The vampire joke “guess I’m a vampire” comes from the classic limitation: cubemap-based reflections often don’t include the player’s own model. So if you walk in front of a mirror that uses a cubemap, you won’t see yourself – just the room around you. It’s like those horror games where the protagonist has no reflection, unintentionally. Even with parallax correction (which adjusts the cubemap as you move so the reflection warps correctly), the lack of dynamic objects stands out. Devs reading this nod knowingly because we’ve all seen those “fake mirrors” where everything looks kind of right except you’re inexplicably missing. It’s a bit eerie and definitely breaks realism – hence the vampire reference. In other words, this technique slavishly adheres to a technique (lawful), and it neither actively helps nor harms the player experience too much (neutral), but it has this funny quirk that you might joke about if you notice it.

• True Neutral – Regular, Low Rez Cubemap: “foggy up in here isn’t it.” This square represents the baseline, middle-of-the-road hack: just use a simple low-resolution cubemap for the mirror. No fancy corrections, probably even a blurry one to hide inaccuracies. True Neutral alignment fits because it’s neither particularly noble nor especially evil – it’s a purely pragmatic middle. The mirror technically reflects something, but it’s very approximate. The phrase “foggy up in here” humorously describes how such a mirror feels: it’s like a very blurry, fogged-up mirror where you can vaguely see shapes and colors but no detail. That blurriness might be literal because the cubemap might be low-res or intentionally filtered to hide that it’s outdated or not viewpoint-correct. Developers resort to this when they want some reflection for effect, but can’t afford anything better. It’s almost a trope in older 3D games – a glossy floor or mirror that kind of shows the room but in a smeary way, enough to sell wetness or reflectivity without having to be accurate. It’s perfectly neutral: it doesn’t draw attention to itself (if done well, players might not scrutinize it), but it’s certainly not giving players a true mirror. We laugh at the “foggy” line because it’s exactly what we’d quip when seeing such a mirror – “Maybe it’s just a really dirty mirror, yeah, that’s why I can’t see myself clearly!”

• Chaotic Neutral – Shattered Mirror Texture: “the cowards way.” Ah, the infamous broken mirror ploy. This is the developer basically opting out of the mirror problem by destroying the mirror in the game’s fiction. Alignment: chaotic neutral fits perfectly. It’s chaotic because it’s a rather unorthodox solution (it’s like saying, “Mirror rendering is too hard, so let’s pretend the mirror is broken. Problem solved!”). It’s neutral because, in terms of player experience, you’re not giving them a false reflection or an advantage/disadvantage; you just sidestep the issue altogether. The meme calling it “the coward’s way” is a bit of self-deprecating humor from devs: we know this is us chickening out of doing any real rendering work. It is kind of cowardly (albeit sometimes necessary when time or tech is limited). There’s a classic anecdote that many horror games or older games have no working mirrors largely because rendering a mirror was too costly, so they simply made all mirrors cracked or grimy. It becomes almost a cliché that “in video games, all mirrors are broken” – now you know why! It’s funny because it’s true: rather than implement reflections, we might spend a few hours in Photoshop making a shattered-glass texture decal. Graphics programmers half-joke about it with a sigh of relief/defeat. The players might even compliment the atmosphere (“wow, broken mirrors, spooky”), not realizing it’s partly an optimization hack. So this panel resonates as that wink-wink moment acknowledging a common lazy (or deadline-driven) dev decision.

• Lawful Evil – SCREENSPACE REFLECTIONS (scrawled in graffiti): “why no.. thats not how mirrors work at all... what the hell are you doing”. This one is great because it’s calling out screen-space reflections (SSR) with a mix of horror and resignation. Lawful Evil because SSR is a standard technique in modern game engines (very much by the book in terms of being offered as part of many GameEngine rendering pipelines), but the results can be deceptively wrong. Every experienced dev has seen SSR produce wacky artifacts: reflections that disappear when they shouldn’t, or stretching and ghosting that betrays the fakery. The caption mimics a shocked reaction: “that’s not how mirrors work at all!” For example, if you try to use pure SSR on a big mirror and walk around, you’ll notice the reflection might vanish or distort for objects not currently in front of the mirror. It feels wrong – like the mirror is possessed or something. SSR is a bit of an evil trick because it gives the illusion of a correct reflection some of the time, but it will quietly fail in edge cases, potentially confusing players. Developers have a love-hate with SSR: we love the performance it gives (hey, cheap reflections without a second render – sign me up), but we hate the artifacts and limitations. Calling it lawful evil is a cheeky way to say “this technique is by all standard measures acceptable (it follows the ‘law’ of engine conventions), but wow, it produces some diabolical results that break reality.” The graffiti style in the meme image (red scrawl) adds to the joke that SSR is like vandalizing the concept of a real mirror. We smirk because we’ve all been there tuning SSR parameters to minimize the weirdness, effectively bargaining with this little devil: please work just enough that players don’t notice!.

• Neutral Evil – Render Target Texture: “look ma I’m on TV”. This panel is about using a live video texture for a mirror, which is a bit sneaky. It’s neutral because it’s a somewhat routine capability (many games have security cameras showing on monitors, etc., implemented via render-to-texture), but it’s evil because as a mirror it’s not truly reflective perspective-wise – it might feel more like a slightly off camera feed. The “look ma I’m on TV” caption nails it: the mirror acts like a TV screen showing the player. The humor here is that as the player, you expect a mirror (which would be a reversed, first-person perspective), but what you get feels like seeing yourself on a live news broadcast or closed-circuit TV – typically a third-person angle or a slightly shifted perspective. Maybe the mirror camera is at the wrong position so it’s like someone filming you rather than your own eyes’ reflection. It’s a bit unnerving and definitely breaks immersion if you notice it. Developers might do this if the engine easily supports a camera-to-texture feature but doesn’t readily support true mirrored rendering. It’s evil in the sense that it deceives – it presents a live image, but subtly wrong. And of course, performance-wise, it’s essentially doing the work of rendering the player (and maybe scene) again to that texture, so it’s not even a big performance win over planar reflection; it’s often done for convenience or because the exact mirror effect isn’t available. We find it amusing because it’s a kludge: the player might not immediately realize the mirror is “wrong”, but something feels off, and if they move oddly or try to test it (like wave to the mirror and see a slight lag or angle), they’ll go “is this thing a camera?!”. It’s the kind of cheeky trick you pull when you have a render-to-texture framework and think, “hey, I can jury-rig this into a mirror, sort of.”

• Chaotic Evil – Bad Photo Texture: “what”. The final panel is pure silliness: it implies the mirror is literally just a static image (quite possibly a bad one at that, like a stock photo or an accidental selfie). Chaotic Evil is the alignment assigned to utterly unpredictable, no-rules behavior – which a bad photo slapped on the mirror definitely is. The caption “what” is the reaction of any player encountering such a mirror: utter confusion or speechlessness. It’s funny to us devs because it’s the ultimate low-effort hack – it’s basically saying “I’m not even going to try to show a reflection, I’ll just put something here.” Maybe it was a placeholder during development that accidentally shipped, or a sarcastic Easter egg by a tired artist/programmer. Imagine playing a game and you look in a mirror and see, say, a real photograph of a random person instead of your character… that’s so wrong it’s comedic. It breaks all immersion in the name of zero effort. We joke about it because after all the other fancier tricks, this one is just giving up on both realism and consistency. It’s evil (toward the player experience) and chaotic (no sane pipeline or rule would suggest doing this). You won’t often see such an extreme in released games (unless intentionally as humor or due to constraints in a game jam or something), but the mere idea of it is a riot. It’s like the meme equivalent of saying “screw it, I’ll draw the mirror with crayon.”

All together, these panels capture the tug-of-war between graphics fidelity vs performance trade-offs. Any developer who’s worked on rendering will recognize at least a few of these approaches. The alignment chart labeling is perfect because it anthropomorphizes the techniques: the honorable but impractical ones, the balanced compromises, and the outright rogue cheats. We find it hilarious because it’s true – we have in fact done these things! Maybe not the literal “adjacent bathroom” often, but certainly broken mirrors or low-res cubemaps. The meme is essentially laughing at the gameDev reality that mirrors are expensive and developers have a million tricks to avoid doing them properly. It also implicitly pokes at how far we’ll go to maintain frame rate: from doing things properly (at great cost) to shamelessly faking it. There’s also a bit of camaraderie in this humor: it’s like a catalog of war stories from graphics programming. Each technique has pros and cons we’ve painfully learned: - Raytracing: beautiful but a frame-rate killer. - Dual render (planar): reliable but doubling draw calls is scary. - Cubemaps: cheap and easy, but static and “vampiric”. - SSR: magical when it works, monstrous when it fails. - Outright fakes (broken mirror, photo): design hacks that save our hides when coding fails, at the cost of our pride 😅.

By framing it in the Dungeons & Dragons alignment format (lawful/chaotic vs good/evil), the meme adds an extra layer of humor: it’s as if these techniques are characters or strategies in a morality play. Lawful Good is righteous but maybe over-the-top, Chaotic Evil is absurd and reckless. This resonates with developers because we often personify our code or methods (“That hack is evil, but it works”). The alignment chart is a familiar nerdy reference, so using it for rendering hacks is an instant win for the gaming/graphics audience.

In short, experienced devs laugh at this meme and maybe feel a pinch of “I’ve been there.” It’s both a celebration of our clever solutions and a roast of our sillier shortcuts. We’ve all cut corners on graphical features under pressure, and seeing them presented as an alignment chart is both creative and cathartic. If you’ve ever optimized a game, you know sometimes you have to go a bit “chaotic evil” to meet the frame budget. This meme just tabulates those possibilities in one glorious, memetic taxonomy of mirror trickery. It’s a great snapshot of GameDevelopment culture: equal parts engineering ingenuity and tongue-in-cheek acknowledgement that, at the end of the day, what matters is it looks kind of like a mirror and the game doesn’t lag – even if under the hood it’s held together with spit and duct tape (or a conveniently placed “out of order” sign on the mirror!).

Level 4: Laws of Reflection

At the most fundamental level, mirror reflections in games pit the laws of physics against the limits of real-time computing. A perfect mirror image means solving the actual light transport: every ray of light bouncing off the mirror should show what’s really behind the player, obeying optics. In computer graphics terms, that’s part of the rendering equation – a complex integral over incoming light directions. The lawful approach (in D&D terms) is to simulate those photon paths directly with ray tracing. Ray tracing sends out rays from the camera, bounces them off surfaces (like a mirror) to find what they hit, and thus computes a truly accurate reflection. This technique aligns with physics – it effectively traces rays according to the angle of incidence equals angle of reflection, capturing everything visible to the mirror even if it’s off-screen from the player’s view. The result is gorgeous and mostly accurate, as the meme notes. However, ray tracing is expensive in computation: every pixel in the mirror may spawn one or more extra rays, each potentially hitting another object (or even bouncing again). Historically, real-time engines using rasterization couldn’t afford this except in special cases. Only with modern GPUs supporting hardware raytracing (e.g. NVIDIA’s RTX) have some games started doing real-time raytraced reflections – and even then, it eats frame time. Think of it as solving a physics problem for each pixel; it’s inherently heavy. If your game performance budget is 16ms per frame (to hit ~60 FPS), doing true ray tracing for mirrors might consume a big chunk of that, making it a luxury for GraphicsProgramming purists or the latest hardware.

To avoid that cost, developers rely on approximation techniques – basically graphic illusions that follow simpler rules (less lawful to physics, if you will). A classic method is the environment map, often a cubemap. A cubemap is like a 360° panoramic snapshot of the room in six directions (formatted as the faces of a cube). Instead of calculating a live reflection, the mirror can just look up the appropriate pre-rendered image from this cubemap based on view angle. It’s fast: sampling a texture is trivial for a GPU. But it’s also fundamentally an approximation – essentially assuming the viewer’s eye is at the cubemap’s center. Move the camera, and the reflection doesn’t obey correct parallax (things don’t shift properly in the reflection as they should). Also, unless the cubemap is continuously updated, it’s usually a static snapshot; dynamic objects (like the player’s own avatar or other characters) won’t show up. That’s why the meme jokes “guess I’m a vampire now” for parallax-corrected cubemaps – these methods often omit the player’s reflection entirely, as if the character has no reflection! A parallax corrected cubemap is a slightly more advanced hack: it tries to adjust the sampling of the cubemap as the camera moves, to partially correct the perspective error. Essentially, the engine uses the mirror’s position and perhaps a proxy plane or volume to shift the environment map coordinates, so the reflection feels a bit more anchored in the world. It’s closer to respecting geometry (hence more “lawful neutral” in the chart). But mathematically, it’s still not tracing actual light rays; it doesn’t truly know which objects are where relative to the mirror. It’s a clever hack blending world-space data and view-space adjustment – good enough that your brain might accept the mirror at a glance, yet still flawed (no self-reflection for the player, and often things feel just slightly off, especially at the edges or for large mirrors).

Another category is screen-space techniques, epitomized by Screen-Space Reflections (SSR). This is a modern twist that leverages the already-rendered image and GPU depth buffer to cheaply approximate reflections. Here’s how it works in theory: after rendering the scene normally (from the player’s view), you have a depth map of what’s visible. For each pixel that’s reflective (say, part of a mirror or a shiny floor), the shader marches a ray out into the screen-space depth buffer, essentially following the reflection angle and seeing where it intersects something in the already-rendered scene. If it finds a hit in that screen image, that’s used as the reflection color. This uses only information on screen, so it’s much cheaper than casting new rays into the full 3D world. The downside? It’s fundamentally myopic. If the true reflection should include something outside the current view (for example, something just off-camera, or behind the player), SSR can’t see it – those things aren’t in the screen/depth buffer. So SSR often produces incomplete reflections: you might notice the mirror looks fine in areas where it reflects stuff you can also directly see, but turns into a weird blurry smear or black void where it would require off-screen data. Visually, this can manifest as the lower part of a mirror reflecting the floor and your legs correctly (since those are on screen), but the top part of the mirror that should show the ceiling (which you’re not looking at) just fades out or shows some stretched distortion. It’s not how mirrors work at all, as the meme’s “lawful evil” panel scrawls in protest. Technically, SSR violates the global nature of true reflections, making it an evil imposter under a veneer of respectability (it’s a standard engine feature nowadays, hence “lawful”). From a theoretical perspective, SSR is an incomplete sampling of the scene’s reflective solution – it only solves the reflection equation for rays that hit already-visible surfaces. It’s a hack that exploits frame coherence and human perception: if used subtlety (like small puddles or glossy floors), players might not notice the missing bits. And it’s far cheaper than full ray tracing, since it reuses rasterization results. But in essence, SSR is a screen-space trick that works within the confines of the rendered image, bending the laws of reflection to what’s readily at hand in memory. It’s a fascinating example of trading physical accuracy for speed, embodying the neutral/evil engineer mindset: “I’ll follow the rules of our rendering pipeline (lawful), but I’ll cheat physics to get performance (evil).”

The most direct method short of raytracing – and one used since early 3D games – is planar reflections via rendering the scene twice. This is depicted as Neutral Good: “ol reliable”. The idea is straightforward: you place a second virtual camera in the scene, positioned as a mirror image of the player’s camera relative to the mirror plane. Then you render the whole scene from that mirrored camera’s perspective onto a texture, and map that texture onto the mirror surface. In effect, you’re performing an extra render pass that generates the mirror’s view. This approach gives a correct reflection for that planar mirror, including all dynamic objects and the player (assuming the player model is rendered; first-person games might need a trick to render the player in the mirror since the main camera might not). This technique obeys the actual geometry of the scene – it’s physically lawful and not a hack in terms of correctness. If you derive it mathematically, you’re essentially using a reflection transformation matrix to flip the camera and objects across the mirror plane (an application of linear algebra that mirrors the coordinate system). The result is equivalent to real optics for a flat mirror. The cost, however, is high: you’re drawing everything twice (or at least everything visible in the mirror). That roughly doubles the workload for that frame whenever the mirror is in view. In terms of complexity, if your scene has N draw calls or X million triangles, now you have ~2N or 2X when a mirror is present. GPUs and game engines often struggle if you naively double rendering like this, so developers might optimize by reducing quality or culling some objects in the mirror view. Still, it’s the reason this method is “Neutral Good” – it’s faithful (“good”) to reality, and straightforward (neutral, neither chaotic nor strictly clever), but not as saintly as raytracing in a purist sense (raytracing could handle any reflection scenario, including curved mirrors or multiple bounces, whereas planar dual-render is limited to flat mirrors and one bounce). Many games in the early 2000s used this trick sparingly – for example, a bathroom mirror might be a small separate room render. It’s a reliable workhorse solution even today for specific cases (like render_target_texture techniques for planar mirrors or water reflections) when performance can accommodate it. In fact, engines like Unreal Engine provide planar reflection components that essentially do exactly this under the hood. It’s the “old reliable” because while it’s expensive, it’s predictable and straightforward: no fancy algorithms, just brute-force rendering the scene again from another angle, giving a high-fidelity mirror at the expense of GPU time.

Now we venture into chaotic territory – the truly hacky or humorous solutions that break the “rules” for either fun or desperation. The meme’s Chaotic Good is "Window to Adjacent Bathroom", which is a tongue-in-cheek reference to literally building a duplicate room behind a fake mirror. Instead of doing any reflective rendering, the developer constructs a second space that looks identical to the original room, placed behind the mirror wall, and possibly has a duplicate of the player character model mimicking your movements. So when you look at what you think is a mirror, you’re actually peering through a transparent window into this copycat room, seeing your clone move opposite – like a bizarre theatre performance! This is good in the sense of being creative and ensuring zero performance cost for rendering (it’s all just normal rendering of a physical room), and if perfectly set up, it looks convincingly like a mirror reflection. It’s chaotic because it’s a totally outside-the-box, non-standard solution – it’s not using any graphics tech for reflections at all; it’s solving the problem at the level of game world design. It can lead to ridiculously funny situations, especially in multiplayer: imagine two players each think the other is their reflection in a mirror, but then one steps out of sync – the illusion shatters in a comical way. Or if a third player walks into that hidden “mirror room,” suddenly the jig is up. This trick has been rumored or observed in a few games and is often cited in programming discussions as a last resort hack. It’s like the chaotic good character who will break the rules of reality (in this case, the reality of how a mirror should work) but with positive intent (to get a working mirror effect and maybe a laugh). It’s hard to implement (requires duplicating geometry and syncing movements), but it bypasses the heavy math of reflections entirely by treating the mirror as a portal. Ironically, in true portal-based games (like Portal or Prey), mirrors could literally be handled as linked portals – which is essentially this idea.

For Neutral Evil, the meme shows Render Target Texture with the caption “look ma I’m on TV.” This refers to using a camera feed rendered onto a surface, much like security cameras or video screens in games – and co-opting that as a mirror. Concretely, it’s similar to planar reflection, but usually implies a slightly different use-case: the mirror might not be perfectly aligned or you might use an existing renderer feature for CCTV monitors. The result is more akin to seeing yourself on a live video feed rather than a true mirror (hence the TV joke). It’s “evil” because it’s not the honest mirror perspective – the viewpoint might be wrong (e.g., the camera might be at the character’s eye position but oriented differently, or at a slight offset). If not tuned carefully, the mirror image might look reversed incorrectly or feel laggy. Some games in the PS2/Xbox era did this: they’d place an invisible camera in front of the player and map it onto a mirror polygon. Technically, this is rendering the scene twice (so it’s similar cost to planar reflection), but calling it a “render target texture” emphasizes using the engine’s generic render-to-texture system. That system might allow lowering the resolution or update frequency of the mirror view to save performance (making the mirror look a bit grainy or delayed, like a creepy CCTV mirror). It’s neutral in alignment because it’s a standard engine feature (not as off-the-wall as the “adjacent room” trick), but it’s edging into evil because it can distort what a true mirror would do. Essentially, the game is pretending the mirror is a TV showing you, which subtly breaks immersion. It’s a pragmatic compromise: you get the dynamic reflection (you do see yourself move), but via a hack that might be noticeable if you move erratically (the perspective might not perfectly match your expectation of how a mirror should behave).

Finally, the Chaotic Neutral and Chaotic Evil panels showcase the ultimate cheats — just not doing real reflections at all. "Shattered Mirror Texture" (Chaotic Neutral, “the coward’s way”) depicts a mirror that’s completely cracked, so you only see jagged pieces of a reflective texture or mostly glare. Game developers sometimes deliberately do this in levels with mirrors: they put a dirty, frosted, or shattered texture on the mirror so that the player can’t see a clear reflection. It’s neutral because it’s not actively lying or showing the wrong thing (it’s basically showing nothing useful), and it’s chaotic because it throws away the entire problem of rendering a correct reflection. It’s the coward’s solution, as the meme says – from a tech perspective, the dev is saying “I absolutely refuse to deal with rendering this mirror properly, so I’ll make sure the design doesn’t require it.” It might fit a horror game vibe (old spooky mansion with broken mirrors everywhere) or just be a tongue-in-cheek way to hide engine limitations. Similarly, "Bad Photo Texture" (Chaotic Evil) is the most absurd, low-effort solution: stick a flat image that vaguely looks mirror-like and call it a day. The meme’s example even seems to show a blurry photo of a person with a camera flash — possibly implying a real-world photo of a mirror flash or just random nonsense. This is the chaotic evil of mirrors because it’s actively wrong: it’s showing something that isn’t the game world or the player at all. It’s the equivalent of lying to the player’s face. It might be done as a joke or in extremely low-budget situations. (There’s a bit of fourth-wall humor if the “bad photo” is e.g. the developer’s own face or a creepy figure – players will go “What…why is this mirror just a picture?!”) In terms of tech, a static texture is trivial to render (virtually no cost), so it’s the ultimate performance saver at the total expense of fidelity. It violates any expectation of realism (hence chaotic). No serious finished game would do exactly this for an actual mirror object – it’s more of a placeholder you’d see in early dev, or something done in a rush. But it perfectly encapsulates the extreme end of the graphics fidelity vs cost spectrum: it’s all the way on the “save cost, lose fidelity” end.

In summary, this alignment chart meme runs the gamut of mirror_reflection_techniques from the noble physically-accurate to the hilariously desperate. Each square’s joke is rooted in real GameDevelopment practices or anecdotes: from raytracing_vs_cubemaps debates, to the pitfalls of screenspace_reflections, to quick-and-dirty developer_shortcuts like broken mirror props. As graphics programmers (or enthusiasts), we chuckle because we recognize the underlying truth: real-time rendering is a constant battle between what looks right (lawful good fidelity) and what runs fast (chaotic evil hacks). The gaming culture love-hate relationship with these tricks is evident – we admire the clever hacks (and sometimes mischievously employ them), even as we dream of having the GPU power to simply do it the correct way. It’s a comical reflection (pun intended) on how game devs align on a spectrum from purists to pragmatists, all trying to make a mirror work in a game without shattering the frame budget.