语境#

class arcade.gl.Context(window: BaseWindow, gc_mode: str = 'context_gc', gl_api: str = 'gl')[源代码]#

基类：

表示OpenGL上下文。此上下文属于 pyglet.Window 通常通过以下方式访问 window.ctx 。

Context类包含用于创建资源、全局状态和常用枚举的方法。所有枚举也都存在于 gl 模块。 (ctx.BLEND 或 arcade.gl.BLEND )。

active: Context | None = None#: 活动的上下文

NEAREST = 9728#

最近的像素

类型:: 纹理内插

LINEAR = 9729#

线性插补

类型:: 纹理内插

NEAREST_MIPMAP_NEAREST = 9984#

用于mipmap的缩小滤镜

类型:: 纹理内插

LINEAR_MIPMAP_NEAREST = 9985#

用于mipmap的缩小滤镜

类型:: 纹理内插

NEAREST_MIPMAP_LINEAR = 9986#

用于mipmap的缩小滤镜

类型:: 纹理内插

LINEAR_MIPMAP_LINEAR = 9987#

用于mipmap的缩小滤镜

类型:: 纹理内插

REPEAT = 10497#

重复

类型:: 纹理换行模式

CLAMP_TO_EDGE = 33071#

CLAMP_TO_BORDER = 33069#

MIRRORED_REPEAT = 33648#

BLEND = 3042#

调合

类型:: 上下文标志

DEPTH_TEST = 2929#

深度测试

类型:: 上下文标志

CULL_FACE = 2884#

人脸剔除

类型:: 上下文标志

PROGRAM_POINT_SIZE = 34370#

启用 gl_PointSize 在顶点或几何体着色器中。

启用后，我们可以写入 gl_PointSize 在顶点着色器中指定每个点的点大小。

如果未在着色器中设置此值，则行为未定义。这意味着这些点可能会显示，也可能不会显示，具体取决于驱动程序是否强制执行某些默认值 gl_PointSize 。

禁用时 Context.point_size 使用的是。

类型:: 上下文标志

ZERO = 0#: 混合函数

ONE = 1#: 混合函数

SRC_COLOR = 768#: 混合函数

ONE_MINUS_SRC_COLOR = 769#: 混合函数

SRC_ALPHA = 770#: 混合函数

ONE_MINUS_SRC_ALPHA = 771#: 混合函数

DST_ALPHA = 772#: 混合函数

ONE_MINUS_DST_ALPHA = 773#: 混合函数

DST_COLOR = 774#: 混合函数

ONE_MINUS_DST_COLOR = 775#: 混合函数

FUNC_ADD = 32774#: 源+目标

FUNC_SUBTRACT = 32778#

源-目标

类型:: 混合方程

FUNC_REVERSE_SUBTRACT = 32779#

目标-源

类型:: 混合方程

MIN = 32775#

源和目标的最小数量

类型:: 混合方程

MAX = 32776#

源和目标的最大值

类型:: 混合方程

BLEND_DEFAULT = (770, 771)#

SRC_ALPHA, ONE_MINUS_SRC_ALPHA

类型:: 默认混合模式的混合模式快捷方式

BLEND_ADDITIVE = (1, 1)#

ONE, ONE

类型:: 添加混合的混合模式快捷方式

BLEND_PREMULTIPLIED_ALPHA = (770, 1)#

SRC_ALPHA, ONE

类型:: 预乘Alpha的混合模式快捷方式

POINTS = 0#: 基元模式

LINES = 1#: 基元模式

LINE_LOOP = 2#: 基元模式

LINE_STRIP = 3#: 基元模式

TRIANGLES = 4#: 基元模式

TRIANGLE_STRIP = 5#: 基元模式

TRIANGLE_FAN = 6#: 基元模式

LINES_ADJACENCY = 10#: 基元模式

LINE_STRIP_ADJACENCY = 11#: 基元模式

TRIANGLES_ADJACENCY = 12#: 基元模式

TRIANGLE_STRIP_ADJACENCY = 13#: 基元模式

PATCHES = 14#: 面片模式(细分)

gl_api: str = 'gl'#: OpenGL API。通常是“gl”或“gles”。

objects: Deque[Any]#: 当GC_MODE为“CONTEXT_GC”时，收集到GC的对象。这可以在调试期间使用。

info#

获取此上下文的Limits对象，该对象包含有关硬件/驱动程序限制的信息和其他上下文信息。

示例：：

>> ctx.info.MAX_TEXTURE_SIZE
(16384, 16384)
>> ctx.info.VENDOR
NVIDIA Corporation
>> ctx.info.RENDERER
NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2

limits#

获取此上下文的Limits对象，该对象包含有关硬件/驱动程序限制的信息和其他上下文信息。

警告

这是一个旧的别名 info 并且只是为了向后兼容。

示例：：

>> ctx.limits.MAX_TEXTURE_SIZE
(16384, 16384)
>> ctx.limits.VENDOR
NVIDIA Corporation
>> ctx.limits.RENDERER
NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2

stats#

获取包含有关创建和销毁OpenGL对象的运行时信息的Stats实例。

示例：：

>> ctx.limits.MAX_TEXTURE_SIZE
(16384, 16384)
>> ctx.limits.VENDOR
NVIDIA Corporation
>> ctx.limits.RENDERER
NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2

window#

此上下文所属的窗口。

类型:: pyglet.Window

screen#

窗口的帧缓冲区。

类型:: Framebuffer

fbo#

获取当前活动的帧缓冲区。此属性为只读

类型:: arcade.gl.Framebuffer

gl_version#

两个组件元组形式的OpenGL版本。这是驱动程序中报告的OpenGL版本，可能比您要求的版本更高。

类型:: 元组(主要、次要)版本

gc() → int[源代码]#

为此上下文运行OpenGL对象的垃圾回收。仅在以下情况下才需要此功能 gc_mode 是 context_gc 。

返回:: 被破坏的资源数量

gc_mode#

设置OpenGL资源的垃圾收集模式。支持的模式包括：

# Default:
# Defer garbage collection until ctx.gc() is called
# This can be useful to enforce the main thread to
# run garbage collection of opengl resources
ctx.gc_mode = "context_gc"

# Auto collect is similar to python garbage collection.
# This is a risky mode. Know what you are doing before using this.
ctx.gc_mode = "auto"

error#

检查OpenGL错误

返回发生的错误的字符串表示形式，或者 None 没有发生任何错误。

示例：：

err = ctx.error
if err:
    raise RuntimeError("OpenGL error: {err}")

类型:: 应力

classmethod activate(ctx: Context)[源代码]#: 将上下文标记为当前活动的上下文。

警告

除非你确切知道自己在做什么，否则永远不要打这个电话。

enable(*flags)[源代码]#

启用一个或多个上下文标志：

# Single flag
ctx.enable(ctx.BLEND)
# Multiple flags
ctx.enable(ctx.DEPTH_TEST, ctx.CULL_FACE)

enable_only(*args)[源代码]#

仅启用一些标志。这将禁用所有其他标志。这是一种简单的方法，可以确保上下文标志状态不会在代码库的其他部分中徘徊：

# Ensure all flags are disabled (enable no flags)
ctx.enable_only()
# Make sure only blending is enabled
ctx.enable_only(ctx.BLEND)
# Make sure only depth test and culling is enabled
ctx.enable_only(ctx.DEPTH_TEST, ctx.CULL_FACE)

enabled(*flags)[源代码]#

临时更改启用标志。

最初启用的标志将保持启用状态。只有新启用的标志在退出上下文时才会被反转。

示例：：

with ctx.enabled(ctx.BLEND, ctx.CULL_FACE):
    # Render something

enabled_only(*flags)[源代码]#

临时更改启用标志。

只有在上下文中启用了提供的标志。当退出上下文时，旧标志将被恢复。

示例：：

with ctx.enabled_only(ctx.BLEND, ctx.CULL_FACE):
    # Render something

disable(*args)[源代码]#

禁用一个或多个上下文标志：：

# Single flag
ctx.disable(ctx.BLEND)
# Multiple flags
ctx.disable(ctx.DEPTH_TEST, ctx.CULL_FACE)

is_enabled(flag) → bool[源代码]#

检查是否启用了上下文标志

类型:: 布尔尔

viewport#

获取或设置当前活动帧缓冲区的视区。该视口只描述OpenGL应该渲染到的屏幕像素。通常它是窗口的帧缓冲区的大小：：

# 4:3 screen
ctx.viewport = 0, 0, 800, 600
# 1080p
ctx.viewport = 0, 0, 1920, 1080
# Using the current framebuffer size
ctx.viewport = 0, 0, *ctx.screen.size

类型:: 元组(x，y，宽度，高度)

scissor#

获取或设置活动帧缓冲区的剪贴框。这是一条快捷方式 scissor() 。

默认情况下，剪裁框处于禁用状态，不起作用，初始值为 None 。设置值时启用剪贴框，设置为时禁用剪贴框 None 。

示例：：

# Set and enable scissor box only drawing
# in a 100 x 100 pixel lower left area
ctx.scissor = 0, 0, 100, 100
# Disable scissoring
ctx.scissor = None

类型:: 元组(x，y，宽度，高度)

blend_func#

获取或设置混合函数。这是指定如何计算源和目标像素的颜色和Alpha混合因子的元组。

当使用两个成分的元组时，您可以为源和目标指定混合函数。

使用四分量元组时，您可以为源颜色、源Alpha目标颜色和目标Alpha指定混合函数。(颜色和Alpha的单独混合函数)

支持的混合功能包括：

ZERO
ONE
SRC_COLOR
ONE_MINUS_SRC_COLOR
DST_COLOR
ONE_MINUS_DST_COLOR
SRC_ALPHA
ONE_MINUS_SRC_ALPHA
DST_ALPHA
ONE_MINUS_DST_ALPHA

# Shortcuts
DEFAULT_BLENDING     # (SRC_ALPHA, ONE_MINUS_SRC_ALPHA)
ADDITIVE_BLENDING    # (ONE, ONE)
PREMULTIPLIED_ALPHA  # (SRC_ALPHA, ONE)

这些枚举可以在 arcade.gl 模块或简单地作为上下文对象的属性。来自的原始枚举 pyglet.gl 也可以使用。

示例：：

# Using constants from the context object
ctx.blend_func = ctx.ONE, ctx.ONE
# from the gl module
from arcade import gl
ctx.blend_func = gl.ONE, gl.ONE

类型:: 元组(源、dst)

front_face#

配置三角形的正面缠绕顺序。

默认情况下，逆时针缠绕侧为正面。可以将其设置为顺时针或逆时针：：

ctx.front_face = "cw"
ctx.front_face = "ccw"

cull_face#

启用面消隐时要消隐的面侧。

默认情况下，将消隐背面。可以将其设置为FORWER、BACK或FORENT_AND_BACK：：

ctx.cull_face = "front"
ctx.cull_face = "back"
ctx.cull_face = "front_and_back"

wireframe#

获取或设置线框模式。启用后，所有基元都将呈现为线条。

类型:: 布尔尔

patch_vertices#

获取或设置将用于组成单个面片基本体的顶点数。面片基本体由细分控制着色器(如果存在)使用，并随后用于细分。

类型:: 集成

point_size#

设置或获取磅大小。缺省值为 1.0 。

点大小更改渲染点的像素大小。最小值和最大值受以下限制 POINT_SIZE_RANGE 。该值通常至少 (1, 100) ，但这取决于驱动程序/供应商。

如果需要可变磅大小，您可以启用 PROGRAM_POINT_SIZE 并写信给 gl_PointSize 在顶点或几何体着色器中。

备注

使用几何体着色器从点创建三角形条带通常是渲染大点的更安全的方法，因为您没有任何大小限制。

primitive_restart_index#: 获取或设置基元重新启动索引。缺省值为 -1 。可以在索引缓冲区中使用原语重新启动索引来重新启动原语。例如，当您使用三角形条带或线条并希望在同一缓冲区/绘制调用中开始一个新的条带时，这是很有用的。

finish() → None[源代码]#

等待所有OpenGL渲染命令完成。

此函数实际上将停止，直到完成所有工作，并且可能会对性能造成严重影响。

flush() → None[源代码]#: 建议驱动程序执行所有排队的绘图调用，即使队列还未满。这不是阻止呼叫，只是一个建议。当我们没有其他东西可以渲染时，这可能会用于加速。

copy_framebuffer(src: Framebuffer, dst: Framebuffer, src_attachment_index: int = 0, depth: bool = True)[源代码]#

将一个帧缓冲区复制/b到另一个帧缓冲区。我们可以选择一个颜色附件进行复制，外加一个可选的深度附件。

此操作有许多限制，以确保其跨不同平台和驱动程序工作：

源和目标帧缓冲区的大小必须相同
附件的格式必须相同
只能对源帧缓冲区进行多重采样
帧缓冲区不能有整数附件

参数:

src -- 要从中进行复制的帧缓冲区
dst -- 我们复制到的帧缓冲区
src_attachment_index -- 要从中复制的颜色附件
depth -- 也复制深度附件(如果存在)

buffer(*, data: Buffer | None = None, reserve: int = 0, usage: str = 'static') → Buffer[源代码]#

创建一个OpenGL缓冲区对象。如果未提供数据，则缓冲区将包含所有零字节。

示例：

# Create 1024 byte buffer
ctx.buffer(reserve=1024)
# Create a buffer with 1000 float values using python's array.array
from array import array
ctx.buffer(data=array('f', [i for in in range(1000)])
# Create a buffer with 1000 random 32 bit floats using numpy
self.ctx.buffer(data=np.random.random(1000).astype("f4"))

这个 data 参数可以是实现 Buffer Protocol 。

这包括 bytes ， bytearray ， array.array ，以及更多。对于非内置类型，您可能需要使用类型化解决方法。看见将原始字节写入GL缓冲区和纹理以获取更多信息。

这个 usage 参数使GL实现能够做出可能影响缓冲区对象性能的更智能的决策。它没有增加任何限制。如果有疑问，请跳过此参数并在优化时重新访问。结果可能因供应商/驱动程序不同而不同，或者可能没有任何影响。

可用值如下所示：

stream
    The data contents will be modified once and used at most a few times.
static
    The data contents will be modified once and used many times.
dynamic
    The data contents will be modified repeatedly and used many times.

参数:

data -- 缓冲区数据。这可能是一种 bytes 实例或任何其他支持缓冲区协议的对象。
reserve -- 要保留的字节数
usage -- 缓冲区使用率。“静态”、“动态”或“流”

framebuffer(*, color_attachments: Texture2D | List[Texture2D] | None = None, depth_attachment: Texture2D | None = None) → Framebuffer[源代码]#

创建帧缓冲区。

参数:

color_attachments -- 要渲染到的纹理列表
depth_attachment -- 深度纹理

texture(size: Tuple[int, int], *, components: int = 4, dtype: str = 'f1', data: Buffer | None = None, wrap_x: int | None = None, wrap_y: int | None = None, filter: Tuple[int, int] | None = None, samples: int = 0, immutable: bool = False, internal_format: int | None = None, compressed: bool = False, compressed_data: bool = False) → Texture2D[源代码]#

创建2D纹理。

示例：：

# Create a 1024 x 1024 RGBA texture
image = PIL.Image.open("my_texture.png")
ctx.texture(size=(1024, 1024), components=4, data=image.tobytes())

# Create and compress a texture. The compression format is set by the internal_format
image = PIL.Image.open("my_texture.png")
ctx.texture(
    size=(1024, 1024),
    components=4,
    compressed=True,
    internal_format=gl.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
    data=image.tobytes(),
)

# Create a compressed texture from raw compressed data. This is an extremely
# fast way to load a large number of textures.
image_bytes = "<raw compressed data from some source>"
ctx.texture(
    size=(1024, 1024),
    components=4,
    internal_format=gl.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
    compressed_data=True,
    data=image_bytes,
)

换行模式： GL_REPEAT ， GL_MIRRORED_REPEAT ， GL_CLAMP_TO_EDGE ， GL_CLAMP_TO_BORDER

缩小滤镜： GL_NEAREST ， GL_LINEAR ， GL_NEAREST_MIPMAP_NEAREST ， GL_LINEAR_MIPMAP_NEAREST GL_NEAREST_MIPMAP_LINEAR ， GL_LINEAR_MIPMAP_LINEAR

放大滤镜： GL_NEAREST ， GL_LINEAR

参数:

size (Tuple[int, int]) -- 纹理的大小
components -- 组件数量(1：R、2：RG、3：RGB、4：RGBA)
dtype -- 各组件的数据类型：f1、f2、f4/i1、i2、i4/u1、u2、u4
data -- 纹理数据(可选)。可以是 bytes 或支持缓冲协议的任何对象。
wrap_x -- 纹理在x方向上的换行方式
wrap_y -- 纹理在y方向上的换行方式
filter -- 缩小和放大滤镜
samples -- 为大于0的值创建多采样纹理
immutable -- 使存储(而不是内容)不可变。将纹理与计算着色器一起使用时，有时可能需要此选项。
internal_format -- 纹理的内部格式。这可用于启用sRGB或纹理压缩。
compressed -- 如果要压缩纹理，请设置为True。这假设您已将INTERNAL_FORMAT设置为压缩格式。
compressed_data -- 如果要传递原始压缩像素数据，则设置为True。这意味着 compressed=True 。

depth_texture(size: Tuple[int, int], *, data: Buffer | None = None) → Texture2D[源代码]#

创建2D深度纹理。中的深度附件。 Framebuffer 。

参数:

size (Tuple[int, int]) -- 纹理的大小
data -- 纹理数据(可选)。可以是 bytes 或支持缓冲协议的任何对象。

geometry(content: Sequence[BufferDescription] | None = None, index_buffer: Buffer | None = None, mode: int | None = None, index_element_size: int = 4)[源代码]#

创建几何体实例。这是Arade版本的顶点数组，为用户增加了很多便利。几何体对象相当轻。它们主要负责将缓冲区输入自动映射到着色器(S)，并提供渲染或处理该几何体的各种方法。

只要着色器使用一个或多个输入属性，就可以使用不同的程序渲染相同的几何体。这意味着具有位置和颜色的几何体只能通过使用位置的程序进行渲染。我们将自动映射所需的内容，并在内部缓存这些映射以提高性能。

简而言之，几何体对象是一个灯光对象，它描述缓冲区包含的内容并自动与着色器/程序协商。这在OpenGL中是一个非常复杂的字段，因此Geometry对象可以节省大量时间，并极大地降低代码的复杂性。

几何体还提供支持以下内容的渲染方法：

使用和不使用索引缓冲区渲染几何图形
使用实例化渲染几何体。可以提供每个实例的缓冲区，也可以使用 gl_InstanceID 在着色器中。
运行写入缓冲区而不是屏幕的变换反馈着色器。这可以写入一个或多个缓冲区。
使用间接渲染渲染几何体。这意味着将多个网格打包到同一缓冲区(S)中并批绘制它们。

示例：

# Single buffer geometry with a vec2 vertex position attribute
ctx.geometry([BufferDescription(buffer, '2f', ["in_vert"])], mode=ctx.TRIANGLES)

# Single interlaved buffer with two attributes. A vec2 position and vec2 velocity
ctx.geometry([
        BufferDescription(buffer, '2f 2f', ["in_vert", "in_velocity"])
    ],
    mode=ctx.POINTS,
)

# Geometry with index buffer
ctx.geometry(
    [BufferDescription(buffer, '2f', ["in_vert"])],
    index_buffer=ibo,
    mode=ctx.TRIANGLES,
)

# Separate buffers
ctx.geometry([
        BufferDescription(buffer_pos, '2f', ["in_vert"])
        BufferDescription(buffer_vel, '2f', ["in_velocity"])
    ],
    mode=ctx.POINTS,
)

# Providing per-instance data for instancing
ctx.geometry([
        BufferDescription(buffer_pos, '2f', ["in_vert"])
        BufferDescription(buffer_instance_pos, '2f', ["in_offset"], instanced=True)
    ],
    mode=ctx.POINTS,
)

参数:

content -- 列表 BufferDescription (可选)
index_buffer -- 索引/元素缓冲区(可选)
mode -- 默认绘图模式(可选)
mode -- 默认绘图模式(可选)
index_element_size -- 索引缓冲区中单个索引/元素的字节大小。换句话说，索引缓冲区可以是8位、16位或32位整数。可以是1、2或4(8、16或32位无符号整数)

program(*, vertex_shader: str, fragment_shader: str | None = None, geometry_shader: str | None = None, tess_control_shader: str | None = None, tess_evaluation_shader: str | None = None, common: List[str] | None = None, defines: Dict[str, str] | None = None, varyings: Sequence[str] | None = None, varyings_capture_mode: str = 'interleaved') → Program[源代码]#

创建 Program 给定顶点、碎片和几何体着色器。

参数:

vertex_shader -- 顶点着色器源
fragment_shader -- 片段着色器源(可选)
geometry_shader -- 几何体着色器源(可选)
tess_control_shader -- 细分控制着色器源(可选)
tess_evaluation_shader -- 细分求值明暗器源(可选)
common -- 注入到所有着色器的通用着色器源
defines -- 替换#定义源中的值(可选)
varyings -- 变换着色器中的输出属性的名称。这通常是不必要的，因为我们会自动检测它们，而是一些我们无法检测到的更复杂的外部结构。
varyings_capture_mode -- 转换的捕获模式。 "interleaved" 意味着所有输出属性将写入单个缓冲区。 "separate" 意味着每个OUT属性将被写入单独的缓冲区。根据这些设置， transform() 方法将接受单个缓冲区或缓冲区列表。

query(*, samples=True, time=True, primitives=True) → Query[源代码]#

在OpenGL中创建一个用于测量渲染调用的Query对象。

参数:

samples -- 收集书面样本
time -- 测量渲染持续时间
primitives -- 收集发出的基元数量

compute_shader(*, source: str, common: Iterable[str] = ()) → ComputeShader[源代码]#

创建计算着色器。

参数:

source -- GLSL源代码
common -- 注入计算着色器的公共/库源代码

ContextStats#

class arcade.gl.context.ContextStats(warn_threshold=100)[源代码]#

基类：

OpenGL对象的运行时分配统计信息。

texture#: 纹理(已创建、已释放)

framebuffer#: 帧缓冲区(已创建、已释放)

buffer#: 缓冲区(已创建、已释放)

program#: 程序(已创建、已释放)

vertex_array#: 顶点数组(已创建、已释放)

geometry#: 几何图形(已创建、已释放)

compute_shader#: 计算着色器(已创建、已释放)

query#: 查询(已创建、已释放)

incr(key: str) → None[源代码]#

递增计数器。

参数:: key -- 要递增的属性名称/计数器。

decr(key)[源代码]#

递减计数器。

参数:: key -- 要递减的属性名称/计数器。

极限#

class arcade.gl.context.Limits(ctx)[源代码]#

基类：

OpenGL限制

MINOR_VERSION#: 当前上下文支持的OpenGL API的次版本号

MAJOR_VERSION#: 当前上下文支持的OpenGL API的主版本号。

VENDOR#: 供应商字符串。例如“NVIDIA Corporation”

RENDERER#: 渲染器的事情。例如“NVIDIA GeForce RTX 2080超级/PCIe/SSE2”

SAMPLE_BUFFERS#: 值，该值指示与帧缓冲区关联的采样缓冲区的数量

SUBPIXEL_BITS#: 用于在窗口坐标中定位栅格化几何的亚像素分辨率位数的估计

UNIFORM_BUFFER_OFFSET_ALIGNMENT#: 统一缓冲区大小和偏移量的最低要求对齐

MAX_ARRAY_TEXTURE_LAYERS#: 值表示数组纹理中允许的最大层数，必须至少为256

MAX_3D_TEXTURE_SIZE#: GL可以处理的最大3D纹理的粗略估计。该值必须至少为64

MAX_COLOR_ATTACHMENTS#: 帧缓冲区中颜色附件的最大数量

MAX_COLOR_TEXTURE_SAMPLES#: 颜色多采样纹理中的最大采样数

MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS#: 所有统一块中片段着色器统一变量的字数

MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS#: 所有均匀块中几何着色器统一变量的字数

MAX_COMBINED_TEXTURE_IMAGE_UNITS#: 可用于从顶点着色器访问纹理贴图的最大支持纹理图像单位

MAX_COMBINED_UNIFORM_BLOCKS#: 每个程序的最大统一块数量

MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS#: 所有统一块中顶点着色器统一变量的字数

MAX_CUBE_MAP_TEXTURE_SIZE#: GL可以处理的最大立方体贴图纹理的粗略估计

MAX_DEPTH_TEXTURE_SAMPLES#: 多采样深度或深度模板纹理中的最大采样数

MAX_DRAW_BUFFERS#: 可写入片段着色器的同时输出的最大数量

MAX_ELEMENTS_INDICES#: 建议的最大顶点数组索引数

MAX_ELEMENTS_VERTICES#: 建议的最大顶点数组顶点数

MAX_FRAGMENT_INPUT_COMPONENTS#: 片段着色器读取的输入组件的最大数量

MAX_FRAGMENT_UNIFORM_COMPONENTS#: 片段着色器的统一变量存储中可以保存的单个浮点、整型或布尔值的最大数量

MAX_FRAGMENT_UNIFORM_VECTORS#: 可保存在片段着色器的统一变量存储中的浮点、整型或布尔值的单个4向量的最大数量

MAX_FRAGMENT_UNIFORM_BLOCKS#: 每个碎片着色器的最大统一块数。

MAX_GEOMETRY_INPUT_COMPONENTS#: 几何图形着色器读取的输入组件的最大数量

MAX_GEOMETRY_OUTPUT_COMPONENTS#: 几何着色器写入的输出的最大组件数

MAX_GEOMETRY_TEXTURE_IMAGE_UNITS#: 可用于从几何着色器访问纹理贴图的最大支持纹理图像单位

MAX_GEOMETRY_UNIFORM_BLOCKS#: 每个几何体着色器的最大统一块数

MAX_GEOMETRY_UNIFORM_COMPONENTS#: 几何着色器的统一变量存储中可以保存的单个浮点值、整数值或布尔值的最大数量

MAX_INTEGER_SAMPLES#: 整数格式多样本缓冲区支持的最大样本数

MAX_SAMPLES#: 帧缓冲区的最大采样数

MAX_RENDERBUFFER_SIZE#: 渲染缓冲区支持的最大大小

MAX_SAMPLE_MASK_WORDS#: 最大样本掩码字数

MAX_TEXTURE_SIZE#: 该值提供GL可以处理的最大纹理的粗略估计

MAX_UNIFORM_BUFFER_BINDINGS#: 上下文上的统一缓冲区绑定点的最大数量

MAX_UNIFORM_BLOCK_SIZE#: 以基本机器单位表示的统一块的最大尺寸

MAX_VARYING_VECTORS#: 变变量的4维向量

MAX_VERTEX_ATTRIBS#: 顶点着色器可访问的4组件通用顶点属性的最大数量。

MAX_VERTEX_TEXTURE_IMAGE_UNITS#: 可用于从顶点着色器访问纹理贴图的支持的最大纹理图像单位。

MAX_VERTEX_UNIFORM_COMPONENTS#: 顶点着色器的统一变量存储中可以保存的单个浮点、整型或布尔值的最大数量

MAX_VERTEX_UNIFORM_VECTORS#: 顶点着色器的统一变量存储中可以保存的4向量的最大数量

MAX_VERTEX_OUTPUT_COMPONENTS#: 顶点着色器写入的输出的最大组件数

MAX_VERTEX_UNIFORM_BLOCKS#: 每个顶点着色器的最大统一块数量。

MAX_TEXTURE_MAX_ANISOTROPY#: 支持的最高各向异性值。通常是8.0或16.0。

MAX_VIEWPORT_DIMS: Tuple[int, int]#: 最大支持窗口或帧缓冲区视口中。这通常与最大纹理大小相同

MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS#: 在进行转换(反馈)时，我们可以有多少缓冲区作为输出。这通常是4

POINT_SIZE_RANGE#: 最小和最大点大小

get_int_tuple(enum: c_uint | int, length: Literal[2]) → Tuple[int, int][源代码]#
get_int_tuple(enum: c_uint | int, length: int) → Tuple[int, ...]: 获取整型元组形式的枚举

get(enum: c_uint | int, default=0) → int[源代码]#: 获取整数限制

get_float(enum: c_uint | int, default=0.0) → float[源代码]#: 获得浮动限制

get_str(enum: c_uint | int) → str[源代码]#: 获取字符串限制