Intel Patents Technology That Stops Graphics Chips Recalculating the Same Surface Twice

By Patentlyze Team · Updated Jul 10, 2026

Every time a ray of light touches a see-through surface in a game, the GPU has to figure out how transparent that surface is. Intel's new patent wants to do that math once and remember the answer forever.

How Intel's opacity cache cuts GPU busywork in games

Imagine a forest in a video game. Every leaf on every tree is partially transparent, and your graphics card is casting millions of simulated light rays per second. Each time a ray hits a leaf, the GPU runs a small program called a shader to figure out how transparent that leaf is at that exact spot. The problem is that the same leaf gets hit over and over, and the GPU runs that calculation fresh every single time.

Intel's patent describes a system that remembers the answer. The first time a ray hits a given triangle (the basic building block of 3D shapes), the GPU runs the shader as normal. But it also saves the result in a compact map called an Opacity Micro-Map, or OMM. The next time a ray hits that same triangle, the GPU just looks up the answer instead of running the shader again.

The system starts every triangle marked as "uncertain" and fills in real answers as rays actually land. Intel also lets developers plug in their own rules for how transparency is decided, or let the compiler handle it automatically. Either way, the GPU does less work on average, which means faster frame rates.

How the OMM stores and reuses per-triangle opacity results

The patent centers on a data structure called an Opacity Micro-Map (OMM). Think of an OMM as a tiny grid overlaid on a triangle, where each cell records whether that slice of the triangle is fully opaque, fully transparent, or still unknown. During ray tracing (the lighting technique that simulates actual light bouncing through a scene), every surface intersection has to answer one key question: does this ray pass through, or does it stop here?

Intel's approach works like this:

• At startup, every cell in every OMM is flagged ambiguous, meaning "we don't know yet."
• The first time a ray hits a triangle, the GPU runs the shader (a small program that computes surface properties like transparency) as it normally would.
• The result gets written into the OMM for that triangle's sub-region.
• On all future ray hits to the same region, the GPU reads the cached result and skips the shader entirely.

The patent supports two modes. In explicit mode, an application programming interface (API) lets developers define their own opacity rules. In implicit mode, the compiler (the tool that converts code into GPU instructions) analyzes shaders automatically and populates the OMM without developer input. The processor can also pick the right OMM grid resolution based on how large a triangle appears on screen, which avoids wasting memory on tiny triangles.

What this means for ray tracing performance on Intel GPUs

Ray tracing's biggest performance cost isn't the math of bouncing rays, it's the extra shader calls triggered every time a ray hits a partially transparent surface. Tree leaves, chain-link fences, hair, cloth, and windows all create this problem. By caching those decisions, Intel's system reduces redundant GPU work directly proportional to how often the same triangle gets hit, which in dense, complex scenes can be very often.

This patent also signals Intel's interest in competing in GPU ray tracing at the architecture level, not just the driver level. The OMM format itself is part of Vulkan and DirectX 12 extensions supported across the industry, so Intel baking dynamic OMM construction into hardware puts it on a path that Nvidia and AMD are also pursuing. For you as a player or developer, the end result is ray tracing that runs faster without any change to how content is made.

Editorial commentary on a publicly published patent application. Not legal advice.