Merge pull request #87 from Live2D/develop

Update to Cubism 5 SDK for Unity R5 beta1

Author: itoh-at-live2d-com

Assets/Live2D/Cubism/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 
+## [5-r.5-beta.1] - 2025-08-26
+
+### Added
+
+* Add support for Blend mode and Offscreen drawing.
+  * If the model uses blend mode or offscreen drawing, it will be rendered using a new drawing method that differs from `Cubism 5.2` and earlier.
+* Add high-precision mask method.
+  * This is only available with the new rendering method in `Cubism 5.3` and later, and masks in the new rendering method from `Cubism 5.3` onward will automatically use this method.
+
+### Changed
+
+* Change the version of the development project to `6000.0.55f1`.
+* Change `_isOverriddenDrawableScreenColors` and `_isOverriddenDrawableMultiplyColors` to `_isOverriddenDrawObjectScreenColors` and `_isOverriddenDrawObjectMultiplyColors`.
+  * The property names that use these backing fields have also been updated accordingly.
+  * Serialization of `_isOverriddenDrawableScreenColors` and `_isOverriddenDrawableMultiplyColors` is maintained by the `FormerlySerializedAs` attribute.
+
+### Removed
+
+* Remove `CubismCoreDll.GetDrawableRenderOrders` and `CubismUnmanagedDrawables.RenderOrders`.
+  * If you need to use these functions, please use `CubismModel.AllDrawObjectsRenderOrder` instead.
+    * See `CHANGELOG.md` in Core.
+* Remove Chrome OS from the tested environment.
+
+
 ## [5-r.4.1] - 2025-07-17
 
 ### Changed
@@ -474,6 +498,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * Fix issue where Priority value was not reset after playing motion with CubismMotionController.
 
 
+[5-r.5-beta.1]: https://github.com/Live2D/CubismUnityComponents/compare/5-r.4.1...5-r.5-beta.1
 [5-r.4.1]: https://github.com/Live2D/CubismUnityComponents/compare/5-r.4...5-r.4.1
 [5-r.4]: https://github.com/Live2D/CubismUnityComponents/compare/5-r.3...5-r.4
 [5-r.3]: https://github.com/Live2D/CubismUnityComponents/compare/5-r.2...5-r.3

Assets/Live2D/Cubism/Core/ArrayExtensionMethods.cs

@@ -278,5 +278,25 @@ internal static unsafe void ReadFrom(this CubismDynamicDrawableData[] self, Cubi
         }
 
         #endregion
+
+        #region Offscreens
+
+        /// <summary>
+        /// Revives (and sorts) <see cref="CubismOffscreen"/>s.
+        /// </summary>
+        /// <param name="self">Container.</param>
+        /// <param name="model">TaskableModel to unmanaged model.</param>
+        internal static void Revive(this CubismOffscreen[] self, CubismUnmanagedModel model)
+        {
+            Array.Sort(self, (a, b) => a.UnmanagedIndex - b.UnmanagedIndex);
+
+
+            for (var i = 0; i < self.Length; ++i)
+            {
+                self[i].Revive(model);
+            }
+        }
+
+        #endregion
     }
 }

Assets/Live2D/Cubism/Core/CubismDrawable.cs

@@ -8,6 +8,7 @@
 
 using Live2D.Cubism.Core.Unmanaged;
 using Live2D.Cubism.Framework;
+using Live2D.Cubism.Rendering.Util;
 using UnityEngine;
 
 
@@ -152,7 +153,7 @@ public Color ScreenColor
                 _screenColor.b = UnmanagedDrawables.ScreenColors[index + 2];
                 _screenColor.a = UnmanagedDrawables.ScreenColors[index + 3];
 
-                return _screenColor; ;
+                return _screenColor;
             }
         }
 
@@ -376,6 +377,34 @@ public bool MultiplyBlend
             }
         }
 
+        #region Cubism 5.3
+
+        /// <summary>
+        /// Gets the color blend mode of the drawable.
+        /// </summary>
+        public BlendTypes.ColorBlend ColorBlend
+        {
+            get
+            {
+                // Pull data.
+                return (BlendTypes.ColorBlend)(UnmanagedDrawables.BlendModes[UnmanagedIndex] & 0xFF);
+            }
+        }
+
+        /// <summary>
+        /// Gets the alpha blend mode of the drawable.
+        /// </summary>
+        public BlendTypes.AlphaBlend AlphaBlend
+        {
+            get
+            {
+                // Pull data.
+                return (BlendTypes.AlphaBlend)((UnmanagedDrawables.BlendModes[UnmanagedIndex] >> 8) & 0xFF);
+            }
+        }
+
+        #endregion
+
         /// <summary>
         /// Revives instance.
         /// </summary>

Assets/Live2D/Cubism/Core/CubismMoc.cs

@@ -199,6 +199,11 @@ public uint Version
         {
             get
             {
+                if (!IsRevived)
+                {
+                    Revive();
+                }
+
                 return UnmanagedMoc.MocVersion;
             }
         }

Assets/Live2D/Cubism/Core/CubismModel.cs

@@ -6,9 +6,13 @@
  */
 
 
+using Live2D.Cubism.Core.Unmanaged;
 using Live2D.Cubism.Framework;
 using System;
 using UnityEngine;
+using Live2D.Cubism.Rendering.Util;
+
+
 #if UNITY_2019_3_OR_NEWER
 using UnityEngine.LowLevel;
 using UnityEngine.PlayerLoop;
@@ -115,7 +119,7 @@ public CubismMoc Moc
         private CubismParameter[] _parameters;
 
         /// <summary>
-        /// Drawables of model.
+        /// Parameters of model.
         /// </summary>
         public CubismParameter[] Parameters
         {
@@ -204,6 +208,40 @@ public CubismCanvasInformation CanvasInformation
             private set { _canvasInformation = value; }
         }
 
+        /// <summary>
+        /// <see cref="Offscreens"/> backing field.
+        /// </summary>
+        [NonSerialized]
+        private CubismOffscreen[] _offscreens;
+
+        /// <summary>
+        /// Offscreens of model.
+        /// </summary>
+        public CubismOffscreen[] Offscreens
+        {
+            get
+            {
+                if (_offscreens == null)
+                {
+                    Revive();
+                }
+
+                return _offscreens;
+            }
+            private set { _offscreens = value; }
+        }
+
+        /// <summary>
+        /// All draw objects render order.
+        /// </summary>
+        public CubismUnmanagedIntArrayView AllDrawObjectsRenderOrder
+        {
+            get
+            {
+                return TaskableModel.UnmanagedModel.AllDrawObjectRenderOrders;
+            }
+        }
+
         /// <summary>
         /// Parameter store cache.
         /// </summary>
@@ -271,6 +309,39 @@ private bool CanRevive
         /// </summary>
         private int LastTick { get; set; }
 
+        /// <summary>
+        /// Is the model's MOC version higher than Cubism 5.0?
+        /// </summary>
+        public bool IsOverMocVersion50
+        {
+            get
+            {
+                return CubismCoreDll.MocVersion_50 < Moc.Version;
+            }
+        }
+
+        /// <summary>
+        /// Is this model using blend mode.
+        /// </summary>
+        [SerializeField, HideInInspector]
+        private bool _isUsingBlendMode;
+
+
+        /// <summary>
+        /// Get Flag is this model using blend mode.
+        /// </summary>
+        /// <returns>True if Is this model using blend mode; otherwise returns false.</returns>
+        public bool IsUsingBlendMode
+        {
+            get
+            {
+                return _isUsingBlendMode;
+            }
+            private set
+            {
+                _isUsingBlendMode = value;
+            }
+        }
 
         /// <summary>
         /// Revives instance.
@@ -309,7 +380,6 @@ private void Reset(CubismMoc moc)
                 return;
             }
 
-
             Parameters = GetComponentsInChildren<CubismParameter>();
             if (Parameters.Length < 1 && (transform.Find("Parameters") == null))
             {
@@ -351,6 +421,42 @@ private void Reset(CubismMoc moc)
                 Drawables.Revive(TaskableModel.UnmanagedModel);
             }
 
+            if (0 < CubismCoreDll.GetOffscreenCount(TaskableModel.UnmanagedModel.Ptr))
+            {
+                IsUsingBlendMode = true;
+                Offscreens = GetComponentsInChildren<CubismOffscreen>();
+                if (Offscreens.Length < 1 && (transform.Find("Offscreens") == null))
+                {
+                    // Create and initialize proxies.
+                    var offscreens = CubismOffscreen.CreateOffscreens(TaskableModel.UnmanagedModel);
+                    offscreens.transform.SetParent(transform);
+                    Offscreens = offscreens.GetComponentsInChildren<CubismOffscreen>();
+                }
+                else
+                {
+                    Offscreens.Revive(TaskableModel.UnmanagedModel);
+                }
+            }
+
+            if (IsOverMocVersion50 && !IsUsingBlendMode)
+            {
+                var drawableCount = Drawables.Length;
+                for (var i = 0; i < drawableCount; ++i)
+                {
+                    var colorBlendType = Drawables[i].ColorBlend;
+                    var alphaBlendType = Drawables[i].AlphaBlend;
+                    if (colorBlendType == BlendTypes.ColorBlend.Normal &&
+                        alphaBlendType == BlendTypes.AlphaBlend.Over ||
+                        colorBlendType == BlendTypes.ColorBlend.Add ||
+                        colorBlendType == BlendTypes.ColorBlend.Multiply)
+                    {
+                        continue;
+                    }
+
+                    IsUsingBlendMode = true;
+                    break;
+                }
+            }
 
             CanvasInformation = new CubismCanvasInformation(TaskableModel.UnmanagedModel);
 

Assets/Live2D/Cubism/Core/CubismModelTypes.cs

@@ -0,0 +1,92 @@
+using Live2D.Cubism.Core;
+
+/**
+ * Copyright(c) Live2D Inc. All rights reserved.
+ *
+ * Use of this source code is governed by the Live2D Open Software license
+ * that can be found at https://www.live2d.com/eula/live2d-open-software-license-agreement_en.html.
+ */
+
+
+public class CubismModelTypes
+{
+    /// <summary>
+    /// Type of draw object in a model.
+    /// </summary>
+    public enum DrawObjectType
+    {
+        Drawable,
+        Offscreen,
+        Unknown = -1
+    }
+
+    /// <summary>
+    /// Type of child object in a part.
+    /// </summary>
+    public enum PartChildObjectType
+    {
+        Drawable,
+        Parts,
+        Unknown = -1
+    }
+
+    /// <summary>
+    /// Information about a single part in a <see cref="CubismModel"/>.
+    /// </summary>
+    public struct PartInfo
+    {
+        public int PartUnmanagedIndex;
+        public PartChildObjectInfo[] ChildObjects;
+        public PartDrawObjectInfo DrawObjects;
+
+        /// <summary>
+        /// Number of child objects in this part.
+        /// </summary>
+        public int ChildCount
+        {
+            get
+            {
+                if (ChildObjects == null)
+                {
+                    return 0;
+                }
+
+                return ChildObjects.Length;
+            }
+        }
+
+        /// <summary>
+        /// Number of draw object in this part.
+        /// </summary>
+        public int DrawObjectCount
+        {
+            get
+            {
+                if (DrawObjects.Drawables == null)
+                {
+                    return 0;
+                }
+
+                return DrawObjects.Drawables.Length;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Information about a child object in a part.
+    /// </summary>
+    public struct PartChildObjectInfo
+    {
+        public PartChildObjectType ChildObjectType;
+        public int ChildObjectIndex;
+    }
+
+    /// <summary>
+    /// Information about draw objects in a part.
+    /// </summary>
+    public struct PartDrawObjectInfo
+    {
+        public CubismDrawable[] Drawables;
+        public CubismOffscreen[] Offscreens;
+    }
+}