GDCubismUserModel

Desc

Live2Dモデルを読み込み、表示に必要な Texture を生成したり操作を行うための SubVieport 継承クラスです。

Properties

Vector2

adjust_position

[default: Vector2(0, 0)]

float

adjust_scale

[default: 1.0]

String

assets

[default: ""]

bool

auto_scale

[default: true]

bool

load_expressions

[default: true]

bool

load_motions

[default: true]

Vector2i

[id-property-mask_viewport_size]

[default: Vector2i(0, 0)]

ParameterMode

parameter_mode

[default: 0]

bool

[physics_evaluate]

[default: true]

MotionProcessCallback

playback_process_mode

[default: 1]

bool

[pose_update]

[default: true]

Shader

Shader

Shader

Shader

Shader

Shader

Shader

Shader

Shader

Shader

float

[default: 1.0]

Methods

void

advance(delta: float)

void

clear()

moc3FileFormatVersion

csm_get_latest_moc_version()

moc3FileFormatVersion

csm_get_moc_version()

Dictionary

csm_get_version()

Dictionary

get_canvas_info()

Array

get_cubism_motion_queue_entries()

Array

get_expressions()

Array

get_hit_areas()

Dictionary

get_meshes()

Dictionary

get_motions()

Array

get_parameters()

Array

get_part_opacities()

void

start_expression(expression_id: String)

GDCubismMotionQueueEntryHandle

start_motion(group: String, no: int, priority: Priority)

GDCubismMotionQueueEntryHandle

start_motion_loop(group: String, no: int, priority: Priority, loop: bool, loop_fade_in: bool)

void

stop_expression()

void

stop_motion()

Signals

motion_event(value: String): Motion に埋め込まれたイベント時刻のタイミングで呼び出されます。

Example

func _on_motion_event(value: String):
    print(value)

func _ready():
    $GDCubismUserModel.motion_event.connect(_on_motion_event)

motion_finished(): Motion が再生終了したタイミングで呼び出されます。

Example

func _on_motion_finished(value: String):
    print(value)

func _ready():
    $GDCubismUserModel.motion_event.connect(_on_motion_event)

Enumerations

enum moc3FileFormatVersion

CSM_MOC_VERSION_UNKNOWN = 0
不明または読み込み失敗
CSM_MOC_VERSION_30 = 1
moc3 file version 3.0.00 から 3.2.07
CSM_MOC_VERSION_33 = 2
moc3 file version 3.3.00 から 3.3.03
CSM_MOC_VERSION_40 = 3
moc3 file version 4.0.00 から 4.1.05
CSM_MOC_VERSION_42 = 4
moc3 file version 4.2.00 から 4.2.02
CSM_MOC_VERSION_50 = 5
moc3 file version 5.0.00以上

enum Priority

PRIORITY_NONE = 0
PRIORITY_IDLE = 1
PRIORITY_NORMAL = 2
PRIORITY_FORCE = 3
強制的に切り替わります。

enum ParameterMode

FULL_PARAMETER = 0
start_motion 関数で指定した Motion を再生する時に指定します。
この指定がされているときは GDCubismParameter による操作は行えません。
NONE_PARAMETER = 1
get_parameters 関数で取得した GDCubismParameter を使用して、Live2Dモデルを操作する場合に指定します。
この指定がされているときは start_motion 関数でモーション再生は行えません。

enum MotionProcessCallback

PHYSICS = 0
アニメーションの更新処理を _physics_process 関数内で行います。物理シミュレーションとインタラクションさせたい時に使用します。
IDLE = 1
アニメーションの更新処理を _process 関数内で行います。
MANUAL = 2
アニメーションの更新処理を行いません。アニメーションを処理するには advance 関数を使用します。

Property Descriptions

Vector2 adjust_position [default: Vector2(0, 0)]: Live2Dモデルの描画位置を変更します。
GDCubismは自身が持つSubViewport内にLive2Dモデルの描画を行います。
このパラメータを調整する事でLive2Dモデルの一部をクローズアップしたり auto_scale された描画結果がうまく描画されない場合に利用してください。

float adjust_scale [default: 1.0]: Live2Dモデルの描画サイズを変更します。
GDCubismは自身が持つSubViewport内にLive2Dモデルの描画を行います。
このパラメータを調整する事でLive2Dモデルの描画サイズを自由に変更できます。

String assets [default: ""]: *.model3.json 拡張子のファイルを指定することでLive2Dモデルを読み込みます。ファイルを指定すると即座にファイルが読み込まれます。
Live2Dモデルを切り替えたい場合は新しいファイルを指定するだけで切り替える事が出来ます。

bool auto_scale [default: true]: GDCubismUserModel は、自分自身に指定された SubViewport サイズ内に収まる様にLive2Dモデルを描画しようとします。そのためLive2Dモデルの製作者が意図しない結果になってしまう場合があります。

このチェックを外すことで、スケーリングなしで表示を行います。

bool load_expressions [default: true]: false にすると、 Live2D Modelの読み込み時に Expression の読み込みを行いません。

bool load_motions [default: true]: false にすると、 Live2D Modelの読み込み時に Motion の読み込みを行いません。

Vector2i mask_viewport_size [default: Vector2i(0, 0)]: Live2Dモデルでマスク画像を必要とする場合の解像度を指定します。

x, y のどちらかに 0 が設定されている場合は、 GDCubismUserModel に設定されている Viewport と同じサイズが使用されます。

解像度を下げるとGPUメモリの消費を抑える事が出来ます。512x512程度のサイズより小さくしてしまうと、マスクの適用場所によっては描画品質に問題が生じる可能性があります。

この画像の縦横比は GDCubismUserModel の Viewport と同じ比率となるようにしてください。1024x512 であれば、512x256 や 128x64 といった数値です。

GDCubism は Viewport と同じ比率であることを前提に描画を行うため、正しい比率以外の場合は望ましい結果を得る事が出来ません。

ParameterMode parameter_mode [default: 0]: 現在保持しているLive2Dモデルのコントロール方法を指定します。

bool physics_evaluate [default: true]: false にすると、物理計算を行わなくなります。

MotionProcessCallback playback_process_mode [default: 1]: 現在保持しているLive2Dモデルの再生方法を指定します。

bool pose_update [default: true]: false にすると、ポーズグループに指定された描画パーツ同士で透明度の計算を行わなくなります。
全ての透明度計算を手動で行いたい場合は false にしてください。

Shader shader_mask_add: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Add
shader_type canvas_item;
render_mode blend_premul_alpha, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;

void vertex() {
    UV.y = 1.0 - UV.y;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = (color_tex.rgb + color_screen.rgb) - (color_tex.rgb * color_screen.rgb);
    vec4 color = color_tex * color_base;
    COLOR = vec4(color.rgb * color.a, 0.0);
}

Shader shader_mask: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mask
shader_type canvas_item;
render_mode blend_mix, unshaded;

uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;

void vertex() {
    UV.y = 1.0 - UV.y;
}

void fragment() {
    COLOR = channel * texture(tex_main, UV).a;
}

Shader shader_mask_add: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mask + Add
shader_type canvas_item;
render_mode blend_premul_alpha, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;
uniform sampler2D tex_mask : filter_linear_mipmap;

uniform bool auto_scale;
uniform vec2 canvas_size;
uniform vec2 mask_size;
uniform float ratio;
uniform vec2 adjust_pos;
uniform float adjust_scale;


void vertex() {
    UV.y = 1.0 - UV.y;
}

vec2 lookup_mask_uv(vec2 screen_uv) {

    if(auto_scale == false) return screen_uv;

    vec2 r_uv = screen_uv - 0.5;
    vec2 calc_pos;

    calc_pos.x = (canvas_size.x * adjust_scale) - canvas_size.x;
    calc_pos.x = calc_pos.x * (adjust_pos.x / canvas_size.x);
    calc_pos.x = calc_pos.x / canvas_size.x;

    calc_pos.y = (canvas_size.y * adjust_scale) - canvas_size.y;
    calc_pos.y = calc_pos.y * (adjust_pos.y / canvas_size.y);
    calc_pos.y = calc_pos.y / canvas_size.y;

    r_uv = r_uv + calc_pos;
    r_uv = r_uv * (1.0 / adjust_scale);

    return r_uv + 0.5;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = color_tex.rgb + color_screen.rgb - (color_tex.rgb * color_screen.rgb);
    vec4 color_for_mask = color_tex * color_base;
    color_for_mask.rgb = color_for_mask.rgb * color_for_mask.a;

    vec4 clip_mask = texture(tex_mask, lookup_mask_uv(SCREEN_UV)) * channel;

    float mask_val = clip_mask.r + clip_mask.g + clip_mask.b + clip_mask.a;
    color_for_mask.rgb = color_for_mask.rgb * mask_val;
    COLOR = vec4(color_for_mask.rgb, 0.0);
}

Shader shader_mask_add_inv: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mask + AddInv
shader_type canvas_item;
render_mode blend_premul_alpha, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;
uniform sampler2D tex_mask : filter_linear_mipmap;

uniform bool auto_scale;
uniform vec2 canvas_size;
uniform vec2 mask_size;
uniform float ratio;
uniform vec2 adjust_pos;
uniform float adjust_scale;


void vertex() {
    UV.y = 1.0 - UV.y;
}

vec2 lookup_mask_uv(vec2 screen_uv) {

    if(auto_scale == false) return screen_uv;

    vec2 r_uv = screen_uv - 0.5;
    vec2 calc_pos;

    calc_pos.x = (canvas_size.x * adjust_scale) - canvas_size.x;
    calc_pos.x = calc_pos.x * (adjust_pos.x / canvas_size.x);
    calc_pos.x = calc_pos.x / canvas_size.x;

    calc_pos.y = (canvas_size.y * adjust_scale) - canvas_size.y;
    calc_pos.y = calc_pos.y * (adjust_pos.y / canvas_size.y);
    calc_pos.y = calc_pos.y / canvas_size.y;

    r_uv = r_uv + calc_pos;
    r_uv = r_uv * (1.0 / adjust_scale);

    return r_uv + 0.5;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = color_tex.rgb + color_screen.rgb - (color_tex.rgb * color_screen.rgb);
    vec4 color_for_mask = color_tex * color_base;
    color_for_mask.rgb = color_for_mask.rgb * color_for_mask.a;

    vec4 clip_mask = texture(tex_mask, lookup_mask_uv(SCREEN_UV)) * channel;

    float mask_val = clip_mask.r + clip_mask.g + clip_mask.b + clip_mask.a;
    color_for_mask.rgb = color_for_mask.rgb * (1.0 - mask_val);
    COLOR = vec4(color_for_mask.rgb, 0.0);
}

Shader shader_mask_mix: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mask + Mix
shader_type canvas_item;
render_mode blend_premul_alpha, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;
uniform sampler2D tex_mask : filter_linear_mipmap;

uniform bool auto_scale;
uniform vec2 canvas_size;
uniform vec2 mask_size;
uniform float ratio;
uniform vec2 adjust_pos;
uniform float adjust_scale;


void vertex() {
    UV.y = 1.0 - UV.y;
}

vec2 lookup_mask_uv(vec2 screen_uv) {

    if(auto_scale == false) return screen_uv;

    vec2 r_uv = screen_uv - 0.5;
    vec2 calc_pos;

    calc_pos.x = (canvas_size.x * adjust_scale) - canvas_size.x;
    calc_pos.x = calc_pos.x * (adjust_pos.x / canvas_size.x);
    calc_pos.x = calc_pos.x / canvas_size.x;

    calc_pos.y = (canvas_size.y * adjust_scale) - canvas_size.y;
    calc_pos.y = calc_pos.y * (adjust_pos.y / canvas_size.y);
    calc_pos.y = calc_pos.y / canvas_size.y;

    r_uv = r_uv + calc_pos;
    r_uv = r_uv * (1.0 / adjust_scale);

    return r_uv + 0.5;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = color_tex.rgb + color_screen.rgb - (color_tex.rgb * color_screen.rgb);
    vec4 color_for_mask = color_tex * color_base;
    color_for_mask.rgb = color_for_mask.rgb * color_for_mask.a;

    vec4 clip_mask = texture(tex_mask, lookup_mask_uv(SCREEN_UV)) * channel;

    float mask_val = clip_mask.r + clip_mask.g + clip_mask.b + clip_mask.a;
    color_for_mask = color_for_mask * mask_val;
    COLOR = color_for_mask;
}

Shader shader_mask_mix_inv: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mask + MixInv
shader_type canvas_item;
render_mode blend_premul_alpha, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;
uniform sampler2D tex_mask : filter_linear_mipmap;

uniform bool auto_scale;
uniform vec2 canvas_size;
uniform vec2 mask_size;
uniform float ratio;
uniform vec2 adjust_pos;
uniform float adjust_scale;


void vertex() {
    UV.y = 1.0 - UV.y;
}

vec2 lookup_mask_uv(vec2 screen_uv) {

    if(auto_scale == false) return screen_uv;

    vec2 r_uv = screen_uv - 0.5;
    vec2 calc_pos;

    calc_pos.x = (canvas_size.x * adjust_scale) - canvas_size.x;
    calc_pos.x = calc_pos.x * (adjust_pos.x / canvas_size.x);
    calc_pos.x = calc_pos.x / canvas_size.x;

    calc_pos.y = (canvas_size.y * adjust_scale) - canvas_size.y;
    calc_pos.y = calc_pos.y * (adjust_pos.y / canvas_size.y);
    calc_pos.y = calc_pos.y / canvas_size.y;

    r_uv = r_uv + calc_pos;
    r_uv = r_uv * (1.0 / adjust_scale);

    return r_uv + 0.5;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = color_tex.rgb + color_screen.rgb - (color_tex.rgb * color_screen.rgb);
    vec4 color_for_mask = color_tex * color_base;
    color_for_mask.rgb = color_for_mask.rgb * color_for_mask.a;

    vec4 clip_mask = texture(tex_mask, lookup_mask_uv(SCREEN_UV)) * channel;

    float mask_val = clip_mask.r + clip_mask.g + clip_mask.b + clip_mask.a;
    color_for_mask = color_for_mask * (1.0 - mask_val);
    COLOR = color_for_mask;
}

Shader shader_mask_mul: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mask + Mul
shader_type canvas_item;
render_mode blend_mul, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;
uniform sampler2D tex_mask : filter_linear_mipmap;

uniform bool auto_scale;
uniform vec2 canvas_size;
uniform vec2 mask_size;
uniform float ratio;
uniform vec2 adjust_pos;
uniform float adjust_scale;


void vertex() {
    UV.y = 1.0 - UV.y;
}

vec2 lookup_mask_uv(vec2 screen_uv) {

    if(auto_scale == false) return screen_uv;

    vec2 r_uv = screen_uv - 0.5;
    vec2 calc_pos;

    calc_pos.x = (canvas_size.x * adjust_scale) - canvas_size.x;
    calc_pos.x = calc_pos.x * (adjust_pos.x / canvas_size.x);
    calc_pos.x = calc_pos.x / canvas_size.x;

    calc_pos.y = (canvas_size.y * adjust_scale) - canvas_size.y;
    calc_pos.y = calc_pos.y * (adjust_pos.y / canvas_size.y);
    calc_pos.y = calc_pos.y / canvas_size.y;

    r_uv = r_uv + calc_pos;
    r_uv = r_uv * (1.0 / adjust_scale);

    return r_uv + 0.5;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = color_tex.rgb + color_screen.rgb - (color_tex.rgb * color_screen.rgb);
    vec4 color_for_mask = color_tex * color_base;
    color_for_mask.rgb = color_for_mask.rgb * color_for_mask.a;

    vec4 clip_mask = texture(tex_mask, lookup_mask_uv(SCREEN_UV)) * channel;

    float mask_val = clip_mask.r + clip_mask.g + clip_mask.b + clip_mask.a;
    color_for_mask = color_for_mask * mask_val;
    COLOR = vec4(
        color_for_mask.r + (1.0 - color_for_mask.a),
        color_for_mask.g + (1.0 - color_for_mask.a),
        color_for_mask.b + (1.0 - color_for_mask.a),
        1.0
    );
}

Shader shader_mask_mul_inv: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mask + MulInv
shader_type canvas_item;
render_mode blend_mul, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;
uniform sampler2D tex_mask : filter_linear_mipmap;

uniform bool auto_scale;
uniform vec2 canvas_size;
uniform vec2 mask_size;
uniform float ratio;
uniform vec2 adjust_pos;
uniform float adjust_scale;


void vertex() {
    UV.y = 1.0 - UV.y;
}

vec2 lookup_mask_uv(vec2 screen_uv) {

    if(auto_scale == false) return screen_uv;

    vec2 r_uv = screen_uv - 0.5;
    vec2 calc_pos;

    calc_pos.x = (canvas_size.x * adjust_scale) - canvas_size.x;
    calc_pos.x = calc_pos.x * (adjust_pos.x / canvas_size.x);
    calc_pos.x = calc_pos.x / canvas_size.x;

    calc_pos.y = (canvas_size.y * adjust_scale) - canvas_size.y;
    calc_pos.y = calc_pos.y * (adjust_pos.y / canvas_size.y);
    calc_pos.y = calc_pos.y / canvas_size.y;

    r_uv = r_uv + calc_pos;
    r_uv = r_uv * (1.0 / adjust_scale);

    return r_uv + 0.5;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = color_tex.rgb + color_screen.rgb - (color_tex.rgb * color_screen.rgb);
    vec4 color_for_mask = color_tex * color_base;
    color_for_mask.rgb = color_for_mask.rgb * color_for_mask.a;

    vec4 clip_mask = texture(tex_mask, lookup_mask_uv(SCREEN_UV)) * channel;

    float mask_val = clip_mask.r + clip_mask.g + clip_mask.b + clip_mask.a;
    color_for_mask = color_for_mask * (1.0 - mask_val);
    COLOR = vec4(
        color_for_mask.r + (1.0 - color_for_mask.a),
        color_for_mask.g + (1.0 - color_for_mask.a),
        color_for_mask.b + (1.0 - color_for_mask.a),
        1.0
    );
}

Shader shader_mix: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mix
shader_type canvas_item;
render_mode blend_premul_alpha, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;

void vertex() {
    UV.y = 1.0 - UV.y;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = (color_tex.rgb + color_screen.rgb) - (color_tex.rgb * color_screen.rgb);
    vec4 color = color_tex * color_base;
    COLOR = vec4(color.rgb * color.a, color.a);
}

Shader shader_mul: Live2Dモデルの描画に使用する shader を指定します。
既定では以下の内容の shader が使用されます。

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2023 MizunagiKB <mizukb@live.jp>
// GDCubism shader: Mul
shader_type canvas_item;
render_mode blend_premul_alpha, unshaded;

uniform vec4 color_base;
uniform vec4 color_screen;
uniform vec4 color_multiply;
uniform vec4 channel;
uniform sampler2D tex_main : filter_linear_mipmap;

void vertex() {
    UV.y = 1.0 - UV.y;
}

void fragment() {
    vec4 color_tex = texture(tex_main, UV);
    color_tex.rgb = color_tex.rgb * color_multiply.rgb;

    // premul alpha
    color_tex.rgb = (color_tex.rgb + color_screen.rgb) - (color_tex.rgb * color_screen.rgb);
    vec4 color = color_tex * color_base;
    COLOR = vec4(color.rgb * color.a, color.a);
}

floats speed_scale [default: 1.0]: 現在保持しているLive2Dモデルの再生速度を指定します。

Method Descriptions

void advance(delta: float): アニメーションを指定した delta 時間（単位は秒数）だけ進めます。

deltaには 0.0 以上の値を指定してください。

void clear(): この関数は操作の一貫性向上を目的に削除されました。
同様の操作を行うには assets プロパティに "" をセットしてください。

moc3FileFormatVersion csm_get_latest_moc_version(): GDCubismUserModelが読み込める最新のファイルバージョンを戻します。

moc3FileFormatVersion csm_get_moc_version(): 読み込まれたmoc3ファイルのバージョンを戻します。

Dictionary csm_get_version()

GDCubism が使用している Cubism Native SDK Core のバージョン番号を Dictionary 形式で戻します。

version: int: csmVersion 関数が戻す値がそのまま格納されています。
major: int: versionからメジャーバージョンのみを抜き出した値が格納されています。
minor: int: versionからマイナーバージョンのみを抜き出した値が格納されています。
patch: int: versionからパッチ番号のみを抜き出した値が格納されています。

Dictionary get_canvas_info()

Dictionary 形式で以下の情報を戻します。

size_in_pixels: Vector2: 読み込んだLive2Dモデルのキャンバスの幅と高さをピクセル数で戻します。
origin_in_pixels: Vector2: 読み込んだLive2Dモデルの中心位置をピクセル数で戻します。
pixels_per_unit: float: 読み込んだLive2Dモデルの pixelsPerUnit を戻します。

Array get_cubism_motion_queue_entries(): 現在再生中の Motion 情報を戻します。

Array get_expressions(): 現在保持しているLive2Dモデルから Expression 一覧を戻します。

取得した情報は start_expression 関数の引数として使用できます。

Array get_hit_areas(): Live2Dモデルに設定されている HitArea 情報を取得します。
配列の要素は Dictionary になっており、要素として id と name を持ちます。

id は mesh 要素を指す為、 get_meshes のキーとして利用可能です。

この関数と get_meshes で得られる情報を使用する事で、 Live2Dモデルとのインタラクションを実装できます。
高度な処理を必要としない場合は、 GDCubismEffectHitArea クラスを使用する事で、簡単に利用する事が可能です。

Dictionary get_meshes(): 現在の Motion 状態で使用されている MeshInstance の ArrayMesh 情報を取得します。

この Dictionary が持つキーは GDCubismUserModel が生成する MeshInstance の名前と同一です。取得できる情報は内部で使用されている ArrayMesh です。
以下の様な形で使用することができます。

var dict_mesh: Dictionary = model.get_meshes()
var ary_mesh: ArrayMesh = dict_mesh[art_mesh_name]
var ary_surface: Array = ary_mesh.surface_get_arrays(0)

var mesh_vertex: PackedVector2Array = ary_surface[ArrayMesh.ARRAY_VERTEX]
var mesh_tex_uv: PackedVector2Array = ary_surface[ArrayMesh.ARRAY_TEX_UV]
var mesh_index: PackedInt32Array = ary_surface[ArrayMesh.ARRAY_INDEX]

get_meshes は v0.1 で追加された実験的な関数です。今後仕様が変更されたり削除される可能性がある事に注意してください。

Dictionary get_motions(): 現在保持しているLive2Dモデルから Motion 一覧を戻します。
戻される Dictionary は group とその中に含まれるモーション数です。

全てのモーションを列挙する場合は、以下の様に記述します。

var dict_motion = $GDCubismUserModel.get_motions()
for group in dict_motion.keys():
    for no in dict_motion[group]:
        print("group: %s, no: %d" % [group, no])

Array get_parameters(): 現在保持しているLive2Dモデルを操作するためのクラスを取得します。

Array get_part_opacities(): 現在保持しているLive2Dモデルのパーツ透明度を操作するためのクラスを取得します。

void start_expression(expression_id: String): 指定した expression_id を再生します。

GDCubismMotionQueueEntryHandle start_motion(group: String, no: int, priority: Priority): 指定した group と no の Motion を再生します。

GDCubismMotionQueueEntryHandle start_motion_loop(group: String, no: int, priority: Priority): 指定した group と no の Motion を再生します。

繰り返し再生を行いたい場合に指定します。 loop 引数が false の場合は、 start_motion 関数と同じ動作となります。

void stop_expression(): 現在再生中の Expression を停止します。

void stop_motion(): 現在再生中の Motion を停止します。