*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->Tru64 Unix man pages -> glTexImage3D (3)              
Title
Content
Arch
Section
 

glTexImage3D(3G)

Contents


NAME    [Toc]    [Back]

       glTexImage3D - specify a three-dimensional texture image

SYNOPSIS    [Toc]    [Back]

       void glTexImage3D(
               GLenum target,
               GLint level,
               GLenum internalformat,
               GLsizei width,
               GLsizei height,
               GLsizei depth,
               GLint border,
               GLenum format,
               GLenum type,
               const GLvoid *pixels );

PARAMETERS    [Toc]    [Back]

       Specifies  the  target  texture.  Must be GL_TEXTURE_3D or
       GL_PROXY_TEXTURE_3D.  Specifies the  level-of-detail  number.
  Level 0 is the base image level. Level n is the n^th
       mipmap reduction image.  Specifies  the  number  of  color
       components  in  the texture. Must be 1, 2, 3, or 4, or one
       of the following symbolic constants: GL_ALPHA,  GL_ALPHA4,
       GL_ALPHA8,  GL_ALPHA12, GL_ALPHA16, GL_LUMINANCE, GL_LUMINANCE4,
  GL_LUMINANCE8,  GL_LUMINANCE12,   GL_LUMINANCE16,
       GL_LUMINANCE_ALPHA,     GL_LUMINANCE4_ALPHA4,     GL_LUMINANCE6_ALPHA2,
       GL_LUMINANCE8_ALPHA8,        GL_LUMINANCE12_ALPHA4,
      GL_LUMINANCE12_ALPHA12,      GL_LUMINANCE16_ALPHA16,
  GL_INTENSITY,  GL_INTENSITY4,  GL_INTENSITY8,
    GL_INTENSITY12,   GL_INTENSITY16,   GL_R3_G3_B2,
       GL_RGB, GL_RGB4,  GL_RGB5,  GL_RGB8,  GL_RGB10,  GL_RGB12,
       GL_RGB16,   GL_RGBA,   GL_RGBA2,   GL_RGBA4,   GL_RGB5_A1,
       GL_RGBA8, GL_RGB10_A2, GL_RGBA12, or GL_RGBA16.  Specifies
       the width of the texture image. Must be 2^n + 2 ( border )
       for some integer n. All  implementations  support  texture
       images  that  are  at least 64 texels wide.  Specifies the
       height of the texture image. Must be 2^m + 2  (  border  )
       for  some  integer  m. All implementations support texture
       images that are at least 64 texels  high.   Specifies  the
       depth of the texture image. Must be 2^k + 2 ( border ) for
       some integer k. All implementations support texture images
       that  are at least 64 texels deep.  Specifies the width of
       the border. Must be either 0 or 1.  Specifies the  of  the
       pixel  data.  The  following symbolic values are accepted:
       GL_COLOR_INDEX,  GL_RED,  GL_GREEN,   GL_BLUE,   GL_ALPHA,
       GL_RGB,   GL_BGR,   GL_RGBA,  GL_BGRA,  GL_LUMINANCE,  and
       GL_LUMINANCE_ALPHA.  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,        GL_UNSIGNED_BYTE_2_3_3_REV,
       GL_UNSIGNED_SHORT_5_6_5,      GL_UNSIGNED_SHORT_5_6_5_REV,
       GL_UNSIGNED_SHORT_4_4_4_4,  GL_UNSIGNED_SHORT_4_4_4_4_REV,
       GL_UNSIGNED_SHORT_5_5_5_1,  GL_UNSIGNED_SHORT_1_5_5_5_REV,
       GL_UNSIGNED_INT_8_8_8_8,      GL_UNSIGNED_INT_8_8_8_8_REV,
       GL_UNSIGNED_INT_10_10_10_2,                            and
       GL_UNSIGNED_INT_2_10_10_10_REV.  Specifies  a  pointer  to
       the image data in memory.




DESCRIPTION    [Toc]    [Back]

       Texturing maps a portion of a specified texture image onto
       each graphical primitive for which texturing  is  enabled.
       To  enable  and  disable three-dimensional texturing, call
       glEnable() and glDisable() with argument GL_TEXTURE_3D.

       To define texture images, call glTexImage3D().  The  arguments
  describe  the parameters of the texture image, such
       as height, width, depth, width of  the  border,  level-ofdetail
  number (see glTexParameter()), and number of color
       components provided. The last three arguments describe how
       the  image is represented in memory; they are identical to
       the pixel formats used for glDrawPixels().

       If target is GL_PROXY_TEXTURE_3D, 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
       sets all of the image state to 0, but does not generate an
       error (see glGetError()). To query for  an  entire  mipmap
       array,  use  an image array level greater than or equal to
       1.

       If target is GL_TEXTURE_3D, 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.  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 lower left corner of
       the texture image. Subsequent elements  progress  left-toright
  through  the  remaining texels in the lowest row of
       the texture image, and then in successively higher rows of
       the  texture  image.  The final element corresponds to the
       upper right corner of the texture image.

       format determines the composition of each element in  pixels.
  It  can  assume  one of eleven symbolic values: Each
       element is a single value, a color index. The GL  converts
       it 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].  Each element is a single  red
       component. The GL converts it to floating point and assembles
 it into an RGBA element by attaching 0 for green  and
       blue,  and  1 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()).
  Each element is a single green  component.
       The GL converts it to floating point and assembles it into
       an RGBA element by attaching 0 for red and blue, and 1 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()).
  Each element is a single blue component. The
       GL  converts it to floating point and assembles it into an
       RGBA element by attaching 0 for red and green, and  1  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()).
  Each element is a  single  alpha  component.
       The GL converts it to floating point and assembles it into
       an RGBA element by attaching 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()).  Each
       element is an RGB triple. The GL converts it  to  floating
       point and assembles it into an RGBA element by attaching 1
       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()).
   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] (see glPixelTransfer()).   Each
       element is a single luminance value. The GL converts it to
       floating point, then assembles it into an RGBA element  by
       replicating  the  luminance  value  three  times  for red,
       green, and blue and attaching 1 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()).  Each element is a
       luminance/alpha pair.  The  GL  converts  it  to  floating
       point, then assembles it 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()).


       Refer to the glDrawPixels() reference page for a  description
 of the acceptable values for the type parameter.

       If  an application wants to store the texture at a certain
       resolution or in a certain , it can request the resolution
       and   with  internalformat. The GL will choose an internal
       representation that closely approximates that requested by
       internalformat,  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.)


       Use the GL_PROXY_TEXTURE_3D target to try out a resolution
       and format. The implementation will update  and  recompute
       its  best match for the requested storage resolution and .
       To then query this state,  call  glGetTexLevelParameter().
       If  the  texture  cannot be accommodated, texture state is
       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.






NOTES    [Toc]    [Back]

       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().


       glTexImage3D()  is available only if the GL version is 1.2
       or greater.

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

       pixels  may be a null pointer. In this case texture memory
       is allocated to accommodate  a  texture  of  width  width,
       height height, and depth depth. You can then download subtextures
 to initialize this texture memory. The  image  is
       undefined if the user tries to apply an uninitialized portion
 of the texture image to a primitive.

       Formats     GL_BGR,     and     GL_BGRA     and      types
       GL_UNSIGNED_BYTE_3_3_2,        GL_UNSIGNED_BYTE_2_3_3_REV,
       GL_UNSIGNED_SHORT_5_6_5,      GL_UNSIGNED_SHORT_5_6_5_REV,
       GL_UNSIGNED_SHORT_4_4_4_4,  GL_UNSIGNED_SHORT_4_4_4_4_REV,
       GL_UNSIGNED_SHORT_5_5_5_1,  GL_UNSIGNED_SHORT_1_5_5_5_REV,
       GL_UNSIGNED_INT_8_8_8_8,      GL_UNSIGNED_INT_8_8_8_8_REV,
       GL_UNSIGNED_INT_10_10_10_2,                            and
       GL_UNSIGNED_INT_2_10_10_10_REV  are  available only if the
       GL version is 1.2 or greater.

       When  the  GL_ARB_multitexture  extension  is   supported,
       glTexImage3D() specifies the three-dimensional texture for
       the current  texture  unit,  specified  with  glActiveTextureARB().


       If  the  GL_ARB_imaging  extension is supported, RGBA elements
 may also be processed by the imaging pipeline.   The
       following  stages  may  be applied to an RGBA color before
       color   component   clamping   to   the   range    [0, 1]:
       GL_COLOR_TABLE,    if    enabled.    See   glColorTable().
       GL_POST_CONVOLUTION_COLOR_TABLE, if enabled.   See  glColorTable().
   and  added to GL_POST_COLOR_MATRIX_c_BIAS, if
       enabled.               See              glPixelTransfer().
       GL_POST_COLOR_MATRIX_COLOR_TABLE,  if enabled.  See glColorTable().

ERRORS    [Toc]    [Back]

       GL_INVALID_ENUM is generated  if  target  is  not  GL_TEXTURE_3D
 or GL_PROXY_TEXTURE_3D.

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

       GL_INVALID_ENUM  is  generated  if 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 0.

       GL_INVALID_VALUE may be generated if level is greater than
       log  sub  2max,  where  max  is  the  returned  value   of
       GL_MAX_TEXTURE_SIZE.

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

       GL_INVALID_VALUE  is  generated if width, height, or depth
       is less than 0 or greater than 2 + GL_MAX_TEXTURE_SIZE, or
       if  either  cannot be represented as 2^k + 2( border ) for
       some integer value of k.

       GL_INVALID_VALUE is generated if border is not 0 or 1.

       GL_INVALID_OPERATION is  generated  if  glTexImage3D()  is
       executed between the execution of glBegin() and the corresponding
 execution of glEnd().

       GL_INVALID_OPERATION  is  generated  if  type  is  one  of
       GL_UNSIGNED_BYTE_3_3_2,        GL_UNSIGNED_BYTE_2_3_3_REV,
       GL_UNSIGNED_SHORT_5_6_5,  or   GL_UNSIGNED_SHORT_5_6_5_REV
       and format is not GL_RGB.

       GL_INVALID_OPERATION  is  generated  if  type  is  one  of
       GL_UNSIGNED_SHORT_4_4_4_4,  GL_UNSIGNED_SHORT_4_4_4_4_REV,
       GL_UNSIGNED_SHORT_5_5_5_1,  GL_UNSIGNED_SHORT_1_5_5_5_REV,
       GL_UNSIGNED_INT_8_8_8_8,      GL_UNSIGNED_INT_8_8_8_8_REV,
       GL_UNSIGNED_INT_10_10_10_2,                             or
       GL_UNSIGNED_INT_2_10_10_10_REV  and  format   is   neither
       GL_RGBA nor GL_BGRA.

ASSOCIATED GETS    [Toc]    [Back]

       glGetTexImage()
       glIsEnabled() with argument GL_TEXTURE_3D

SEE ALSO    [Toc]    [Back]

      
      
       glActiveTextureARB(3),    glCopyPixels(3),    glCopyTexImage1D(3),   glCopyTexImage2D(3),   glCopyTexSubImage1D(3),
       glCopyTexSubImage2D(3), glCopyTexSubImage3D(3), glDrawPixels(3), glPixelStore(3), glPixelTransfer(3),  glTexEnv(3),
       glTexGen(3), glTexImage1D(3), glTexImage2D(3), glTexSubImage2D(3), glTexSubImage1D(3), glTexSubImage3D(3), glTexParameter




                                                 glTexImage3D(3G)
[ Back ]
 Similar pages
Name OS Title
glTexImage1D Tru64 specify a one-dimensional texture image
glteximage2d IRIX specify a two-dimensional texture image
glteximage1d IRIX specify a one-dimensional texture image
glTexImage2D Tru64 specify a two-dimensional texture image
glteximage4dext IRIX specify a four-dimensional texture image
texdef3d IRIX convert a 3-dimensional image into a texture
texdef2d IRIX convert a 2-dimensional image into a texture
texdef IRIX convert a 2-dimensional image into a texture
gltexsubimage2d IRIX specify a two-dimensional texture subimage
glTexSubImage1D Tru64 specify a one-dimensional texture subimage
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service