Clipping discards all fragments that are outside your view, increasing performance.Ī fragment in OpenGL is all the data required for OpenGL to render a single pixel. Before the fragment shaders run, clipping is performed. The output of the geometry shader is then passed on to the rasterization stage where it maps the resulting primitive(s) to the corresponding pixels on the final screen, resulting in fragments for the fragment shader to use. In this example case, it generates a second triangle out of the given shape. The geometry shader takes as input a collection of vertices that form a primitive and has the ability to generate other shapes by emitting new vertices to form new (or other) primitive(s). The output of the primitive assembly stage is passed to the geometry shader. The primitive assembly stage takes as input all the vertices (or vertex if GL_POINTS is chosen) from the vertex shader that form a primitive and assembles all the point(s) in the primitive shape given in this case a triangle. The main purpose of the vertex shader is to transform 3D coordinates into different 3D coordinates (more on that later) and the vertex shader allows us to do some basic processing on the vertex attributes. The first part of the pipeline is the vertex shader that takes as input a single vertex. Some of these hints are GL_POINTS, GL_TRIANGLES and GL_LINE_STRIP.
Do we want the data rendered as a collection of points, a collection of triangles or perhaps just one long line? Those hints are called primitives and are given to OpenGL while calling any of the drawing commands. In order for OpenGL to know what to make of your collection of coordinates and color values OpenGL requires you to hint what kind of render types you want to form with the data. This vertex's data is represented using vertex attributes that can contain any data we'd like, but for simplicity's sake let's assume that each vertex consists of just a 3D position and some color value. A vertex is a collection of data per 3D coordinate. We will briefly explain each part of the pipeline in a simplified way to give you a good overview of how the pipeline operates.Īs input to the graphics pipeline we pass in a list of three 3D coordinates that should form a triangle in an array here called Vertex Data this vertex data is a collection of vertices. Note that the blue sections represent sections where we can inject our own shaders.Īs you can see, the graphics pipeline contains a large number of sections that each handle one specific part of converting your vertex data to a fully rendered pixel. Shaders are written in the OpenGL Shading Language ( GLSL) and we'll delve more into that in the next chapter.īelow you'll find an abstract representation of all the stages of the graphics pipeline.
This gives us much more fine-grained control over specific parts of the pipeline and because they run on the GPU, they can also save us valuable CPU time. Some of these shaders are configurable by the developer which allows us to write our own shaders to replace the existing default shaders. The processing cores run small programs on the GPU for each step of the pipeline. Because of their parallel nature, graphics cards of today have thousands of small processing cores to quickly process your data within the graphics pipeline. All of these steps are highly specialized (they have one specific function) and can easily be executed in parallel. The graphics pipeline can be divided into several steps where each step requires the output of the previous step as its input. The graphics pipeline takes as input a set of 3D coordinates and transforms these to colored 2D pixels on your screen. In this chapter we'll briefly discuss the graphics pipeline and how we can use it to our advantage to create fancy pixels. The graphics pipeline can be divided into two large parts: the first transforms your 3D coordinates into 2D coordinates and the second part transforms the 2D coordinates into actual colored pixels. The process of transforming 3D coordinates to 2D pixels is managed by the graphics pipeline of OpenGL. In OpenGL everything is in 3D space, but the screen or window is a 2D array of pixels so a large part of OpenGL's work is about transforming all 3D coordinates to 2D pixels that fit on your screen. Hello Triangle Getting-started/Hello-Triangle
0 kommentar(er)
