OpenGL上下文#

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

基类：Context

用于Arade的OpenGL上下文实现，具有添加的自定义功能。此上下文通常通过以下方式访问 arcade.Window.ctx 。

Pyglet用户可以使用基上下文类，并可以随意扩展。

This is part of the low level rendering API in arcade and is mainly for more advanced usage

参数:

  • window -- 侏儒窗口

  • gc_mode -- OpenGL对象的垃圾回收模式。 auto 正是我们在python中所期望的，而 context_gc (默认)需要您调用 Context.gc() 。在不清楚哪个线程将GC对象的情况下使用多个线程时，后一种方法很有用。

🧙 delattr(selfname, /)#

实现delattr(self，name)。

🧙 dir(self)#

默认的dir()实现。

🧙 self == value#

返回self==值。

🧙 format(selfformat_spec, /)#

默认对象格式化程序。

如果Format_Spec为空，则返回str(Self)。否则引发TypeError。

🧙 self >= value#

返回self>=值。

🧙 self > value#

返回self>Value。

🧙 hash(self)#

返回hash(Self)。

🧙 self <= value#

返回self<=Value。

🧙 self < value#

返回self<Value。

🧙 self != value#

返回自我！=值。

🧙 repr(self)#

返回epr(Self)。

🧙 setattr(selfname, value, /)#

实现setattr(self，name，value)。

🧙 sys.getsizeof(self)#

内存中对象的大小，以字节为单位。

🧙 str(self)#

返回str(Self)。

classmethod activate(ctx: Context)#

将上下文标记为当前活动的上下文。

警告

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

bind_window_block() → None[源代码]#

绑定投影和视图统一缓冲区对象。应始终将其绑定到索引0，以便所有着色器都可以访问它们。

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 -- 缓冲区使用率。“静态”、“动态”或“流”

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

创建计算着色器。

参数:

  • source -- GLSL源代码

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

copy_framebuffer(src: Framebuffer, dst: Framebuffer, src_attachment_index: int = 0, depth: bool = True)#

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

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

  • 源和目标帧缓冲区的大小必须相同

  • 附件的格式必须相同

  • 只能对源帧缓冲区进行多重采样

  • 帧缓冲区不能有整数附件

参数:

  • src -- 要从中进行复制的帧缓冲区

  • dst -- 我们复制到的帧缓冲区

  • src_attachment_index -- 要从中复制的颜色附件

  • depth -- 也复制深度附件(如果存在)

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

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

参数:

  • size (Tuple[int, int]) -- 纹理的大小

  • data -- 纹理数据(可选)。可以是 bytes 或支持缓冲协议的任何对象。

disable(*args)#

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

# Single flag
ctx.disable(ctx.BLEND)
# Multiple flags
ctx.disable(ctx.DEPTH_TEST, ctx.CULL_FACE)
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
finish() → None#

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

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

flush() → None#

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

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

创建帧缓冲区。

参数:

  • color_attachments -- 要渲染到的纹理列表

  • depth_attachment -- 深度纹理

gc() → int#

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

返回:

被破坏的资源数量

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位无符号整数)

get_framebuffer_image(fbo: Framebuffer, components: int = 4, flip: bool = True) → Image[源代码]#

从帧缓冲区读取数据并将其转换为PIL图像的快捷方法。

参数:

  • fbo -- 要从中获取图像的帧缓冲区

  • components -- 要读取的组件数

  • flip -- 将图像颠倒过来

is_enabled(flag) → bool#

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

类型:

布尔尔

load_compute_shader(path: str | Path, common: Iterable[str | Path] = ()) → ComputeShader[源代码]#

从文件加载计算着色器。此方法支持资源句柄。

示例：：

ctx.load_compute_shader(":shader:compute/do_work.glsl")
参数:

  • path -- 纹理路径

  • common -- 注入计算着色器的公共源代码

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

在给定包含顶点着色器和片段着色器的文件名的情况下创建新程序。请注意，在加载变换着色器时，碎片着色器和几何体着色器是可选的。

此方法还支持资源句柄。

示例：：

# The most common use case if having a vertex and fragment shader
program = window.ctx.load_program(
    vertex_shader="vert.glsl",
    fragment_shader="frag.glsl",
)
参数:

  • vertex_shader -- 顶点着色器的路径

  • fragment_shader -- 片段着色器的路径(可选)

  • geometry_shader -- 几何体着色器的路径(可选)

  • tess_control_shader -- 细分控制着色器

  • tess_evaluation_shader -- 细分求值明暗器

  • common -- 要包含在所有着色器中的通用文件

  • defines -- 代替品 #define 源代码中的值

  • varyings -- 变换着色器中的输出属性的名称。这通常是不必要的，因为我们会自动检测它们，而是一些我们无法检测到的更复杂的外部结构。

  • varyings_capture_mode -- 转换的捕获模式。 "interleaved" 意味着所有输出属性将写入单个缓冲区。 "separate" 意味着每个OUT属性将被写入单独的缓冲区。根据这些设置， transform() 方法将接受单个缓冲区或缓冲区列表。

load_texture(path: str | Path, *, flip: bool = True, build_mipmaps: bool = False, internal_format: int | None = None, compressed: bool = False) → Texture2D[源代码]#

加载并创建OpenGL 2D纹理。目前，为简单起见，所有纹理都转化为RGBA。

示例：：

# Load a texture in current working directory
texture = window.ctx.load_texture("background.png")

# Load a texture using Arcade resource handle
texture = window.ctx.load_texture(":textures:background.png")

# Load and compress a texture
texture = window.ctx.load_texture(
    ":textures:background.png",
    internal_format=gl.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
    compressed=True,
)
参数:

  • path -- 纹理路径

  • flip -- 将图像颠倒

  • build_mipmaps -- 为纹理构建mipmap

  • internal_format -- 纹理的内部格式。这可用于在使用sRGBA或压缩纹理时覆盖默认内部格式。

  • compressed -- 如果内部格式是压缩格式，则意味着您的纹理将由GPU压缩。

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() 方法将接受单个缓冲区或缓冲区列表。

pyglet_rendering()[源代码]#

上下文管理器，用于使用侏儒进行渲染，以确保恢复上下文状态。这会影响到混合之类的东西。

query(*, samples=True, time=True, primitives=True) → Query#

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

参数:

  • samples -- 收集书面样本

  • time -- 测量渲染持续时间

  • primitives -- 收集发出的基元数量

reset() → None[源代码]#

重置上下文标志和其他状态。这主要用于单元测试。

shader_inc(source: str) → str[源代码]#

解析着色器源代码以查找 #include 指令，并用包含文件的内容替换它们。

这个 #include 指令必须在其自己的行上，并且文件和路径应使用资源句柄。

示例：：

#include :my_shader:lib/common.glsl
参数:

source -- 着色器

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 。

BLEND = 3042#

调合

类型:

上下文标志

BLEND_ADDITIVE = (1, 1)#

ONE, ONE

类型:

添加混合的混合模式快捷方式

BLEND_DEFAULT = (770, 771)#

SRC_ALPHA, ONE_MINUS_SRC_ALPHA

类型:

默认混合模式的混合模式快捷方式

BLEND_PREMULTIPLIED_ALPHA = (770, 1)#

SRC_ALPHA, ONE

类型:

预乘Alpha的混合模式快捷方式

CLAMP_TO_BORDER = 33069#
CLAMP_TO_EDGE = 33071#
CULL_FACE = 2884#

人脸剔除

类型:

上下文标志

DEPTH_TEST = 2929#

深度测试

类型:

上下文标志

DST_ALPHA = 772#

混合函数

DST_COLOR = 774#

混合函数

FUNC_ADD = 32774#

源+目标

FUNC_REVERSE_SUBTRACT = 32779#

目标-源

类型:

混合方程

FUNC_SUBTRACT = 32778#

源-目标

类型:

混合方程

LINEAR = 9729#

线性插补

类型:

纹理内插

LINEAR_MIPMAP_LINEAR = 9987#

用于mipmap的缩小滤镜

类型:

纹理内插

LINEAR_MIPMAP_NEAREST = 9985#

用于mipmap的缩小滤镜

类型:

纹理内插

LINES = 1#

基元模式

LINES_ADJACENCY = 10#

基元模式

LINE_LOOP = 2#

基元模式

LINE_STRIP = 3#

基元模式

LINE_STRIP_ADJACENCY = 11#

基元模式

MAX = 32776#

源和目标的最大值

类型:

混合方程

MIN = 32775#

源和目标的最小数量

类型:

混合方程

MIRRORED_REPEAT = 33648#
NEAREST = 9728#

最近的像素

类型:

纹理内插

NEAREST_MIPMAP_LINEAR = 9986#

用于mipmap的缩小滤镜

类型:

纹理内插

NEAREST_MIPMAP_NEAREST = 9984#

用于mipmap的缩小滤镜

类型:

纹理内插

ONE = 1#

混合函数

ONE_MINUS_DST_ALPHA = 773#

混合函数

ONE_MINUS_DST_COLOR = 775#

混合函数

ONE_MINUS_SRC_ALPHA = 771#

混合函数

ONE_MINUS_SRC_COLOR = 769#

混合函数

PATCHES = 14#

面片模式(细分)

POINTS = 0#

基元模式

PROGRAM_POINT_SIZE = 34370#

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

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

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

禁用时 Context.point_size 使用的是。

类型:

上下文标志

REPEAT = 10497#

重复

类型:

纹理换行模式

SRC_ALPHA = 770#

混合函数

SRC_COLOR = 768#

混合函数

TRIANGLES = 4#

基元模式

TRIANGLES_ADJACENCY = 12#

基元模式

TRIANGLE_FAN = 6#

基元模式

TRIANGLE_STRIP = 5#

基元模式

TRIANGLE_STRIP_ADJACENCY = 13#

基元模式

ZERO = 0#

混合函数

active: 'Context' | None = None#

活动的上下文

atlas_size: Tuple[int, int] = (512, 512)#
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)

cull_face#

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

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

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

默认纹理贴图集。这是在初始化Arcade时创建的。所有精灵列表都将使用此地图集，除非在 arcade.SpriteList 构造函数。

类型:

TextureAtlas

error#

检查OpenGL错误

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

示例：：

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

应力

fbo#

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

类型:

arcade.gl.Framebuffer

front_face#

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

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

ctx.front_face = "cw"
ctx.front_face = "ccw"
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"
gl_api: str = 'gl'#

OpenGL API。通常是“gl”或“gles”。

gl_version#

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

类型:

元组(主要、次要)版本

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
objects: Deque[Any]#

当GC_MODE为“CONTEXT_GC”时，收集到GC的对象。这可以在调试期间使用。

patch_vertices#

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

类型:

集成

point_size#

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

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

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

备注

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

primitive_restart_index#

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

projection_matrix#

获取当前投影矩阵。这个4x4的浮点32矩阵是由摄像机计算的。

该属性只是获取和设置Piglet的投影矩阵。

类型:

pyglet.math.Mat4

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，宽度，高度)

screen#

窗口的帧缓冲区。

类型:

Framebuffer

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
view_matrix#

获取当前的视图矩阵。此4x4浮点32矩阵是在设置 view_matrix_2d 。

该属性只是获取和设置Piglet的视图矩阵。

类型:

pyglet.math.Mat4

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，宽度，高度)

window#

此上下文所属的窗口。

类型:

pyglet.Window

wireframe#

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

类型:

布尔尔