live2d-py 0.2.2__tar.gz → 0.2.4__tar.gz

{live2d_py-0.2.2 → live2d_py-0.2.4}/CMakeLists.txt

@@ -18,7 +18,7 @@ if(DEFINED PYTHON_INSTALLATION_PATH)
     set(CMAKE_PREFIX_PATH ${PYTHON_INSTALLATION_PATH})
 else()
     # 寻找Python
-    message("Not found PYTHON_INSTALLATION_PATH in environment variables")
+    message("Not found PYTHON_INSTALLATION_PATH in environment variables. \nUse default path.")
     set(CMAKE_PREFIX_PATH D:/Python/x64/3.12)
 endif()
 
@@ -26,8 +26,12 @@ if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
   set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/static)
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zi")
   add_compile_options("/utf-8" "/wd4018" "/wd4244" "/wd4996")
-  add_link_options("/NODEFAULTLIB:LIBCMT")
+  add_link_options("/NODEFAULTLIB:LIBCMT" "/DEBUG")
+
+
 else()
   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE})
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/${CMAKE_BUILD_TYPE})

{live2d_py-0.2.2 → live2d_py-0.2.4}/Framework/src/Motion/ACubismMotion.hpp

@@ -10,6 +10,7 @@
 #include "CubismFramework.hpp"
 #include "Id/CubismId.hpp"
 #include "Type/csmVector.hpp"
+#include <functional>
 
 namespace Live2D { namespace Cubism { namespace Framework {
 
@@ -26,7 +27,7 @@ class ACubismMotion
 {
 public:
     /// モーション再生終了コールバック関数定義
-    typedef void (*FinishedMotionCallback)(ACubismMotion* self);
+    using FinishedMotionCallback = std::function<void(ACubismMotion*)>;
     /**
      * @brief インスタンスの破棄
      *

{live2d_py-0.2.2 → live2d_py-0.2.4}/LAppModelWrapper.cpp

@@ -1,3 +1,8 @@
+#include <GL/glew.h>
+#ifdef WIN32
+#include <GL/wglew.h>
+#endif // WIN32
+
 #include <LAppModel.hpp>
 #include <CubismFramework.hpp>
 #include <LAppPal.hpp>
@@ -10,6 +15,10 @@
 
 #include <Python.h>
 
+#ifdef WIN32
+#include <Windows.h>
+#endif
+
 static LAppAllocator _cubismAllocator;
 static Csm::CubismFramework::Option _cubismOption;
 
@@ -97,82 +106,66 @@ static PyObject *PyLAppModel_Draw(PyLAppModelObject *self, PyObject *args)
 typedef Live2D::Cubism::Framework::ACubismMotion::FinishedMotionCallback FinishedMotionCallback;
 typedef Live2D::Cubism::Framework::ACubismMotion ACubismMotion;
 
-// 全局回调函数，任何时刻只可能有一个 motion 在播放
-// 而优先权高的 motion 会顶替当前 motion，当前 motion 作废
-static PyObject *g_start_callback;
-static PyObject *g_finish_callback;
-
-static void default_start_call_back(const char *group, int no)
-{
-    PyGILState_STATE gstate;
-    gstate = PyGILState_Ensure();
-    PyObject *result = PyObject_CallFunction(g_start_callback, "si", group, no);
-    if (result != NULL)
-        Py_XDECREF(result);
-
-    // Py_DECREF(g_start_callback);
-    // g_start_callback = nullptr;                          
-    PyGILState_Release(gstate);
-};
-
-static void default_finish_call_back(ACubismMotion *self)
-{
-    PyGILState_STATE gstate;
-    gstate = PyGILState_Ensure();
-    PyObject *result = PyObject_CallFunction(g_finish_callback, NULL);
-
-    if (result != NULL)
-        Py_XDECREF(result);
-
-    // Py_DECREF(g_finish_callback);
-    // g_finish_callback = nullptr;
-    PyGILState_Release(gstate);
-};
-
 static PyObject *PyLAppModel_StartMotion(PyLAppModelObject *self, PyObject *args, PyObject *kwargs)
 {
     const char *group;
     int no, priority;
     PyObject *onStartHandler = nullptr;
     PyObject *onFinishHandler = nullptr;
-    LAppModel::OnStartMotionHandler s_call = nullptr;
-    FinishedMotionCallback f_call = nullptr;
 
-    static char *kwlist[] = {(char*)"group", (char*)"no", (char*)"priority", (char*)"onStartMotionHandler", (char*)"onFinishMotionHandler", NULL};
+    static char *kwlist[] = {(char *)"group", (char *)"no", (char *)"priority", (char *)"onStartMotionHandler", (char *)"onFinishMotionHandler", NULL};
     if (!(PyArg_ParseTupleAndKeywords(args, kwargs, "sii|OO", kwlist, &group, &no, &priority, &onStartHandler, &onFinishHandler)))
     {
         return NULL;
     }
 
+    bool isStartNull = true, isFinishNull = true;
+
     if (onStartHandler != nullptr)
     {
-        bool isNone = Py_IsNone(onStartHandler);
-        if (!isNone && !PyCallable_Check(onStartHandler))
+        isStartNull = Py_IsNone(onStartHandler);
+        if (!isStartNull && !PyCallable_Check(onStartHandler))
         {
             PyErr_SetString(PyExc_TypeError, "Argument 4 must be callable.");
             return NULL;
         }
-        Py_XDECREF(g_start_callback);
         Py_XINCREF(onStartHandler);
-        g_start_callback = onStartHandler;
-        s_call = isNone ? nullptr : default_start_call_back;
     }
 
     if (onFinishHandler != nullptr)
     {
-        bool isNone = Py_IsNone(onFinishHandler);
-        if (!isNone && !PyCallable_Check(onFinishHandler))
+        isFinishNull = Py_IsNone(onFinishHandler);
+        if (!isFinishNull && !PyCallable_Check(onFinishHandler))
         {
             PyErr_SetString(PyExc_TypeError, "Argument 5 must be callable.");
             return NULL;
         }
-        Py_XDECREF(g_finish_callback);
-        Py_INCREF(onFinishHandler);
-        g_finish_callback = onFinishHandler;
-        f_call = isNone ? nullptr : default_finish_call_back;
+        Py_XINCREF(onFinishHandler);
     }
 
-    Csm::CubismMotionQueueEntryHandle handle = self->model->StartMotion(group, no, priority, s_call, f_call);
+    auto onStartCallback = [=](const char *group, int no)
+    {
+        if (isStartNull)
+            return;
+        PyObject *result = PyObject_CallFunction(onStartHandler, "si", group, no);
+        if (result != NULL)
+            Py_XDECREF(result);
+        Py_XDECREF(onStartHandler);
+    };
+
+    auto onFinishCallback = [=](Csm::ACubismMotion *)
+    {
+        if (isFinishNull)
+            return;
+        PyObject *result = PyObject_CallFunction(onFinishHandler, NULL);
+        if (result != NULL)
+            Py_XDECREF(result);
+        Py_XDECREF(onFinishHandler);
+    };
+
+    Csm::CubismMotionQueueEntryHandle handle = self->model->StartMotion(group, no, priority,
+                                                                        onStartCallback,
+                                                                        onFinishCallback);
 
     Py_RETURN_NONE;
 }
@@ -184,44 +177,57 @@ static PyObject *PyLAppModel_StartRandomMotion(PyLAppModelObject *self, PyObject
 
     PyObject *onStartHandler = nullptr;
     PyObject *onFinishHandler = nullptr;
-    LAppModel::OnStartMotionHandler s_call = nullptr;
-    FinishedMotionCallback f_call = nullptr;
 
-    static char *kwlist[] = {(char*)"group", (char*)"priority", (char*)"onStartMotionHandler", (char*)"onFinishMotionHandler", NULL};
+    static char *kwlist[] = {(char *)"group", (char *)"priority", (char *)"onStartMotionHandler", (char *)"onFinishMotionHandler", NULL};
     if (!(PyArg_ParseTupleAndKeywords(args, kwargs, "si|OO", kwlist, &group, &priority, &onStartHandler, &onFinishHandler)))
     {
         return NULL;
     }
+    bool isStartNull = true, isFinishNull = true;
 
     if (onStartHandler != nullptr)
     {
-        bool isNone = Py_IsNone(onStartHandler);
-        if (!isNone && !PyCallable_Check(onStartHandler))
+        isStartNull = Py_IsNone(onStartHandler);
+        if (!isStartNull && !PyCallable_Check(onStartHandler))
         {
             PyErr_SetString(PyExc_TypeError, "Argument 4 must be callable.");
             return NULL;
         }
-        Py_XDECREF(g_start_callback);
         Py_XINCREF(onStartHandler);
-        g_start_callback = onStartHandler;
-        s_call = isNone ? nullptr : default_start_call_back;
     }
 
     if (onFinishHandler != nullptr)
     {
-        bool isNone = Py_IsNone(onFinishHandler);
-        if (!isNone && !PyCallable_Check(onFinishHandler))
+        isFinishNull = Py_IsNone(onFinishHandler);
+        if (!isFinishNull && !PyCallable_Check(onFinishHandler))
         {
             PyErr_SetString(PyExc_TypeError, "Argument 5 must be callable.");
             return NULL;
         }
-        Py_XDECREF(g_finish_callback);
-        Py_INCREF(onFinishHandler);
-        g_finish_callback = onFinishHandler;
-        f_call = isNone ? nullptr : default_finish_call_back;
+        Py_XINCREF(onFinishHandler);
     }
 
-    self->model->StartRandomMotion(group, priority, s_call, f_call);
+    auto onStartCallback = [=](const char *group, int no)
+    {
+        if (isStartNull)
+            return;
+        PyObject *result = PyObject_CallFunction(onStartHandler, "si", group, no);
+        if (result != NULL)
+            Py_XDECREF(result);
+        Py_XDECREF(onStartHandler);
+    };
+
+    auto onFinishCallback = [=](Csm::ACubismMotion *)
+    {
+        if (isFinishNull)
+            return;
+        PyObject *result = PyObject_CallFunction(onFinishHandler, NULL);
+        if (result != NULL)
+            Py_XDECREF(result);
+        Py_XDECREF(onFinishHandler);
+    };
+
+    self->model->StartRandomMotion(group, priority, onStartCallback, onFinishCallback);
 
     Py_RETURN_NONE;
 }
@@ -279,60 +285,69 @@ static PyObject *PyLAppModel_HasMocConsistencyFromFile(PyLAppModelObject *self,
 
 static PyObject *PyLAppModel_Touch(PyLAppModelObject *self, PyObject *args, PyObject *kwargs)
 {
-    int mx, my;
-    PyObject *onStartMotionHandler = nullptr;
-    PyObject *onFinishMotionHandler = nullptr;
-
+    float mx, my;
     PyObject *onStartHandler = nullptr;
     PyObject *onFinishHandler = nullptr;
-    LAppModel::OnStartMotionHandler s_call = nullptr;
-    FinishedMotionCallback f_call = nullptr;
 
-    static char *kwlist[] = {(char*)"mx", (char*)"my", (char*)"onStartMotionHandler", (char*)"onFinishMotionHandler", NULL};
-    if (!(PyArg_ParseTupleAndKeywords(args, kwargs, "ii|OO", kwlist, &mx, &my, &onStartHandler, &onFinishHandler)))
+    static char *kwlist[] = {(char *)"mx", (char *)"my", (char *)"onStartMotionHandler", (char *)"onFinishMotionHandler", NULL};
+    if (!(PyArg_ParseTupleAndKeywords(args, kwargs, "ff|OO", kwlist, &mx, &my, &onStartHandler, &onFinishHandler)))
     {
         return NULL;
     }
 
+    bool isStartNull = true, isFinishNull = true;
+
     if (onStartHandler != nullptr)
     {
-        bool isNone = Py_IsNone(onStartHandler);
-        if (!isNone && !PyCallable_Check(onStartHandler))
+        isStartNull = Py_IsNone(onStartHandler);
+        if (!isStartNull && !PyCallable_Check(onStartHandler))
         {
             PyErr_SetString(PyExc_TypeError, "Argument 4 must be callable.");
             return NULL;
         }
-        Py_XDECREF(g_start_callback);
         Py_XINCREF(onStartHandler);
-        g_start_callback = onStartHandler;
-        s_call = isNone ? nullptr : default_start_call_back;
     }
 
     if (onFinishHandler != nullptr)
     {
-        bool isNone = Py_IsNone(onFinishHandler);
-        if (!isNone && !PyCallable_Check(onFinishHandler))
+        isFinishNull = Py_IsNone(onFinishHandler);
+        if (!isFinishNull && !PyCallable_Check(onFinishHandler))
         {
             PyErr_SetString(PyExc_TypeError, "Argument 5 must be callable.");
             return NULL;
         }
-        Py_XDECREF(g_finish_callback);
-        Py_INCREF(onFinishHandler);
-        g_finish_callback = onFinishHandler;
-        f_call = isNone ? nullptr : default_finish_call_back;
+        Py_XINCREF(onFinishHandler);
     }
 
-    float xf = (float)mx;
-    float yf = (float)my;
-    self->matrixManager.ScreenToScene(&xf, &yf);
+    auto onStartCallback = [=](const char *group, int no)
+    {
+        if (isStartNull)
+            return;
+        PyObject *result = PyObject_CallFunction(onStartHandler, "si", group, no);
+        if (result != NULL)
+            Py_XDECREF(result);
+        Py_XDECREF(onStartHandler);
+    };
+
+    auto onFinishCallback = [=](Csm::ACubismMotion *)
+    {
+        if (isFinishNull)
+            return;
+        PyObject *result = PyObject_CallFunction(onFinishHandler, NULL);
+        if (result != NULL)
+            Py_XDECREF(result);
+        Py_XDECREF(onFinishHandler);
+    };
 
-    csmString hitArea = self->model->HitTest(xf, yf);
+    self->matrixManager.ScreenToScene(&mx, &my);
+
+    csmString hitArea = self->model->HitTest(mx, my);
     if (strlen(hitArea.GetRawString()) != 0)
     {
         Info("hit area: [%s]", hitArea.GetRawString());
         if (strcmp(hitArea.GetRawString(), HIT_AREA_HEAD) == 0)
             self->model->SetRandomExpression();
-        self->model->StartRandomMotion(hitArea.GetRawString(), MOTION_PRIORITY_FORCE, s_call, f_call);
+        self->model->StartRandomMotion(hitArea.GetRawString(), MOTION_PRIORITY_FORCE, onStartCallback, onFinishCallback);
     }
 
     Py_RETURN_NONE;
@@ -340,17 +355,15 @@ static PyObject *PyLAppModel_Touch(PyLAppModelObject *self, PyObject *args, PyOb
 
 static PyObject *PyLAppModel_Drag(PyLAppModelObject *self, PyObject *args)
 {
-    int mx, my;
-    if (!(PyArg_ParseTuple(args, "ii", &mx, &my)))
+    float mx, my;
+    if (!(PyArg_ParseTuple(args, "ff", &mx, &my)))
     {
         return NULL;
     }
 
-    float xf = (float)mx;
-    float yf = (float)my;
-    self->matrixManager.ScreenToScene(&xf, &yf);
+    self->matrixManager.ScreenToScene(&mx, &my);
 
-    self->model->SetDragging(xf, yf);
+    self->model->SetDragging(mx, my);
 
     Py_RETURN_NONE;
 }
@@ -400,7 +413,7 @@ static PyObject *PyLAppModel_SetScale(PyLAppModelObject *self, PyObject *args)
 
 static PyObject *PyLAppModel_SetParameterValue(PyLAppModelObject *self, PyObject *args)
 {
-    const char* paramId;
+    const char *paramId;
     float value, weight;
 
     if (PyArg_ParseTuple(args, "sff", &paramId, &value, &weight) < 0)
@@ -414,9 +427,9 @@ static PyObject *PyLAppModel_SetParameterValue(PyLAppModelObject *self, PyObject
     Py_RETURN_NONE;
 }
 
-static PyObject* PyLAppModel_AddParameterValue(PyLAppModelObject* self, PyObject* args)
+static PyObject *PyLAppModel_AddParameterValue(PyLAppModelObject *self, PyObject *args)
 {
-    const char* paramId;
+    const char *paramId;
     float value;
 
     if (PyArg_ParseTuple(args, "sf", &paramId, &value) < 0)
@@ -430,8 +443,7 @@ static PyObject* PyLAppModel_AddParameterValue(PyLAppModelObject* self, PyObject
     Py_RETURN_NONE;
 }
 
-
-static PyObject* PyLAppModel_Update(PyLAppModelObject* self, PyObject* args)
+static PyObject *PyLAppModel_Update(PyLAppModelObject *self, PyObject *args)
 {
 
     self->model->Update();
@@ -439,7 +451,7 @@ static PyObject* PyLAppModel_Update(PyLAppModelObject* self, PyObject* args)
     Py_RETURN_NONE;
 }
 
-static PyObject* PyLAppModel_SetAutoBreathEnable(PyLAppModelObject* self, PyObject* args)
+static PyObject *PyLAppModel_SetAutoBreathEnable(PyLAppModelObject *self, PyObject *args)
 {
     bool enable;
 
@@ -454,7 +466,7 @@ static PyObject* PyLAppModel_SetAutoBreathEnable(PyLAppModelObject* self, PyObje
     Py_RETURN_NONE;
 }
 
-static PyObject* PyLAppModel_SetAutoBlinkEnable(PyLAppModelObject* self, PyObject* args)
+static PyObject *PyLAppModel_SetAutoBlinkEnable(PyLAppModelObject *self, PyObject *args)
 {
     bool enable;
 
@@ -469,6 +481,89 @@ static PyObject* PyLAppModel_SetAutoBlinkEnable(PyLAppModelObject* self, PyObjec
     Py_RETURN_NONE;
 }
 
+static PyObject *PyLAppModel_GetParameterCount(PyLAppModelObject *self, PyObject *args)
+{
+    return PyLong_FromLong(self->model->GetParameterCount());
+}
+
+static PyObject *module_live2d_v3_params = nullptr;
+static PyObject *class_parameter = nullptr;
+
+static PyObject *PyLAppModel_GetParameter(PyLAppModelObject *self, PyObject *args)
+{
+    int index;
+    if (PyArg_ParseTuple(args, "i", &index) < 0)
+    {
+        PyErr_SetString(PyExc_TypeError, "Invalid param");
+        return NULL;
+    }
+
+    Parameter param = self->model->GetParameter(index);
+
+    PyObject *instance = PyObject_CallObject(class_parameter, NULL);
+    if (instance == NULL)
+    {
+        PyErr_Print();
+        return NULL;
+    }
+
+    PyObject_SetAttrString(instance, "id", PyUnicode_FromString(param.id.c_str()));
+    PyObject_SetAttrString(instance, "type", PyLong_FromLong(param.type));
+    PyObject_SetAttrString(instance, "value", PyFloat_FromDouble(param.value));
+    PyObject_SetAttrString(instance, "max", PyFloat_FromDouble(param.maxValue));
+    PyObject_SetAttrString(instance, "min", PyFloat_FromDouble(param.minValue));
+    PyObject_SetAttrString(instance, "default", PyFloat_FromDouble(param.defaultValue));
+
+    return instance;
+}
+
+// GetPartCount() -> int
+static PyObject* PyLAppModel_GetPartCount(PyLAppModelObject* self, PyObject* args)
+{
+    return PyLong_FromLong(self->model->GetPartCount());
+}
+
+// GetPartId(index: int) -> str
+static PyObject* PyLAppModel_GetPartId(PyLAppModelObject* self, PyObject* args)
+{
+    int index;
+    if (PyArg_ParseTuple(args, "i", &index) < 0)
+    {
+        PyErr_SetString(PyExc_TypeError, "Invalid param");
+        return NULL;
+    }
+
+    return PyUnicode_FromString(self->model->GetPartId(index).GetRawString());
+}
+
+// GetPartIds() -> tuple[str]
+static PyObject* PyLAppModel_GetPartIds(PyLAppModelObject* self, PyObject* args)
+{
+    const int size = self->model->GetPartCount();
+
+    PyObject* list = PyList_New(size);
+
+    for (int i = 0; i < size; ++i) {
+        PyList_SetItem(list, i, PyUnicode_FromString(self->model->GetPartId(i).GetRawString()));
+    }
+
+    return list;
+}
+
+// SetPartOpacity(id: str, opacity: float) -> None
+static PyObject* PyLAppModel_SetPartOpacity(PyLAppModelObject* self, PyObject* args)
+{
+    int index;
+    float opacity;
+    if (PyArg_ParseTuple(args, "if", &index, &opacity) < 0)
+    {
+        PyErr_SetString(PyExc_TypeError, "Invalid param");
+        return NULL;
+    }
+
+    self->model->SetPartOpacity(index, opacity);
+    Py_RETURN_NONE;
+}
 
 // 包装模块方法的方法列表
 static PyMethodDef PyLAppModel_methods[] = {
@@ -486,15 +581,24 @@ static PyMethodDef PyLAppModel_methods[] = {
     {"IsMotionFinished", (PyCFunction)PyLAppModel_IsMotionFinished, METH_VARARGS, ""},
     {"SetOffset", (PyCFunction)PyLAppModel_SetOffset, METH_VARARGS, ""},
     {"SetScale", (PyCFunction)PyLAppModel_SetScale, METH_VARARGS, ""},
-    {"SetParameterValue", (PyCFunction)PyLAppModel_SetParameterValue, METH_VARARGS, ""},
-    {"AddParameterValue", (PyCFunction)PyLAppModel_AddParameterValue, METH_VARARGS, ""},
     {"Update", (PyCFunction)PyLAppModel_Update, METH_VARARGS, ""},
+    
     {"SetAutoBreathEnable", (PyCFunction)PyLAppModel_SetAutoBreathEnable, METH_VARARGS, ""},
     {"SetAutoBlinkEnable", (PyCFunction)PyLAppModel_SetAutoBlinkEnable, METH_VARARGS, ""},
+
+    {"SetParameterValue", (PyCFunction)PyLAppModel_SetParameterValue, METH_VARARGS, ""},
+    {"AddParameterValue", (PyCFunction)PyLAppModel_AddParameterValue, METH_VARARGS, ""},
+    {"GetParameterCount", (PyCFunction)PyLAppModel_GetParameterCount, METH_VARARGS, ""},
+    {"GetParameter", (PyCFunction)PyLAppModel_GetParameter, METH_VARARGS, ""},
+
+    {"GetPartCount", (PyCFunction)PyLAppModel_GetPartCount, METH_VARARGS, ""},
+    {"GetPartId", (PyCFunction)PyLAppModel_GetPartId, METH_VARARGS, ""},
+    {"GetPartIds", (PyCFunction)PyLAppModel_GetPartIds, METH_VARARGS, ""},
+    {"SetPartOpacity", (PyCFunction)PyLAppModel_SetPartOpacity, METH_VARARGS, ""},
     {NULL} // 方法列表结束的标志
 };
 
-// 定义Rectangle类的类型对象
+// 定义LAppModel类的类型对象
 static PyTypeObject PyLAppModelType = {
     PyVarObject_HEAD_INIT(NULL, 0) "live2d.LAppModel", /* tp_name */
     sizeof(PyLAppModelObject),                         /* tp_basicsize */
@@ -538,11 +642,8 @@ static PyTypeObject PyLAppModelType = {
 static PyObject *live2d_init()
 {
     _cubismOption.LogFunction = LAppPal::PrintLn;
-#ifdef LOG_MODE_RELEASE
-    _cubismOption.LoggingLevel = Csm::CubismFramework::Option::LogLevel_Off;
-#else
     _cubismOption.LoggingLevel = Csm::CubismFramework::Option::LogLevel_Verbose;
-#endif
+
     Csm::CubismFramework::StartUp(&_cubismAllocator, &_cubismOption);
     Csm::CubismFramework::Initialize();
     Py_RETURN_NONE;
@@ -588,16 +689,28 @@ static PyObject *live2d_set_gl_properties()
     Py_RETURN_NONE;
 }
 
-static PyObject *live2d_clear_buffer()
+static PyObject *live2d_clear_buffer(PyObject *self, PyObject *args)
 {
-    glClearColor(0.0, 0.0, 0.0, 0.0);
+    // 默认为黑色
+    float r = 0.0, g = 0.0, b = 0.0, a = 0.0;
+
+    // 解析传入的参数，允许指定颜色
+    if (!PyArg_ParseTuple(args, "|ffff", &r, &g, &b, &a))
+    {
+        return NULL;
+    }
+
+    // 设置清屏颜色
+    glClearColor(r, g, b, a);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glClearDepth(1.0);
 
     Py_RETURN_NONE;
 }
 
-static PyObject* live2d_set_log_enable(PyObject* self, PyObject* args)
+extern bool live2dLogEnable;
+
+static PyObject *live2d_set_log_enable(PyObject *self, PyObject *args)
 {
     bool enable;
     if (!PyArg_ParseTuple(args, "p", &enable))
@@ -606,29 +719,38 @@ static PyObject* live2d_set_log_enable(PyObject* self, PyObject* args)
         return NULL;
     }
 
-    setLogEnable(enable);
+    live2dLogEnable = enable;
 
     Py_RETURN_NONE;
 }
 
-// 定义模块的方法
-static PyMethodDef module_methods[] = {
-    {"init", (PyCFunction)live2d_init, METH_VARARGS, "initialize sdk"},
-    {"dispose", (PyCFunction)live2d_dispose, METH_VARARGS, "release sdk"},
-    {"glewInit", (PyCFunction)live2d_glew_init, METH_VARARGS, "release sdk"},
-    {"setGLProperties", (PyCFunction)live2d_set_gl_properties, METH_VARARGS, "configure gl"},
-    {"clearBuffer", (PyCFunction)live2d_clear_buffer, METH_VARARGS, "clear buffer"},
-    {"setLogEnable", (PyCFunction)live2d_set_log_enable, METH_VARARGS, "clear buffer"},
-    {NULL, NULL, 0, NULL} // 哨兵
-};
+static PyObject *live2d_log_enable(PyObject *self, PyObject *args)
+{
+
+    if (live2dLogEnable)
+        Py_RETURN_TRUE;
+    else
+        Py_RETURN_FALSE;
+}
 
-// 定义模块
+// 定义live2d模块的方法
+static PyMethodDef live2d_methods[] = {
+    {"init", (PyCFunction)live2d_init, METH_VARARGS, ""},
+    {"dispose", (PyCFunction)live2d_dispose, METH_VARARGS, ""},
+    {"glewInit", (PyCFunction)live2d_glew_init, METH_VARARGS, ""},
+    {"setGLProperties", (PyCFunction)live2d_set_gl_properties, METH_VARARGS, ""},
+    {"clearBuffer", (PyCFunction)live2d_clear_buffer, METH_VARARGS, ""},
+    {"setLogEnable", (PyCFunction)live2d_set_log_enable, METH_VARARGS, ""},
+    {"logEnable", (PyCFunction)live2d_log_enable, METH_VARARGS, ""},
+    {NULL, NULL, 0, NULL}};
+
+// 定义live2d模块
 static struct PyModuleDef liv2d_module = {
     PyModuleDef_HEAD_INIT,
     "live2d",
     "Module that creates live2d objects",
     -1,
-    module_methods};
+    live2d_methods};
 
 // 模块初始化函数的实现
 PyMODINIT_FUNC PyInit_live2d(void)
@@ -649,5 +771,25 @@ PyMODINIT_FUNC PyInit_live2d(void)
         return NULL;
     }
 
+    module_live2d_v3_params = PyImport_ImportModule("live2d.v3.params");
+    if (module_live2d_v3_params == NULL)
+    {
+        PyErr_Print();
+        return NULL;
+    }
+
+    class_parameter = PyObject_GetAttrString(module_live2d_v3_params, "Parameter");
+    if (class_parameter == NULL)
+    {
+        Py_DECREF(module_live2d_v3_params);
+        PyErr_Print();
+        return NULL;
+    }
+
+#ifdef WIN32
+    // 强制utf-8
+    // SetConsoleOutputCP(65001);
+#endif
+
     return m;
 }

{live2d_py-0.2.2 → live2d_py-0.2.4}/Main/CMakeLists.txt

@@ -27,7 +27,7 @@ else(CMAKE_SYSTEM_NAME MATCHES "Windows")
 endif()
 
 # Specify version of compiler.
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)