是否可以将渲染部分的代码和计算部分的代码分开？

[makabakadot]

我在自己的Qt项目中先使用ModernGL库渲染图片和Spine动画，然后想使用这个库渲染Live2d动画，但是库里v2和v3两个版本都不可以用。v2会抛出NoneType调用loadParam()的错误，使用v3则在Live2d初始化后会直接崩溃，退出代码不是1或者0，就和Pybind包装的Cpp出错崩溃一样。怀疑是PyOpenGl的调用和ModernGL底层冲突了。可不可以像Spine Runtime库一样将OpenGl渲染相关的部分和其他通用部分分开，方便修改调用？

[Arkueid]

关于 live2d 初始化崩溃，我觉得有可能是渲染 spine 或者图片的过程中，其内部渲染逻辑没有对 opengl 的一些配置进行复位。单纯使用 moderngl 渲染 live2d 我试了一下应该是没有大问题。方便提供 图片+spine+live2d的示例程序吗？

v3 目前有一个新的类，live2d.v3.Model，把渲染和通用计算分开了，可以参考：Model 代码示例 main_pygame_fine_grained.py，可以在未创建opengl上下文的情况下加载和控制模型。

v2 版本目前对 opengl 有一层抽象，之后可以提供一个设置，把这个实际使用的 pyopengl 换成其他的 opengl 库或API。后续也能将初始化方法拆分，把通用计算和渲染逻辑分离。

moderngl 渲染 live2d：

2025-06-26.11-00-22.00_00_12-00_00_23.mp4

[makabakadot]

我用的Python是3.13，所以我不确定Pyside2和Pyqt5和moderngl交互有没有这个这个需要调用fbo的bug

[makabakadot]

上面我写错了，是moderngl和qt的openglwidget组件之间有Bug
因此这个使用moderngl的例子可能有问题。至少在我使用的pyside6的版本中，需要在QOpenGLWidge的paintGl()中调用moderngl.Context的detect_framebuffer()，对其返回的fbo调用use()方法,才可以正常进行渲染。
我程序主要是用一个通用的QOpenGLWidget类作为展示窗口，通过实现IRenderObject接口的不同的Render类达到渲染不同图片或动画的目的，我测试v2，v3就是依照示例的调用顺序，封装了一个Live2dRender类。更新显示通过keyPressEvent触发事件，在 RenderWidget.LoadRender()中更新Render类。Live2dRender类中调用API就是按照示例调用顺序调用。实验的时候在运行测试的Live2dRender之前只有运行过DefaultRender，没有使用展示图片和Spine的类。
代码有点屎山了，删掉和图片与Spine相关调用的代码居然跑不动，凑合的看一下吧

import moderngl
import numpy as np
from PySide6.QtGui import QSurfaceFormat
from PySide6.QtOpenGLWidgets import QOpenGLWidget


def setFormat(vsync=False):#是否垂直同步
    fmt=QSurfaceFormat()
    fmt.setVersion(3,3)
    fmt.setProfile(QSurfaceFormat.OpenGLContextProfile.CoreProfile)
    fmt.setSwapBehavior(QSurfaceFormat.SwapBehavior.DoubleBuffer)
    fmt.setSwapInterval(1 if vsync else 0)
    QSurfaceFormat.setDefaultFormat(fmt)
    return fmt
class RenderWidget(QOpenGLWidget):
    #一个专注渲染的类，不负责交互
    def __init__(self,parent=None,fps=60,default_render=None):
        super().__init__(parent)
        #设置句柄
        self.setFormat(setFormat())
        #计时调用省略
        #不同Render的实例
        self.Render: "IRenderObject" = None
        self.Updating=False#用于描述是否调用过Start，调用过为True，没有为False

        self.defaultRender=default_render#默认渲染类，作用是画一个彩三角
        self.fbo=None#需要在paintGL中获取的fbo,在获取后才可以渲染
        # self._updateType=UpdateType.Default
    def initializeGL(self, /):
        self._ctx = moderngl.create_context()
        self._viewport = (0, 0, self.size().width(), self.size().height())
        if self.defaultRender is not None:
            self.SetDefaultRender()
    def paintGL(self, /):
        if self.Updating:
            self.Render.Update()#非第一次调用，则调用Update()函数
        else:
            self.Render.Start(self.Updata_Fbo)#第一次调用，则调用Start()函数如绑定Texture等
            self.Updating=True
    def SetDefaultRender(self):
        if self.Render is None or (not isinstance(self.Render,self.defaultRender)):
            if self.defaultRender is not None:
                self.Render=self.defaultRender(self._ctx)
                self.Render.Init(self._viewport)
    def Updata_Fbo(self):
        #获取Fbo的函数，需要在paintGL()中调用:
        if self.fbo is None:
            self.fbo = self._ctx.detect_framebuffer()
            self.fbo.use()
            self._ctx.enable(self._ctx.BLEND)
    #派发函数，用于派发不同的渲染方式
    def LoadRender(self,Render:"Type['IRenderObject']",updateType:"UpdateType",*data,**kwargs):
        match updateType:
            # case UpdateType.Spine:
            #     pass
                #实例化Spine渲染类，以及初始化不需要在paintGL中执行的步骤
            case _:#UpdateType.Live2d
                pass
                # 实例化Live2d渲染类，未完成
                #大体就是在__new__中选择v2或v3初始化live2d模块,并返回model()对象,__init__中读取Json,更新主要放在Updata()中
            # case UpdateType.Picture:
            #     pass
                #实例化普通渲染类，加载普通图片
            # case UpdateType.Default:
            #     self.SetDefaultRender()
                #清屏，回到默认屏幕
        self.Updating=False#重设标志，表示需要调用Start()在paintGL



# class DefaultRender("IRenderObject"):
class DefaultRender:
    #这个类继承接口后没有重写Update()方法，父方法默认就是个空方法。因为默认屏幕不需要重复更新
    _instance=None
    vertrex = '''
        #version 330 core
        in vec2 xy;
        in vec3 color;
        out vec3 v_color;
        void main()
        {
            gl_Position = vec4(xy,0.0, 1.0);
            v_color=color;
        }
        '''
    fragment = """
        #version 330 core
        in vec3 v_color;
        out vec4 FragColor;
        void main()
        {
            FragColor = vec4(v_color,1.0);
        }

        """
    def __new__(cls,ctx:'Context'):#单例模式，不需要创建过多默认渲染对象，在这里直接创建shader
        if cls._instance is None:
            cls._instance=object.__new__(cls)
            setattr(
                cls._instance,
                "prog",
                ctx.program(
                    cls.vertrex,cls.fragment
                )
            )
            vbo = np.array(
                [
                       0,  0.5774, 0.0, 1.0, 0.0,
                    -0.5, -0.2887, 1.0, 0.0, 0.0,
                     0.5, -0.2887, 0.0, 0.0, 1.0
                ], dtype='f4'
            )
            data = ctx.buffer(vbo.tobytes())
            setattr(
                cls._instance,
                "vao",
                ctx.vertex_array(
                    cls._instance.prog,
                    data,
                    "xy",
                    "color"
                )
            )
        return cls._instance
    def __init__(self,ctx:'Context'):
        self._ctx=ctx
    def Update(self,*args):
        pass
    def Init(self,viewport:tuple[int,int,int,int]):
        self._ctx.viewport=viewport
    def Start(self,Fbo_UpdaterFunc, background=(1, 1, 1)):
        Fbo_UpdaterFunc()#必须调用获取Fbo的函数
        self._ctx.clear(*background)
        self.vao.render(moderngl.TRIANGLES)
    # def GetType(self):#返回默认渲染类标志
    #     return RenderType.Default

[Arkueid]

PyQt5 使用 QOpenGLWidget 也存在 fbo 的 bug，但是使用 QGLWidget 不需要重新获取 fbo，确实是 QOpenGLWidget 和 moderngl 在 fbo 方面有冲突。

另外，绘制 三角形+ live2d 时出现了这个问题：

问题可能在于 vao 未解绑。

绘制三角形使用了 vao，而整个 live2d 绘制流程中没有使用到 vao，每帧绘制 live2d 时都会重新绑定 vbo。在绘制三角形时，如果不解绑 vao，三角形的数据会“污染” live2d 的数据。（moderngl 貌似在绘制后没有自动解绑 vao，具体是如何“污染”的暂不清楚）

在绘制 live2d 前使用 pyopengl 对 vao 进行解绑，绘制 live2d 时，v3 使用 cpp 层的 opengl 进行绘制，v2 使用 pyopengl 进行绘制，三角形使用 moderngl 进行绘制，至少在我的设备上可以成功绘制：

v3：

v2：

代码：

import sys
import numpy as np
import moderngl

from PySide6.QtWidgets import QApplication
from PySide6.QtOpenGLWidgets import QOpenGLWidget

# import live2d.v3 as live2d
import live2d.v2 as live2d
import os
import OpenGL.GL as GL

import resources

from typing import Optional


class DefaultRenderer:

    _instance = None

    vertex = """
    #version 330 core
    in vec2 in_position;
    in vec3 in_color;
    out vec3 v_color;
    void main() 
    {
        gl_Position = vec4(in_position, 0.0, 1.0);
        v_color = in_color;
    }
    """

    fragment = """
    #version 330 core
    in vec3 v_color;
    out vec4 FragColor;
    void main() 
    {
        FragColor = vec4(v_color, 1.0);
    }
    """
    vao: moderngl.VertexArray
    prog: moderngl.Program

    def __init__(self, ctx: 'moderngl.Context'):
        self._ctx = ctx

    def __new__(cls, ctx: 'moderngl.Context'):
        if cls._instance is None:
            cls._instance = object.__new__(cls)
            setattr(cls._instance, "prog", ctx.program(cls.vertex, cls.fragment))
            vbo = np.array([
                # 位置        # 颜色
                0.0, 1.0,     1.0, 0.0, 0.0,  # 上顶点 - 红色
                -1.0, -1.0,   0.0, 1.0, 0.0,  # 左下顶点 - 绿色
                1.0, -1.0,    0.0, 0.0, 1.0   # 右下顶点 - 蓝色
            ], dtype=np.float32)
            data = ctx.buffer(vbo.tobytes())
            setattr(cls._instance, "vao", ctx.vertex_array(cls._instance.prog, data, "in_position", "in_color"))
            return cls._instance
    
    def Render(self):
        self.vao.render(moderngl.TRIANGLES)

class GLWidget(QOpenGLWidget):
    def __init__(self, parent=None):
        super().__init__()
        
        # 初始化变量
        self.ctx: Optional[moderngl.Context] = None
        self.model: Optional[live2d.LAppModel] = None
        self.triangle: Optional[DefaultRenderer] = None
        
        # 设置窗口尺寸
        self.setMinimumSize(800, 600)
    
    def initializeGL(self):
        # 创建ModernGL上下文
        self.ctx = moderngl.create_context()

        live2d.glInit()

        self.model = live2d.LAppModel()
        self.model.LoadModelJson(
            os.path.join(
                resources.RESOURCES_DIRECTORY, 
                "v3/llny/llny.model3.json" if live2d.LIVE2D_VERSION == 3
                         else "v2/kasumi2/kasumi2.model.json"
                         ))
        
        self.triangle = DefaultRenderer(self.ctx)

        self.first = False

        self.startTimer(int(1000 / 60))

    def timerEvent(self, e):
        self.update()

    def paintGL(self):
        fbo = self.ctx.detect_framebuffer()
        fbo.use()

        # 清除屏幕
        self.ctx.clear(0.2, 0.2, 0.2, 1.0)

        self.triangle.Render()

        GL.glBindVertexArray(0) # 绘制live2d 前 解绑 vao
        self.model.Update()
        self.model.Draw()


    def resizeGL(self, w, h):
        self.ctx.viewport = (0, 0, w, h)
        self.model.Resize(w, h)


if __name__ == '__main__':
    live2d.init()
    app = QApplication(sys.argv)
    window = GLWidget()
    window.setWindowTitle('ModernGL + PySide6 + live2d')
    window.show()
    app.exec()
    live2d.dispose()

[makabakadot]

v3版本解决忘记init()的问题，v2版本报错
在PlatformManager.loadTexture()中的gl.glEnable(gl.GL_TEXTURE_2D)抛出错误

Error calling Python override of QOpenGLWidget::keyPressEvent(): Traceback (most recent call last):
  File "E:\python\Live2d\test.py", line 23, in keyPressEvent
    self.LoadRender(Live2dRender.Live2dRender, UpdateType.Live2d_Updata,
    ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                 r"R:\download\live2d-py-main\live2d-py-main\Resources\v2\shizuku\shizuku.model.json")
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "E:\python\Live2d\CustomWidgets\RenderWidget.py", line 135, in LoadRender
    self.Render=Live2dRender(data[0],2)
                ~~~~~~~~~~~~^^^^^^^^^^^
  File "E:\python\Live2d\Renders\Live2dRender.py", line 32, in __init__
    self.model.LoadModelJson(json)
    ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^
  File "E:\python\Live2d\.venv\Lib\site-packages\live2d\v2\lapp_model.py", line 47, in LoadModelJson
    self.loadTexture(i, tex_paths)
    ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^
  File "E:\python\Live2d\.venv\Lib\site-packages\live2d\v2\framework\model\l2d_base_model.py", line 107, in loadTexture
    pm.loadTexture(self.live2DModel, no, path)
    ~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "E:\python\Live2d\.venv\Lib\site-packages\live2d\v2\platform_manager.py", line 25, in loadTexture
    gl.glEnable(gl.GL_TEXTURE_2D)
    ~~~~~~~~~~~^^^^^^^^^^^^^^^^^^
  File "E:\python\Live2d\.venv\Lib\site-packages\OpenGL\platform\baseplatform.py", line 487, in __call__
    return self(*args, **named)
  File "E:\python\Live2d\.venv\Lib\site-packages\OpenGL\error.py", line 230, in glCheckError
    raise self._errorClass(
    ...<4 lines>...
    )
OpenGL.error.GLError: GLError(
	err = 1280,
	description = b'\xce\xde\xd0\xa7\xc1\xd0\xbe\xd9',
	baseOperation = glEnable,
	cArguments = (GL_TEXTURE_2D,)
)

v3版本输出不知道和后面报错有没有关系

[INFO] [CSM][E]Shader compile log: WARNING: 0:1: '#version' : version number deprecated in OGL 3.0 forward-compatible context driver

我这边也出现了vao混乱的情况，怀疑可能和DefaultRenderer有关，DefaultRenderer采用单例模式，里面的vao一直没有回收。解绑vao的语句在重复调用时GL.glBindVertexArray(0)报下面错，如果只是调用一次则黑屏

Error calling Python override of QOpenGLWidget::paintGL(): Traceback (most recent call last):
  File "E:\python\Live2d\CustomWidgets\RenderWidget.py", line 109, in paintGL
    self.Render.Update(delta/1000*self._speed)
    ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^
  File "E:\python\Live2d\Renders\Live2dRender.py", line 42, in Update
    GL.glBindVertexArray(0)
    ~~~~~~~~~~~~~~~~~~~~^^^
  File "E:\python\Live2d\.venv\Lib\site-packages\OpenGL\error.py", line 230, in glCheckError
    raise self._errorClass(
    ...<4 lines>...
    )
OpenGL.error.GLError: GLError(
	err = 1282,
	description = b'\xce\xde\xd0\xa7\xb2\xd9\xd7\xf7',
	baseOperation = glBindVertexArray,
	cArguments = (0,)
)

[makabakadot]

刚刚看了一下moderngl的文档，底层托管的openGL对象默认的释放方式是手动释放的，通过调用release()。在DefaultRender的__del__调用vao.release()也应该可以解绑,消除bug。我这边结果和调用GL.glBindVertexArray(0)一次一样直接黑屏

[Arkueid]

黑屏的问题不太清楚，可能是报错的衍生问题，看看报错问题解决之后还会不会出现。

v2在PlatformManager.loadTexture()中的gl.glEnable(gl.GL_TEXTURE_2D)抛出错误 和 v3 报错可能都是这段代码导致的：

fmt = QSurfaceFormat()
fmt.setVersion(3, 3)
fmt.setProfile(QSurfaceFormat.OpenGLContextProfile.CoreProfile)
fmt.setSwapInterval(0)
QSurfaceFormat.setDefaultFormat(fmt)

去掉应该就没问题了。

live2d 为了兼容性使用的是版本 120，显式声明 opengl profile 版本可能导致 live2d 的着色器无法通过编译。

[makabakadot]

感谢大佬，问题解决了，之前和这个错误应该都是因为显式声明版本的原因

[makabakadot]

v2版本渲染主要和PlatformManager.loadTexture()函数,ClippingManagerOpenGL.setupClip()函数,DrawParamOpenGL类这三个部分相关。通过改变这几个函数和类可以实现渲染部分的自定义。
modergl的context我是通过在init函数中传入参数后保存在Live2d类中,GLContext类是用于包装context的类，由于Qt与Moderngl之间的bug，使用Context.screen()返回的fbo不能作为离屏渲染的老fbo，要使用在paintGL()中Context.detect_framebuffer()获取的fbo。因此随context一起传入。

@dataclass
class GLContext:
    Context:'moderngl.Context'=None
    Fbo:'moderngl.Framebuffer'=None
    Bg:tuple[float,float,float]=(0,0,0)

def init(ctx):
    Live2D.init(ctx)
    Live2DFramework.setPlatformManager(PlatformManager())
class Live2D:
    L2D_OUTSIDE_PARAM_AVAILABLE = False
    __firstInit = True
    clippingMaskBufferSize = 256
    GLContext:"GLContext"=None
    @staticmethod
    def init(context:GLContext):
        Live2D.GLContext=context
        if Live2D.__firstInit:
            Live2D.__firstInit = False
    @staticmethod
    def clear(r,g,b,a):
        Live2D.GLContext.Context.clear(r,g,b,a)

在PlatformManager.loadTexture()中加载纹理，所以这个函数需要修改

class PlatformManager:
    def loadTexture(self, live2DModel, no, path):
        image = Image.open(path)
        if image.mode != 'RGBA':
            image = image.convert("RGBA")
        texture = Live2D.GLContext.Context.texture(
            image.size,
            4,
            image.tobytes()
        )
        texture.build_mipmaps()
        sampler = Live2D.GLContext.Context.sampler(
            filter=(moderngl.LINEAR_MIPMAP_NEAREST, moderngl.LINEAR),
            texture=texture
        )
        live2DModel.setTexture(no, sampler)

在ClippingManagerOpenGL.setupClip()中实现离屏渲染，需要切换fbo和viewport

    def setupClip(self, a1, aQ):
        aK = 0
        for aO in range(0, len(self.clipContextList), 1):
            aP = self.clipContextList[aO]
            self.calcClippedDrawTotalBounds(a1, aP)
            if aP.isUsing:
                aK += 1

        if aK > 0:
            aQ.gl就是GLContext
            oldFbo = aQ.gl.Fbo#获取屏幕fbo
            view=aQ.gl.Context.viewport#保存屏幕viewport
            rect = [None for i in range(4)]
            rect[0] = 0
            rect[1] = 0
            rect[2] = view[2]
            rect[3] = view[3]
            aQ.gl.Context.viewport=(0, 0, Live2D.clippingMaskBufferSize, Live2D.clippingMaskBufferSize)#更新viewport
            self.setupLayoutBounds(aK)
            aQ.framebufferObject.framebuffer.use()#使用离屏fbo
            aQ.ctx.clear(0,0,0,0)
            for aO in range(0, len(self.clipContextList), 1):
                aP = self.clipContextList[aO]
                aT = aP.allClippedDrawRect
                aV = aP.layoutBounds
                aJ = 0.05
                self.tmpBoundsOnModel.setRect(aT)
                self.tmpBoundsOnModel.expand(aT.width * aJ, aT.height * aJ)
                aZ = aV.width / self.tmpBoundsOnModel.width
                aY = aV.height / self.tmpBoundsOnModel.height
                self.tmpMatrix2.identity()
                self.tmpMatrix2.translate(-1, -1, 0)
                self.tmpMatrix2.scale(2, 2, 1)
                self.tmpMatrix2.translate(aV.x, aV.y, 0)
                self.tmpMatrix2.scale(aZ, aY, 1)
                self.tmpMatrix2.translate(-self.tmpBoundsOnModel.x, -self.tmpBoundsOnModel.y, 0)
                self.tmpMatrixForMask.setMatrix(self.tmpMatrix2.m)
                self.tmpMatrix2.identity()
                self.tmpMatrix2.translate(aV.x, aV.y, 0)
                self.tmpMatrix2.scale(aZ, aY, 1)
                self.tmpMatrix2.translate(-self.tmpBoundsOnModel.x, -self.tmpBoundsOnModel.y, 0)
                self.tmpMatrixForDraw.setMatrix(self.tmpMatrix2.m)
                aH = self.tmpMatrixForMask.getArray()
                for aX in range(0, 16, 1):
                    aP.matrixForMask[aX] = aH[aX]

                a0 = self.tmpMatrixForDraw.getArray()
                for aX in range(0, 16, 1):
                    aP.matrixForDraw[aX] = a0[aX]

                aS = len(aP.clippingMaskDrawIndexList)
                for aU in range(0, aS, 1):
                    aR = aP.clippingMaskDrawIndexList[aU]
                    aI = a1.getDrawData(aR)
                    aL = a1.getDrawContext(aR)
                    aQ.setClipBufPre_clipContextForMask(aP)
                    aI.draw(aQ, a1, aL)#绘制函数，会调用DrawParamOpenGL.drawTexture()

            oldFbo.use()#切换回屏幕fbo
            aQ.setClipBufPre_clipContextForMask(None)
            aQ.gl.Context.viewport=rect[0], rect[1], rect[2], rect[3]#重设viewport

DrawParamOpenGL是渲染的主体，必须全部改写，主要是shader的编译，数据的绑定以及vbo,ibo，fbo的生成。

@dataclass
class FrameBufferObject:#FrameBufferObject的包装
    framebuffer: "Framebuffer" = None
    renderbuffer: 'Renderbuffer' = None
    texture: "Sampler" = None
class Location:#绑定纹理的位置
    ShaderProgram_texture0= 1
    ShaderProgramOff_texture0 = 2
    ShaderProgramOff_texture1 = 3
class DrawParamOpenGL(DrawParam):

    def __init__(self):
        super().__init__()
        self.framebufferObject: "FrameBufferObject" | None = None
        self.shaderProgramOff = None
        self.shaderProgram = None
        self.textures = []
        self.transform = None
        self.gl = Live2D.GLContext
        self.ctx = Live2D.GLContext.Context
        self.firstDraw = True
        self.anisotropyExt = None
        self.maxAnisotropy = 0
        self.uv_vbo = None
        self.vbo = None
        self.ibo = None  # 原本是ebo,改ibo,个人习惯

    def resize(self, ww, wh):
        self.ctx.viewport = (0, 0, ww, wh)

    def setTransform(self, aH):
        self.transform = aH

    def setupDraw(self):
        # a_h = self.gl
        if self.firstDraw:
            self.initShader()
            self.firstDraw = False
            # self.anisotropyExt = aH.MAX_TEXTURE_MAX_ANISOTROPY
            # if self.anisotropyExt:
            #     self.maxAnisotropy = a_h.getParameter(self.anisotropyExt)

        self.ctx.scissor = None  # gl.disable(gl.SCISSOR_TEST)
        self.ctx.disable(self.ctx.DEPTH_TEST)  # gl.disable(gl.DEPTH_TEST)
        # STENCIL_TEST似乎不支持设置，刚好这里也不用

        self.ctx.front_face = 'cw'  # gl.frontFace(gl.CW)
        self.ctx.enable(self.ctx.BLEND)  # gl.enable(gl.BLEND)
        # gl.colorMask(1, 1, 1, 1) 在framebuffer里设置

    def drawTexture(self, texNo, screenColor, indexArray, vertexArray, uvArray, opacity, comp, multiplyColor):
        if opacity < 0.01 and self.clipBufPre_clipContextMask is None:
            return

        r = self.baseRed * opacity
        g = self.baseGreen * opacity
        b = self.baseBlue * opacity
        a = self.baseAlpha * opacity
        # print("baseColor", a_w, a2, a5, a7)
        if self.clipBufPre_clipContextMask is not None:
            # 根据蒙版进行裁剪
            self.ctx.front_face = 'ccw'
            self.bindOrCreateIBO(indexArray)
            self.bindOrCreateVBO(vertexArray)
            self.bindOrCreateUV_VBO(uvArray)
            texture = self.textures[texNo]
            texture.use(Location.ShaderProgram_texture0)
            vao = self.ctx.vertex_array(
                self.shaderProgram, [
                    (self.vbo, '2f', "a_position"),
                    (self.uv_vbo, '2f', 'a_texCoord')
                ],
                index_buffer=self.ibo,
                index_element_size=4
            )
            self.shaderProgram["u_mvpMatrix"] = self.getClipBufPre_clipContextMask().matrixForMask
            channelNumber = self.getClipBufPre_clipContextMask().layoutChannelNo
            color = self.getChannelFlagAsColor(channelNumber)
            self.shaderProgram["u_channelFlag"] = color.r, color.g, color.b, color.a

            layoutBounds = self.getClipBufPre_clipContextMask().layoutBounds
            self.shaderProgram["u_baseColor"] = (layoutBounds.x * 2.0 - 1.0,
                                                 layoutBounds.y * 2.0 - 1.0,
                                                 layoutBounds.getRight() * 2.0 - 1.0,
                                                 layoutBounds.getBottom() * 2.0 - 1.0)
            self.shaderProgram["u_maskFlag"] = True
            self.shaderProgram["u_screenColor"] = screenColor
            self.shaderProgram["u_multiplyColor"] = multiplyColor
        elif self.clipBufPre_clipContextDraw is not None:
            # 绘制蒙版
            self.bindOrCreateIBO(indexArray)
            self.bindOrCreateVBO(vertexArray)
            self.bindOrCreateUV_VBO(uvArray)
            texture = self.textures[texNo]
            texture.use(Location.ShaderProgramOff_texture0)

            vao = self.ctx.vertex_array(
                self.shaderProgramOff, [
                    (self.vbo, '2f', "a_position"),
                    (self.uv_vbo, '2f', 'a_texCoord')
                ],
                index_buffer=self.ibo,
                index_element_size=4
            )
            self.shaderProgramOff["u_clipMatrix"] = self.getClipBufPre_clipContextDraw().matrixForDraw
            self.shaderProgramOff["u_mvpMatrix"] = self.matrix4x4

            self.framebufferObject.texture.use(Location.ShaderProgramOff_texture1)
            channelNumber = self.getClipBufPre_clipContextDraw().layoutChannelNo
            color = self.getChannelFlagAsColor(channelNumber)
            self.shaderProgramOff["u_channelFlag"] = (
                color.r, color.g, color.b, color.a
            )
            self.shaderProgramOff["u_baseColor"] = (
                r, g, b, a
            )
            self.shaderProgramOff["u_screenColor"] = screenColor
            self.shaderProgramOff["u_multiplyColor"] = multiplyColor
        else:
            self.bindOrCreateIBO(indexArray)
            self.bindOrCreateVBO(vertexArray)
            self.bindOrCreateUV_VBO(uvArray)
            texture = self.textures[texNo]
            texture.use(Location.ShaderProgram_texture0)

            vao = self.ctx.vertex_array(
                self.shaderProgram, [
                    (self.vbo, '2f', "a_position"),
                    (self.uv_vbo, '2f', 'a_texCoord')
                ],
                index_buffer=self.ibo,
                index_element_size=4
            )
            self.shaderProgram["u_mvpMatrix"] = self.matrix4x4
            self.shaderProgram["u_baseColor"] = r, g, b, a
            self.shaderProgram["u_maskFlag"] = False
            self.shaderProgram["u_screenColor"] = screenColor
            self.shaderProgram["u_multiplyColor"] = multiplyColor
        if self.culling:
            self.ctx.enable(self.ctx.CULL_FACE)
        else:
            self.ctx.disable(self.ctx.CULL_FACE)

        self.ctx.enable(self.ctx.BLEND)

        self.ctx.blend_equation = self.ctx.FUNC_ADD
        if self.clipBufPre_clipContextMask is not None or (comp == Mesh.COLOR_COMPOSITION_NORMAL):
            self.ctx.blend_func = (
                self.ctx.ONE, self.ctx.ONE_MINUS_SRC_ALPHA,
                self.ctx.ONE, self.ctx.ONE_MINUS_SRC_ALPHA
            )
        else:
            if comp == Mesh.COLOR_COMPOSITION_SCREEN:
                self.ctx.blend_func = (
                    self.ctx.ONE, self.ctx.ONE,
                    self.ctx.ZERO, self.ctx.ONE
                )
            elif comp == Mesh.COLOR_COMPOSITION_MULTIPLY:
                self.ctx.blend_func = (
                    self.ctx.DST_COLOR, self.ctx.ONE_MINUS_SRC_ALPHA,
                    self.ctx.ZERO, self.ctx.ONE
                )
            else:
                raise RuntimeError("unknown comp")

        vao.render(moderngl.TRIANGLES)

    def setTexture(self, aH, aI):
        size = len(self.textures)
        if aH >= size:
            for i in range(size, aH + 1):
                self.textures.append(None)
        self.textures[aH] = aI

    def initShader(self):
        self.loadShaders2()
        self.shaderProgram["s_texture0"] = Location.ShaderProgram_texture0

        self.shaderProgramOff["s_texture0"] = Location.ShaderProgramOff_texture0
        self.shaderProgramOff["s_texture1"] = Location.ShaderProgramOff_texture1

    def loadShaders2(self):
        #openGL version改到3.3
        #原本的createProgram,compileShader,deleteProgram由于modergl的封装就全部删掉了
        vert = """#version 330 core
                 in vec2 a_position;
                 in vec2 a_texCoord;
                 out vec2 v_texCoord;
                 out vec4 v_clipPos;
                 uniform mat4 u_mvpMatrix;
                 void main(){
                     gl_Position = u_mvpMatrix * vec4(a_position, 0.0, 1.0);
                     v_clipPos = gl_Position;
                     v_texCoord = a_texCoord;
                     v_texCoord.y = 1.0 - v_texCoord.y;
                }
              """
        frag = """#version 330 core
                in vec2       v_texCoord;
                in vec4       v_clipPos;
                uniform sampler2D  s_texture0;
                uniform vec4       u_channelFlag;
                uniform vec4       u_baseColor;
                uniform bool       u_maskFlag;
                uniform vec4       u_screenColor;
                uniform vec4       u_multiplyColor;
                out vec4 FragColor;
                void main(){
                    vec4 smpColor;
                    if(u_maskFlag){
                    float isInside = 
                    step(u_baseColor.x, v_clipPos.x/v_clipPos.w)
                    * step(u_baseColor.y, v_clipPos.y/v_clipPos.w)
                    * step(v_clipPos.x/v_clipPos.w, u_baseColor.z)
                    * step(v_clipPos.y/v_clipPos.w, u_baseColor.w);
                    smpColor = u_channelFlag * texture(s_texture0, v_texCoord).a * isInside;
                    }else{
                    smpColor = texture(s_texture0 , v_texCoord);
                    smpColor.rgb = smpColor.rgb * smpColor.a;
                    smpColor.rgb = smpColor.rgb * u_multiplyColor.rgb;
                    smpColor.rgb = smpColor.rgb + u_screenColor.rgb - (smpColor.rgb * u_screenColor.rgb);
                    smpColor = smpColor * u_baseColor;
                    }
                FragColor = smpColor;}"""
        vertOff = """#version 330 core
              in vec2     a_position;
              in vec2     a_texCoord;
              out vec2       v_texCoord;
              out vec4       v_clipPos;
              uniform mat4       u_mvpMatrix;
              uniform mat4       u_clipMatrix;
              void main(){
                vec4 pos = vec4(a_position, 0, 1.0);
                gl_Position = u_mvpMatrix * pos;
                v_clipPos = u_clipMatrix * pos;
                v_texCoord = a_texCoord;
                v_texCoord.y = 1.0 - v_texCoord.y;
              }"""
        fragOff = """#version 330 core
                    in   vec2   v_texCoord;
                    in   vec4   v_clipPos;
                    uniform sampler2D  s_texture0;
                    uniform sampler2D  s_texture1;
                    uniform vec4       u_channelFlag;
                    uniform vec4       u_baseColor;
                    uniform vec4       u_screenColor;
                    uniform vec4       u_multiplyColor;
                    out vec4 FragColor;
                    void main(){
                        vec4 col_formask = texture(s_texture0, v_texCoord);
                        col_formask.rgb = col_formask.rgb * u_multiplyColor.rgb;
                        col_formask.rgb = col_formask.rgb + u_screenColor.rgb - (col_formask.rgb * u_screenColor.rgb);
                        col_formask = col_formask * u_baseColor;
                        col_formask.rgb = col_formask.rgb * col_formask.a;
                        vec4 clipMask = texture(s_texture1, v_clipPos.xy / v_clipPos.w) * u_channelFlag;
                        float maskVal = clipMask.r + clipMask.g + clipMask.b + clipMask.a;
                        col_formask = col_formask * maskVal;
                        FragColor = col_formask;}"""
        self.shaderProgram = self.ctx.program(vert, frag)
        self.shaderProgramOff = self.ctx.program(vertOff, fragOff)
        return True

    def createFramebuffer(self):
        #创建离屏渲染fbo
        size = Live2D.clippingMaskBufferSize
        rbo = self.ctx.renderbuffer(
            size=(size, size),
            components=4,
            dtype='f4'
        )
        texture = self.ctx.texture(
            size=(size, size),
            components=4,
            dtype="f1"
        )
        sampler = self.ctx.sampler(
            repeat_x=False,  # gl.texParameteri(aL.TEXTURE_2D, gl.TEXTURE_WRAP_S, aL.CLAMP_TO_EDGE)
            repeat_y=False,  # gl.texParameteri(aL.TEXTURE_2D, gl.TEXTURE_WRAP_T, aL.CLAMP_TO_EDGE)
            texture=texture,
            filter=(moderngl.LINEAR, moderngl.LINEAR)
            # aL.texParameteri(aL.TEXTURE_2D, aL.TEXTURE_MIN_FILTER, aL.LINEAR)
            # aL.texParameteri(aL.TEXTURE_2D, aL.TEXTURE_MAG_FILTER, aL.LINEAR)
        )
        fbo = self.ctx.framebuffer(
            color_attachments=[texture],
            # depth_attachment=rbo
        )
        self.framebufferObject = FrameBufferObject()
        self.framebufferObject.rbo = rbo
        self.framebufferObject.framebuffer = fbo
        self.framebufferObject.texture = sampler
    #原本独立的创建buffer函数作为类函数
    def bindOrCreateVBO(self, data: list):
        b = np.array(data, dtype='f4').tobytes()
        if self.vbo is None:
            self.vbo = self.ctx.buffer(
                data=b,
                dynamic=True
            )
            return
        else:
            offset = self.vbo.size - len(b)  # 计算差值
            if offset >= 0:  # 说明有空位，可以直接填充
                self.vbo.write(
                    data=b,
                    offset=0
                )
                if offset != 0:
                    self.vbo.write(
                        data=bytes(offset),#填充为0的byte
                        offset=len(b)
                    )
            else:  # 释放内存,重新分配
                self.vbo.release()
                self.vbo = self.ctx.buffer(
                    data=b,
                    dynamic=True
                )
                return

    def bindOrCreateUV_VBO(self, data: list):
        b = np.array(data, dtype='f4').tobytes()
        if self.uv_vbo is None:
            self.uv_vbo = self.ctx.buffer(
                data=b,
                dynamic=True
            )
            return
        else:
            offset = self.uv_vbo.size - len(b)  # 计算差值
            if offset >= 0:  # 说明有空位，可以直接填充
                self.uv_vbo.write(
                    data=b,
                    offset=0
                )
                if offset != 0:
                    self.uv_vbo.write(
                        data=bytes(offset),
                        offset=len(b)
                    )
            else:  # 释放内存,重新分配
                self.uv_vbo.release()
                self.uv_vbo = self.ctx.buffer(
                    data=b,
                    dynamic=True
                )
                return

    def bindOrCreateIBO(self, data: list):
        b = np.array(data, dtype='i4').tobytes()
        if self.ibo is None:
            self.ibo = self.ctx.buffer(
                data=b,
                dynamic=True
            )
            return
        else:
            offset = self.ibo.size - len(b)  # 计算差值
            if offset >= 0:  # 说明有空位，可以直接填充
                self.ibo.write(
                    data=b,
                    offset=0
                )
                if offset != 0:  # 用0填充
                    self.ibo.write(
                        data=bytes(offset),
                        offset=len(b)
                    )
            else:  # 释放内存,重新分配
                self.ibo.release()
                self.ibo = self.ctx.buffer(
                    data=b,
                    dynamic=True
                )
                return

测试脚本，模拟Qt渲染组件中需要detect fbo传入的情况

import math
import os
import time
import glfw
import moderngl as mgl
import numpy as np
from PIL import Image
import modernv2
# import live2d.v2 as modernv2
if not glfw.init():
    raise Exception('GLFW出错')
window = glfw.create_window(800, 600 ,'LearnOpenGL', None, None)
if not window:
    glfw.terminate()
    raise Exception('window出错')
glfw.make_context_current(window)
ctx = mgl.create_context()
def framebuffer_size_callback(window, width, height):
    ctx.viewport=(0, 0, width, height)
glfw.set_framebuffer_size_callback(window, framebuffer_size_callback)
def process_input(window):
    if glfw.get_key(window, glfw.KEY_ESCAPE) == glfw.PRESS:
        glfw.set_window_should_close(window, True)
clc=modernv2.GLContext()
clc.Context=ctx
clc.Fbo=ctx.screen#这里偷了个懒，在qtopengl组件里要用detect的fbo
clc.Bg=(0,0,0,0)
modernv2.init(clc)
# modernv2.init()
modernv2.glewInit()
model=modernv2.LAppModel()
model.LoadModelJson(os.path.join(r"R:\download\live2d-py-main\live2d-py-main\Resources", r"v2/kasumi2/kasumi2.model.json"))
model.StartMotion("TapBody", 3, 3, onStartMotionHandler=None, onFinishMotionHandler=lambda: print("end 1"))
model.StartMotion("TapBody", 4, 3, onFinishMotionHandler=lambda: print("end 2"))
model.StartRandomMotion("TapBody", 3, onStartMotionHandler=lambda group, no: print(f"start 1 {group} {no}"),
                        onFinishMotionHandler=lambda: print("end 3"))
glfw.swap_interval(0)
# model.SetOffset(0.5,0.5)
model.Resize(800, 600)
while not glfw.window_should_close(window):
    modernv2.clearBuffer(0.2,0.3,0.3)
    model.Update()
    model.Draw()
    glfw.poll_events()
    glfw.swap_buffers(window)
glfw.terminate()

结果