In this lesson, you will learn how the legacy fixed-function workflow within the Built-in Render Pipeline shaped early Unity development and why its architectural constraints necessitate a transition toward modern approaches.
The Fixed-Function Heritage
When Unity first emerged, the "Built-in Pipeline" was designed around the concept of a fixed-function pipeline. In this era, graphics hardware was less programmable. Developers relied on a rigid, predefined set of states—like GL_LIGHTING or GL_FOG—which were toggled via simple commands. While this made rendering accessible, it lacked the flexibility required for today’s complex visual effects.
Limitations of the Legacy Workflow
The primary bottleneck of the legacy approach is state management. Because the pipeline follows a "black box" logic, the CPU must frequently issue commands to change the GPU state (e.g., swapping shaders, textures, or blend modes). This is expensive in terms of draw calls. If you have a scene with a thousand objects, the CPU spends most of its time "talking" to the GPU, telling it how to render each individual object rather than processing game logic.
Furthermore, cross-platform compatibility is difficult. A shader written for the fixed-function pipeline might look drastically different on a mobile device versus a desktop GPU because the hardware implementation of those "fixed" states varies wildly across manufacturers.
The Impact on Performance
Modern optimization relies on batching and minimizing state changes. In the Built-in Pipeline, this is often handled via MaterialPropertyBlocks:
// Using PropertyBlocks to modify material values without creating new instances
MaterialPropertyBlock propBlock = new MaterialPropertyBlock();
propBlock.SetColor("_Color", Color.red);
GetComponent<Renderer>().SetPropertyBlock(propBlock);
By using MaterialPropertyBlock, you avoid creating new material instances, which would otherwise break batching and trigger expensive state changes. However, this is merely a workaround for a pipeline that was never designed for the granular control required by modern GPU-bound applications. As your projects grow, these legacy architectural constraints often become the primary limit to your frame rate.
Key Takeaway: The Built-in Pipeline's fixed-function roots prioritize ease of use over deep GPU control, creating performance bottlenecks through excessive state changes that modern, programmable pipelines were specifically engineered to resolve.