opengl传统管线和现代管线的区别

### OpenGL Fixed Function Pipeline vs Programmable Pipeline Differences In traditional OpenGL versions prior to 2.0, the **fixed function pipeline** was utilized where developers had limited control over how vertices were transformed or fragments shaded; this process relied on predefined functions set by the API itself[^1]. The architecture included stages like transformation, lighting, clipping, rasterization, texture application, and finally pixel operations. With the advent of more advanced GPUs, OpenGL introduced the **programmable pipeline**, starting from version 2.0 onwards with specifications such as OpenGL ES 2.0 which emphasized creating shader programs using GLSL (OpenGL Shading Language). This shift allowed for greater flexibility in defining custom behavior at various points within the rendering pipeline through user-defined shaders—specifically vertex shaders that manipulate geometric data before it reaches later stages of processing, and fragment shaders responsible for determining final colors per-pixel after rasterization has occurred. The key distinctions between these two approaches are summarized below: #### Control Over Processing Stages - In the fixed-function approach, each stage operates according to pre-established rules without any direct intervention possible beyond setting parameters. - Conversely, under the programmable model, one writes code directly controlling what happens during both vertex transformations and fragment shading processes via shaders written in GLSL. #### Flexibility & Customizability - Limited customization options exist when working strictly inside a rigid framework provided solely by built-in functionalities offered by earlier APIs. - Enhanced capabilities allow artists/developers full access to modify nearly every aspect related to visual effects generation including but not limited to implementing non-standard algorithms unachievable otherwise due to constraints imposed previously upon them. #### Performance Considerations - While simpler applications may benefit slightly better performance-wise out-of-the-box because they do not require compilation time associated with writing new shaders, - Complex scenes requiring intricate interactions among multiple elements often see significant improvements once optimized specifically tailored towards target hardware characteristics thanks largely in part owing much credit given hereafter attributed primarily toward leveraging modern GPU architectures effectively. ```cpp // Example Vertex Shader Code Snippet #version 330 core layout(location = 0) in vec3 position; void main() { gl_Position = vec4(position, 1.0); } ``` ```cpp // Example Fragment Shader Code Snippet #version 330 core out vec4 FragColor; void main(){ FragColor = vec4(1.0f); // White color output } ```