/// <summary> Do a texture lookup as in texture but with offset added to the (u,v,w) texel coordinates before looking up each texel.
 /// The offset value must be a constant expression. A limited range of offset values are supported; 
 /// the minimum and maximum offset values are implementation-dependent and given by MIN_PROGRAM_TEXEL_OFFSET and MAX_PROGRAM_TEXEL_OFFSET, respectively.
 /// Note that offset does not apply to the layer coordinate for texture arrays. This is explained in detail in section 3.8.11
 /// “Texture Minification” of the OpenGL Graphics System Specification, where offset is (∂u ,∂v ,∂w).
 /// </summary>
 protected internal static vec4 TextureOffset(sampler2D sampler, vec2 P, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary>Returns x if x >= 0, otherwise it returns –x.</summary>
 /// <returns>The absolute value of x</returns>
 protected internal static ivec2 Abs(ivec2 x)
 {
     throw _invalidAccess;
 }

 public ivec3(ivec2 xy, int z_)
 {
     x = xy.x;
     y = xy.y;
     z = z_;
 }

 /// <summary>
 /// Returns a floating-point value corresponding to a signed integer encoding 
 /// of a floating-point value. If a NaN is passed in, it will not signal, 
 /// and the resulting floating point value is unspecified. If an Inf is passed in,
 /// the resulting floating-point value is the corresponding Inf.
 /// </summary>
 protected static vec2 intBitsToFloat(ivec2 value)
 {
     throw _invalidAccess;
 }

 /// <summary>Returns 1.0 if x &gt; 0, 0.0 if x = 0, or –1.0 if x &lt; 0.</summary>
 /// <returns>The sign of x</returns>
 protected static ivec2 sign(ivec2 x)
 {
     throw _invalidAccess;
 }

 /// <summary>
 /// Use integer texture coordinate P to lookup a single texel from sampler. 
 /// The level-ofdetail lod is as described in sections 2.11.8 “Shader Execution” 
 /// under Texel Fetches and 3.8 “Texturing” of the OpenGL GraphicsSystem Specification.
 /// </summary>
 protected static ivec4 texelFetch(isampler2D sampler, ivec2 P, int lod)
 {
     throw _invalidAccess;
 }

 /// <summary>Returns y if y &lt; x, otherwise it returns x.</summary>
 protected internal static ivec2 Min(ivec2 x, int y)
 {
     throw _invalidAccess;
 }

 /// <summary> Fetch a single texel as in texelFetch offset by offset as described in textureOffset. </summary>
 protected static ivec4 texelFetchOffset(isampler2D sampler, ivec2 P, int lod, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary>  Do an offset texture lookup with explicit LOD. See textureLod and textureOffset.</summary>
 protected static ivec4 textureProjLodOffset(isampler2D sampler, vec4 P, float lod, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary>Do a texture lookup projectively and with explicit gradient as described in textureProjGrad,
 /// as well as with offset, as described in textureOffset.</summary>
 protected static ivec4 textureProjGradOffset(isampler2DRect sampler, vec4 P, vec2 dPdx, vec2 dPdy, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary> Do a texture lookup as in texture but with offset added to the (u,v,w) texel coordinates before looking up each texel.
 /// The offset value must be a constant expression. A limited range of offset values are supported; 
 /// the minimum and maximum offset values are implementation-dependent and given by MIN_PROGRAM_TEXEL_OFFSET and MAX_PROGRAM_TEXEL_OFFSET, respectively.
 /// Note that offset does not apply to the layer coordinate for texture arrays. This is explained in detail in section 3.8.11
 /// “Texture Minification” of the OpenGL Graphics System Specification, where offset is (∂u ,∂v ,∂w).
 /// </summary>
 protected static float textureOffset(sampler2DRectShadow sampler, vec3 P, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary>  Do an offset texture lookup with explicit LOD. See textureLod and textureOffset.</summary>
 protected static uvec4 textureLodOffset(usampler2D sampler, vec2 P, float lod, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary>  Do a projective texture lookup as described in textureProj offset by offset as described in textureOffset. </summary>
 protected static ivec4 textureProjOffset(isampler2D sampler, vec3 P, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary>
 /// Splits x into a floating-point significand in the range [0.5, 1.0) 
 /// and an integral exponent of two, such that: x=significand⋅2**exponent
 /// The significand is returned by the function and the exponent is returned in the parameter exp. 
 /// For a floating-point value of zero, the significant and exponent are both zero. 
 /// For a floating-point value that is an infinity or is not a number, the results are undefined.
 /// </summary>
 protected static dvec2 frexp(dvec2 x, out ivec2 exp)
 {
     throw _invalidAccess;
 }

 /// <summary>
 /// Builds a floating-point number from x and the corresponding integral exponent of two in exp, 
 /// returning: significand⋅2*+exponent
 /// If this product is too large to be represented in the floating-point type, the result is undefined.
 /// </summary>
 protected static dvec2 ldexp(dvec2 x, ivec2 exp)
 {
     throw _invalidAccess;
 }

 /// <summary>Returns Min (Max (x, minVal), maxVal). Results are undefined if minVal > maxVal.</summary>
 protected internal static ivec2 Clamp(ivec2 x, ivec2 minVal, ivec2 maxVal)
 {
     throw _invalidAccess;
 }

 /// <summary>Do a texture lookup with both explicit gradient and offset, as described in textureGrad and textureOffset. </summary>
 protected static uvec4 textureGradOffset(usampler2DRect sampler, vec2 P, vec2 dPdx, vec2 dPdy, ivec2 offset)
 {
     throw _invalidAccess;
 }

 /// <summary>Returns y if x &lt; y, otherwise it returns x.</summary>
 protected internal static ivec2 Max(ivec2 x, ivec2 y)
 {
     throw _invalidAccess;
 }

 /// <summary>
 /// </summary>
 /// <param name="uniformName"></param>
 /// <param name="values"></param>
 /// <returns></returns>
 public int SetUniform(string uniformName, ivec2[] values)
 {
     int location = GetUniformLocation(uniformName);
     if (location >= 0)
     {
         if (glUniform2iv == null) { glUniform2iv = OpenGL.GetDelegateFor<OpenGL.glUniform2iv>(); }
         int count = values.Length;
         var value = new int[count * 2];
         int index = 0;
         for (int i = 0; i < value.Length; i++)
         {
             value[index++] = values[i].x;
             value[index++] = values[i].y;
         }
         glUniform2iv(location, count, value);
     }
     return location;
 }

 /// <summary>  Do an offset texture lookup with explicit LOD. See TextureLod and TextureOffset.</summary>
 protected internal static ivec4 TextureLodOffset(isampler2D sampler, vec2 P, float lod, ivec2 offset)
 {
     throw _invalidAccess;
 }