GLCLEARBUFFERDATA(3G)

📦

version 1.1 · 7 versions

1.1 · centos-stream 9 (latest)
arch rolling
1.1 · fedora 43
1.0~svn33624 · ubuntu jammy, ubuntu noble
1.1 · fedora 44
1.0~svn33624 · ubuntu resolute, ubuntu stonking
1.0~svn33624 · debian trixie, ubuntu questing

💖 NAME

Yeah bestie, this is the glClearBufferData(3G) manual page — GLCLEARBUFFERDATA(3G) if we're yelling it in all caps — and the header is also doing a whole [FIXME: manual] placeholder moment. The actual assignment is iconic and simple: glClearBufferData, glClearNamedBufferData — fill a buffer object's data store with a fixed value. Periodt. 💅

🧾 C SPECIFICATION

Okay so the C-level vibe is exactly this, and yes these signatures are literal:

void glClearBufferData(GLenum target, GLenum internalformat,
                       GLenum format, GLenum type, const void * data);

void glClearNamedBufferData(GLuint buffer, GLenum internalformat,
                            GLenum format, GLenum type,
                            const void *data);

🎀 PARAMETERS

Here's the parameter roll call, bestie — no skipped entries, no invented flags, fr fr.

target — specifies the target to which the buffer object is bound for glClearBufferData, and it must be one of the buffer binding targets in the following table:
- GL_ARRAY_BUFFER — vertex attributes
- GL_ATOMIC_COUNTER_BUFFER — atomic counter storage
- GL_COPY_READ_BUFFER — buffer copy source
- GL_COPY_WRITE_BUFFER — buffer copy destination
- GL_DISPATCH_INDIRECT_BUFFER — indirect compute dispatch commands
- GL_DRAW_INDIRECT_BUFFER — indirect command arguments
- GL_ELEMENT_ARRAY_BUFFER — vertex array indices
- GL_PIXEL_PACK_BUFFER — pixel read target
- GL_PIXEL_UNPACK_BUFFER — texture data source
- GL_QUERY_BUFFER — query result buffer
- GL_SHADER_STORAGE_BUFFER — read-write storage for shaders
- GL_TEXTURE_BUFFER — texture data buffer
- GL_TRANSFORM_FEEDBACK_BUFFER — transform feedback buffer
- GL_UNIFORM_BUFFER — uniform block storage
buffer — specifies the name of the buffer object for glClearNamedBufferData.
internalformat — the internal format with which the data will be stored in the buffer object.
format — the format of the data in memory addressed by data.
type — the type of the data in memory addressed by data.
data — the address of a memory location storing the data to be replicated into the buffer's data store. 🫶

✨ DESCRIPTION ✨

okay so bestie, picture this: glClearBufferData and glClearNamedBufferData are out here filling the entirety of a buffer object's data store with data straight from client memory. like, the whole thing. no crumbs. 🫶

Here's the vibe: the data starts life in a format you specify with format, in a data type you specify with type, and it gets read from the memory address given by data. then it's converted into the internal representation given by internalformat — and heads up, internalformat has to be one of these sized internal formats, no substitutions 💅:

┌─────────────┬───────────┬────────────┬──────┬───────────────┐
│             │           │            │      │   Component   │
├─────────────┼───────────┼────────────┼──────┼───┬───┬───┬───┤
│ Sized       │ Base Type │ Components │ Norm │ 0 │ 1 │ 2 │ 3 │
│ Internal    │           │            │      │   │   │   │   │
│ Format      │           │            │      │   │   │   │   │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R8       │ ubyte     │ 1          │ YES  │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R16      │ ushort    │ 1          │ YES  │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R16F     │ half      │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R32F     │ float     │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R8I      │ byte      │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R16I     │ short     │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R32I     │ int       │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R8UI     │ ubyte     │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R16UI    │ ushort    │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_R32UI    │ uint      │ 1          │ NO   │ R │ 0 │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG8      │ ubyte     │ 2          │ YES  │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG16     │ ushort    │ 2          │ YES  │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG16F    │ half      │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG32F    │ float     │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG8I     │ byte      │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG16I    │ short     │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG32I    │ int       │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG8UI    │ ubyte     │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG16UI   │ ushort    │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RG32UI   │ uint      │ 2          │ NO   │ R │ G │ 0 │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGB32F   │ float     │ 3          │ NO   │ R │ G │ B │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGB32I   │ int       │ 3          │ NO   │ R │ G │ B │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGB32UI  │ uint      │ 3          │ NO   │ R │ G │ B │ 1 │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA8    │ uint      │ 4          │ YES  │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA16   │ short     │ 4          │ YES  │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA16F  │ half      │ 4          │ NO   │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA32F  │ float     │ 4          │ NO   │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA8I   │ byte      │ 4          │ NO   │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA16I  │ short     │ 4          │ NO   │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA32I  │ int       │ 4          │ NO   │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA8UI  │ ubyte     │ 4          │ NO   │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA16UI │ ushort    │ 4          │ NO   │ R │ G │ B │ A │
├─────────────┼───────────┼────────────┼──────┼───┼───┼───┼───┤
│ GL_RGBA32UI │ uint      │ 4          │ NO   │ R │ G │ B │ A │
└─────────────┴───────────┴────────────┴──────┴───┴───┴───┴───┘

so that's the menu 🌸 — pick from that list or it's not happening.

Once it's converted, that data gets replicated throughout the buffer object's data store — like, the whole store gets the same treatment, no half-sending it. ✨ And here's a lil bonus: if data is NULL, then the buffer's data store just gets filled with zeros. clean slate energy, we love to see it 🧚

💀 ERRORS 💀

ngl, these are the ways it can go off the rails — memorize them so you don't get caught lacking 🙈

GL_INVALID_ENUM is generated by glClearBufferData if target is not one of the generic buffer binding targets.
GL_INVALID_VALUE is generated by glClearBufferData if no buffer is bound to target.
GL_INVALID_OPERATION is generated by glClearNamedBufferData if buffer is not the name of an existing buffer object.
GL_INVALID_ENUM is generated if internalformat is not one of the valid sized internal formats listed in the table above. (yes, the table. the whole table. go back up, bestie 👑)
GL_INVALID_OPERATION is generated if any part of the specified range of the buffer object is mapped with glMapBufferRange() or glMapBuffer(), unless it was mapped with the GL_MAP_PERSISTENT_BIT bit set in the glMapBufferRange access flags.
GL_INVALID_VALUE is generated if format is not a valid format, or type is not a valid type.

fr fr, that mapped-buffer one is the sneaky one — if any part of that range is mapped and it wasn't mapped with GL_MAP_PERSISTENT_BIT in the glMapBufferRange access flags, it's an GL_INVALID_OPERATION and your whole vibe check fails 😭

✨ VERSION SUPPORT ✨

Okay bestie, this is the vibe check on which OpenGL versions actually show up for these two functions 💅 the table in the original is basically a wall of dashes with three little checkmarks hiding at the end, so here's the tea in list form, no details skipped, periodt:

glClearBufferData — where it's supported across the OpenGL versions:

OpenGL 2.0 — nope, -
OpenGL 2.1 — nope, -
OpenGL 3.0 — nope, -
OpenGL 3.1 — nope, -
OpenGL 3.2 — nope, -
OpenGL 3.3 — nope, -
OpenGL 4.0 — nope, -
OpenGL 4.1 — nope, -
OpenGL 4.2 — nope, -
OpenGL 4.3 — ✔ yes!! she's here 🎀
OpenGL 4.4 — ✔
OpenGL 4.5 — ✔

glClearNamedBufferData — same treatment:

OpenGL 2.0 — -
OpenGL 2.1 — -
OpenGL 3.0 — -
OpenGL 3.1 — -
OpenGL 3.2 — -
OpenGL 3.3 — -
OpenGL 4.0 — -
OpenGL 4.1 — -
OpenGL 4.2 — -
OpenGL 4.3 — -
OpenGL 4.4 — -
OpenGL 4.5 — ✔ only 4.5, she's a late bloomer but iconic 🌸

Ngl the way the two function names column and feature-name column are stacked in the original (Function / / / Feature / Name) is just the manpage being extra — the point is: glClearBufferData lands in 4.3, 4.4, 4.5, and glClearNamedBufferData is 4.5 only. Main character energy, both of them 👑

🌈 SEE ALSO 🌈

glClearBufferSubData() — go read that one next, bestie, it's the sibling 🫶

💜 COPYRIGHT 💜

Copyright © 2011-2014 Khronos Group. This material may be distributed subject to the terms and conditions set forth in the Open Publication License, v 1.0, 8 June 1999. http://opencontent.org/openpub/.

okay that's the whole page, you made it to the end, I'm so proud of you fr fr 🥹💖 this little beauty came from [FIXME: source], version stamped 08/09/2021, and she goes by GLCLEARBUFFERDATA(3G) — go clear some buffer data, you absolute icon ✨🦋

📦 where this page comes from

centos-stream 9: gl-manpages 1.1-24.20190306.el9 · MIT and Open Publication
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms