Provided by: opengl-4-man-doc_1.0~svn33624-1_all bug

NAME

       glLinkProgram - Links a program object

C SPECIFICATION

       void glLinkProgram(GLuint program);

PARAMETERS

       program
           Specifies the handle of the program object to be linked.

DESCRIPTION

       glLinkProgram links the program object specified by program. If any shader objects of type
       GL_VERTEX_SHADER are attached to program, they will be used to create an executable that
       will run on the programmable vertex processor. If any shader objects of type
       GL_GEOMETRY_SHADER are attached to program, they will be used to create an executable that
       will run on the programmable geometry processor. If any shader objects of type
       GL_FRAGMENT_SHADER are attached to program, they will be used to create an executable that
       will run on the programmable fragment processor.

       The status of the link operation will be stored as part of the program object's state.
       This value will be set to GL_TRUE if the program object was linked without errors and is
       ready for use, and GL_FALSE otherwise. It can be queried by calling glGetProgram() with
       arguments program and GL_LINK_STATUS.

       As a result of a successful link operation, all active user-defined uniform variables
       belonging to program will be initialized to 0, and each of the program object's active
       uniform variables will be assigned a location that can be queried by calling
       glGetUniformLocation(). Also, any active user-defined attribute variables that have not
       been bound to a generic vertex attribute index will be bound to one at this time.

       Linking of a program object can fail for a number of reasons as specified in the OpenGL
       Shading Language Specification. The following lists some of the conditions that will cause
       a link error.

       •   The number of active attribute variables supported by the implementation has been
           exceeded.

       •   The storage limit for uniform variables has been exceeded.

       •   The number of active uniform variables supported by the implementation has been
           exceeded.

       •   The main function is missing for the vertex, geometry or fragment shader.

       •   A varying variable actually used in the fragment shader is not declared in the same
           way (or is not declared at all) in the vertex shader, or geometry shader shader if
           present.

       •   A reference to a function or variable name is unresolved.

       •   A shared global is declared with two different types or two different initial values.

       •   One or more of the attached shader objects has not been successfully compiled.

       •   Binding a generic attribute matrix caused some rows of the matrix to fall outside the
           allowed maximum of GL_MAX_VERTEX_ATTRIBS.

       •   Not enough contiguous vertex attribute slots could be found to bind attribute
           matrices.

       •   The program object contains objects to form a fragment shader but does not contain
           objects to form a vertex shader.

       •   The program object contains objects to form a geometry shader but does not contain
           objects to form a vertex shader.

       •   The program object contains objects to form a geometry shader and the input primitive
           type, output primitive type, or maximum output vertex count is not specified in any
           compiled geometry shader object.

       •   The program object contains objects to form a geometry shader and the input primitive
           type, output primitive type, or maximum output vertex count is specified differently
           in multiple geometry shader objects.

       •   The number of active outputs in the fragment shader is greater than the value of
           GL_MAX_DRAW_BUFFERS.

       •   The program has an active output assigned to a location greater than or equal to the
           value of GL_MAX_DUAL_SOURCE_DRAW_BUFFERS and has an active output assigned an index
           greater than or equal to one.

       •   More than one varying out variable is bound to the same number and index.

       •   The explicit binding assigments do not leave enough space for the linker to
           automatically assign a location for a varying out array, which requires multiple
           contiguous locations.

       •   The count specified by glTransformFeedbackVaryings() is non-zero, but the program
           object has no vertex or geometry shader.

       •   Any variable name specified to glTransformFeedbackVaryings() in the varyings array is
           not declared as an output in the vertex shader (or the geometry shader, if active).

       •   Any two entries in the varyings array given glTransformFeedbackVaryings() specify the
           same varying variable.

       •   The total number of components to capture in any transform feedback varying variable
           is greater than the constant GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS and the
           buffer mode is GL_SEPARATE_ATTRIBS.

       When a program object has been successfully linked, the program object can be made part of
       current state by calling glUseProgram(). Whether or not the link operation was successful,
       the program object's information log will be overwritten. The information log can be
       retrieved by calling glGetProgramInfoLog().

       glLinkProgram will also install the generated executables as part of the current rendering
       state if the link operation was successful and the specified program object is already
       currently in use as a result of a previous call to glUseProgram(). If the program object
       currently in use is relinked unsuccessfully, its link status will be set to GL_FALSE , but
       the executables and associated state will remain part of the current state until a
       subsequent call to glUseProgram removes it from use. After it is removed from use, it
       cannot be made part of current state until it has been successfully relinked.

       If program contains shader objects of type GL_VERTEX_SHADER, and optionally of type
       GL_GEOMETRY_SHADER, but does not contain shader objects of type GL_FRAGMENT_SHADER, the
       vertex shader executable will be installed on the programmable vertex processor, the
       geometry shader executable, if present, will be installed on the programmable geometry
       processor, but no executable will be installed on the fragment processor. The results of
       rasterizing primitives with such a program will be undefined.

       The program object's information log is updated and the program is generated at the time
       of the link operation. After the link operation, applications are free to modify attached
       shader objects, compile attached shader objects, detach shader objects, delete shader
       objects, and attach additional shader objects. None of these operations affects the
       information log or the program that is part of the program object.

NOTES

       If the link operation is unsuccessful, any information about a previous link operation on
       program is lost (i.e., a failed link does not restore the old state of program ). Certain
       information can still be retrieved from program even after an unsuccessful link operation.
       See for instance glGetActiveAttrib() and glGetActiveUniform().

ERRORS

       GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.

       GL_INVALID_OPERATION is generated if program is not a program object.

       GL_INVALID_OPERATION is generated if program is the currently active program object and
       transform feedback mode is active.

ASSOCIATED GETS

       glGet() with the argument GL_CURRENT_PROGRAM

       glGetActiveAttrib() with argument program and the index of an active attribute variable

       glGetActiveUniform() with argument program and the index of an active uniform variable

       glGetAttachedShaders() with argument program

       glGetAttribLocation() with argument program and an attribute variable name

       glGetProgram() with arguments program and GL_LINK_STATUS

       glGetProgramInfoLog() with argument program

       glGetUniform() with argument program and a uniform variable location

       glGetUniformLocation() with argument program and a uniform variable name

       glIsProgram()

VERSION SUPPORT

       ┌──────────────┬───────────────────────────────────────────────────────────────────────┐
       │              │                OpenGL Version                                         │
       ├──────────────┼─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┤
       │Function2.02.13.03.13.23.34.04.14.24.34.44.5 │
       │/             │     │     │     │     │     │     │     │     │     │     │     │     │
       │Feature       │     │     │     │     │     │     │     │     │     │     │     │     │
       │Name          │     │     │     │     │     │     │     │     │     │     │     │     │
       ├──────────────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
       │glLinkProgram │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │  ✔  │
       └──────────────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

SEE ALSO

       glAttachShader(), glBindAttribLocation(), glCompileShader(), glCreateProgram(),
       glDeleteProgram(), glDetachShader(), glUniform(), glUseProgram(), glValidateProgram()

COPYRIGHT

       Copyright © 2003-2005 3Dlabs Inc. Ltd. Copyright © 2010-2014 Khronos Group. This material
       may be distributed subject to the terms and conditions set forth in the Open Publication
       License, v 1.0, 8 June 1999.  http://opencontent.org/openpub/.

COPYRIGHT

       Copyright © 2003-2005 3Dlabs Inc. Ltd.
       Copyright © 2010-2014 Khronos Group

[FIXME: source]                             01/03/2018                          GLLINKPROGRAM(3G)