live2d_embed.lua

-- live2d_embed.lua - windowless Live2D renderer for host applications.
--
-- The host application must create and make current an OpenGL context before
-- calling init/load_model/draw. This module intentionally does not create an
-- SDL window or run an event loop, so it can be driven from Python, C#, etc.
--
-- Raw model resources can be supplied before load_model with:
--   set_resource_stream(path, bytes)
-- or through opts.resource_streams[path] = bytes. Paths should match the model
-- JSON path and paths referenced from it, using repo-relative separators.
-- Raw RGBA textures can be supplied before load_model with:
--   set_texture_stream(no, width, height, rgba_bytes)
-- or through opts.texture_streams[no] = { width = w, height = h, data = bytes }.
-- Texture numbers are zero-based, matching the Live2D model JSON order.

package.path = package.path .. ";./?.lua;./?/init.lua"

local gl = require("live2d.gl_loader")
local live2d = require("live2d")
local Live2DFramework = live2d.Live2DFramework
local Live2D = live2d.Live2D
local MotionPriority = live2d.MotionPriority
local LAppModel = live2d.LAppModel
local Live2DGLWrapper = require("live2d.core.live2d_gl_wrapper")

local M = {}
local Renderer = {}
Renderer.__index = Renderer

local runtime_initialized = false
local current_renderer = nil
local platform_manager = nil

local function init_runtime()
    if runtime_initialized then return end

    -- Requires an active GL context; extension pointers are context-bound.
    gl.ensureExtensions()

    platform_manager = require("live2d.platform_manager").new()
    Live2DFramework.setPlatformManager(platform_manager)
    Live2D.init()
    runtime_initialized = true
end

local function get_platform_manager()
    init_runtime()
    return platform_manager
end

local function require_model(self)
    if self.model == nil then
        error("Live2D model is not loaded", 3)
    end
    return self.model
end

function Renderer:load_model(model_path, width, height, opts)
    if model_path == nil or model_path == "" then
        error("model_path is required", 2)
    end

    opts = opts or {}
    self:dispose_model()
    self.width = tonumber(width) or self.width
    self.height = tonumber(height) or self.height
    local pm = get_platform_manager()
    pm:setResourceStreams(opts.resource_streams or opts.resourceStreams)
    pm:setTextureStreams(opts.texture_streams or opts.textureStreams)

    local model = LAppModel.new()
    model.deferExpressions = opts.defer_expressions == true or opts.deferExpressions == true
    model:LoadModelJson(model_path)
    model:Resize(self.width, self.height)
    model:SetAutoBreathEnable(opts.auto_breath ~= false)
    model:SetAutoBlinkEnable(opts.auto_blink ~= false)

    if opts.center ~= false then
        model.modelMatrix:identity()
        model.modelMatrix:setWidth(tonumber(opts.model_width) or 2.0)
        model.modelMatrix:setCenterPosition(
            tonumber(opts.center_x) or 0,
            tonumber(opts.center_y) or 0
        )
    end

    self.model = model
    self.model_path = model_path
    self:resize(self.width, self.height)
    if opts.release_streams_after_load == true or opts.releaseStreamsAfterLoad == true or opts.clear_streams_after_load == true then
        pm:clearStreams()
        collectgarbage("collect")
    end
    return self
end

function Renderer:dispose_model()
    if self.model ~= nil and self.model.live2DModel ~= nil then
        local drawParam = self.model.live2DModel:getDrawParam()
        if drawParam ~= nil and drawParam.dispose ~= nil then
            drawParam:dispose()
        end
    end
    self.model = nil
    self.model_path = nil
    return self
end

function Renderer:dispose()
    self:dispose_model()
    self:clear_streams()
    collectgarbage("collect")
    return true
end

function Renderer:set_resource_stream(path, data)
    get_platform_manager():setResourceStream(path, data)
    return self
end

function Renderer:set_resource_streams(resource_streams)
    get_platform_manager():setResourceStreams(resource_streams)
    return self
end

function Renderer:clear_resource_streams()
    get_platform_manager():clearResourceStreams()
    return self
end

function Renderer:set_texture_stream(no, width, height, data)
    local texture_no = tonumber(no)
    if texture_no == nil then
        error("texture number is required", 2)
    end

    local stream
    if type(width) == "table" or type(width) == "function" then
        stream = width
    else
        stream = { width = width, height = height, data = data }
    end

    local pm = get_platform_manager()
    pm.textureStreams[texture_no] = stream

    if self.model ~= nil and self.model.live2DModel ~= nil then
        pm:loadTexture(self.model.live2DModel, texture_no, "stream:" .. texture_no)
    end
    return self
end

function Renderer:set_texture_streams(texture_streams)
    get_platform_manager():setTextureStreams(texture_streams)
    return self
end

function Renderer:clear_texture_streams()
    get_platform_manager():clearTextureStreams()
    return self
end

function Renderer:clear_streams()
    get_platform_manager():clearStreams()
    return self
end

function Renderer:resize(width, height)
    self.width = tonumber(width) or self.width
    self.height = tonumber(height) or self.height

    if self.width <= 0 or self.height <= 0 then
        error("width and height must be positive", 2)
    end

    Live2DGLWrapper.viewport(0, 0, self.width, self.height)
    if self.model ~= nil then
        self.model:Resize(self.width, self.height)
    end
    return self
end

function Renderer:clear(r, g, b, a)
    Live2DGLWrapper.clearColor(r or 0.0, g or 0.0, b or 0.0, a or 0.0)
    Live2DGLWrapper.clear(Live2DGLWrapper.COLOR_BUFFER_BIT)
    return self
end

function Renderer:update()
    require_model(self):Update()
    return self
end

function Renderer:draw(opts)
    opts = opts or {}
    local model = require_model(self)

    if opts.clear ~= false then
        self:clear(opts.r, opts.g, opts.b, opts.a)
    end

    model:Update()
    if opts.parameters ~= nil then
        for i = 1, #opts.parameters do
            local p = opts.parameters[i]
            if p ~= nil and p.id ~= nil then
                model:SetParameterValue(p.id, tonumber(p.value) or 0, tonumber(p.weight) or 1.0)
            end
        end
    end
    model:Draw()

    -- Keep unrelated short-lived Lua/FFI allocations bounded when the host
    -- renders faster than display refresh; mesh upload buffers are reused.
    collectgarbage("step", tonumber(opts.gc_step) or 200)
    return self
end

function Renderer:drag(x, y)
    require_model(self):Drag(tonumber(x) or 0, tonumber(y) or 0)
    return self
end

function Renderer:set_offset(x, y)
    require_model(self):SetOffset(tonumber(x) or 0, tonumber(y) or 0)
    return self
end

function Renderer:set_scale(scale)
    require_model(self):SetScale(tonumber(scale) or 1.0)
    return self
end

function Renderer:set_parameter(param_id, value, weight)
    require_model(self):SetParameterValue(param_id, tonumber(value) or 0, tonumber(weight) or 1.0)
    return self
end

function Renderer:add_parameter(param_id, value, weight)
    require_model(self):AddParameterValue(param_id, tonumber(value) or 0, tonumber(weight) or 1.0)
    return self
end

function Renderer:set_expression(name)
    require_model(self):SetExpression(name)
    return self
end

function Renderer:preload_expression(name)
    require_model(self):PreloadExpression(name)
    return self
end

function Renderer:reset_expression()
    require_model(self):ResetExpression()
    return self
end

function Renderer:start_motion(name, no, priority)
    priority = priority or MotionPriority.FORCE
    require_model(self):StartMotion(name, tonumber(no) or 0, priority)
    return self
end

function Renderer:preload_motion_group(name)
    require_model(self):PreloadMotionGroup(name)
    return self
end

function Renderer:clear_motions()
    require_model(self):ClearMotions()
    return self
end

function Renderer:hit_test(x, y)
    return require_model(self):HitPart(tonumber(x) or 0, tonumber(y) or 0, true)
end

function Renderer:get_model()
    return self.model
end


function M.init()
    init_runtime()
    return true
end

function M.new(width, height, opts)
    init_runtime()
    opts = opts or {}

    local renderer = setmetatable({
        width = tonumber(width) or 400,
        height = tonumber(height) or 650,
        model = nil,
        model_path = nil,
    }, Renderer)
    local pm = get_platform_manager()
    pm:setResourceStreams(opts.resource_streams or opts.resourceStreams)
    pm:setTextureStreams(opts.texture_streams or opts.textureStreams)

    if opts.model_path ~= nil then
        renderer:load_model(opts.model_path, renderer.width, renderer.height, opts)
    else
        renderer:resize(renderer.width, renderer.height)
    end

    return renderer
end

-- Singleton API for hosts that prefer simple global-style calls through Lua C API.
function M.load_model(model_path, width, height, opts)
    current_renderer = current_renderer or M.new(width, height)
    current_renderer:load_model(model_path, width, height, opts)
    return current_renderer
end

function M.current()
    return current_renderer
end

function M.resize(width, height)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:resize(width, height)
end

function M.draw(opts)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:draw(opts)
end

function M.update()
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:update()
end

function M.clear(r, g, b, a)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:clear(r, g, b, a)
end

function M.set_texture_stream(no, width, height, data)
    current_renderer = current_renderer or M.new()
    return current_renderer:set_texture_stream(no, width, height, data)
end

function M.set_resource_stream(path, data)
    current_renderer = current_renderer or M.new()
    return current_renderer:set_resource_stream(path, data)
end

function M.set_resource_streams(resource_streams)
    current_renderer = current_renderer or M.new()
    return current_renderer:set_resource_streams(resource_streams)
end

function M.clear_resource_streams()
    if current_renderer ~= nil then
        return current_renderer:clear_resource_streams()
    end
    get_platform_manager():clearResourceStreams()
    return true
end

function M.set_texture_streams(texture_streams)
    current_renderer = current_renderer or M.new()
    return current_renderer:set_texture_streams(texture_streams)
end

function M.clear_texture_streams()
    if current_renderer ~= nil then
        return current_renderer:clear_texture_streams()
    end
    get_platform_manager():clearTextureStreams()
    return true
end

function M.clear_streams()
    if current_renderer ~= nil then
        return current_renderer:clear_streams()
    end
    get_platform_manager():clearStreams()
    return true
end

function M.drag(x, y)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:drag(x, y)
end

function M.set_offset(x, y)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:set_offset(x, y)
end

function M.set_scale(scale)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:set_scale(scale)
end

function M.set_parameter(param_id, value, weight)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:set_parameter(param_id, value, weight)
end

function M.add_parameter(param_id, value, weight)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:add_parameter(param_id, value, weight)
end

function M.start_motion(name, no, priority)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:start_motion(name, no, priority)
end

function M.set_expression(name)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:set_expression(name)
end

function M.hit_test(x, y)
    if current_renderer == nil then error("no current renderer", 2) end
    return current_renderer:hit_test(x, y)
end

function M.dispose()
    if current_renderer ~= nil then
        current_renderer:dispose()
    elseif platform_manager ~= nil then
        platform_manager:clearStreams()
    end
    current_renderer = nil
    platform_manager = nil
    Live2D.dispose()
    collectgarbage("collect")
    runtime_initialized = false
end

M.Renderer = Renderer
M.MotionPriority = MotionPriority

return M