Todo.txt

   1 Current functionality level: ESSL 3.0
   2
   3 Link Validation
   4     + provide input config file for setting limits
   5           - also consider spitting out measures of complexity
   6     + ensure no static references thrown away
   7     - generate static use of object even if the only use is to access the length of its array
   8     Cross-stage linking
   9       - type consistency check of uniform and ins <-> outs, both variables and blocks, stage-specific arrayness matching
  10       - location/binding/index check
  11       - matching initializers for uniforms
  12       - mixed es/non-es profiles
  13       - statically consumed input not produced by previous stage
  14       - matching between gl_PerVertex blocks and gl_PerFragment blocks
  15       - compute shader not combined with any other stages
  16       - give error for sharing a packed block
  17       - 1.3: deprecated mixing fixed vertex/fragment stage with programmable fragment/vertex stage.
  18       - 4.3: remove cross-version linking restrictions.
  19       - 4.3: Allow mismatches in interpolation and auxiliary qualification across stages.
  20           - 4.4: A stage contains two different blocks, each with no instance name, where the blocks contain a member with the same name.
  21     Intra-stage linking
  22       + exactly one main
  23       + Non ES: type consistency check of uniforms, globals, ins, and outs
  24       + Non ES: value checking of global const initializers
  25       + Non ES: value checking of uniform initializers
  26       + Non ES: location match
  27       - location aliasing/overlap (except desktop vertex shader inputs)
  28       - 1.0: count the number of uniforms and varyings, compare against limits
  29       + recursion for functions
  30       - Non ES: block matching
  31       - Non ES: component/binding/index/offset match check
  32       - Non ES: geometry shader input array sizes and input layout qualifier declaration
  33       - Non ES: compute shader layout(local_size_*) matching
  34       + mixed es/non-es profiles are an error
  35       - Non ES: Even the potential for recursion through subroutine uniforms is an error.
  36       - Non ES: matching redeclarations of interface blocks
  37       - Non ES: read or write to both gl_ClipVertex and gl_ClipDistance
  38       - Non ES: write to only one of gl_FragColor, gl_FragData, or user-declared
  39       - 4.3: Be clear that early_fragment_tests is only needed in one fragment-stage compilation unit.
  40       - 4.3: Be clear that implicit array sizing is only within a stage, not cross stage.
  41       - 4.4: overlapping transform/feedback offsets, offset/stride overflow checks, and stride matching
  42           - 4.4: If gl_FragCoord is redeclared in any fragment shader in a program, it must be redeclared in all the fragment shaders in that program that have a static use gl_FragCoord
  43           - 4.4: An interface contains two different blocks, each with no instance name, where the blocks contain a member with the same name.
  44           - 4.4: component aliasing (except desktop vertex shader inputs)
  45
  46 Shader Functionality to Implement/Finish
  47     ESSL 2.0 (#version 100)
  48       - implement non-inductive loop limitation detection
  49       - implement non-inductive array accesses limitation detection
  50     ESSL 3.0
  51       - "const" compile-time constant propagation in the front-end has to be complete, for all built-in functions
  52     GLSL 1.2
  53       + Handle multiple compilation units per stage
  54       + Allow initializers on uniform declarations
  55       - signature matching takes type conversions into account, ambiguity is an error
  56     GLSL 1.3
  57       . flat is for both user and predeclared built-in in/out variables
  58     GLSL 1.3 (Non-ES)
  59       - Preprocessor token pasting (##), ## does macro expansion after pasting not before
  60       - non-perspective (linear) interpolation (noperspective)
  61       - add gl_ClipDistance[] to both vertex and fragment shaders
  62       - only statically used built-ins have to be redeclared as flat
  63       - Deprecated gl_ClipVertex
  64       - deprecate almost all built-in state
  65       - ftransform() is deprecated
  66       - Deprecated built-in vertex inputs (attributes) and some outputs (varyings).
  67     GLSL 1.4 (Non-ES)
  68       - track as removed in this release, but present in others:
  69         - Use of gl_ClipVertex.  Use gl_ClipDistance instead.
  70         - Built-in vertex shader inputs.
  71         - Built-in uniforms except for depth range parameters
  72         - Built-in interface between vertex and fragment:  gl_TexCoord, gl_FogFragCoord, and all the color values.
  73         - Built-in two-sided coloring.
  74         - Fixed functionality for a programmable stage.  Supply shaders for all stages currently being used.
  75         - ftransform().  Use invariant outputs instead.
  76     GLSL 1.5 (Non-ES)
  77       - Deprecated gl_MaxVaryingComponents
  78       - Add new minimum maximums for gl_MaxVertexOutputComponents, gl_MaxGeometryInputComponents, gl_MaxGeometryOutputComponents, and gl_MaxFragmentInputComponents,
  79                 rather than relying on gl_MaxVaryingComponents.  Also, corrected gl_MaxVaryingComponents to be 60 instead of 64.
  80       - Added gl_PrimitiveID as an input to fragment shaders.
  81       - Added gl_FragCoord qualifiers origin_upper_left, and pixel_center_integer to modify the values returned by gl_FragCoord (and have no affect on any other aspect of the pipeline or language).
  82         - including redeclaration of gl_FragCoord that adds nothing
  83       - Added support for multi-sample textures through sampler2DMS and sampler2DMSArray support in texelFetch() and textureSize().
  84       - Broadened interface blocks from just uniforms to in and out interfaces as well.
  85       - Broaden array usage to include vertex shader inputs (vertex in).
  86       - Added geometry shaders.  This includes targeting layers in FBO rendering.
  87       - geometry shader layouts: they must be declared, telling the system the primitive input and output types and maximum number of vertices.
  88       - Added geometry shader constants.
  89       - Broaden structure usage to include geometry inputs and geometry outputs.
  90     GLSL 4.0
  91       - tessellation control stage and tessellation evaluation stage. Includes barrier() built-in for synchronization.
  92       - Polymorphic functions: Run-time selection of what function gets called, through the new keyword subroutine.
  93       - 64bit floating point numbers with the new type keyword double.  Built-in functions extended for doubles, and new function matching rules are added to both allow implicit conversions when calling a function and preserve most existing function matching once doubles are included.
  94       + More implicit conversions
  95          + float to double, and similarly for all floating-point vector and matrix types
  96          + int to uint, and similarly for all integer vector types
  97          + int to double, and similarly for all vectors of integers and doubles.
  98          + uint to double, and similarly for all vectors of integers and doubles.
  99       - Cube map array textures and texture functions texture(), textureSize(), textureLod(), and textureGrad().
 100       - Sampler arrays can take a variable index now, as long as it's value is uniform for all uses.
 101       - Per-sample shading. Including sample input mask gl_SampleMaskIn[] and per-sample interpolation, with explicit interpolation built-ins interpolateAtCentroid(), interpolateAtSample(), and interpolateAtOffset().
 102       - New precise qualifier to disallow optimizations that re-order operations or treat different instances of the same operator with different precision.
 103       - Add a fused multiply and add built-in, fma(), in relation to the new precise qualifier. (Because \93a * b + c\94 will require two operations under new rules for precise.)
 104       - Added new built-in floating-point functions
 105          - frexp() and ldexp()
 106          - packUnorm2x16(), packUnorm4x8(),packSnorm4x8(), and packDouble2x32()
 107          - unpackUnorm2x16(), unpackUnorm4x8(),unpackSnorm4x8(), and unpackDouble2x32()
 108       - Add new built-in integer functions
 109          - uaddCarry() andusubBorrow()
 110          - umulExtended() andimulExtended()
 111          - bitfieldExtract() andbitfieldInsert()
 112          - bitfieldReverse()
 113          - bitCount(),findLSB(), andfindMSB()
 114       - New built-in to query LOD, textureQueryLod().
 115       - New overloaded function matching algorithm, handling selection from many valid multiple choices.
 116       - Texture gather functions that return four texels with a single call.
 117          - textureGather()
 118          - textureGatherOffset()
 119          - textureGatherOffsets()
 120       - Add streams out from geometry shader. Output can be directed to streams through
 121          - EmitStreamVertex() and EndStreamPrimitive().
 122     GLSL 4.1
 123       - Support for partitioning shaders into multiple programs to provide light-weight mixing of different shader stages.
 124             (GL_ARB_separate_shader_objects)
 125         - layout qualifiers
 126         - redeclaration of input/output blocks
 127         - ...
 128       - Add 64-bit floating-point attributes for vertex shader inputs.
 129       - Support viewport arrays so where the geometry shader selects which viewport array will transform its output.
 130     GLSL 4.2
 131       + Move these previously deprecated features to be only in the compatibility profile:
 132         + The keyword attribute for vertex shader inputs. (Use in instead.)
 133         + The keyword varying for inputs and outputs. (Use in and out instead.)
 134         + The original texturing built-in functions. (Use the new forms instead.)
 135         + The built-in variables gl_FragColor and gl_FragData. (Use out instead.)
 136         + Built-in constants related to these.
 137       + Change from ASCII to UTF-8 for the language character set and also allow any characters inside comments (except the byte value 0),
 138         including '\'.
 139       + Add line-continuation using '\', as in C++.
 140       + ES convergence
 141         + Clarify that .xyzwxy.xy is illegal, as it temporarily makes a \93vec6\94.
 142         + Clarify that return statements only accept values (no return of a void function).
 143       - Add image types (GL_ARB_shader_image_load_store)
 144         + 33 new types, all with \93image\94 in their name, correspond to the non-shadow texture types
 145         + addition of memory qualifiers: coherent,volatile, restrict, readonly, and writeonly
 146         - can read/write/modify images from a shader, through new built-in functions
 147         - qualifiers can act independently on the opaque shader variable and the backing image, so extra qualifiers can be used to separately qualify these
 148       + Variables declared in if and else statements are scoped only to the end of those statements, especially for non-compound statements
 149         Note, this is not backward compatible, it may depend on #version.
 150       - Allow implicit conversions of return values to the declared type of the function.
 151       - The const keyword can be used to declare variables within a function body with initializer expressions that are not constant expressions.
 152       + Qualifiers on variable declarations no longer have to follow a strict order. The layout qualifier can be used multiple times, and multiple parameter qualifiers can be used.
 153       + Parameter qualifiers can include precision and memory qualifiers.
 154       - Add a new atomic_uint type to support atomic counters. Also, add built-in functions for manipulating atomic counters.
 155         - atomicCounterIncrement, atomicCounterDecrement, and atomicCounter
 156       - Add layout qualifier identifiers binding and offset to bind units to sampler and image variable declarations, atomic counters, and uniform blocks.
 157       - Add built-in functions to pack/unpack 16 bit floating-point numbers (ARB_shading_language_pack2f).
 158         - packHalf2x16 and unpackHalf2x16
 159         - packSnorm2x16and unpackSnorm2x16
 160       - Add gl_FragDepthlayout qualifiers to communicate what kind of changes will be made to gl_FragDepth(GL_AMD_conservative depth).
 161       - Add C-style curly brace initializer lists syntax for initializers. Full initialization of aggregates is required when these are used.
 162       - Allow .length() to be applied to vectors and matrices, returning the number of components or columns.
 163       + Clarify that .length() returns an int type and can be used as a constant integer expression.
 164       - Allow swizzle operations on scalars.
 165       - Positive signed decimal literals, as well as octal and hexadecimal, can set all 32 bits. This includes setting the sign bit to create a negative value.
 166       - Make GLSL consistent with the API regarding user clipping, by no longer referring to gl_Positionwhen gl_ClipVertex is not written. Rather, user clipping becomes undefined.
 167       - Clarified that a comma sequence-operator expression cannot be a constant expression. E.g., \93(2,3)\94 is not allowed, semantically,
 168             as a valid constant expression 3, even though it is an expression that will evaluate to 3.
 169       - Use vec2 instead of vec3 for coordinate in textureGather*(sampler2DRect,...).
 170       - Clarify that textureGatherOffset() can take non-constants for the offsets.
 171     GLSL 4.3
 172       - Add shader storage buffer objects, as per the ARB_shader_storage_buffer_object extension. This includes
 173             - allowing the last member of a storage buffer block to be an array that does not know its size until render time
 174             - read/write memory shared with the application and other shader invocations
 175             - adding the std430 layout qualifier for shader storage blocks
 176       - Allow .length() on all arrays; returning a compile-time constant or not, depending on how the
 177         array is sized, as per the ARB_shader_storage_buffer_object extension.
 178       - Be clear that implicit array sizing is only within a stage, not cross stage.
 179       - Array clarifications:
 180             - All arrays are inherently homogeneous, except for arrays of the new shader storage buffer objects
 181             - Arrays of shader storage buffer objects will be dereferenced when the .length() method is used on an unsized array
 182                 member, so that must a have valid index.
 183             - Arrays of other objects (uniform blocks) containing implicitly sized arrays will have the same implicit size for all
 184                 elements of the array.
 185       - Arrays of arrays are now supported, as per the GL_ARB_arrays_of_arraysextension.
 186       - Compute shaders are now supported, as per the GL_ARB_compute_shader extension.
 187       - Added imageSize() built-ins to query the dimensions of an image.
 188       - Define robust out-of-bounds access behavior when enabled, as per the GL_ARB_robust_buffer_access_behavior extension.
 189       - All choice of depth or stencil texturing, for a packed depth-stencil texture, as per the
 190         GL_ARB_stencil_texturing extension.
 191       - Allow explicit locations/indexes to be assigned to uniform variables and subroutines, as per the
 192         GL_ARB_explicit_uniform_location extension.
 193       - Accept ES GLSL shader #version statements, which will request ES functionality for ES GLSL
 194         versions 100 and 300, as per the GL_ARB_ES3_compatibility extension.
 195       - Clarify and correct scoping rules to what would normally be expected and what was intended.
 196         (Function parameters and body nest inside global space. Loop variables and body nest inside
 197         loop scope.)
 198       - There are no digraphs (trigraphs were already disallowed).
 199       - Remove the CPP difference that it is a compile-time error to use #if or #elif on expressions
 200         containing undefined macro names. This reverts back to following expected CPP behavior.
 201       - Set both gl_MaxFragmentImageUniformsand gl_MaxCombinedImageUniforms to 8.
 202       - Clarify textureSize() for cube map arrays.
 203       - For layout qualifiers,
 204             - make negative output locations a compile-time error, and
 205             - make indexes outside the range [0,1] a compile-time error.
 206       - Add textureQueryLevels() built-ins to query the number of mipmap levels, as per the
 207         GL_ARB_texture_query_levels extension.
 208       - Make gl_Layer and gl_ViewportIndex also be inputs to the fragment shader, as per the
 209         GL_ARB_fragment_layer_viewport extension.
 210       - Add more examples and rules to be more specific about the required behavior of the precise
 211         qualifier.
 212       - Clarify fragment output variables cannot be double precision.
 213       - Allow the new shared keyword to be in layout-qualifier-id, allowing backward compatibility
 214         with the shared identifier that was previously used.
 215       + Added overlooked texture function float textureOffset (sampler2DArrayShadow sampler, vec4 P, vec2 offset [, float bias] ).
 216       + Add missing type in grammar, ATOMIC_UINT, and missing qualifiers COHERENT, VOLATILE, RESTRICT, READONLY, and WRITEONLY.
 217       - do version checking for the above
 218       + Add missing initializer lists to grammar.
 219     GLSL 4.4
 220       - Incorporate the ARB_enhanced_layouts extension, which adds
 221         - compile-time constant expressions for layout qualifier integers
 222         - new offset and align layout qualifiers for control over buffer block layouts
 223         - add location layout qualifier for input and output blocks and block members
 224         - new componentlayout qualifier for finer-grained layout control of input and output variables and blocks
 225         - new xfb_buffer, xfb_stride, and xfb_offsetlayout qualifiers to allow the shader to control
 226           transform feedback buffering.
 227       + Bug 10530: To be consistent with ES, include sample types as valid in a precision statement.
 228         Note the defaults are irrelevant, as precision qualifiers are not required or have any meaning.