1GLTEXIMAGE1D(3G) [FIXME: manual] GLTEXIMAGE1D(3G)
2
6 glTexImage1D - specify a one-dimensional texture image
7
9 void glTexImage1D(GLenum target, GLint level, GLint internalformat,
10 GLsizei width, GLint border, GLenum format,
11 GLenum type, const GLvoid * data);
12
14 target
15 Specifies the target texture. Must be GL_TEXTURE_1D or
16 GL_PROXY_TEXTURE_1D.
17 level
19 Specifies the level-of-detail number. Level 0 is the base image
20 level. Level n is the nth mipmap reduction image.
21 internalformat
23 Specifies the number of color components in the texture. Must be
24 one of base internal formats given in Table 1, one of the sized
25 internal formats given in Table 2, or one of the compressed
26 internal formats given in Table 3, below.
27 width
29 Specifies the width of the texture image. All implementations
30 support texture images that are at least 1024 texels wide. The
31 height of the 1D texture image is 1.
32 border
34 This value must be 0.
35 format
37 Specifies the format of the pixel data. The following symbolic
38 values are accepted: GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA,
39 GL_BGRA, GL_RED_INTEGER, GL_RG_INTEGER, GL_RGB_INTEGER,
40 GL_BGR_INTEGER, GL_RGBA_INTEGER, GL_BGRA_INTEGER, GL_STENCIL_INDEX,
41 GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL.
42 type
44 Specifies the data type of the pixel data. The following symbolic
45 values are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT,
46 GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_HALF_FLOAT, GL_FLOAT,
47 GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV,
48 GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV,
49 GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV,
50 GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV,
51 GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV,
52 GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV.
53 data
55 Specifies a pointer to the image data in memory.
56
58 Texturing maps a portion of a specified texture image onto each
59 graphical primitive for which texturing is enabled. To enable and
60 disable one-dimensional texturing, call glEnable() and
61 glDisable with argument GL_TEXTURE_1D.
63 Texture images are defined with glTexImage1D. The arguments describe
65 the parameters of the texture image, such as width, width of the
66 border, level-of-detail number (see glTexParameter()), and the internal
67 resolution and format used to store the image. The last three arguments
68 describe how the image is represented in memory.
69 If target is GL_PROXY_TEXTURE_1D, no data is read from data, but all of
71 the texture image state is recalculated, checked for consistency, and
72 checked against the implementation's capabilities. If the
73 implementation cannot handle a texture of the requested texture size,
74 it sets all of the image state to 0, but does not generate an error
75 (see glGetError()). To query for an entire mipmap array, use an image
76 array level greater than or equal to 1.
77 If target is GL_TEXTURE_1D, data is read from data as a sequence of
79 signed or unsigned bytes, shorts, or longs, or single-precision
80 floating-point values, depending on type. These values are grouped into
81 sets of one, two, three, or four values, depending on format, to form
82 elements. Each data byte is treated as eight 1-bit elements, with bit
83 ordering determined by GL_UNPACK_LSB_FIRST (see glPixelStore()).
84 If a non-zero named buffer object is bound to the
86 GL_PIXEL_UNPACK_BUFFER target (see glBindBuffer()) while a texture
87 image is specified, data is treated as a byte offset into the buffer
88 object's data store.
89 The first element corresponds to the left end of the texture array.
91 Subsequent elements progress left-to-right through the remaining texels
92 in the texture array. The final element corresponds to the right end of
93 the texture array.
94 format determines the composition of each element in data. It can
96 assume one of these symbolic values:
97 GL_RED
99 Each element is a single red component. The GL converts it to
100 floating point and assembles it into an RGBA element by attaching 0
101 for green and blue, and 1 for alpha. Each component is clamped to
102 the range [0,1].
103 GL_RG
105 Each element is a single red/green double The GL converts it to
106 floating point and assembles it into an RGBA element by attaching 0
107 for blue, and 1 for alpha. Each component is clamped to the range
108 [0,1].
109 GL_RGB, GL_BGR
111 Each element is an RGB triple. The GL converts it to floating point
112 and assembles it into an RGBA element by attaching 1 for alpha.
113 Each component is clamped to the range [0,1].
114 GL_RGBA, GL_BGRA
116 Each element contains all four components. Each component clamped
117 to the range [0,1].
118 GL_DEPTH_COMPONENT
120 Each element is a single depth value. The GL converts it to
121 floating point and clamps to the range [0,1].
122 If an application wants to store the texture at a certain resolution or
124 in a certain format, it can request the resolution and format with
125 internalformat. The GL will choose an internal representation that
126 closely approximates that requested by internalformat, but it may not
127 match exactly. (The representations specified by GL_RED, GL_RG, GL_RGB
128 and GL_RGBA must match exactly.)
129 internalformat may be one of the base internal formats shown in Table
131 1, below
132 Table 1. Base Internal Formats
134 ┌───────────────────┬───────────────────┬─────────────────────┐
135 │Base Internal │ RGBA, Depth and │ Internal Components │
136 │Format │ Stencil Values │ │
137 ├───────────────────┼───────────────────┼─────────────────────┤
138 │GL_DEPTH_COMPONENT │ Depth │ D │
139 ├───────────────────┼───────────────────┼─────────────────────┤
140 │GL_DEPTH_STENCIL │ Depth, Stencil │ D, S │
141 ├───────────────────┼───────────────────┼─────────────────────┤
142 │GL_RED │ Red │ R │
143 ├───────────────────┼───────────────────┼─────────────────────┤
144 │GL_RG │ Red, Green │ R, G │
145 ├───────────────────┼───────────────────┼─────────────────────┤
146 │GL_RGB │ Red, Green, Blue │ R, G, B │
147 ├───────────────────┼───────────────────┼─────────────────────┤
148 │GL_RGBA │ Red, Green, Blue, │ R, G, B, A │
149 │ │ Alpha │ │
150 └───────────────────┴───────────────────┴─────────────────────┘
151 internalformat may also be one of the sized internal formats shown in
153 Table 2, below
154 Table 2. Sized Internal Formats
156 ┌──────────────────┬──────────┬──────────┬────────────┬───────────┬────────────┬────────┐
157 │Sized │ Base │ Red Bits │ Green Bits │ Blue Bits │ Alpha Bits │ Shared │
158 │Internal │ Internal │ │ │ │ │ Bits │
159 │Format │ Format │ │ │ │ │ │
160 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
161 │GL_R8 │ GL_RED │ 8 │ │ │ │ │
162 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
163 │GL_R8_SNORM │ GL_RED │ s8 │ │ │ │ │
164 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
165 │GL_R16 │ GL_RED │ 16 │ │ │ │ │
166 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
167 │GL_R16_SNORM │ GL_RED │ s16 │ │ │ │ │
168 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
169 │GL_RG8 │ GL_RG │ 8 │ 8 │ │ │ │
170 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
171 │GL_RG8_SNORM │ GL_RG │ s8 │ s8 │ │ │ │
172 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
173 │GL_RG16 │ GL_RG │ 16 │ 16 │ │ │ │
174 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
175 │GL_RG16_SNORM │ GL_RG │ s16 │ s16 │ │ │ │
176 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
177 │GL_R3_G3_B2 │ GL_RGB │ 3 │ 3 │ 2 │ │ │
178 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
179 │GL_RGB4 │ GL_RGB │ 4 │ 4 │ 4 │ │ │
180 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
181 │GL_RGB5 │ GL_RGB │ 5 │ 5 │ 5 │ │ │
182 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
183 │GL_RGB8 │ GL_RGB │ 8 │ 8 │ 8 │ │ │
184 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
185 │GL_RGB8_SNORM │ GL_RGB │ s8 │ s8 │ s8 │ │ │
186 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
187 │GL_RGB10 │ GL_RGB │ 10 │ 10 │ 10 │ │ │
188 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
189 │GL_RGB12 │ GL_RGB │ 12 │ 12 │ 12 │ │ │
190 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
191 │GL_RGB16_SNORM │ GL_RGB │ 16 │ 16 │ 16 │ │ │
192 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
193 │GL_RGBA2 │ GL_RGB │ 2 │ 2 │ 2 │ 2 │ │
194 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
195 │GL_RGBA4 │ GL_RGB │ 4 │ 4 │ 4 │ 4 │ │
196 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
197 │GL_RGB5_A1 │ GL_RGBA │ 5 │ 5 │ 5 │ 1 │ │
198 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
199 │GL_RGBA8 │ GL_RGBA │ 8 │ 8 │ 8 │ 8 │ │
200 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
201 │GL_RGBA8_SNORM │ GL_RGBA │ s8 │ s8 │ s8 │ s8 │ │
202 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
203 │GL_RGB10_A2 │ GL_RGBA │ 10 │ 10 │ 10 │ 2 │ │
204 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
205 │GL_RGB10_A2UI │ GL_RGBA │ ui10 │ ui10 │ ui10 │ ui2 │ │
206 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
207 │GL_RGBA12 │ GL_RGBA │ 12 │ 12 │ 12 │ 12 │ │
208 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
209 │GL_RGBA16 │ GL_RGBA │ 16 │ 16 │ 16 │ 16 │ │
210 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
211 │GL_SRGB8 │ GL_RGB │ 8 │ 8 │ 8 │ │ │
212 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
213 │GL_SRGB8_ALPHA8 │ GL_RGBA │ 8 │ 8 │ 8 │ 8 │ │
214 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
215 │GL_R16F │ GL_RED │ f16 │ │ │ │ │
216 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
217 │GL_RG16F │ GL_RG │ f16 │ f16 │ │ │ │
218 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
219 │GL_RGB16F │ GL_RGB │ f16 │ f16 │ f16 │ │ │
220 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
221 │GL_RGBA16F │ GL_RGBA │ f16 │ f16 │ f16 │ f16 │ │
222 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
223 │GL_R32F │ GL_RED │ f32 │ │ │ │ │
224 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
225 │GL_RG32F │ GL_RG │ f32 │ f32 │ │ │ │
226 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
227 │GL_RGB32F │ GL_RGB │ f32 │ f32 │ f32 │ │ │
228 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
229 │GL_RGBA32F │ GL_RGBA │ f32 │ f32 │ f32 │ f32 │ │
230 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
231 │GL_R11F_G11F_B10F │ GL_RGB │ f11 │ f11 │ f10 │ │ │
232 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
233 │GL_RGB9_E5 │ GL_RGB │ 9 │ 9 │ 9 │ │ 5 │
234 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
235 │GL_R8I │ GL_RED │ i8 │ │ │ │ │
236 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
237 │GL_R8UI │ GL_RED │ ui8 │ │ │ │ │
238 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
239 │GL_R16I │ GL_RED │ i16 │ │ │ │ │
240 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
241 │GL_R16UI │ GL_RED │ ui16 │ │ │ │ │
242 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
243 │GL_R32I │ GL_RED │ i32 │ │ │ │ │
244 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
245 │GL_R32UI │ GL_RED │ ui32 │ │ │ │ │
246 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
247 │GL_RG8I │ GL_RG │ i8 │ i8 │ │ │ │
248 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
249 │GL_RG8UI │ GL_RG │ ui8 │ ui8 │ │ │ │
250 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
251 │GL_RG16I │ GL_RG │ i16 │ i16 │ │ │ │
252 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
253 │GL_RG16UI │ GL_RG │ ui16 │ ui16 │ │ │ │
254 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
255 │GL_RG32I │ GL_RG │ i32 │ i32 │ │ │ │
256 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
257 │GL_RG32UI │ GL_RG │ ui32 │ ui32 │ │ │ │
258 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
259 │GL_RGB8I │ GL_RGB │ i8 │ i8 │ i8 │ │ │
260 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
261 │GL_RGB8UI │ GL_RGB │ ui8 │ ui8 │ ui8 │ │ │
262 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
263 │GL_RGB16I │ GL_RGB │ i16 │ i16 │ i16 │ │ │
264 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
265 │GL_RGB16UI │ GL_RGB │ ui16 │ ui16 │ ui16 │ │ │
266 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
267 │GL_RGB32I │ GL_RGB │ i32 │ i32 │ i32 │ │ │
268 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
269 │GL_RGB32UI │ GL_RGB │ ui32 │ ui32 │ ui32 │ │ │
270 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
271 │GL_RGBA8I │ GL_RGBA │ i8 │ i8 │ i8 │ i8 │ │
272 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
273 │GL_RGBA8UI │ GL_RGBA │ ui8 │ ui8 │ ui8 │ ui8 │ │
274 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
275 │GL_RGBA16I │ GL_RGBA │ i16 │ i16 │ i16 │ i16 │ │
276 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
277 │GL_RGBA16UI │ GL_RGBA │ ui16 │ ui16 │ ui16 │ ui16 │ │
278 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
279 │GL_RGBA32I │ GL_RGBA │ i32 │ i32 │ i32 │ i32 │ │
280 ├──────────────────┼──────────┼──────────┼────────────┼───────────┼────────────┼────────┤
281 │GL_RGBA32UI │ GL_RGBA │ ui32 │ ui32 │ ui32 │ ui32 │ │
282 └──────────────────┴──────────┴──────────┴────────────┴───────────┴────────────┴────────┘
283 Finally, internalformat may also be one of the generic or compressed
285 texture formats shown in Table 3 below
286 Table 3. Compressed Internal Formats
288 ┌──────────────────────────────────────┬───────────────┬──────────┐
289 │Compressed Internal │ Base Internal │ Type │
290 │Format │ Format │ │
291 ├──────────────────────────────────────┼───────────────┼──────────┤
292 │GL_COMPRESSED_RED │ GL_RED │ Generic │
293 ├──────────────────────────────────────┼───────────────┼──────────┤
294 │GL_COMPRESSED_RG │ GL_RG │ Generic │
295 ├──────────────────────────────────────┼───────────────┼──────────┤
296 │GL_COMPRESSED_RGB │ GL_RGB │ Generic │
297 ├──────────────────────────────────────┼───────────────┼──────────┤
298 │GL_COMPRESSED_RGBA │ GL_RGBA │ Generic │
299 ├──────────────────────────────────────┼───────────────┼──────────┤
300 │GL_COMPRESSED_SRGB │ GL_RGB │ Generic │
301 ├──────────────────────────────────────┼───────────────┼──────────┤
302 │GL_COMPRESSED_SRGB_ALPHA │ GL_RGBA │ Generic │
303 ├──────────────────────────────────────┼───────────────┼──────────┤
304 │GL_COMPRESSED_RED_RGTC1 │ GL_RED │ Specific │
305 ├──────────────────────────────────────┼───────────────┼──────────┤
306 │GL_COMPRESSED_SIGNED_RED_RGTC1 │ GL_RED │ Specific │
307 ├──────────────────────────────────────┼───────────────┼──────────┤
308 │GL_COMPRESSED_RG_RGTC2 │ GL_RG │ Specific │
309 ├──────────────────────────────────────┼───────────────┼──────────┤
310 │GL_COMPRESSED_SIGNED_RG_RGTC2 │ GL_RG │ Specific │
311 ├──────────────────────────────────────┼───────────────┼──────────┤
312 │GL_COMPRESSED_RGBA_BPTC_UNORM │ GL_RGBA │ Specific │
313 ├──────────────────────────────────────┼───────────────┼──────────┤
314 │GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM │ GL_RGBA │ Specific │
315 ├──────────────────────────────────────┼───────────────┼──────────┤
316 │GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT │ GL_RGB │ Specific │
317 ├──────────────────────────────────────┼───────────────┼──────────┤
318 │GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT │ GL_RGB │ Specific │
319 └──────────────────────────────────────┴───────────────┴──────────┘
320 If the internalformat parameter is one of the generic compressed
322 formats, GL_COMPRESSED_RED, GL_COMPRESSED_RG, GL_COMPRESSED_RGB, or
323 GL_COMPRESSED_RGBA, the GL will replace the internal format with the
324 symbolic constant for a specific internal format and compress the
325 texture before storage. If no corresponding internal format is
326 available, or the GL can not compress that image for any reason, the
327 internal format is instead replaced with a corresponding base internal
328 format.
329 If the internalformat parameter is GL_SRGB, GL_SRGB8, GL_SRGB_ALPHAor
331 GL_SRGB8_ALPHA8, the texture is treated as if the red, green, or blue
332 components are encoded in the sRGB color space. Any alpha component is
333 left unchanged. The conversion from the sRGB encoded component c s to a
334 linear component c l is:
335 c l = { c s 12.92 if c s ≤ 0.04045 ( c s + 0.055 1.055 ) 2.4 if c s >
337 0.04045
338 Assume c s is the sRGB component in the range [0,1].
340 Use the GL_PROXY_TEXTURE_1D target to try out a resolution and format.
342 The implementation will update and recompute its best match for the
343 requested storage resolution and format. To then query this state, call
344 glGetTexLevelParameter(). If the texture cannot be accommodated,
345 texture state is set to 0.
346 A one-component texture image uses only the red component of the RGBA
348 color from data. A two-component image uses the R and A values. A
349 three-component image uses the R, G, and B values. A four-component
350 image uses all of the RGBA components.
351 Image-based shadowing can be enabled by comparing texture r coordinates
353 to depth texture values to generate a boolean result. See
354 glTexParameter() for details on texture comparison.
355
357 glPixelStore() modes affect texture images.
358 data may be a null pointer. In this case texture memory is allocated to
360 accommodate a texture of width width. You can then download subtextures
361 to initialize the texture memory. The image is undefined if the program
362 tries to apply an uninitialized portion of the texture image to a
363 primitive.
364 glTexImage1D specifies the one-dimensional texture for the current
366 texture unit, specified with glActiveTexture().
367 GL_STENCIL_INDEX may be used for format only if the GL version is 4.4
369 or higher.
370
372 GL_INVALID_ENUM is generated if target is not GL_TEXTURE_1D or
373 GL_PROXY_TEXTURE_1D.
374 GL_INVALID_ENUM is generated if format is not an accepted format
376 constant. Format constants other than GL_STENCIL_INDEX are accepted.
377 GL_INVALID_ENUM is generated if type is not a type constant.
379 GL_INVALID_VALUE is generated if level is less than 0.
381 GL_INVALID_VALUE may be generated if level is greater than log 2 max,
383 where max is the returned value of GL_MAX_TEXTURE_SIZE.
384 GL_INVALID_VALUE is generated if internalformat is not one of the
386 accepted resolution and format symbolic constants.
387 GL_INVALID_VALUE is generated if width is less than 0 or greater than
389 GL_MAX_TEXTURE_SIZE.
390 GL_INVALID_VALUE is generated if border is not 0.
392 GL_INVALID_OPERATION is generated if type is one of
394 GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV,
395 GL_UNSIGNED_SHORT_5_6_5, or GL_UNSIGNED_SHORT_5_6_5_REV and format is
396 not GL_RGB.
397 GL_INVALID_OPERATION is generated if type is one of
399 GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV,
400 GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV,
401 GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV,
402 GL_UNSIGNED_INT_10_10_10_2, or GL_UNSIGNED_INT_2_10_10_10_REV and
403 format is neither GL_RGBA nor GL_BGRA.
404 GL_INVALID_OPERATION is generated if format is GL_DEPTH_COMPONENT and
406 internalformat is not GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16,
407 GL_DEPTH_COMPONENT24, or GL_DEPTH_COMPONENT32.
408 GL_INVALID_OPERATION is generated if internalformat is
410 GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, or
411 GL_DEPTH_COMPONENT32, and format is not GL_DEPTH_COMPONENT.
412 GL_INVALID_OPERATION is generated if a non-zero buffer object name is
414 bound to the GL_PIXEL_UNPACK_BUFFER target and the buffer object's data
415 store is currently mapped.
416 GL_INVALID_OPERATION is generated if a non-zero buffer object name is
418 bound to the GL_PIXEL_UNPACK_BUFFER target and the data would be
419 unpacked from the buffer object such that the memory reads required
420 would exceed the data store size.
421 GL_INVALID_OPERATION is generated if a non-zero buffer object name is
423 bound to the GL_PIXEL_UNPACK_BUFFER target and data is not evenly
424 divisible into the number of bytes needed to store in memory a datum
425 indicated by type.
426
428 glGetTexImage()
429 glGet() with argument GL_PIXEL_UNPACK_BUFFER_BINDING
431
433 ┌──────────────┬───────────────────────────────────────────────────────────────────────┐
434 │ │ OpenGL Version │
435 ├──────────────┼─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┤
436 │Function │ 2.0 │ 2.1 │ 3.0 │ 3.1 │ 3.2 │ 3.3 │ 4.0 │ 4.1 │ 4.2 │ 4.3 │ 4.4 │ 4.5 │
437 │/ │ │ │ │ │ │ │ │ │ │ │ │ │
438 │Feature │ │ │ │ │ │ │ │ │ │ │ │ │
439 │Name │ │ │ │ │ │ │ │ │ │ │ │ │
440 ├──────────────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
441 │glTexImage1D │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │
442 ├──────────────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
443 │GL_HALF_FLOAT │ - │ - │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │ ✔ │
444 └──────────────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
445
447 glActiveTexture(), glCompressedTexImage1D(),
448 glCompressedTexSubImage1D(), glCopyTexImage1D(), glCopyTexSubImage1D(),
449 glGetCompressedTexImage(), glPixelStore(), glTexImage2D(),
450 glTexImage3D(), glTexSubImage1D(), glTexSubImage2D(),
451 glTexSubImage3D(), glTexParameter()
452
454 Copyright © 1991-2006 Silicon Graphics, Inc. Copyright © 2011-2014
455 Khronos Group. This document is licensed under the SGI Free Software B
456 License. For details, see http://oss.sgi.com/projects/FreeB/.
457
459 Copyright © 1991-2006 Silicon Graphics, Inc.
460[FIXME: source] 03/06/2019 GLTEXIMAGE1D(3G)