sim-2.lua

local sim = table.clone(_S.internalApi.sim)
sim.version = 2
sim.__all = {'app', 'scene', 'self'}

local locals = {}
__2 = {locals = locals, sim = sim} -- sometimes globals are needed (but __2 only for sim-2)

local simEigen = require 'simEigen'
local checkargs = require('checkargs-2')

function sim.callMethod(target, name, ...)
    if callMethod(target, 'getMethodProperty', name, {noError = true}) then
        -- Lua calling custom property Lua method:
        return locals.getMethodProperty(target, 'getMethodProperty', name)(target, ...)
    elseif locals[name] then
        -- Lua calling built-in Lua method:
        return locals[name](target, name, ...)
    elseif (string.sub(name, 1, 1) == "@") then
        -- C-side calling:
        local res = table.pack(pcall(sim.callMethod, target, name:sub(2), ...)) -- sim.callMethod and not callMethod here!
        if res[1] then
            return '', table.unpack(res, 2, res.n)
        else
            return res[2] -- error msg
        end
    else
        -- Lua calling C method:
        return callMethod(target, name, ...)
    end
end

function locals.setMethodProperty(target, methodName, mName, func)
    assert((type(func) == "function") or (func == nil), "expected a function or nil")
    if func ~= nil then
        func = string.dump(func)
    end
    return callMethod(target, methodName, mName, func)
end

function locals.getMethodProperty(target, methodName, mName)
    local bytecode = callMethod(target, methodName, mName)
    if #bytecode == 0 then
        bytecode = nil
    else
        bytecode = load(tostring(bytecode))
    end
    return bytecode
end

function locals.remove(target, methodName, delayed)
    target = sim.Object:toobject(target)
    if target:getPropertyInfo('cleanup', {noError = true}) == sim.propertytype_method then
        target:getMethodProperty('cleanup')(target)
    end
    return callMethod(target, methodName, delayed)
end

function locals.removeObjects(target, methodName, objects, delayed)
    local list = {}
    for i = 1, #objects do
        local obj = sim.Object:toobject(objects[i])
        if obj:isValid() then
            if obj.isCustomObject then
                sim.callMethod(obj, 'remove')
            else
                list[#list + 1] = obj
            end
        end
    end
    callMethod(target, methodName, list, delayed)
end

function locals.registerFunctionHook(target, methodName, funcNm, func, before)
    if before == nil then before = true end
    if type(func) == 'string' then
        registerScriptFuncHook(funcNm, func, before, false)
    else
        local str = tostring(func):gsub("[%s:]", "_") -- typical tostring(func) typically produces: "function: xxxxxxx", and : is reserved
        registerScriptFuncHook(funcNm, '__2.' .. str, before, false)
        __2[str] = func
    end
end

function locals.removeFunctionHook(target, methodName, funcNm, func, before)
    if before == nil then before = true end
    if type(func) == 'string' then
        registerScriptFuncHook(funcNm, func, before, true)
    else
        local str = tostring(func):gsub("[%s:]", "_") -- typical tostring(func) typically produces: "function: xxxxxxx", and : is reserved
        registerScriptFuncHook(funcNm, '__2.' .. str, before, true)
        __2[str] = nil
    end
end

function locals.lock(target, methodName, acquire)
    setYieldAllowed(not acquire)
end

function locals.yield(target, methodName)
    if getYieldAllowed() then
        local thread, yieldForbidden = coroutine.running()
        if not yieldForbidden then coroutine.yield() end
    end
end

function locals.step(target, methodName)
    locals.yield(target, methodName)
end

function locals.getAncestors(target, methodName, options, objTypesMap)
    local types = {}
    options = options or {}
    options.types = options.types or {'sceneObject'}
    options.count = options.count or 9999
    if objTypesMap then
        types = objTypesMap
    else
        for i = 1, #options.types do
            types[options.types[i]] = true
        end
    end
    local retVal = {}
    if options.count > 0 then
        while target do
            target = target.parent
            if target then
                if types[target.type] or types['sceneObject'] then
                    retVal[#retVal + 1] = target
                end
            else
                break
            end
            options.count = options.count - 1
            if options.count == 0 then
                break
            end
        end
    end
    return retVal
end

function locals.getDescendants(target, methodName, options, types, depth)
    if #methodName > 0 then
        options = options or {}
        options.types = options.types or {'sceneObject'}
        options.depth = options.depth or 9999
        types = {}
        for i = 1, #options.types do
            types[options.types[i]] = true
        end
        depth = options.depth
    end
    local retVal = {}

    if depth > 0 then
        if target == sim.scene then
            for i = 1, #target.orphans do
                local child = target.orphans[i]
                if types[child.type] or types['sceneObject'] then
                    retVal[#retVal + 1] = child
                end
                retVal = table.add(retVal, locals.getDescendants(child, '', {}, types, depth - 1))
            end
        else
            for i = 1, #target.children do
                local child = target.children[i]
                if types[child.type] or types['sceneObject'] then
                    retVal[#retVal + 1] = child
                end
                retVal = table.add(retVal, locals.getDescendants(child, '', {}, types, depth - 1))
            end
        end
    end
    return retVal
end

function locals.getFunctions(target, methodName, ...)
    return setmetatable({}, {
        __index = function(self, k)
            return function(self_, ...)
                assert(self_ == self, 'methods must be called with object:method(args...)')
                return target:callFunction(k, ...)
            end
        end,
    })
end

function locals.fastIdleLoop(target, methodName, enable)
    local data = sim.app:getBufferProperty('signal.__IDLEFPSSTACKSIZE__', {noError = true}) -- sim-1 uses buffers too, stay compatible!
    local stage = 0
    local defaultIdleFps
    if data and #data > 0 then
        data = sim.app:unpackInt32Table(data)
        stage = data[1]
        defaultIdleFps = data[2]
    else
        defaultIdleFps = sim.app:getIntProperty('idleFps')
    end
    if enable then
        stage = stage + 1
    else
        if stage > 0 then stage = stage - 1 end
    end
    if stage > 0 then
        sim.app:setIntProperty('idleFps', 0)
    else
        sim.app:setIntProperty('idleFps', defaultIdleFps)
    end
    sim.app:setBufferProperty('signal.__IDLEFPSSTACKSIZE__', app:packArray({stage, defaultIdleFps}, {type = 'int32'}))
end

function locals.throttle(target, methodName, func, interval, options)
    options = options or {}
    options.args = options.args or {}
    locals.lastExecTime = locals.lastExecTime or {}
    locals.throttleSched = locals.throttleSched or {}

    local h = string.dump(func)
    local now = sim.app.systemTime

    -- cancel any previous scheduled execution: (see locals.scheduleExecution below)
    if locals.throttleSched[h] then
        locals.cancelScheduledExecution(-1, '', locals.throttleSched[h])
        locals.throttleSched[h] = nil
    end

    if locals.lastExecTime[h] == nil or locals.lastExecTime[h] + interval < now then
        func(table.unpack(options.args))
        locals.lastExecTime[h] = now
    else
        -- if skipping the call (i.e. because it exceeds target rate)
        -- schedule the last call in the future:
        locals.throttleSched[h] = locals.scheduleExecution(-1, '', function()
            func(table.unpack(options.args))
            locals.lastExecTime[h] = sim.app.systemTime
        end, interval - now + locals.lastExecTime[h], {simulationTime = false, args = options.args})
    end
end

function locals.schedulerCallback()
    local function fn(t, pq)
        local item = pq:peek()
        if item and item.timePoint <= t then
            item.func(table.unpack(item.args or {}))
            pq:pop()
            fn(t, pq)
        end
    end

    fn(sim.app.systemTime, locals.scheduler.rtpq)
    if sim.getSimulationState() == sim.simulation_advancing_running then
        fn(sim.scene.simulation.time, locals.scheduler.simpq)
    end

    if locals.scheduler.simpq:isempty() and locals.scheduler.rtpq:isempty() then
        sim.self:registerFunctionHook('sysCall_nonSimulation', locals.schedulerCallback, true)
        sim.self:registerFunctionHook('sysCall_sensing', locals.schedulerCallback, true)
        sim.self:registerFunctionHook('sysCall_suspended', locals.schedulerCallback, true)
        locals.scheduler.hook = false
    end
end

function locals.scheduleExecution(target, methodName, func, delay, options)
    options = options or {}
    options.simulationTime = options.simulationTime or false
    options.args = options.args or {}
    local timePoint
    if options.simulationTime then
        timePoint = delay + sim.scene.simulation.time
    else
        timePoint = delay + sim.app.systemTime
    end
    if not locals.scheduler then
        local priorityqueue = require 'priorityqueue'
        locals.scheduler = {
            simpq = priorityqueue(),
            rtpq = priorityqueue(),
            simTime = {},
            nextId = 1,
        }
    end

    local id = locals.scheduler.nextId
    locals.scheduler.nextId = id + 1
    local pq
    if options.simulationTime then
        pq = locals.scheduler.simpq
        locals.scheduler.simTime[id] = true
    else
        pq = locals.scheduler.rtpq
    end
    pq:push(timePoint, {
        id = id,
        func = func,
        args = options.args,
        timePoint = timePoint,
        simTime = options.simulationTime,
    })
    if not locals.scheduler.hook then
        sim.self:registerFunctionHook('sysCall_nonSimulation', locals.schedulerCallback, true)
        sim.self:registerFunctionHook('sysCall_sensing', locals.schedulerCallback, true)
        sim.self:registerFunctionHook('sysCall_suspended', locals.schedulerCallback, true)
        locals.scheduler.hook = true
    end
    return id
end

function locals.cancelScheduledExecution(target, methodName, id)
    if not locals.scheduler then return end
    local pq = nil
    if locals.scheduler.simTime[id] then
        locals.scheduler.simTime[id] = nil
        pq = locals.scheduler.simpq
    else
        pq = locals.scheduler.rtpq
    end
    return pq:cancel(function(item) return item.id == id end)
end

function locals.changeColor(target, methodName, ...)
    target = sim.Object:toobject(target)
    local color, options = checkargs({
        {type = 'color'},
        {type = 'table', default = {component = 'diffuse'}},
    }, ...)
    local colorData = {}
    local objs = {target}
    if target.type == 'collection' then
        objs = collection.objects
    end
    for i = 1, #objs, 1 do
        local obj = objs[i]
        if obj.type == 'shape' then -- and obj.visible then
            local colComp = 'diffuse'
            if options.component == 'specular' then
                colComp = options.component
            elseif options.component == 'emission' then
                colComp = options.component
            end
            colorData[#colorData + 1] = {puid = obj.persistentUid, data = obj.compoundColors[colComp], comp = colComp}
            obj.applyColor[colComp] = color
        end
    end
    return colorData
end

function locals.restoreColor(target, methodName, ...)
    local colorData = checkargs({{type = 'table'}, size = '0..*'}, ...)
    for i = 1, #colorData, 1 do
        local obj = sim.scene:getObject(colorData[i].puid, {noError = true})
        if obj then
            obj.compoundColors[colorData[i].comp] = colorData[i].data
        end
    end
end

function locals.wait(target, methodName, ...)
    local dt, simTime = checkargs({{type = 'float'}, {type = 'bool', default = true}}, ...)

    if simTime then
        local st = sim.scene.simulation.time
        while sim.scene.simulation.time - st < dt do sim.self:step() end
    else
        local st = sim.app.systemTime
        while sim.app.systemTime - st < dt do sim.self:step() end
    end
end

function locals.createObject(target, methodName, initialProperties)
    local objectInit = require 'objectInit'
    local retVal = objectInit.init(target, methodName, initialProperties)
    if retVal == nil then
        error ("error in '" .. methodName .. "': unsupported object type.")
    end
    return retVal
end

function locals.getAppearance(target, methodName)
    target = sim.Object:toobject(target)
    assert(target.type == 'shape', 'not a shape')
    local r = {}
    r.edges = target.compoundEdges
    r.wireframe = target.compoundWireframe
    r.visibilityLayer = target.layer
    r.culling = target.compoundCullings
    r.shadingAngle = target.compoundShadingAngles
    r.color = {}
    r.color.diffuse = target.compoundColors.diffuse
    r.color.specular = target.compoundColors.specular
    r.color.emission = target.compoundColors.emission
    r.color.transparency = target.compoundColors.transparency
    return r
end

function locals.setAppearance(target, methodName, savedData)
    target = sim.Object:toobject(target)
    assert(target.type == 'shape', 'not a shape')
    target.compoundEdges = savedData.edges
    target.compoundWireframe = savedData.wireframe
    target.compoundCullings = savedData.culling
    target.compoundShadingAngles = savedData.shadingAngle
    target.layer = savedData.visibilityLayer
    target.compoundColors.diffuse = savedData.color.diffuse
    target.compoundColors.specular = savedData.color.specular
    target.compoundColors.emission = savedData.color.emission
    target.compoundColors.transparency = savedData.color.transparency
end

function locals.openFile(target, methodName, file)
    local simSubprocess = require 'simSubprocess'
    if sim.app.platform == 0 then
        -- windows
        simSubprocess.exec('cmd', {'/c', 'start', '', file})
    elseif sim.app.platform == 1 then
        -- mac
        simSubprocess.exec('open', {file})
    elseif sim.app.platform == 2 then
        -- linux
        simSubprocess.exec('xdg-open', {file})
    else
        error('unknown platform: ' .. platform)
    end
end

-- wrap require() to load embedded scripts' code when called with a script handle, e.g. require(sim.getObject '/foo')
if not _S.requireWrapped then
    _S.requireWrapped = true -- other sim-versions might already have wrapped it
    require = wrap(require, function(origRequire)
        return function (...)
            local arg = ({...})[1]
            if math.type(arg) == 'integer' and sim.isHandle(arg) and sim.getObjectType(arg) == sim.sceneobject_script then
                local txt = sim.getStringProperty(arg, 'code')
                return loadstring(tostring(txt))()
            end
            return origRequire(...)
        end
    end)
end

function locals.serialize(target, methodName, data)
    local cbor = require 'simCBOR'
    function fixTable(v)
        local mt = getmetatable(v)
        if type(v) == 'function' or (mt and not mt.__tocbor) then
            return tostring(v)
        elseif type(v) == 'table' and not mt then
            local t = {}
            for k, v in pairs(v) do
                t[k] = fixTable(v)
            end
            return t
        else
            return v
        end
    end
    return tobuffer(cbor.encode(fixTable(data)))
end

function locals.deserialize(target, methodName, data)
    local cbor = require 'simCBOR'
    return cbor.decode(data)
end

function locals.getPropertyTypeString(target, methodName, ptype)
    if not locals.propertytypeToStringMap then
        locals.propertytypeToStringMap = table.invert(table.filter(sim, {matchKeyPrefix = 'propertytype_', stripKeyPrefix = true}))
    end
    return locals.propertytypeToStringMap[ptype]
end

function locals.getPropertiesInfos(target, methodName, opts)
    opts = opts or {}
    local propertiesInfos = {}
    for i = 0, 1e100 do
        local pname, pclass = sim.callMethod(target, 'getPropertyName', i, {excludeFlags = opts.excludeFlags})
        if not pname then break end
        local ok, err = pcall(function()
            propertiesInfos[pname] = locals.getPropertyInfos(target, '', pname, {decodeMetaInfo = opts.decodeMetaInfo})
        end)
        if not ok then
            error(string.format('property "%s": %s', pname, err))
        end
        propertiesInfos[pname].class = pclass

        --[[ (as of Sep 2026, this part is probably obsolete)
        -- coppeliaSim won't report group properties via getPropertyName
        -- infer them via pname dots:
        if opts.groups ~= false then
            local parts = string.split(pname, '.', true)
            for i = 1, #parts-1 do
                local pname1 = table.join(table.slice(parts, 1, i), '.')
                local ok, err = pcall(function()
                    propertiesInfos[pname1] = locals.getPropertyInfos(target, '', pname1, {decodeMetaInfo = opts.decodeMetaInfo})
                end)
                if not ok then
                    printf('warning: %s: %s', pname1, err)
                end
            end
        end
        ]]--
    end
    return propertiesInfos
end

function locals.getProperties(target, methodName, opts)
    opts = opts or {}
    local propertiesValues = {}
    for pname, pinfos in pairs(sim.callMethod(target, 'getPropertiesInfos', opts)) do
        local skip = not pinfos.flags.readable
            or (opts.skipLarge and pinfos.flags.large)
            or (opts.skipGroups ~= false and pinfos.type == sim.propertytype_group)
        if not skip then
            propertiesValues[pname] = sim.callMethod(target, 'getProperty', pname)
        end
    end
    return propertiesValues
end

function locals.setProperties(target, methodName, props)
    for k, v in pairs(props) do
        locals.setProperty(target, 'setProperty', k, v)
    end
end

function locals.getProperty(target, methodName, pname, opts)
    opts = opts or {}
    local ptype = opts.type or sim.callMethod(target, 'getPropertyInfo', pname, opts)
    if not opts.noError then
        assert(ptype, 'no such property: ' .. pname)
    end
    local retVal
    if ptype then
        local ptypeStr = locals.getPropertyTypeString(-1, '', ptype)
        ptypeStr = string.capitalize(string.gsub(ptypeStr, 'array', 'Array'))
        local getterMethod = 'get' .. ptypeStr .. 'Property'
        retVal = sim.callMethod(target, getterMethod, pname, opts)
    end
    return retVal
end

function locals.setProperty(target, methodName, pname, pvalue, opts)
    if type(opts) == 'number' or type(opts) == 'string' then
        sim.app:logWarn('passing a ' .. type(opts) .. ' as the last argument of setProperty: assuming {type = ...}')
        -- backward compatibility fix: last arg was ptype
        opts = {type = opts}
    end
    opts = opts or {}
    assert(type(opts) == 'table', 'opts must be a table')

    -- if opts.type is a string, e.g.: 'intvector', it will be resolved to int, e.g.: sim.propertytype_intvector
    if type(opts.type) == 'string' then
        opts.type = sim['propertytype_' .. opts.type]
        assert(opts.type, 'invalid property type string')
    end
    assert(opts.type == nil or math.type(opts.type) == 'integer', 'invalid type for option "type"')
    local ptype = opts.type

    -- opts.inferType:
    --     for customData.*/signal.* properties:
    --        defaults to true if opts.type not provided
    --        defaults to false otherwise
    --     otherwise defaults to false
    -- (can be overridden)
    local inferType = (string.startswith(pname, 'customData.') or string.startswith(pname, 'signal.')) and opts.type == nil
    if opts.inferType ~= nil then inferType = opts.inferType end

    if inferType then
        -- infer property type from the type of lua variable
        local ltype = type(pvalue)
        if ltype == 'number' then
            if math.type(pvalue) == 'integer' then
                ptype = sim.propertytype_int
            else
                ptype = sim.propertytype_float
            end
        elseif ltype == 'string' then
            ptype = sim.propertytype_string
        elseif ltype == 'boolean' then
            ptype = sim.propertytype_bool
        elseif ltype == 'function' then
            ptype = sim.propertytype_method
        elseif ltype == 'table' then
            local simEigen = require 'simEigen'
            if Buffer:isbuffer(pvalue) then
                ptype = sim.propertytype_buffer
            elseif Color:iscolor(pvalue) then
                ptype = sim.propertytype_color
            elseif sim.Object:isobject(pvalue) then
                ptype = sim.propertytype_handle
            elseif sim.ObjectArray:isobjectarray(pvalue) then
                ptype = sim.propertytype_handlearray
            elseif simEigen.Quaternion:isquaternion(pvalue) then
                ptype = sim.propertytype_quaternion
            elseif simEigen.Matrix:ismatrix(pvalue) then
                ptype = sim.propertytype_matrix
            elseif simEigen.Pose:ispose(pvalue) then
                ptype = sim.propertytype_pose
            else
                ptype = sim.propertytype_table
            end
        else
            error('unsupported property type: ' .. ltype)
        end
    elseif ptype == nil then
        ptype = sim.callMethod(target, 'getPropertyInfo', pname)
        if ptype == nil then
            if opts.noError then return else error('no such property: ' .. pname) end
        end
    end

    local ptypeStr = locals.getPropertyTypeString(-1, '', ptype)
    ptypeStr = string.capitalize(string.gsub(ptypeStr, 'array', 'Array'))
    local setterMethod = 'set' .. ptypeStr .. 'Property'

    return sim.callMethod(target, setterMethod, pname, pvalue, opts)
end

function locals.getPropertyInfos(target, methodName, pname, opts)
    opts = opts or {}
    local infos = {}
    local ptype, pflags, metaInfo = sim.callMethod(target, 'getPropertyInfo', pname, {bitCoded = 1})
    if not ptype then return end
    infos.type = ptype
    infos.flags = {
        value = pflags,
        readable = pflags & sim.propertyinfo_notreadable == 0,
        writable = pflags & sim.propertyinfo_notwritable == 0,
        removable = pflags & sim.propertyinfo_removable > 0,
        silent = pflags & sim.propertyinfo_silent > 0,
        large = pflags & sim.propertyinfo_largedata > 0,
        deprecated = pflags & sim.propertyinfo_deprecated > 0,
        constant = pflags & sim.propertyinfo_constant > 0,
        modelhashexclude = pflags & sim.propertyinfo_modelhashexclude > 0,
    }
    if opts.decodeMetaInfo ~= false then
        if metaInfo ~= '' then
            local json = require 'dkjson'
            local decodedMetaInfo = json.decode(metaInfo)
            assert(decodedMetaInfo ~= nil, 'invalid meta info: ' .. metaInfo)
            for k, v in pairs(decodedMetaInfo) do
                assert(infos[k] == nil)
                infos[k] = v
            end
        end
    else
        infos.metaInfo = metaInfo
    end
    return infos
end

function locals.getTableProperty(target, methodName, ...)
    local tagName, options = checkargs.checkargsEx({nilGetsDefault=true}, {
        {type = 'string'},
        {type = 'table', default = {}},
    }, ...)
    local buf = callMethod(target, 'getTableProperty', tagName, options)
    if buf then
        local retVal = {}
        if #buf > 0 then
            if string.byte(buf, 1) == 0 or string.byte(buf, 1) == 5 then
                retVal = sim.app:unpack(buf)
            else
                retVal = sim.app:deserialize(buf)
            end
        end
        return retVal
    end
end

function locals.setTableProperty(target, methodName, ...)
    local tagName, theTable, options = checkargs.checkargsEx({nilGetsDefault=true}, {
        {type = 'string'},
        {type = 'table'},
        {type = 'table', default = {}},
    }, ...)
    options.dataType = options.dataType or 'cbor'
    local buf
    if options.dataType == 'cbor' then
        buf = sim.app:serialize(theTable)
    else
        buf = sim.app:pack(theTable)
    end
    return callMethod(target, 'setTableProperty', tagName, buf, options)
end

function locals.getEnumProperty(target, methodName, ...)
    return callMethod(target, 'getIntProperty', ...)
end

function locals.setEnumProperty(target, methodName, ...)
    local pname, pvalue, options = checkargs.checkargsEx({nilGetsDefault=true}, {
        {type = 'string'},
        {union = {{type = 'string'}, {type = 'int'}}},
        {type = 'table', default = {}},
    }, ...)
    if type(pvalue) == 'string' then
        return callMethod(target, 'setStringProperty', ...)
    elseif math.type(pvalue) == 'integer' then
        return callMethod(target, 'setIntProperty', ...)
    else
        error('invalid value type')
    end
end

function __2.sysCallEx_init()
    -- Hook function, registered further down
    if sysCall_selChange then
        local sel = {}
        local selection = sim.scene.selection
        for i = 1, #selection do
            sel[i] = selection[i].handle
        end
        sysCall_selChange({sel = sel, selection = selection})
    end
end

sim.Object = require 'sim.Object'
sim.Object.callMethod = sim.callMethod -- replace [C]callMethod with [Lua]sim.callMethod
sim.ObjectArray = require 'sim.ObjectArray'
sim.PropertyGroup = require 'sim.PropertyGroup'

sim.app = sim.Object.app
sim.scene = sim.Object.scene
sim.self = sim.Object.self
for _, n in ipairs(sim.app.enumTypes) do
    assert(sim[n] == nil, 'cannot write enum sim.' .. n .. ': name clash')
    sim[n] = sim.app:getEnumInfo(n)
end

sim.self:registerFunctionHook('sysCall_init', '__2.sysCallEx_init', false) -- hook on *before* init is incompatible with implicit module load...

---[[
sim._qhull = nil
sim._serialClose = nil
sim._serialOpen = nil
sim._serialRead = nil
sim.addDrawingObjectItem = nil
sim.addForce = nil
sim.addForceAndTorque = nil
sim.addGraphCurve = nil
sim.addGraphStream = nil
sim.addParticleObject = nil
sim.addParticleObjectItem = nil
sim.addReferencedHandle = nil
sim.addToCollection = nil
sim.adjustView = nil
sim.alignShapeBB = nil
sim.announceSceneContentChange = nil
sim.auxFunc = nil
sim.auxiliaryConsoleClose = nil
sim.auxiliaryConsoleOpen = nil
sim.auxiliaryConsolePrint = nil
sim.auxiliaryConsoleShow = nil
sim.broadcastMsg = nil
sim.callScriptFunction = nil
sim.cameraFitToView = nil
sim.cancelScheduledExecution = nil
sim.changeEntityColor = nil
sim.checkCollision = nil
sim.checkDistance = nil
sim.checkOctreePointOccupancy = nil
sim.checkProximitySensor = nil
sim.checkVisionSensor = nil
sim.closePath = nil
sim.closeScene = nil
sim.combineRgbImages = nil
sim.computeMassAndInertia = nil
sim.copyPasteObjects = nil
sim.createCollectionEx = nil
sim.createNakedScript = nil
sim.createDrawingObject = nil
sim.createDummy = nil
sim.createForceSensor = nil
sim.createHeightfieldShape = nil
sim.createJoint = nil
sim.createMarker = nil
sim.createOctree = nil
sim.createPointCloud = nil
sim.createPrimitiveShape = nil
sim.createProximitySensor = nil
sim.createScript = nil
sim.createShape = nil
sim.createTexture = nil
sim.createVisionSensor = nil
sim.destroyCollection = nil
sim.destroyGraphCurve = nil
sim.duplicateGraphCurveToStatic = nil
sim.executeScriptString = nil
sim.exportMesh = nil
sim.fastIdleLoop = nil
sim.floatingViewAdd = nil
sim.floatingViewRemove = nil
sim.generateShapeFromPath = nil
sim.getApiFunc = nil
sim.getApiInfo = nil
sim.getAutoYieldDelay = nil
sim.getBoolProperty = nil
sim.getBufferProperty = nil
sim.getClosestPosOnPath = nil
sim.getColorProperty = nil
sim.getConfigDistance = nil
sim.getContactInfo = nil
sim.getExplicitHandling = nil
sim.getExtensionString = nil
sim.getFloatArrayProperty = nil
sim.getFloatProperty = nil
sim.getGenesisEvents = nil
sim.getGraphCurve = nil
sim.getGraphInfo = nil
sim.getHandleArrayProperty = nil
sim.getHandleProperty = nil
sim.getIntArray2Property = nil
sim.getIntArrayProperty = nil
sim.getIntProperty = nil
sim.getJointDependency = nil
sim.getJointForce = nil
sim.getJointInterval = nil
sim.getJointMode = nil
sim.getJointPosition = nil
sim.getJointTargetForce = nil
sim.getJointTargetPosition = nil
sim.getJointTargetVelocity = nil
sim.getJointType = nil
sim.getJointVelocity = nil
sim.getLastInfo = nil
sim.getLinkDummy = nil
sim.getLongProperty = nil
sim.getMatrixProperty = nil
sim.getNavigationMode = nil
sim.getObject = nil
sim.getObjectAlias = nil
sim.getObjectAliasRelative = nil
sim.getObjectChildPose = nil
sim.getObjectColor = nil
sim.getObjectFromUid = nil
sim.getObjectHierarchyOrder = nil
sim.getObjectPose = nil
sim.getObjectPosition = nil
sim.getObjectQuaternion = nil
sim.getObjectSel = nil
sim.getObjectType = nil
sim.getObjectUid = nil
sim.getObjectVelocity = nil
sim.getOctreeVoxels = nil
sim.getPage = nil
sim.getPathInterpolatedConfig = nil
sim.getPathLengths = nil
sim.getPluginInfo = nil
sim.getPointCloudOptions = nil
sim.getPointCloudPoints = nil
sim.getPoseProperty = nil
sim.getProperties = nil
sim.getPropertiesInfos = nil
sim.getProperty = nil
sim.getPropertyInfo = nil
sim.getPropertyInfos = nil
sim.getPropertyName = nil
sim.getPropertyTypeString = nil
sim.getQuaternionFromMatrix = nil
sim.getQuaternionProperty = nil
sim.getReferencedHandle = nil
sim.getReferencedHandles = nil
sim.getReferencedHandlesTags = nil
sim.getScaledImage = nil
sim.getScript = nil
sim.getSettingBool = nil
sim.getSettingFloat = nil
sim.getSettingInt32 = nil
sim.getSettingString = nil
sim.getShapeAppearance = nil
sim.getShapeBB = nil
sim.getShapeColor = nil
sim.getShapeGeomInfo = nil
sim.getShapeInertia = nil
sim.getShapeMass = nil
sim.getShapeMesh = nil
sim.getShapeTextureId = nil
sim.getShapeViz = nil
sim.getSimulationState = nil
sim.getSimulationTime = nil
sim.getSimulationTimeStep = nil
sim.getSimulatorMessage = nil
sim.getStackTraceback = nil
sim.getStringArrayProperty = nil
sim.getStringProperty = nil
sim.getSystemTime = nil
sim.getTableProperty = nil
sim.getTextureId = nil
sim.getThreadId = nil
sim.getVector3Property = nil
sim.getVelocity = nil
sim.getVisionSensorDepth = nil
sim.getVisionSensorImg = nil
sim.getVisionSensorRes = nil
sim.groupShapes = nil
sim.handleAddOnScripts = nil
sim.handleDynamics = nil
sim.handleEmbeddedScripts = nil
sim.handleExtCalls = nil
sim.handleGraph = nil
sim.handleJointMotion = nil
sim.handleProximitySensor = nil
sim.handleSandboxScript = nil
sim.handleSensingStart = nil
sim.handleSimulationScripts = nil
sim.handleSimulationStart = nil
sim.handleVisionSensor = nil
sim.importMesh = nil
sim.importShape = nil
sim.initScript = nil
sim.insertObjectIntoOctree = nil
sim.insertObjectIntoPointCloud = nil
sim.insertPointsIntoPointCloud = nil
sim.insertVoxelsIntoOctree = nil
sim.intersectPointsWithPointCloud = nil
sim.isDynamicallyEnabled = nil
sim.isHandle = nil
sim.launchExecutable = nil
sim.loadImage = nil
sim.loadModel = nil
sim.loadScene = nil
sim.moduleEntry = nil
sim.openFile = nil
sim.packDoubleTable = nil
sim.packFloatTable = nil
sim.packInt32Table = nil
sim.packInt64Table = nil
sim.packTable = nil
sim.packUInt16Table = nil
sim.packUInt32Table = nil
sim.packUInt8Table = nil
sim.pauseSimulation = nil
sim.pushUserEvent = nil
sim.readTexture = nil
sim.refreshDialogs = nil
sim.relocateShapeFrame = nil
sim.removeNakedScript = nil
sim.removeDrawingObject = nil
sim.removeModel = nil
sim.removeObjects = nil
sim.removeParticleObject = nil
sim.removePointsFromPointCloud = nil
sim.removeProperty = nil
sim.removeReferencedObjects = nil
sim.removeVoxelsFromOctree = nil
sim.resamplePath = nil
sim.resetDynamicObject = nil
sim.resetGraph = nil
sim.resetProximitySensor = nil
sim.resetVisionSensor = nil
sim.restoreEntityColor = nil
sim.ruckigPos = nil
sim.ruckigRemove = nil
sim.ruckigStep = nil
sim.ruckigVel = nil
sim.saveImage = nil
sim.saveModel = nil
sim.saveScene = nil
sim.scaleObject = nil
sim.scaleObjects = nil
sim.scheduleExecution = nil
sim.serialCheck = nil
sim.serialSend = nil
sim.setAutoYieldDelay = nil
sim.setBoolProperty = nil
sim.setBufferProperty = nil
sim.setColorProperty = nil
sim.setEventFilters = nil
sim.setExplicitHandling = nil
sim.setFloatArrayProperty = nil
sim.setFloatProperty = nil
sim.setGraphStreamTransformation = nil
sim.setGraphStreamValue = nil
sim.setHandleArrayProperty = nil
sim.setHandleProperty = nil
sim.setIntArray2Property = nil
sim.setIntArrayProperty = nil
sim.setIntProperty = nil
sim.setJointDependency = nil
sim.setJointInterval = nil
sim.setJointMode = nil
sim.setJointPosition = nil
sim.setJointTargetForce = nil
sim.setJointTargetPosition = nil
sim.setJointTargetVelocity = nil
sim.setLinkDummy = nil
sim.setLongProperty = nil
sim.setMatrixProperty = nil
sim.setNavigationMode = nil
sim.setObjectAlias = nil
sim.setObjectChildPose = nil
sim.setObjectColor = nil
sim.setObjectHierarchyOrder = nil
sim.setObjectParent = nil
sim.setObjectPose = nil
sim.setObjectPosition = nil
sim.setObjectQuaternion = nil
sim.setObjectSel = nil
sim.setPage = nil
sim.setPluginInfo = nil
sim.setPointCloudOptions = nil
sim.setPoseProperty = nil
sim.setProperties = nil
sim.setProperty = nil
sim.setPropertyInfo = nil
sim.setQuaternionProperty = nil
sim.setReferencedHandles = nil
sim.setShapeAppearance = nil
sim.setShapeColor = nil
sim.setShapeInertia = nil
sim.setShapeMass = nil
sim.setShapeMaterial = nil
sim.setShapeTexture = nil
sim.setStringArrayProperty = nil
sim.setStringProperty = nil
sim.setTableProperty = nil
sim.setVector3Property = nil
sim.setVisionSensorImg = nil
sim.startSimulation = nil
sim.stopSimulation = nil
sim.subtractObjectFromOctree = nil
sim.subtractObjectFromPointCloud = nil
sim.systemSemaphore = nil
sim.test = nil
sim.textEditorClose = nil
sim.textEditorGetInfo = nil
sim.textEditorOpen = nil
sim.textEditorShow = nil
sim.throttle = nil
sim.transformBuffer = nil
sim.transformImage = nil
sim.ungroupShape = nil
sim.unpackDoubleTable = nil
sim.unpackFloatTable = nil
sim.unpackInt32Table = nil
sim.unpackInt64Table = nil
sim.unpackTable = nil
sim.unpackUInt16Table = nil
sim.unpackUInt32Table = nil
sim.unpackUInt8Table = nil
sim.wait = nil
sim.writeTexture = nil

-- constants:
sim.buffer_base64 = nil
sim.buffer_clamp = nil
sim.buffer_double = nil
sim.buffer_float = nil
sim.buffer_int16 = nil
sim.buffer_int32 = nil
sim.buffer_int8 = nil
sim.buffer_split = nil
sim.buffer_uint16 = nil
sim.buffer_uint32 = nil
sim.buffer_uint8 = nil
sim.buffer_uint8argb = nil
sim.buffer_uint8bgr = nil
sim.buffer_uint8rgb = nil
sim.buffer_uint8rgba = nil

sim.drawing_cubepts = nil
sim.drawing_cyclic = nil
sim.drawing_discpts = nil
sim.drawing_lines = nil
sim.drawing_linestrip = nil
sim.drawing_local = nil
sim.drawing_overlay = nil
sim.drawing_painttag = nil
sim.drawing_points = nil
sim.drawing_quadpts = nil
sim.drawing_spherepts = nil
sim.drawing_trianglepts = nil
sim.drawing_triangles = nil

sim.handleflag_abscoords = nil
sim.handleflag_addmultiple = nil
sim.handleflag_assembly = nil
sim.handleflag_axis = nil
sim.handleflag_camera = nil
sim.handleflag_codedstring = nil
sim.handleflag_depthbuffer = nil
sim.handleflag_depthbuffermeters = nil
sim.handleflag_extended = nil
sim.handleflag_greyscale = nil
sim.handleflag_keeporiginal = nil
sim.handleflag_model = nil
sim.handleflag_rawvalue = nil
sim.handleflag_reljointbaseframe = nil
sim.handleflag_resetforce = nil
sim.handleflag_resetforcetorque = nil
sim.handleflag_resettorque = nil
sim.handleflag_silenterror = nil
sim.handleflag_togglevisibility = nil
sim.handleflag_wxyzquat = nil

sim.imgcomb_horizontal = nil
sim.imgcomb_vertical = nil

sim.materialcomponent_diffuse = nil
sim.materialcomponent_emission = nil
sim.materialcomponent_lightdiffuse = nil
sim.materialcomponent_specular = nil

sim.message_keypress = nil
sim.message_model_loaded = nil
sim.message_object_selection_changed = nil
sim.message_scene_loaded = nil

sim.modelproperty_not_collidable = nil
sim.modelproperty_not_detectable = nil
sim.modelproperty_not_dynamic = nil
sim.modelproperty_not_measurable = nil
sim.modelproperty_not_model = nil
sim.modelproperty_not_reset = nil
sim.modelproperty_not_respondable = nil
sim.modelproperty_not_showasinsidemodel = nil
sim.modelproperty_not_visible = nil
sim.modelproperty_scripts_inactive = nil

sim.object_collectionend = nil
sim.object_collectionstart = nil
sim.object_customappend = nil
sim.object_customappstart = nil
sim.object_customclassstart = nil
sim.object_customend = nil
sim.object_customsceneend = nil
sim.object_customscenestart = nil
sim.object_customstart = nil
sim.object_nakedScriptend = nil
sim.object_nakedScriptstart = nil
sim.object_drawingend = nil
sim.object_drawingstart = nil
sim.object_sceneobjectend = nil
sim.object_sceneobjectstart = nil
sim.object_stackend = nil
sim.object_stackstart = nil
sim.object_textureend = nil
sim.object_texturestart = nil
sim.object_variousstart = nil

sim.objectproperty_cannotdelete = nil
sim.objectproperty_cannotdeleteduringsim = nil
sim.objectproperty_collapsed = nil
sim.objectproperty_depthinvisible = nil
sim.objectproperty_dontshowasinsidemodel = nil
sim.objectproperty_hiddenforsimulation = nil
sim.objectproperty_ignoreviewfitting = nil
sim.objectproperty_selectable = nil
sim.objectproperty_selectinvisible = nil
sim.objectproperty_selectmodelbaseinstead = nil

sim.objectspecialproperty_collidable = nil
sim.objectspecialproperty_detectable = nil
sim.objectspecialproperty_measurable = nil

sim.objecttype_app = nil
sim.objecttype_collection = nil
sim.objecttype_customobject = nil
sim.objecttype_script = nil
sim.objecttype_interfacestack = nil
sim.objecttype_mesh = nil
sim.objecttype_scene = nil
sim.objecttype_sceneobject = nil
sim.objecttype_script = nil
sim.objecttype_texture = nil

sim.parentingmode_assembly = nil
sim.parentingmode_keeplocalpose = nil
sim.parentingmode_keepworldpose = nil

sim.plugininfo_builddatestr = nil
sim.plugininfo_extversionint = nil
sim.plugininfo_extversionstr = nil
sim.plugininfo_statusbarverbosity = nil
sim.plugininfo_verbosity = nil

sim.primitiveshape_capsule = nil
sim.primitiveshape_cone = nil
sim.primitiveshape_cuboid = nil
sim.primitiveshape_cylinder = nil
sim.primitiveshape_disc = nil
sim.primitiveshape_heightfield = nil
sim.primitiveshape_none = nil
sim.primitiveshape_plane = nil
sim.primitiveshape_spheroid = nil

sim.ruckig_minaccel = nil
sim.ruckig_minvel = nil

sim.sceneobject_camera = nil
sim.sceneobject_customsceneobject = nil
sim.sceneobject_dummy = nil
sim.sceneobject_forcesensor = nil
sim.sceneobject_graph = nil
sim.sceneobject_joint = nil
sim.sceneobject_light = nil
sim.sceneobject_marker = nil
sim.sceneobject_mill = nil
sim.sceneobject_mirror = nil
sim.sceneobject_octree = nil
sim.sceneobject_path = nil
sim.sceneobject_pointcloud = nil
sim.sceneobject_proximitysensor = nil
sim.sceneobject_renderingsensor = nil
sim.sceneobject_script = nil
sim.sceneobject_shape = nil
sim.sceneobject_visionsensor = nil

sim.scriptintparam_autorestartonerror = nil
sim.scriptintparam_enabled = nil
sim.scriptintparam_execcount = nil
sim.scriptintparam_execorder = nil
sim.scriptintparam_type = nil

sim.scriptstringparam_description = nil
sim.scriptstringparam_lang = nil
sim.scriptstringparam_name = nil
sim.scriptstringparam_nameext = nil
sim.scriptstringparam_text = nil

sim.shape_compound = nil
sim.shape_simple = nil

sim.stackitem_bool = nil
sim.stackitem_color = nil
sim.stackitem_double = nil
sim.stackitem_func = nil
sim.stackitem_handle = nil
sim.stackitem_handlearray = nil
sim.stackitem_integer = nil
sim.stackitem_lightuserdat = nil
sim.stackitem_matrix = nil
sim.stackitem_null = nil
sim.stackitem_pose = nil
sim.stackitem_quaternion = nil
sim.stackitem_string = nil
sim.stackitem_table = nil
sim.stackitem_thread = nil
sim.stackitem_userdat = nil

sim.stream_transf_cumulative = nil
sim.stream_transf_derivative = nil
sim.stream_transf_integral = nil
sim.stream_transf_raw = nil

sim.textureapplymode_add = nil
sim.textureapplymode_decal = nil
sim.textureapplymode_modulate = nil

sim.texturemap_cube = nil
sim.texturemap_cylinder = nil
sim.texturemap_plane = nil
sim.texturemap_sphere = nil

sim.volume_cone = nil
sim.volume_cylinder = nil
sim.volume_disc = nil
sim.volume_pyramid = nil
sim.volume_randomizedray = nil
sim.volume_ray = nil

sim.appflavor_edu = nil
sim.appflavor_lite = nil
sim.appflavor_pro = nil

sim.dummytype_assembly = nil
sim.dummytype_default = nil
sim.dummytype_dynloopclosure = nil
sim.dummytype_dyntendon = nil

sim.handle.world = nil
sim.handle_world = nil

sim.jointType = nil
sim.lightType = nil
sim.markerOptions = nil
sim.materialComponent = nil
sim.parentingMode = nil
sim.propertyReturns = nil

sim.jointdynctrl_callback = nil
sim.jointdynctrl_force = nil
sim.jointdynctrl_free = nil
sim.jointdynctrl_position = nil
sim.jointdynctrl_spring = nil
sim.jointdynctrl_velocity = nil
sim.jointmode_dependent = nil
sim.jointmode_dynamic = nil
sim.jointmode_kinematic = nil

sim.handle_all_except_explicit = nil
sim.handle_all_except_self = nil

sim.headlessmode_disabled = nil
sim.headlessmode_emulated = nil
sim.headlessmode_enabled = nil

sim.codeLang = nil
sim.dummyType = nil

sim.lang_lua = nil
sim.lang_python = nil
sim.lang_undefined = nil
sim.light_directional = nil
sim.light_omnidirectional = nil
sim.light_spot = nil
sim.markertype_axes = nil
sim.markertype_cubes = nil
sim.markertype_custom = nil
sim.markertype_cylinders = nil
sim.markertype_discs = nil
sim.markertype_lines = nil
sim.markertype_points = nil
sim.markertype_spheres = nil
sim.markertype_squares = nil
sim.markertype_triangles = nil
sim.markertype_tubes = nil
sim.object_scriptend = nil
sim.object_scriptstart = nil
sim.physics_bullet = nil
sim.physics_drake = nil
sim.physics_mujoco = nil
sim.physics_newton = nil
sim.physics_ode = nil
sim.physics_vortex = nil
sim.platform_linux = nil
sim.platform_macos = nil
sim.platform_windows = nil

sim.proximitySensorType = nil
sim.sceneObjectType = nil

sim.shapeType = nil

sim.proximitysensor_cone = nil
sim.proximitysensor_cylinder = nil
sim.proximitysensor_disc = nil
sim.proximitysensor_pyramid = nil
sim.proximitysensor_ray = nil

sim.sceneobject_scriptobject = nil

sim.scriptexecorder_first = nil
sim.scriptexecorder_last = nil
sim.scriptexecorder_normal = nil

sim.scriptstate_ended = nil
sim.scriptstate_error = nil
sim.scriptstate_initialized = nil
sim.scriptstate_suspended = nil
sim.scriptstate_uninitialized = nil
sim.scriptstate_unloaded = nil

sim.scripttype_addon = nil
sim.scripttype_customization = nil
sim.scripttype_main = nil
sim.scripttype_passive = nil
sim.scripttype_sandbox = nil
sim.scripttype_simulation = nil

sim.simulation_lastbeforestop = nil
sim.simulation_paused = nil
sim.simulation_running = nil
sim.simulation_stopped = nil

--]]
return sim