Improper values for parameters

[achojnicki]

HI,

I've been playing with this module and found a bug within it. Whenever I'm trying to set a value for a parameters, it does it wrong. For example, when I set a value for the parameter ParamAngleZ -10, then to 10, and then to 0, then on the third attempt to set the parameter, it sets the value to negative value.

bug.mp4

In the above video, the value of the text input is used to set the value of the ParamAngleZ parameter. As you can see, it sets the wrong position of the model on the 3rd attempt to set the value.

[achojnicki]

Sorry for the music in the background. I forgot to pause it before recording.

[achojnicki]

I couldn't find any support links on your repo. If you fix it, I'm happy to send you £100 for fixing this.

[Arkueid]

It could be a problem with the live2d model (I guess). Does the issue occur with any other model?

I‘m unable to reproduce the bug using the following code.

2025-06-24.10-27-10.00_00_02-00_00_14.mp4

import os
import pygame
import live2d.v3 as live2d
from live2d.v3 import StandardParams
import resources

opts = [-10.0, 10.0, 0.0]
opti = 0

def main():
    global opts
    global opti

    pygame.init()
    live2d.init()

    display = (500, 600)
    pygame.display.set_mode(display, pygame.DOUBLEBUF | pygame.OPENGL)
    pygame.display.set_caption("pygame window")

    live2d.glewInit()

    model = live2d.LAppModel()

    model.LoadModelJson(
        os.path.join(resources.RESOURCES_DIRECTORY, "v3/Mao/Mao.model3.json")
    )

    model.Resize(*display)
    model.SetAutoBlinkEnable(False)
    model.SetAutoBreathEnable(False)

    running = True
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
                break
            elif event.type == pygame.MOUSEMOTION:
                model.Drag(*pygame.mouse.get_pos())


            elif event.type == pygame.MOUSEBUTTONUP:
                opti %= len(opts)
                model.SetParameterValue(StandardParams.ParamAngleZ, opts[opti])
                print(StandardParams.ParamAngleZ, opts[opti])
                opti += 1
        
        if not running:
            break

        live2d.clearBuffer()
        model.Update()

        model.Draw()

        pygame.display.flip()

    live2d.dispose()

    pygame.quit()

if __name__ == "__main__":
    main()

[achojnicki]

You can use this code to reproduce:

from OpenGL.GL import *
from OpenGL.GLUT import *

from yaml import safe_load
from pathlib import Path
from platform import system
from os import getcwd

import wx
import wx.glcanvas as glcanvas
import live2d.v3 as live2d


class MyCanvasBase(glcanvas.GLCanvas):
    def __init__(self, parent, *args, **kwargs):
        glcanvas.GLCanvas.__init__(self, parent, -1)
        self.init = False
        self.context = glcanvas.GLContext(self)

        self.Bind(wx.EVT_SIZE, self.OnSize)
        self.Bind(wx.EVT_PAINT, self.OnPaint)


    def OnPaint(self, event):
        dc = wx.PaintDC(self)
        self.SetCurrent(self.context)
        if not self.init:
            self.InitGL()
            self.init = True
        self.OnDraw()

class SickenCanvas(MyCanvasBase):
    def __init__(self, parent, root):
        MyCanvasBase.__init__(self, parent)

        self._root=root
        self._live2d_model=None


        self.timer=wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.on_refresh, self.timer)
        self.timer.Start(20)


    def on_refresh(self, event):
        self.Refresh()


    def OnSize(self, event):
        wx.CallAfter(self.DoSetViewport)
        if self._live2d_model:
            self._live2d_model.Resize(*self.GetSize())
        #event.Skip()


    def DoSetViewport(self):
        size = self.size = self.GetClientSize()
        self.SetCurrent(self.context)
        glViewport(0, 0, size.width, size.height)


    def InitGL(self):
        live2d.glInit()

    def OnDraw(self):
        live2d.clearBuffer()

        if self._live2d_model:
            self._live2d_model.Update()
            self._live2d_model.Draw()

        self.SwapBuffers()


class Panel(wx.Panel):
    def __init__(self, root, parent):
        self._root=root
        wx.Panel.__init__(self, parent)


        self.sizer=wx.BoxSizer(wx.VERTICAL)
        self.inner_sizer=wx.BoxSizer(wx.HORIZONTAL)

        self.canvas=SickenCanvas(self, self._root)


        self.textctrl=wx.TextCtrl(self,
            id=wx.ID_ANY,
            pos=wx.DefaultPosition,
            size=wx.DefaultSize,
            style=wx.TE_PROCESS_ENTER
            )


        self.inner_sizer.Add(self.canvas, 1, wx.EXPAND)
        self.sizer.Add(self.inner_sizer, 9, wx.EXPAND)
        self.sizer.Add(self.textctrl, 0, wx.EXPAND)
        self.SetSizer(self.sizer)

        self.SetBackgroundColour((32,34,39))
    
        
        self._live2d_model_path=Path(os.getcwd()).joinpath("2D BLACK AND WHITE OUTFIT ANIME GIRL MODEL 2")
        self._model3_path=Path(self._live2d_model_path).joinpath("2d black and white outfit anime girl model.model3.json")

        print(self._live2d_model_path)
        print(self._model3_path)
        self.textctrl.Bind(wx.EVT_TEXT_ENTER, self.play)

        self.Show(True)
    
    def update_parameters(self, param_id, value):
        if self._live2d_model:
            print(param_id, value)
            self._live2d_model.SetParameterValue(param_id, value)


    def update_model(self):
        if self._live2d_model:
            self._live2d_model.Update()
            self.canvas.on_refresh(None)

    def play(self, event=None):
        #actions=[]
        #actions.append({"action_name":'wink_right_eye_tilt'})
        #self._animation_model.set_actions(actions)
        #self._animation_model.play_actions()
        val=float(self.textctrl.GetValue())
        self.update_parameters('ParamAngleZ', val)
        self.update_model()

    def init_canvas(self):
        self._live2d_model=live2d.LAppModel()
        self._live2d_model.LoadModelJson(str(self._model3_path))
        self._live2d_model.Resize(*self.canvas.GetSize())
        self._live2d_model.SetAutoBlinkEnable(False)
        self._live2d_model.SetAutoBreathEnable(False)
        self.canvas._live2d_model=self._live2d_model




class Frame(wx.Frame):
    def __init__(self, root):
        self._root=root
        wx.Frame.__init__(self, None, title="Bug", size=(1000,1000), style=wx.DEFAULT_FRAME_STYLE)

        self._panel=Panel(parent=self, root=root)


class App:
    def __init__(self):
        self._app=wx.App()
        self._frame=Frame(None)
    
    def start(self):
        self._frame.Show()
        wx.CallLater(1000,self._frame._panel.init_canvas)
        self._app.MainLoop()
        

if __name__=="__main__":
    live2d.init()
    app=App()
    app.start()

[Arkueid]

Based on the video, it might be an issue with the model itself. Two possible causes I've thought of are:

1. The final head angle can be overridden by physics calculation defined in physics3.json.
2. The model creator set the visual output at ParamAngleZ=0.0 the same as ParamAngleZ=-10.0

2025-06-24.17-20-01.00_00_01-00_00_16.mp4