glTexImage1D(3G)

glTexImage1D - specify a one-dimensional texture image

As shipped in IRIX 6.5. First release of IRIX 6.5.

NAME
     glTexImage1D - specify a one-dimensional texture image


C SPECIFICATION
     void glTexImage1D( GLenum target,
                        GLint level,
                        GLint components,
                        GLsizei width,
                        GLint border,
                        GLenum format,
                        GLenum type,
                        const GLvoid *pixels )


PARAMETERS
     target      Specifies the target texture.  Must be GL_TEXTURE_1D,
                 GL_PROXY_TEXTURE_1D or GL_PROXY_TEXTURE_1D_EXT.

     level       Specifies the level-of-detail number.  Level 0 is the base
                 image level.  Level n is the nth mipmap reduction image.

     components  is used to request the internal storage format of the texture
                 image.  It must be 1, 2, 3, or 4, or one of the following
                 symbolic constants:  GL_ALPHA, GL_ALPHA4, GL_ALPHA4_EXT,
                 GL_ALPHA8, GL_ALPHA8_EXT, GL_ALPHA12, GL_ALPHA12_EXT,
                 GL_ALPHA16, GL_ALPHA16_EXT, GL_LUMINANCE, GL_LUMINANCE4,
                 GL_LUMINANCE4_EXT, GL_LUMINANCE8, GL_LUMINANCE8_EXT,
                 GL_LUMINANCE12, GL_LUMINANCE12_EXT, GL_LUMINANCE16,
                 GL_LUMINANCE16_EXT, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4,
                 GL_LUMINANCE4_ALPHA4_EXT, GL_LUMINANCE6_ALPHA2,
                 GL_LUMINANCE6_ALPHA2_EXT, GL_LUMINANCE8_ALPHA8,
                 GL_LUMINANCE8_ALPHA8_EXT, GL_LUMINANCE12_ALPHA4,
                 GL_LUMINANCE12_ALPHA4_EXT, GL_LUMINANCE12_ALPHA12,
                 GL_LUMINANCE12_ALPHA12_EXT, GL_LUMINANCE16_ALPHA16,
                 GL_LUMINANCE16_ALPHA16_EXT, GL_INTENSITY, GL_INTENSITY_EXT,
                 GL_INTENSITY4, GL_INTENSITY4_EXT, GL_INTENSITY8,
                 GL_INTENSITY8_EXT, GL_INTENSITY12, GL_INTENSITY12_EXT,
                 GL_INTENSITY16, GL_INTENSITY16_EXT, GL_RGB, GL_R3_G3_B2,
                 GL_RGB2_EXT, GL_RGB4, GL_RGB4_EXT, GL_RGB5, GL_RGB5_EXT,
                 GL_RGB8, GL_RGB8_EXT, GL_RGB10, GL_RGB10_EXT, GL_RGB12,
                 GL_RGB12_EXT, GL_RGB16, GL_RGB16_EXT, GL_RGBA, GL_RGBA2,
                 GL_RGBA2_EXT, GL_RGBA4, GL_RGBA4_EXT, GL_RGB5_A1,
                 GL_RGB5_A1_EXT, GL_RGBA8, GL_RGBA8_EXT, GL_RGB10_A2,
                 GL_RGB10_A2_EXT, GL_RGBA12, GL_RGBA12_EXT, GL_RGBA16,
                 GL_RGBA16_EXT, GL_DUAL_ALPHA4_SGIS, GL_DUAL_ALPHA8_SGIS,
                 GL_DUAL_ALPHA12_SGIS, GL_DUAL_ALPHA16_SGIS,
                 GL_DUAL_LUMINANCE4_SGIS, GL_DUAL_LUMINANCE8_SGIS,
                 GL_DUAL_LUMINANCE12_SGIS, GL_DUAL_LUMINANCE16_SGIS,
                 GL_DUAL_INTENSITY4_SGIS, GL_DUAL_INTENSITY8_SGIS,
                 GL_DUAL_INTENSITY12_SGIS, GL_DUAL_INTENSITY16_SGIS,
                 GL_DUAL_LUMINANCE_ALPHA4_SGIS, GL_DUAL_LUMINANCE_ALPHA8_SGIS,
                 GL_QUAD_ALPHA4_SGIS, GL_QUAD_ALPHA8_SGIS,
                 GL_QUAD_LUMINANCE4_SGIS, GL_QUAD_LUMINANCE8_SGIS,
                 GL_QUAD_INTENSITY4_SGIS, or GL_QUAD_INTENSITY8_SGIS.

     width       Specifies the width of the texture image.  Must be
                 2**n+2*border for some integer n.  All implementation support
                 texture images that are at least 64 texels wide. The height
                 of the texture image is 1.

     border      Specifies the width of the border.  Must be either 0 or 1.

     format      Specifies the format of the pixel data.  The following
                 symbolic values are accepted:  GL_COLOR_INDEX, GL_RED,
                 GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_RGBA, GL_ABGR_EXT,
                 GL_LUMINANCE, and GL_LUMINANCE_ALPHA.

     type        Specifies the data type of the pixel data.  The following
                 symbolic values are accepted:  GL_UNSIGNED_BYTE, GL_BYTE,
                 GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT,
                 GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2_EXT,
                 GL_UNSIGNED_SHORT_4_4_4_4_EXT, GL_UNSIGNED_SHORT_5_5_5_1_EXT,
                 GL_UNSIGNED_INT_8_8_8_8_EXT, and
                 GL_UNSIGNED_INT_10_10_10_2_EXT.

     pixels      Specifies a pointer to the image data in memory.

DESCRIPTION
     Texturing maps a portion of a specified texture image onto each graphical
     primitive for which texturing is enabled.  To enable and disable one-
     dimensional texturing, use glEnable and glDisable with argument
     GL_TEXTURE_1D.

     Texture images are defined with glTexImage1D.  The arguments describe the
     parameters of the texture image, such as width, width of the border,
     level-of-detail number (see glTexParameter), and the internal resolution
     and format used to store the image.  The last three arguments describe
     how the image is represented in memory, and they are identical to the
     pixel formats used for glDrawPixels.

     If target is GL_PROXY_TEXTURE_1D or GL_PROXY_TEXTURE_1D_EXT no data is
     read from pixels,  but all of the texture image state is recalculated,
     checked for consistency, and checked against the implementation's
     capabilities.  If the implementation cannot handle a texture of the
     requested texture size, it will set all of the texture image state to 0
     (GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_BORDER,
     GL_TEXTURE_INTERNAL_FORMAT, GL_TEXTURE_COMPONENTS, GL_TEXTURE_RED_SIZE,
     GL_TEXTURE_RED_SIZE_EXT, GL_TEXTURE_GREEN_SIZE,
     GL_TEXTURE_GREEN_SIZE_EXT, GL_TEXTURE_BLUE_SIZE,
     GL_TEXTURE_BLUE_SIZE_EXT, GL_TEXTURE_ALPHA_SIZE,
     GL_TEXTURE_ALPHA_SIZE_EXT, GL_TEXTURE_LUMINANCE_SIZE,
     GL_TEXTURE_LUMINANCE_SIZE_EXT, GL_TEXTURE_INTENSITY_SIZE), and
     GL_TEXTURE_INTENSITY_SIZE_EXT), but no error will be generated.
     If target is GL_TEXTURE_1D, data is read from pixels as a sequence of
     signed or unsigned bytes, shorts, or longs, or single-precision
     floating-point values, depending on type. These values are grouped into
     sets of one, two, three, or four values, depending on format, to form
     elements. (Note that if type is set to GL_UNSIGNED_BYTE_3_3_2_EXT,
     GL_UNSIGNED_SHORT_4_4_4_4_EXT, GL_UNSIGNED_SHORT_5_5_5_1_EXT,
     GL_UNSIGNED_INT_8_8_8_8_EXT, or GL_UNSIGNED_INT_10_10_10_2_EXT then it is
     a special case in which all the elements of each group are packed into a
     single unsigned byte, unsigned short, or unsigned int. This is described
     in glDrawPixels.)

     If type is GL_BITMAP, the data is considered as a string of unsigned
     bytes (and format must be GL_COLOR_INDEX). Each data byte is treated as
     eight 1-bit elements, with bit ordering determined by GL_UNPACK_LSB_FIRST
     (see glPixelStore).

     The first element corresponds to the left end of the texture array.
     Subsequent elements progress left-to-right through the remaining texels
     in the texture array.  The final element corresponds to the right end of
     the texture array.

     format determines the composition of each element in pixels.  It can
     assume one of nine symbolic values:

     GL_COLOR_INDEX
               Each element is a single value, a color index. It is converted
               to fixed point (with an unspecified number of zero bits to the
               right of the binary point), shifted left or right depending on
               the value and sign of GL_INDEX_SHIFT, and added to
               GL_INDEX_OFFSET (see glPixelTransfer). The resulting index is
               converted to a set of color components using the
               GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B,
               and GL_PIXEL_MAP_I_TO_A tables, and clamped to the range [0,1].

     GL_RED    Each element is a single red component. It is converted to
               floating point and assembled into an RGBA element by attaching
               0.0 for green and blue, and 1.0 for alpha. Each component is
               then multiplied by the signed scale factor GL_c_SCALE, added to
               the signed bias GL_c_BIAS, and clamped to the range [0,1] (see
               glPixelTransfer).

     GL_GREEN  Each element is a single green component. It is converted to
               floating point and assembled into an RGBA element by attaching
               0.0 for red and blue, and 1.0 for alpha. Each component is then
               multiplied by the signed scale factor GL_c_SCALE, added to the
               signed bias GL_c_BIAS, and clamped to the range [0,1] (see
               glPixelTransfer).

     GL_BLUE   Each element is a single blue component. It is converted to
               floating point and assembled into an RGBA element by attaching
               0.0 for red and green, and 1.0 for alpha. Each component is
               then multiplied by the signed scale factor GL_c_SCALE, added to
               the signed bias GL_c_BIAS, and clamped to the range [0,1] (see
               glPixelTransfer).

     GL_ALPHA  Each element is a single alpha component. It is converted to
               floating point and assembled into an RGBA element by attaching
               0.0 for red, green, and blue.  Each component is then
               multiplied by the signed scale factor GL_c_SCALE, added to the
               signed bias GL_c_BIAS, and clamped to the range [0,1] (see
               glPixelTransfer).

     GL_RGB    Each element is an RGB triple.  It is converted to floating
               point and assembled into an RGBA element by attaching 1.0 for
               alpha.  Each component is then multiplied by the signed scale
               factor GL_c_SCALE, added to the signed bias GL_c_BIAS, and
               clamped to the range [0,1] (see  glPixelTransfer).

     GL_RGBA,

     GL_ABGR_EXT
               Each element contains all four components.  Each component is
               multiplied by the signed scale factor GL_c_SCALE, added to the
               signed bias GL_c_BIAS, and clamped to the range [0,1].
               GL_ABGR_EXT may be faster or slower than GL_RGBA depending on
               the internal ordering native to the GL.  (see glPixelTransfer).

     GL_LUMINANCE
               Each element is a single luminance value.  It is converted to
               floating point, then assembled into an RGBA element by
               replicating the luminance value three times for red, green, and
               blue and attaching 1.0 for alpha. Each component is then
               multiplied by the signed scale factor GL_c_SCALE, added to the
               signed bias GL_c_BIAS, and clamped to the range [0,1] (see
               glPixelTransfer).

     GL_LUMINANCE_ALPHA
               Each element is a luminance/alpha pair.  It is converted to
               floating point, then assembled into an RGBA element by
               replicating the luminance value three times for red, green, and
               blue.  Each component is then multiplied by the signed scale
               factor GL_c_SCALE, added to the signed bias GL_c_BIAS, and
               clamped to the range [0,1] (see glPixelTransfer).

     An application may desire that the texture be stored at a certain
     resolution, or that it be stored in a certain format. This resolution and
     format can be requested by components. The GL will choose an internal
     representation that closely approximates that requested by components,
     but it may not match exactly.  (The representations specified by
     GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, and GL_RGBA must match exactly.
     The numeric values 1, 2, 3, and 4 may also be used to specify the above
     representations.) The GL_PROXY_TEXTURE_1D and GL_PROXY_TEXTURE_1D_EXT
     targets can be used to try-out a resolution and format, the
     implementation will update and recompute it's best match for the
     requested storage resolution and format. This state can then be queried
     using glGetTexLevelParameter.  If the texture cannot be accomodated
     texture state will be set to 0.

     A one-component texture image uses only the red component of the RGBA
     color extracted from pixels. A two-component image uses the R and A
     values.  A three-component image uses the R, G, and B values.  A four-
     component image uses all of the RGBA components.

     The mapping of components from the canonical RGBA to the internal storage
     formats that begin with GL_DUAL_ and GL_QUAD_ needs to be clarified.
     There are three cases.  The first case is for the GL_DUAL_ formats that
     are groups of GL_ALPHA, GL_LUMINANCE, and GL_INTENSITY.  The R value goes
     to the first group while the A value goes to the second group.  The
     second case is for the GL_DUAL_ formats that are groups of
     GL_LUMINANCE_ALPHA.  The R and G values go to the first group while the B
     and A values go to the second group.  The third case is for the GL_QUAD_
     formats.  The R value goes to the first group, the G value to the second
     group, the B value to the third group, and the A value to the fourth
     group.

NOTES
     Texturing has no effect in color index mode.

     The texture image can be represented by the same data formats as the
     pixels in a glDrawPixels command, except that GL_STENCIL_INDEX and
     GL_DEPTH_COMPONENT cannot be used.  glPixelStore and glPixelTransfer
     modes affect texture images in exactly the way they affect glDrawPixels.

     GL_PROXY_TEXTURE_1D may only be used if the GL version is 1.1 or greater.

     Internal formats other than 1, 2, 3, or 4 may only be used if the GL
     version is 1.1 or greater.

     In GL version 1.1 or greater, pixels may be a null pointer. In this case
     texture memory is allocated to accommodate a texture of width width.  You
     can then download subtextures to initialize the texture memory. The image
     is undefined if the program tries to apply an uninitialized portion of
     the texture image to a primitive.

     If the extensions string contains GL_EXT_abgr, then EXT_abgr is
     supported.

     If type is set to GL_UNSIGNED_BYTE_3_3_2_EXT,
     GL_UNSIGNED_SHORT_4_4_4_4_EXT, GL_UNSIGNED_SHORT_5_5_5_1_EXT,
     GL_UNSIGNED_INT_8_8_8_8_EXT, or GL_UNSIGNED_INT_10_10_10_2_EXT and the
     EXT_packed_pixels extension is not supported then a GL_INVALID_ENUM error
     is generated.

     See glIntro for more information on using extensions.

ERRORS
     GL_INVALID_ENUM is generated when target is not GL_TEXTURE_1D.

     GL_INVALID_ENUM is generated when format is not an accepted format
     constant.  Format constants other than GL_STENCIL_INDEX and
     GL_DEPTH_COMPONENT are accepted.

     GL_INVALID_ENUM is generated when type is not a type constant.

     GL_INVALID_ENUM is generated if type is GL_BITMAP and format is not
     GL_COLOR_INDEX.

     GL_INVALID_VALUE is generated if level is less than zero.

     GL_INVALID_VALUE is generated if components is not 1, 2, 3, or 4 or one
     of the accepted resolution and format symbolic constants.

     GL_INVALID_VALUE is generated if width is less than zero or greater than
     2 + GL_MAX_TEXTURE_SIZE, or if it cannot be represented as 2**n+2*border
     for some integer value of n.

     GL_INVALID_VALUE is generated if border is not 0 or 1.

     GL_INVALID_OPERATION is generated if glTexImage1D is executed between the
     execution of glBegin and the corresponding execution of glEnd.

     GL_INVALID_VALUE is generated if the implementation cannot accomodate a
     texture of the size requested.

ASSOCIATED GETS
     glGetTexImage
     glIsEnabled with argument GL_TEXTURE_1D
     glGetTexLevelParameter with a first argument of GL_PROXY_TEXTURE_1D or
     GL_PROXY_TEXTURE_1D_EXT and a third argument of GL_TEXTURE_RED_SIZE,
     GL_TEXTURE_RED_SIZE_EXT, GL_TEXTURE_GREEN_SIZE,
     GL_TEXTURE_GREEN_SIZE_EXT, GL_TEXTURE_BLUE_SIZE,
     GL_TEXTURE_BLUE_SIZE_EXT, GL_TEXTURE_ALPHA_SIZE,
     GL_TEXTURE_ALPHA_SIZE_EXT, GL_TEXTURE_LUMINANCE_SIZE,
     GL_TEXTURE_LUMINANCE_SIZE_EXT, GL_TEXTURE_INTENSITY_SIZE,
     GL_TEXTURE_INTENSITY_SIZE_EXT, GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT,
     GL_TEXTURE_BORDER, GL_TEXTURE_INTERNAL_FORMAT, or GL_TEXTURE_COMPONENTS.



MACHINE DEPENDENCIES
     RealityEngine, RealityEngine2, and VTX systems do not support color
     matrix transformations on images as they are loaded to or read back from
     texture memory.

     RealityEngine, RealityEngine2, and VTX systems do not support convolving
     images as they are loaded into texture memory.

     RealityEngine, RealityEngine2, and VTX systems do not support histogram
     or minmax operations on images as they are being loaded into texture
     memory.

     The EXT_packed_pixels extension is not supported on RealityEngine,
     RealityEngine2, and VTX systems.

     On RealityEngine, RealityEngine2, and VTX systems:

          1.  The texture environment must be defined and texturing must be
              enabled before loading a texture.

          2.  Texture formats composed only of alpha are not supported.

          3.  Borders are not supported; hence the border width must be 0.

          4.  Proxy textures are not supported.

          5.  glTexImage2D with a NULL texture image may not be used inside a
              display list.

          6.  GL_INTERLACE_SGIX is not supported (see glEnable).

     On High Impact and Maximum Impact systems the number of bits per
     component, represented internally, is the same for all components and
     will be 4, 8, or 12 bits per component. All specified internal formats
     will receive an equal or greater representation in this scheme, up to the
     12-bit limit.  High Impact and Maximum Impact on Indigo2 systems do not
     support texture internal formats of the type GL_INTENSITY or GL_ALPHA,
     although High Impact and Maximum Impact on Octane systems do support
     these types.

     High Impact and Maximum Impact on Indigo2 systems without the TRAM option
     card support 4 bits per component for GL_RGB and GL_RGBA, 4/8 bits per
     component for GL_LUMINANCE_ALPHA, and 4/8/12 bits per component for
     GL_LUMINANCE.

     Texture borders are not supported on InfiniteReality systems, so the
     border width should always be zero.  Applications should use the texture
     wrap mode GL_CLAMP_TO_EDGE_SGIS to obtain behavior similar to that of
     borders.

     The SGIS_texture_select extension is supported only on InfiniteReality
     systems, High Impact and Maximum Impact on Octane systems, and High
     Impact and Maximum Impact on Indigo2 systems with the TRAM option card.

     On InfiniteReality, RealityEngine, RealityEngine2, and VTX systems, and
     High Impact and Maximum Impact systems, texture objects (see
     glBindTextureEXT) are significantly faster than display-listed textures,
     and therefore are recommended for managing texture memory.

SEE ALSO_cmnd(CopyPixels),
     glCopyTexImage1D, glCopyTexImage2D, glCopyTexSubImage1D,
     glCopyTexSubImage2D, glDrawPixels, glPixelStore, glPixelTransfer,
     glTexEnv, glTexGen, glTexImage2D, glTexSubImage1D, glTexSubImage2D,
     glTexParameter