OpenGLContext 3.0.0a5__tar.gz → 3.0.0a7__tar.gz

{openglcontext-3.0.0a5 → openglcontext-3.0.0a7}/OpenGLContext/__init__.py

@@ -32,7 +32,7 @@ It is also the primary suite of test cases PyOpenGL is verified against.
 Documentation is under `docs/`, indexed by `docs/documentation.rst`.
 '''
 
-__version__ = "3.0.0a5"
+__version__ = "3.0.0a7"
 __author__ = "Michael Colin Fletcher"
 __license__ = "BSD-Style, see license.txt for details and exceptions"
 

{openglcontext-3.0.0a5 → openglcontext-3.0.0a7}/OpenGLContext/context.py

@@ -40,7 +40,7 @@ from OpenGLContext.screenshot import ScreenshotMixin
 from OpenGLContext.passes import renderpass
 from vrml.vrml97 import nodetypes
 from vrml import node, cache
-from typing import TYPE_CHECKING, Any, ClassVar, Literal, Self, TypeVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeVar, cast
 from collections.abc import Callable, Mapping, Sequence
 import weakref
 import os
@@ -49,6 +49,9 @@ import time
 import logging
 
 if TYPE_CHECKING:
+    # 3.11's Self; the runtime floor is 3.10 and `from __future__ import
+    # annotations` leaves every annotation unevaluated.
+    from typing import Self
     from configparser import ConfigParser
 
     from OpenGLContext.contextdefinition import ContextDefinition

openglcontext-3.0.0a7/OpenGLContext/shaders/pose_blend.comp

@@ -0,0 +1,253 @@
+#version 330 core
+#extension GL_ARB_compute_shader : require
+#extension GL_ARB_shader_storage_buffer_object : require
+// readonly/writeonly are reserved words until GLSL 4.20; the memory
+// qualifiers a storage buffer is declared with come from this extension,
+// so a #version 330 shader that uses them has to ask for it. A permissive
+// compiler takes them without; a strict one rejects the whole shader.
+#extension GL_ARB_shader_image_load_store : require
+
+// One thread per joint of every figure: sample whatever clips that figure is
+// playing, blend them layer by layer, and write the joint's translation,
+// rotation and scale into the pose the skeleton pass reads.
+//
+// **Layers, in order, each masked to the joints it may move.** A figure runs on
+// its base layer and fires on an upper one masked to its arms; each layer is a
+// weighted **mean** of its own tracks -- two clips at full weight give the
+// midpoint between them and not twice either -- blended over the pose built so
+// far, and where a layer's weights do not reach one the shortfall is taken from
+// underneath it. That is the same arithmetic the processor-side blend does, and
+// the test for this file is that the two agree.
+//
+// What is *not* here: additive layers and morph weights. A figure using either
+// is blended on the processor instead.
+
+layout(local_size_x = 64) in;
+
+layout(std430, binding = 0) writeonly buffer Pose {
+    vec4 pose[];                    // three per joint: translation, rotation, scale
+};
+layout(std430, binding = 1) readonly buffer Rest {
+    vec4 rest[];                    // the same three, where the model rests
+};
+layout(std430, binding = 2) readonly buffer ChannelIndex {
+    // (clip * joints + slot) * 3 + path -> a channel, or -1 for a joint this
+    // clip does not move.
+    int channelOf[];
+};
+layout(std430, binding = 3) readonly buffer Channels {
+    // keyCount, first key time, first key value, interpolation (0 step,
+    // 1 linear, 2 cubic).
+    ivec4 channels[];
+};
+layout(std430, binding = 4) readonly buffer Times {
+    float keyTimes[];
+};
+layout(std430, binding = 5) readonly buffer Values {
+    vec4 keyValues[];
+};
+layout(std430, binding = 6) readonly buffer Tracks {
+    // clip, time, weight, unused -- one per clip playing on a layer.
+    vec4 tracks[];
+};
+layout(std430, binding = 7) readonly buffer FigureLayers {
+    ivec4 figureLayers[];           // first layer, how many, unused, unused
+};
+layout(std430, binding = 8) readonly buffer Layers {
+    // first track, how many, which mask (-1 for none), the layer's weight.
+    vec4 layers[];
+};
+layout(std430, binding = 9) readonly buffer Masks {
+    uint maskWords[];               // maskStride words per mask, a bit per joint
+};
+
+uniform int jointsPerFigure;
+uniform int figures;
+uniform int maskStride;
+
+const int STEP = 0;
+const int LINEAR = 1;
+const int CUBIC = 2;
+
+vec4 normalizeRotation(vec4 q) {
+    float n = dot(q, q);
+    return n > 0.0 ? q * inversesqrt(n) : vec4(0.0, 0.0, 0.0, 1.0);
+}
+
+vec4 slerp(vec4 a, vec4 b, float u) {
+    a = normalizeRotation(a);
+    b = normalizeRotation(b);
+    float d = dot(a, b);
+    if (d < 0.0) {                  // the shorter arc: -q is the same rotation
+        b = -b;
+        d = -d;
+    }
+    if (d > 0.9995) {               // where the sin denominator underflows
+        return normalizeRotation(a + u * (b - a));
+    }
+    float theta0 = acos(clamp(d, -1.0, 1.0));
+    float sin0 = sin(theta0);
+    float theta = theta0 * u;
+    return normalizeRotation(a * (sin(theta0 - theta) / sin0)
+                             + b * (sin(theta) / sin0));
+}
+
+// Which keyframe segment `t` falls in, and how far along it. Held at either
+// end, as a clip is outside its own range.
+void segmentOf(int first, int count, float t, out int index, out float fraction) {
+    index = 0;
+    fraction = 0.0;
+    if (count < 2 || t <= keyTimes[first]) {
+        return;
+    }
+    if (t >= keyTimes[first + count - 1]) {
+        index = count - 1;
+        return;
+    }
+    int low = 0;
+    int high = count - 1;
+    while (low + 1 < high) {        // the last segment starting at or before t
+        int mid = (low + high) / 2;
+        if (keyTimes[first + mid] <= t) {
+            low = mid;
+        } else {
+            high = mid;
+        }
+    }
+    index = low;
+    float span = keyTimes[first + low + 1] - keyTimes[first + low];
+    fraction = span > 0.0 ? (t - keyTimes[first + low]) / span : 0.0;
+}
+
+vec4 keyValue(int channel, int interpolation, int key) {
+    ivec4 entry = channels[channel];
+    int offset = interpolation == CUBIC ? 3 * key + 1 : key;
+    return keyValues[entry.z + offset];
+}
+
+vec4 sampleChannel(int channel, float t, bool rotation) {
+    ivec4 entry = channels[channel];
+    int count = entry.x;
+    int interpolation = entry.w;
+    if (count <= 0) {
+        return vec4(0.0);
+    }
+    int index;
+    float fraction;
+    segmentOf(entry.y, count, t, index, fraction);
+    if (interpolation == CUBIC) {
+        if (count == 1 || t <= keyTimes[entry.y]) {
+            return keyValues[entry.z + 1];
+        }
+        if (t >= keyTimes[entry.y + count - 1]) {
+            return keyValues[entry.z + 3 * (count - 1) + 1];
+        }
+        int following = min(index + 1, count - 1);
+        float span = keyTimes[entry.y + following] - keyTimes[entry.y + index];
+        vec4 v0 = keyValues[entry.z + 3 * index + 1];
+        vec4 b0 = keyValues[entry.z + 3 * index + 2];
+        vec4 v1 = keyValues[entry.z + 3 * following + 1];
+        vec4 a1 = keyValues[entry.z + 3 * following];
+        float u = fraction;
+        float u2 = u * u;
+        float u3 = u2 * u;
+        vec4 out4 = (2.0 * u3 - 3.0 * u2 + 1.0) * v0
+                  + (u3 - 2.0 * u2 + u) * span * b0
+                  + (-2.0 * u3 + 3.0 * u2) * v1
+                  + (u3 - u2) * span * a1;
+        return rotation ? normalizeRotation(out4) : out4;
+    }
+    if (count == 1 || fraction == 0.0 || interpolation == STEP) {
+        return keyValue(channel, interpolation, index);
+    }
+    vec4 a = keyValue(channel, interpolation, index);
+    vec4 b = keyValue(channel, interpolation, min(index + 1, count - 1));
+    return rotation ? slerp(a, b, fraction) : a + (b - a) * fraction;
+}
+
+bool movesThisJoint(int mask, int slot) {
+    if (mask < 0) {
+        return true;                // an unmasked layer moves the whole model
+    }
+    uint word = maskWords[mask * maskStride + (slot >> 5)];
+    return (word & (1u << uint(slot & 31))) != 0u;
+}
+
+void main() {
+    int index = int(gl_GlobalInvocationID.x);
+    if (index >= figures * jointsPerFigure) {
+        return;
+    }
+    int figure = index / jointsPerFigure;
+    int slot = index - figure * jointsPerFigure;
+    int restBase = slot * 3;
+
+    vec4 value[3];
+    for (int path = 0; path < 3; ++path) {
+        value[path] = rest[restBase + path];
+    }
+
+    ivec4 stack = figureLayers[figure];
+    for (int step = 0; step < stack.y; ++step) {
+        vec4 layer = layers[stack.x + step];
+        if (!movesThisJoint(int(layer.z), slot)) {
+            continue;               // this layer leaves the joint as it found it
+        }
+        vec4 blended[3];
+        float total[3];
+        bool touched[3];
+        for (int path = 0; path < 3; ++path) {
+            blended[path] = vec4(0.0);
+            total[path] = 0.0;
+            touched[path] = false;
+        }
+        int first = int(layer.x);
+        int count = int(layer.y);
+        for (int k = 0; k < count; ++k) {
+            vec4 track = tracks[first + k];
+            int clip = int(track.x);
+            float t = track.y;
+            float weight = track.z;
+            if (weight <= 0.0) {
+                continue;
+            }
+            for (int path = 0; path < 3; ++path) {
+                int channel = channelOf[(clip * jointsPerFigure + slot) * 3 + path];
+                if (channel < 0) {
+                    continue;
+                }
+                bool rotation = (path == 1);
+                vec4 sampled = sampleChannel(channel, t, rotation);
+                if (!touched[path]) {
+                    blended[path] = sampled;
+                } else {
+                    float fraction = weight / (total[path] + weight);
+                    blended[path] = rotation
+                        ? slerp(blended[path], sampled, fraction)
+                        : blended[path] + (sampled - blended[path]) * fraction;
+                }
+                total[path] += weight;
+                touched[path] = true;
+            }
+        }
+        for (int path = 0; path < 3; ++path) {
+            if (!touched[path]) {
+                continue;
+            }
+            float strength = layer.w * min(1.0, total[path]);
+            if (strength >= 1.0) {
+                value[path] = blended[path];
+            } else if (path == 1) {
+                value[path] = slerp(value[path], blended[path], strength);
+            } else {
+                value[path] = value[path]
+                            + (blended[path] - value[path]) * strength;
+            }
+        }
+    }
+
+    int base = index * 3;
+    for (int path = 0; path < 3; ++path) {
+        pose[base + path] = value[path];
+    }
+}

openglcontext-3.0.0a7/OpenGLContext/shaders/skeleton_palette.comp

@@ -0,0 +1,72 @@
+#version 330 core
+#extension GL_ARB_compute_shader : require
+#extension GL_ARB_shader_storage_buffer_object : require
+// readonly/writeonly are reserved words until GLSL 4.20; the memory
+// qualifiers a storage buffer is declared with come from this extension,
+// so a #version 330 shader that uses them has to ask for it. A permissive
+// compiler takes them without; a strict one rejects the whole shader.
+#extension GL_ARB_shader_image_load_store : require
+
+// One thread per joint of every skin of every figure: turn a world matrix into
+// the matrix the skinning vertex shader multiplies a vertex by.
+//
+//     palette[j] = inverseBind[j] * world[joint j] * inverse(world[mesh node])
+//
+// in row-vector terms; the inverse of the mesh node's own transform is what
+// cancels the modelview the mesh will be drawn with, so the skin lives in the
+// space the vertices were modelled in. Written straight into the buffer the
+// vertex shader reads as a texture buffer, so nothing crosses the bus.
+
+layout(local_size_x = 64) in;
+
+layout(std430, binding = 2) readonly buffer World {
+    mat4 world[];
+};
+layout(std430, binding = 3) readonly buffer Joints {
+    int jointSlot[];            // rig slot of each joint, per skin, run together
+};
+layout(std430, binding = 4) readonly buffer InverseBind {
+    mat4 inverseBind[];         // one per entry of jointSlot
+};
+layout(std430, binding = 5) readonly buffer Targets {
+    // Per (figure, skin) that wants a palette written:
+    //   x = figure, y = first joint of the skin in jointSlot/inverseBind,
+    //   z = how many joints, w = where the palette range starts.
+    ivec4 targets[];
+};
+layout(std430, binding = 6) readonly buffer MeshSlots {
+    int meshSlot[];             // rig slot of each target's mesh node, or -1
+};
+layout(std430, binding = 7) writeonly buffer Palette {
+    mat4 palette[];
+};
+
+uniform int jointsPerFigure;
+uniform int targetCount;
+uniform int jointsPerTarget;    // the widest skin, so the grid is rectangular
+
+void main() {
+    int index = int(gl_GlobalInvocationID.x);
+    int target = index / jointsPerTarget;
+    if (target >= targetCount) {
+        return;
+    }
+    int joint = index - target * jointsPerTarget;
+    ivec4 entry = targets[target];
+    if (joint >= entry.z) {
+        return;
+    }
+    int figure = entry.x;
+    int slot = jointSlot[entry.y + joint];
+    mat4 jointWorld = slot >= 0
+        ? world[figure * jointsPerFigure + slot]
+        : mat4(1.0);
+    int mesh = meshSlot[target];
+    mat4 nodeInverse = mesh >= 0
+        ? inverse(world[figure * jointsPerFigure + mesh])
+        : mat4(1.0);
+    // Row-vector `ib * jointWorld * nodeInverse`, which in the transposed
+    // matrices a GLSL mat4 holds reads the other way about.
+    palette[entry.w + joint] =
+        nodeInverse * jointWorld * inverseBind[entry.y + joint];
+}

openglcontext-3.0.0a7/OpenGLContext/shaders/skeleton_world.comp

@@ -0,0 +1,82 @@
+#version 330 core
+#extension GL_ARB_compute_shader : require
+#extension GL_ARB_shader_storage_buffer_object : require
+// readonly/writeonly are reserved words until GLSL 4.20; the memory
+// qualifiers a storage buffer is declared with come from this extension,
+// so a #version 330 shader that uses them has to ask for it. A permissive
+// compiler takes them without; a strict one rejects the whole shader.
+#extension GL_ARB_shader_image_load_store : require
+
+// One thread per joint of every figure: compose that joint's local transform
+// and every ancestor's, and multiply them into a world matrix.
+//
+// Walking to the root per joint rather than composing a generation at a time
+// costs each thread as many small matrix products as the skeleton is deep --
+// a dozen for a humanoid -- and buys the whole pass: no second dispatch, no
+// barrier, and no intermediate buffer of local matrices to write and read
+// back. A GPU has far more threads than a skeleton has joints, so the work
+// that is repeated is work that would otherwise have sat idle.
+//
+// Matrices are stored the way the rest of the renderer means them: row-vector,
+// `p * M`, `world = local * parent`. A GLSL mat4 holds the transpose of that
+// (its columns are the row-vector matrix's rows), which is why the products
+// below read right to left.
+
+layout(local_size_x = 64) in;
+
+layout(std430, binding = 0) readonly buffer Pose {
+    // Three vec4 per joint: translation.xyz, rotation (x,y,z,w), scale.xyz.
+    vec4 pose[];
+};
+layout(std430, binding = 1) readonly buffer Hierarchy {
+    int parent[];               // parent slot of each joint, -1 at a root
+};
+layout(std430, binding = 2) writeonly buffer World {
+    mat4 world[];
+};
+
+uniform int jointsPerFigure;
+uniform int figures;
+
+mat3 rotationOf(vec4 q) {
+    float x = q.x, y = q.y, z = q.z, w = q.w;
+    float n = x * x + y * y + z * z + w * w;
+    if (n > 0.0) {
+        float s = inversesqrt(n);
+        x *= s; y *= s; z *= s; w *= s;
+    } else {
+        x = 0.0; y = 0.0; z = 0.0; w = 1.0;
+    }
+    return mat3(
+        1.0 - 2.0 * (y * y + z * z), 2.0 * (x * y + w * z), 2.0 * (x * z - w * y),
+        2.0 * (x * y - w * z), 1.0 - 2.0 * (x * x + z * z), 2.0 * (y * z + w * x),
+        2.0 * (x * z + w * y), 2.0 * (y * z - w * x), 1.0 - 2.0 * (x * x + y * y));
+}
+
+mat4 localOf(int figure, int slot) {
+    int base = (figure * jointsPerFigure + slot) * 3;
+    vec3 translation = pose[base].xyz;
+    vec4 rotation = pose[base + 1];
+    vec3 scale = pose[base + 2].xyz;
+    mat3 r = rotationOf(rotation);
+    return mat4(vec4(scale.x * r[0], 0.0),
+                vec4(scale.y * r[1], 0.0),
+                vec4(scale.z * r[2], 0.0),
+                vec4(translation, 1.0));
+}
+
+void main() {
+    int index = int(gl_GlobalInvocationID.x);
+    if (index >= figures * jointsPerFigure) {
+        return;
+    }
+    int figure = index / jointsPerFigure;
+    int slot = index - figure * jointsPerFigure;
+    mat4 composed = localOf(figure, slot);
+    int up = parent[slot];
+    while (up >= 0) {
+        composed = localOf(figure, up) * composed;
+        up = parent[up];
+    }
+    world[index] = composed;
+}

openglcontext-3.0.0a7/OpenGLContext/shaders/vrml97_wide_line.geom

@@ -0,0 +1,72 @@
+#version 330 core
+
+// A line segment as a quad lineWidth pixels across, facing the screen, for
+// X3D's LineProperties. Each output vertex carries how far along the
+// polyline it is in pixels, for the dash pattern: the segment's distance
+// along the polyline (vAlong) scaled to its length on screen.
+
+layout(lines) in;
+layout(triangle_strip, max_vertices = 4) out;
+
+in vec3 vColor[];
+in vec3 vEyePosition[];
+in float vAlong[];
+
+uniform vec2 viewportSize;   // pixels
+uniform float lineWidth;     // pixels
+
+out vec3 gColor;
+out vec3 gEyePosition;
+out float gAlong;            // pixels along the polyline
+
+// A clip-space point in front of the near plane, so it has a screen position
+const float NEAR_W = 1e-4;
+
+void emit(vec4 position, vec2 offset, int corner, float along) {
+    gl_Position = position + vec4(offset * position.w, 0.0, 0.0);
+    // The ClipPlanes' distances at the segment's end, from the vertex stage
+    // (_clipplane_inc.glsl), with constant indices as GLSL 3.30 asks
+    gl_ClipDistance[0] = gl_in[corner].gl_ClipDistance[0];
+    gl_ClipDistance[1] = gl_in[corner].gl_ClipDistance[1];
+    gl_ClipDistance[2] = gl_in[corner].gl_ClipDistance[2];
+    gl_ClipDistance[3] = gl_in[corner].gl_ClipDistance[3];
+    gl_ClipDistance[4] = gl_in[corner].gl_ClipDistance[4];
+    gl_ClipDistance[5] = gl_in[corner].gl_ClipDistance[5];
+    gl_ClipDistance[6] = gl_in[corner].gl_ClipDistance[6];
+    gl_ClipDistance[7] = gl_in[corner].gl_ClipDistance[7];
+    gColor = vColor[corner];
+    gEyePosition = vEyePosition[corner];
+    gAlong = along;
+    EmitVertex();
+}
+
+void main() {
+    vec4 start = gl_in[0].gl_Position;
+    vec4 end = gl_in[1].gl_Position;
+    if (start.w < NEAR_W && end.w < NEAR_W) {
+        return;
+    }
+    // The part of the segment in front of the viewer
+    if (start.w < NEAR_W) {
+        start = mix(start, end, (NEAR_W - start.w) / (end.w - start.w));
+    } else if (end.w < NEAR_W) {
+        end = mix(end, start, (NEAR_W - end.w) / (start.w - end.w));
+    }
+    vec2 halfViewport = 0.5 * viewportSize;
+    vec2 first = start.xy / start.w * halfViewport;
+    vec2 second = end.xy / end.w * halfViewport;
+    vec2 along = second - first;
+    float pixels = length(along);
+    vec2 direction = pixels > 0.0 ? along / pixels : vec2(1.0, 0.0);
+    // Half the width either side, in normalised device units
+    vec2 offset = vec2(-direction.y, direction.x) * (0.5 * lineWidth) / halfViewport;
+    float distance = vAlong[1] - vAlong[0];
+    float scale = distance > 0.0 ? pixels / distance : 0.0;
+    float startAlong = vAlong[0] * scale;
+    float endAlong = startAlong + pixels;
+    emit(start, offset, 0, startAlong);
+    emit(start, -offset, 0, startAlong);
+    emit(end, offset, 1, endAlong);
+    emit(end, -offset, 1, endAlong);
+    EndPrimitive();
+}

{openglcontext-3.0.0a5 → openglcontext-3.0.0a7}/OpenGLContext/video/__init__.py

@@ -1,7 +1,7 @@
 """Recording what the engine draws.
 
 :class:`~OpenGLContext.video.recorder.VideoRecorder` takes the frame a context
-has just drawn and writes it to an H.264 video file, with the frame going
+has just drawn and writes it to an MP4 video file (H.264, HEVC, VP9 or AV1), with the frame going
 straight from the framebuffer to the GPU's video encoder.
 
 Recording needs the ``video`` extra::

{openglcontext-3.0.0a5 → openglcontext-3.0.0a7}/OpenGLContext/video/clock.py

@@ -54,8 +54,9 @@ class FixedStepClock:
         denominator)`` pair. The pair is what keeps a long recording at 29.97
         from drifting: the step is 1001/30000 of a second, not a rounding of it.
     start -- the time the first frame happens at. By default the clock this one
-        replaces is asked, so a recording continues the world's time rather than
-        restarting it.
+        replaces is asked when this one is installed, so a recording continues
+        the world's time rather than restarting it, and one that waited to be
+        installed does not set the world back by the wait.
 
     Installed by using it as a context manager, or with :meth:`install` and
     :meth:`restore`. Nothing advances it: call :meth:`advance` once per frame
@@ -77,6 +78,7 @@ class FixedStepClock:
         self.step = denominator / numerator
         #: Frames finished since the clock started.
         self.frames = 0
+        self._start_given = start is not None
         self.start = systemtime.systemTime() if start is None else float(start)
         self._previous: Any = None
         self._installed = False
@@ -112,6 +114,8 @@ class FixedStepClock:
     def install(self) -> "FixedStepClock":
         """Take over as the engine's time source."""
         if not self._installed:
+            if not self._start_given and not self.frames:
+                self.start = systemtime.systemTime()
             self._previous = systemtime.setTimeSource(self)
             self._installed = True
         return self

openglcontext-3.0.0a7/OpenGLContext/video/codecs.py

@@ -0,0 +1,32 @@
+"""The codecs a recording can be written in, and the names they are asked for by.
+
+A recording is H.264, HEVC, VP9 or AV1, all stored in an MP4 file. Which of them
+a machine produces is up to its GPU's encoder; this module only names them, so a
+command line can check a spelling before any window opens or any encoder
+package is imported.
+"""
+from __future__ import annotations
+
+__all__ = ['CODECS', 'canonical']
+
+#: The codecs a recording takes, in the names the encoder package uses.
+CODECS = ('h264', 'hevc', 'vp9', 'av1')
+
+_ALIASES = {
+    'avc': 'h264', 'h.264': 'h264', 'x264': 'h264',
+    'h265': 'hevc', 'h.265': 'hevc', 'x265': 'hevc',
+}
+
+
+def canonical(name: str) -> str:
+    """The name in :data:`CODECS` that `name` spells, whatever its case.
+
+    ``'h265'`` is HEVC and ``'avc'`` is H.264. Raises :class:`ValueError`
+    listing the codecs there are for any other name.
+    """
+    lowered = name.strip().lower()
+    lowered = _ALIASES.get(lowered, lowered)
+    if lowered not in CODECS:
+        raise ValueError('%r is not a recording codec; the codecs are %s'
+                         % (name, ', '.join(CODECS)))
+    return lowered