You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
435 lines
8.5 KiB
Lua
435 lines
8.5 KiB
Lua
local ecs = require "ecs.core"
|
|
|
|
local REFERENCE_ID <const> = 1
|
|
|
|
local function get_attrib(opt, inout)
|
|
if opt == nil then
|
|
return { exist = true }
|
|
end
|
|
local desc = {}
|
|
if opt == "?" then
|
|
desc.opt = true
|
|
else
|
|
assert(opt == ":")
|
|
end
|
|
if inout == "in" then
|
|
desc.r = true
|
|
elseif inout == "out" then
|
|
desc.w = true
|
|
elseif inout == "update" then
|
|
desc.r = true
|
|
desc.w = true
|
|
elseif inout == "exist" then
|
|
desc.exist = true
|
|
assert(not desc.opt)
|
|
elseif inout == "absent" then
|
|
desc.absent = true
|
|
assert(not desc.opt)
|
|
else
|
|
assert(inout == "temp")
|
|
end
|
|
return desc
|
|
end
|
|
|
|
local function cache_world(obj, k)
|
|
local c = {
|
|
typenames = {},
|
|
id = 0,
|
|
select = {},
|
|
ref = {},
|
|
}
|
|
|
|
local function gen_ref_pat(key)
|
|
local typenames = c.typenames
|
|
local desc = {}
|
|
local tc = typenames[key]
|
|
if tc == nil then
|
|
error("Unknown type " .. key)
|
|
end
|
|
local a = {
|
|
exist = true,
|
|
name = tc.name,
|
|
id = tc.id,
|
|
type = tc.type,
|
|
}
|
|
local n = #tc
|
|
for i=1,#tc do
|
|
a[i] = tc[i]
|
|
end
|
|
desc[1] = a
|
|
return desc
|
|
end
|
|
|
|
local function gen_all_pat()
|
|
local desc = {}
|
|
local i = 1
|
|
for name,t in pairs(c.typenames) do
|
|
if t.tag ~= "ORDER" then
|
|
local a = {
|
|
name = t.name,
|
|
id = t.id,
|
|
type = t.type,
|
|
opt = true,
|
|
r = true,
|
|
}
|
|
table.move(t, 1, #t, 1, a)
|
|
desc[i] = a
|
|
i = i + 1
|
|
end
|
|
end
|
|
return desc
|
|
end
|
|
|
|
setmetatable(c, { __index = function(_, key)
|
|
if key == "all" then
|
|
local all = k:_groupiter(gen_all_pat())
|
|
c.all = all
|
|
return all
|
|
end
|
|
end })
|
|
|
|
local function gen_select_pat(pat)
|
|
local typenames = c.typenames
|
|
local desc = {}
|
|
local idx = 1
|
|
for token in pat:gmatch "[^ ]+" do
|
|
local key, index, padding = token:match "^([_%w]+)%(?([_%w]*)%)?(.*)"
|
|
assert(key, "Invalid pattern")
|
|
local opt, inout
|
|
if padding ~= "" then
|
|
opt, inout = padding:match "^([:?])(%l+)$"
|
|
assert(opt, "Invalid pattern")
|
|
end
|
|
local tc = typenames[key]
|
|
if tc == nil then
|
|
error("Unknown type " .. key)
|
|
end
|
|
if index ~= "" then
|
|
local indexc = typenames[index]
|
|
if indexc == nil then
|
|
error("Unknown index type "..index)
|
|
end
|
|
local a = get_attrib(opt, inout == "temp" and "temp" or "in")
|
|
a.name = index
|
|
a.id = indexc.id
|
|
a.type = indexc.type
|
|
a.ref = true
|
|
desc[idx] = a
|
|
idx = idx + 1
|
|
end
|
|
local a = get_attrib(opt, inout)
|
|
a.name = tc.name
|
|
a.id = tc.id
|
|
a.type = tc.type
|
|
local n = #tc
|
|
for i=1,#tc do
|
|
a[i] = tc[i]
|
|
end
|
|
desc[idx] = a
|
|
idx = idx + 1
|
|
if tc.ref and index == "" then
|
|
local dead = typenames[key .. "_dead"]
|
|
local a = {
|
|
absent = true,
|
|
name = dead.name,
|
|
id = dead.id,
|
|
}
|
|
desc[idx] = a
|
|
idx = idx + 1
|
|
end
|
|
end
|
|
return desc
|
|
end
|
|
|
|
local function cache_select(cache, pat)
|
|
local pat_desc = gen_select_pat(pat)
|
|
cache[pat] = k:_groupiter(pat_desc)
|
|
return cache[pat]
|
|
end
|
|
|
|
setmetatable(c.select, {
|
|
__mode = "kv",
|
|
__index = cache_select,
|
|
})
|
|
|
|
local function cache_ref(cache, pat)
|
|
local pat_desc = gen_ref_pat(pat)
|
|
cache[pat] = k:_groupiter(pat_desc)
|
|
return cache[pat]
|
|
end
|
|
|
|
setmetatable(c.ref, {
|
|
__mode = "kv",
|
|
__index = cache_ref,
|
|
})
|
|
|
|
obj[k] = c
|
|
return c
|
|
end
|
|
|
|
local context = setmetatable({}, { __index = cache_world })
|
|
local typeid = {
|
|
int = assert(ecs._TYPEINT),
|
|
float = assert(ecs._TYPEFLOAT),
|
|
bool = assert(ecs._TYPEBOOL),
|
|
int64 = assert(ecs._TYPEINT64),
|
|
dword = assert(ecs._TYPEDWORD),
|
|
word = assert(ecs._TYPEWORD),
|
|
byte = assert(ecs._TYPEBYTE),
|
|
double = assert(ecs._TYPEDOUBLE),
|
|
userdata = assert(ecs._TYPEUSERDATA),
|
|
}
|
|
local typesize = {
|
|
[typeid.int] = 4,
|
|
[typeid.float] = 4,
|
|
[typeid.bool] = 1,
|
|
[typeid.int64] = 8,
|
|
[typeid.dword] = 4,
|
|
[typeid.word] = 2,
|
|
[typeid.byte] = 1,
|
|
[typeid.double] = 8,
|
|
[typeid.userdata] = 8,
|
|
}
|
|
|
|
local M = ecs._METHODS
|
|
|
|
do -- newtype
|
|
local function parse(s)
|
|
-- s is "name:typename"
|
|
local name, typename = s:match "^([%w_]+):(%w+)$"
|
|
local typeid = assert(typeid[typename])
|
|
return { typeid, name }
|
|
end
|
|
|
|
local function align(c, field)
|
|
local t = field[1]
|
|
local tsize = typesize[t]
|
|
local offset = ((c.size + tsize - 1) & ~(tsize-1))
|
|
c.size = offset + tsize
|
|
field[3] = offset
|
|
return field
|
|
end
|
|
|
|
local function align_struct(c, t)
|
|
if t then
|
|
local s = typesize[t] - 1
|
|
c.size = ((c.size + s) & ~s)
|
|
end
|
|
end
|
|
|
|
function M:register(typeclass)
|
|
local name = assert(typeclass.name)
|
|
local ctx = context[self]
|
|
ctx.all = nil -- clear all pattern
|
|
local typenames = ctx.typenames
|
|
local id = ctx.id + 1
|
|
assert(typenames[name] == nil and id <= ecs._MAXTYPE)
|
|
ctx.id = id
|
|
local c = {
|
|
id = id,
|
|
name = name,
|
|
size = 0,
|
|
}
|
|
for i, v in ipairs(typeclass) do
|
|
c[i] = align(c, parse(v))
|
|
end
|
|
local ttype = typeclass.type
|
|
if ttype == "lua" then
|
|
assert(c.size == 0)
|
|
c.size = ecs._LUAOBJECT
|
|
assert(c[1] == nil)
|
|
elseif c.size > 0 then
|
|
align_struct(c, typeclass[1][1])
|
|
else
|
|
-- size == 0, one value
|
|
if ttype then
|
|
local t = assert(typeid[typeclass.type])
|
|
c.type = t
|
|
c.size = typesize[t]
|
|
c[1] = { t, "v", 0 }
|
|
elseif typeclass.order then
|
|
c.size = ecs._ORDERKEY
|
|
c.tag = "ORDER"
|
|
else
|
|
c.tag = true
|
|
end
|
|
end
|
|
typenames[name] = c
|
|
self:_newtype(id, c.size)
|
|
if typeclass.ref then
|
|
c.ref = true
|
|
self:register { name = name .. "_dead" }
|
|
end
|
|
end
|
|
end
|
|
|
|
local function dump(obj)
|
|
for e,v in pairs(obj) do
|
|
if type(v) == "table" then
|
|
for k,v in pairs(v) do
|
|
print(e,k,v)
|
|
end
|
|
else
|
|
print(e,v)
|
|
end
|
|
end
|
|
end
|
|
|
|
function M:new(obj)
|
|
-- dump(obj)
|
|
local eid = self:_newentity()
|
|
local typenames = context[self].typenames
|
|
local reference = obj.reference
|
|
if reference then
|
|
obj.reference = nil
|
|
end
|
|
for k,v in pairs(obj) do
|
|
local tc = typenames[k]
|
|
if not tc then
|
|
error ("Invalid key : ".. k)
|
|
end
|
|
local id = self:_addcomponent(eid, tc.id)
|
|
if tc.tag ~= "ORDER" then
|
|
self:object(k, id, v)
|
|
end
|
|
end
|
|
if reference then
|
|
local id = self:_addcomponent(eid, REFERENCE_ID)
|
|
reference[1] = id
|
|
reference[2] = REFERENCE_ID
|
|
self:object("reference", id, reference)
|
|
obj.reference = reference
|
|
return reference
|
|
end
|
|
end
|
|
|
|
function M:ref(name, refobj)
|
|
local obj = assert(refobj[name])
|
|
local ctx = context[self]
|
|
local typenames = ctx.typenames
|
|
local tc = assert(typenames[name])
|
|
local refid = self:_reuse(tc.id)
|
|
refobj[2] = tc.id
|
|
if refid then
|
|
local p = context[self].select[name .. ":out"]
|
|
refobj[1] = refid
|
|
self:_sync(p, refobj)
|
|
else
|
|
local eid = self:_newentity()
|
|
refid = self:_addcomponent(eid, tc.id)
|
|
refobj[1] = refid
|
|
self:object(name, refid, obj)
|
|
end
|
|
for k,v in pairs(refobj) do
|
|
if (v == true or v == false) and name ~= k then
|
|
local p = context[self].select[k .. "?out"]
|
|
self:_sync(p, refobj)
|
|
end
|
|
end
|
|
return refid
|
|
end
|
|
|
|
function M:object_ref(name, refid)
|
|
local typenames = context[self].typenames
|
|
return { refid, typenames[name].id }
|
|
end
|
|
|
|
function M:release(name, refid)
|
|
local id = assert(context[self].typenames[name].id)
|
|
self:_release(id, refid)
|
|
end
|
|
|
|
function M:context(t)
|
|
local typenames = context[self].typenames
|
|
local id = {}
|
|
for i, name in ipairs(t) do
|
|
local tc = typenames[name]
|
|
if not tc then
|
|
error ("Invalid component name " .. name)
|
|
end
|
|
id[i] = tc.id
|
|
end
|
|
return self:_context(id)
|
|
end
|
|
|
|
function M:select(pat)
|
|
return context[self].select[pat]()
|
|
end
|
|
|
|
function M:sync(pat, iter)
|
|
local p = context[self].select[pat]
|
|
self:_sync(p, iter)
|
|
return iter
|
|
end
|
|
|
|
function M:readall(iter)
|
|
local p = context[self].all
|
|
self:_sync(p, iter)
|
|
return iter
|
|
end
|
|
|
|
function M:clear(name)
|
|
local id = assert(context[self].typenames[name].id)
|
|
self:_clear(id)
|
|
end
|
|
|
|
function M:dumpid(name)
|
|
local typenames = context[self].typenames
|
|
return self:_dumpid(typenames[name].id)
|
|
end
|
|
|
|
function M:update()
|
|
self:_update_reference(REFERENCE_ID)
|
|
self:_update()
|
|
end
|
|
|
|
function M:remove_reference(ref)
|
|
ref.reference = false
|
|
self:sync("reference:out", ref)
|
|
ref[1] = nil
|
|
end
|
|
|
|
do
|
|
local _object = M._object
|
|
function M:object(name, refid, v)
|
|
local pat = context[self].ref[name]
|
|
return _object(pat, v, refid)
|
|
end
|
|
|
|
function M:singleton(name, pattern, iter)
|
|
local typenames = context[self].typenames
|
|
if iter == nil then
|
|
iter = { 1, typenames[name].id }
|
|
if pattern then
|
|
local p = context[self].select[pattern]
|
|
self:_sync(p, iter)
|
|
end
|
|
return iter
|
|
else
|
|
iter[1] = 1
|
|
iter[2] = typenames[name].id
|
|
local p = context[self].select[pattern]
|
|
self:_sync(p, iter)
|
|
end
|
|
return iter
|
|
end
|
|
end
|
|
|
|
function ecs.world()
|
|
local w = ecs._world()
|
|
context[w].typenames.REMOVED = {
|
|
name = "REMOVED",
|
|
id = ecs._REMOVED,
|
|
size = 0,
|
|
tag = true,
|
|
}
|
|
w:register {
|
|
name = "reference",
|
|
type = "lua",
|
|
}
|
|
assert(context[w].typenames.reference.id == REFERENCE_ID)
|
|
return w
|
|
end
|
|
|
|
return ecs
|