summaryrefslogtreecommitdiff
path: root/honey/ecs
diff options
context:
space:
mode:
Diffstat (limited to 'honey/ecs')
-rw-r--r--honey/ecs/collision.lua57
-rw-r--r--honey/ecs/ecs.lua274
-rw-r--r--honey/ecs/ecs.test.lua280
-rw-r--r--honey/ecs/node.lua47
-rw-r--r--honey/ecs/physics.lua158
-rw-r--r--honey/ecs/render.lua98
-rw-r--r--honey/ecs/script.lua44
7 files changed, 958 insertions, 0 deletions
diff --git a/honey/ecs/collision.lua b/honey/ecs/collision.lua
new file mode 100644
index 0000000..722c256
--- /dev/null
+++ b/honey/ecs/collision.lua
@@ -0,0 +1,57 @@
+local glm = require 'honey.glm'
+local Vec3 = glm.Vec3
+local ode = honey.ode
+
+local module = {}
+setmetatable(module, {__index=_G})
+setfenv(1, module)
+
+
+--===== collision space =====--
+
+
+local function createGeom(self, id, collision)
+ local geom
+ if collision.class == "sphere" then
+ geom = ode.CreateSphere(self.space, collision.radius)
+ elseif collision.class == "capsule" then
+ geom = ode.CreateCapsule(self.space, collision.radius, collision.length)
+ elseif collision.class == "plane" then
+ local node = self.db:getComponent(id, "node")
+ local m = node.matrix
+ local normal = node.matrix:mulv3(Vec3{0,1,0}):normalize()
+ local position = Vec3{m[1][4], m[2][4], m[3][4]}
+ print(position)
+ local d = normal:dot(position)
+ print(normal, d)
+ geom = ode.CreatePlane(self.space, normal[1], normal[2], normal[3], d)
+ end
+ collision._geom = geom
+ collision._gc = honey.util.gc_canary(function()
+ print("release geom for id"..id)
+ ode.GeomDestroy(geom)
+ end)
+end
+
+system = function(params)
+ local db = params.db
+ local space = params.space
+ return {
+ db=db,
+ space=space,
+ priority=0,
+ update = function(self, dt)
+ local query = self.db:queryComponent("collision")
+ for id, collision in pairs(query) do
+ if not collision._geom then
+ createGeom(self, id, collision)
+ print(id, collision._geom)
+ end
+ end
+ end
+ }
+end
+
+
+
+return module
diff --git a/honey/ecs/ecs.lua b/honey/ecs/ecs.lua
new file mode 100644
index 0000000..b0409e4
--- /dev/null
+++ b/honey/ecs/ecs.lua
@@ -0,0 +1,274 @@
+math.randomseed(os.time())
+
+local glm = require 'honey.glm'
+
+local module = {}
+setmetatable(module, {__index=_G})
+setfenv(1, module)
+
+
+--===== EntityDb =====--
+
+
+-- EntityDb is a database of entities and their associated components
+-- it should be quite efficient to query for all entities with a given component, and reasonably
+-- efficient to query for all components of a given entity
+
+
+EntityDb = {}
+EntityDb.__index = EntityDb
+
+
+function EntityDb.new(_)
+ local self = {
+ entities = {},
+ components = {},
+ }
+ setmetatable(self, EntityDb)
+ return self
+end
+setmetatable(EntityDb, {__call=EntityDb.new})
+
+
+local function serialize(tbl)
+ local tostr = function(x, value)
+ if type(x) == "table" then
+ if x.__tostring then
+ return tostring(x)
+ else
+ return serialize(x)
+ end
+ elseif type(x) == "string" then
+ if value then
+ return string.format("\"%s\"", x)
+ else
+ return x
+ end
+ else
+ return tostring(x)
+ end
+ end
+ local str = "{"
+ for key, value in pairs(tbl) do
+ if type(key) == "string" and string.match(key, "^_") then
+ -- ignore keys starting with an underscore
+ else
+ str = str .. string.format("%s=%s,", tostr(key), tostr(value, true))
+ end
+ end
+ str = string.sub(str, 1, -2) .. "}"
+ return str
+end
+
+
+-- save current database to file
+function EntityDb.save(self, filename)
+ local file, err = io.open(filename, "w")
+ if not file then error(err) end
+
+ for entity in pairs(self.entities) do
+ local components = self:queryEntity(entity)
+ file:write(string.format("Entity(\"%s\", %s)\n", entity, serialize(components)))
+ end
+
+ file:close()
+end
+
+
+-- load database from file
+function EntityDb.load(self, filename)
+ print(collectgarbage("count"))
+ self.entities = {}
+ self.components = {}
+ collectgarbage()
+ print(collectgarbage("count"))
+ local env = {
+ Entity = function(id, components)
+ self:createEntity(id)
+ self:addComponents(id, components)
+ end,
+ Vec3 = glm.Vec3,
+ Mat4 = glm.Mat4,
+ }
+ local f, err = loadfile(filename)
+ if not f then error(err) end
+ setfenv(f, env)
+ f()
+end
+
+
+-- check if a given entity id is legitimate
+function EntityDb.checkIsValid(self, id)
+ if not self.entities[id] then
+ error(string.format("invalid entity id: %s", tostring(id)))
+ end
+end
+
+
+local random = math.random
+local function uuid()
+ local template ='xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'
+ return string.gsub(template, '[xy]', function (c)
+ local v = (c == 'x') and random(0, 0xf) or random(8, 0xb)
+ return string.format('%x', v)
+ end)
+end
+
+
+-- create a new entity
+function EntityDb.createEntity(self, id)
+ local id = id or uuid() -- allow inserting entities at preset ids for loading
+ self.entities[id] = true
+ return id
+end
+
+
+-- add a component to an entity
+function EntityDb.addComponent(self, id, name, value)
+ self:checkIsValid(id)
+
+ -- create the relevant component table if it doesn't exist
+ if not self.components[name] then
+ self.components[name] = { count=0, data={} }
+ end
+
+ local component = self.components[name]
+ component.data[id] = value
+ component.count = component.count + 1
+end
+
+
+-- add multiple components at once, for convenience
+function EntityDb.addComponents(self, id, components)
+ for name, value in pairs(components) do
+ self:addComponent(id, name, value)
+ end
+end
+
+
+-- create an entity with components
+function EntityDb.createEntityWithComponents(self, components)
+ local id = self:createEntity()
+ self:addComponents(id, components)
+ return id
+end
+
+
+-- get all entities with a given component
+function EntityDb.queryComponent(self, name)
+ local component = self.components[name]
+ if component then
+ return component.data
+ else
+ return {}
+ end
+end
+
+
+-- get all components associated with an entity
+function EntityDb.queryEntity(self, id)
+ self:checkIsValid(id)
+ local query = {}
+ for name, component in pairs(self.components) do
+ query[name] = component.data[id]
+ end
+ return query
+end
+
+
+-- get a specific component from an entity
+function EntityDb.getComponent(self, id, name)
+ self:checkIsValid(id)
+ return self.components[name].data[id]
+end
+
+
+-- remove a component from an entity
+function EntityDb.removeComponent(self, id, name)
+ self:checkIsValid(id)
+ local component = self.components[name]
+ if component.data[id] ~= nil then
+ component.data[id] = nil
+ component.count = component.count - 1
+ if component.count == 0 then
+ self.components[name] = nil
+ end
+ end
+end
+
+
+-- remove an entity from the db
+function EntityDb.deleteEntity(self, id)
+ self:checkIsValid(id)
+ for name in pairs(self.components) do
+ self:removeComponent(id, name)
+ end
+ self.entities[id] = nil
+end
+
+
+--===== SystemDb =====--
+
+SystemDb = {}
+SystemDb.__index = SystemDb
+
+
+function SystemDb.new(_, entityDb)
+ local self = {
+ systems = {},
+ sorted = {},
+ entityDb = entityDb,
+ }
+ setmetatable(self, SystemDb)
+ return self
+end
+setmetatable(SystemDb, {__call=SystemDb.new})
+
+
+local function systemId()
+ local template = "xx:xx:xx"
+ return string.gsub(template, "x", function(c)
+ return string.format("%x", random(0, 0xf))
+ end)
+end
+
+
+function SystemDb.addSystem(self, systemFunc, params)
+ local system
+ if type(systemFunc) == "table" then
+ system = systemFunc
+ else
+ local params = params or {}
+ params.db = self.entityDb
+ system = systemFunc(params)
+ end
+
+ local id = systemId()
+ self.systems[id] = system
+ table.insert(self.sorted, id)
+ self:sort()
+ return id
+end
+
+
+function SystemDb.sort(self)
+ table.sort(self.sorted, function(a, b) return (self.systems[a].priority or 100) < (self.systems[b].priority or 100) end)
+end
+
+
+function SystemDb.update(self, dt)
+ for _, system in ipairs(self.sorted) do
+ self.systems[system]:update(dt)
+ end
+end
+
+
+function SystemDb.removeSystem(self, id)
+ self.systems[id] = nil
+ for i=#self.sorted,1,-1 do
+ if self.sorted[i] == id then table.remove(self.sorted, i) end
+ end
+end
+
+
+return module
diff --git a/honey/ecs/ecs.test.lua b/honey/ecs/ecs.test.lua
new file mode 100644
index 0000000..74e27dc
--- /dev/null
+++ b/honey/ecs/ecs.test.lua
@@ -0,0 +1,280 @@
+local testCount = 0
+local failCount = 0
+
+local function test(msg, f)
+ testCount = testCount + 1
+ local success, error = xpcall(f, debug.traceback)
+ if success then
+ print(msg .. "\t\t[OK]")
+ else
+ failCount = failCount + 1
+ print(msg .. "\t\t[FAIL]")
+ print(error)
+ end
+end
+
+
+local ecs = require 'ecs'
+
+
+--===== Component tests =====--
+
+local Component = ecs.Component
+
+test("factories work as expected", function()
+ local factory = Component.newFactory("health", { percent=100 })
+ local comp1 = factory()
+ assert(comp1.__type == "health", "bad component type for comp1")
+ assert(comp1.percent == 100, "bat percent for comp1")
+
+ local comp2 = factory{ percent=50 }
+ assert(comp2.__type == "health", "bad component type for comp2")
+ assert(comp2.percent == 50, "bad percent for comp2")
+
+ local success = pcall(function()
+ comp2.dne = 5
+ end)
+ assert(not success, "incorrectly succeeded in setting comp2.dne")
+
+ local success = pcall(function()
+ local comp3 = factory{ percent = 44, something = 2 }
+ end)
+ assert(not success, "incorrectly succeeded in creating comp3")
+end)
+
+
+test("components serialize as expected", function()
+ local position = Component.newFactory("position", { x=0, y=0, z=0 })
+ local comp = position{x=10, y=15, z=10}
+ local str = tostring(comp)
+ local tbl = (loadstring("return " .. str))()
+ assert(tbl.__type == "position", "bad type")
+ assert(tbl.x == 10, "bad x")
+ assert(tbl.y == 15, "bad y")
+ assert(tbl.z == 10, "bad z")
+end)
+
+
+test("components serialize successfully with subcomponents", function()
+ local position = Component.newFactory("position", { x=0, y=0, z=0 })
+ local player = Component.newFactory("player", { name="", position={} })
+
+ local p = player{ name="hannah", position=position{x=10, y=9, z=8} }
+ local tbl = (loadstring("return " .. tostring(p)))()
+ assert(tbl.__type == "player")
+ assert(tbl.name == "hannah")
+ assert(tbl.position.__type == "position")
+ assert(tbl.position.x == 10)
+ assert(tbl.position.y == 9)
+ assert(tbl.position.z == 8)
+end)
+
+
+--===== EntityDb tests =====--
+
+local EntityDb = ecs.EntityDb
+
+
+test("EntityDb.createEntity() always returns a new id", function()
+ local db = EntityDb()
+
+ local ids = {}
+ for i=1,100 do
+ local id = db:createEntity()
+ assert(ids[id] == nil, "id was already returned!")
+ ids[id] = true
+ end
+end)
+
+
+test("EntityDb.queryComponent() gets all entities with a given component", function()
+ local db = EntityDb()
+
+ local ids = {}
+ for i=1,100 do
+ local id = db:createEntity()
+ if i%2==0 then
+ ids[id] = 5*i
+ db:addComponent(id, "number", 5*i)
+ end
+ end
+
+ local query = db:queryComponent("number")
+ local count = 0
+ for id, number in pairs(query) do
+ count = count + 1
+ assert(number == ids[id])
+ end
+ assert(count == 50)
+end)
+
+
+test("EntityDb.queryEntity() gets all components associated with an entity", function()
+ local db = EntityDb()
+
+ local entity
+ for i=1,100 do
+ local id = db:createEntity()
+ if i%2 == 0 then db:addComponent(id, "number", 2) end
+ if i%3 == 0 then db:addComponent(id, "string", "hello") end
+ if i%5 == 0 then db:addComponent(id, "number2", 4) end
+ if i%7 == 0 then db:addComponent(id, "string2", "world") end
+ if i == 30 then entity=id end
+ end
+
+ local query = db:queryEntity(entity)
+ assert(query.number == 2)
+ assert(query.string == "hello")
+ assert(query.number2 == 4)
+ assert(query.string2 == nil)
+end)
+
+
+test("EntityDb.removeComponent() removes components correctly", function()
+ local db = EntityDb()
+
+ local id = db:createEntity()
+ db:addComponent(id, "number", 2)
+ db:addComponent(id, "string", "hello")
+ db:addComponent(id, "number2", 4)
+ db:addComponent(id, "string2", "world")
+
+ local query = db:queryEntity(id)
+ assert(query.number == 2)
+ assert(query.string == "hello")
+ assert(query.number2 == 4)
+ assert(query.string2 == "world")
+
+ db:removeComponent(id, "string2")
+ query = db:queryEntity(id)
+ assert(query.number == 2)
+ assert(query.string == "hello")
+ assert(query.number2 == 4)
+ assert(query.string2 == nil)
+
+ db:removeComponent(id, "number2")
+ query = db:queryEntity(id)
+ assert(query.number == 2)
+ assert(query.string == "hello")
+ assert(query.number2 == nil)
+ assert(query.string2 == nil)
+
+ db:removeComponent(id, "string")
+ query = db:queryEntity(id)
+ assert(query.number == 2)
+ assert(query.string == nil)
+ assert(query.number2 == nil)
+ assert(query.string2 == nil)
+
+ db:removeComponent(id, "number")
+ query = db:queryEntity(id)
+ assert(query.number == nil)
+ assert(query.string == nil)
+ assert(query.number2 == nil)
+ assert(query.string2 == nil)
+end)
+
+
+test("EntityDb.removeComponent() deletes component table when empty", function()
+ local db = EntityDb()
+ local id1 = db:createEntity()
+ local id2 = db:createEntity()
+ db:addComponent(id1, "number", 2)
+ db:addComponent(id2, "number", 3)
+
+ assert(db.components.number ~= nil)
+ db:removeComponent(id1, "number")
+ assert(db.components.number ~= nil)
+ db:removeComponent(id2, "number")
+ assert(db.components.number == nil)
+end)
+
+
+test("EntityDb.removeComponent() does nothing if the component is not present", function()
+ local db = EntityDb()
+ local id1 = db:createEntity()
+ local id2 = db:createEntity()
+ db:addComponent(id1, "number", 2)
+ db:addComponent(id2, "number", 3)
+
+ assert(db.components.number ~= nil)
+ db:removeComponent(id1, "number")
+ assert(db.components.number ~= nil)
+ db:removeComponent(id1, "number")
+ assert(db.components.number ~= nil)
+
+ db:removeComponent(id2, "number")
+ assert(db.components.number == nil)
+
+end)
+
+
+test("EntityDb.deleteEntity() correctly removes an entity", function()
+ local db = EntityDb()
+ local id1 = db:createEntity()
+ local id2 = db:createEntity()
+ db:addComponent(id1, "number", 2)
+ db:addComponent(id2, "number", 3)
+
+ local query = db:queryComponent("number")
+ assert(query[id1] and query[id2])
+ db:deleteEntity(id1)
+ query = db:queryComponent("number")
+ assert(query[id1] == nil)
+ assert(query[id2] ~= nil)
+
+ assert(false == pcall(function()
+ local query = db:queryEntity(id1)
+ end))
+end)
+
+
+--===== SystemDb tests =====--
+
+local SystemDb = ecs.SystemDb
+
+test("addSystem() correctly sorts systems", function()
+ local sdb = SystemDb(nil)
+ local str = ""
+ sdb:addSystem(function () return {
+ update=function(self, dt) str = str .. "c" end,
+ priority = 3,
+ } end)
+ sdb:addSystem{
+ update=function(self, dt) str = "a" end,
+ priority = 1,
+ }
+ sdb:addSystem{
+ update=function(self, dt) str = str .. "b" end,
+ priority = 2,
+ }
+ sdb:update(0)
+ assert(str == "abc")
+end)
+
+
+test("removeSystem() correctly handles things", function()
+ local sdb = SystemDb(nil)
+ local str = ""
+ sdb:addSystem(function () return {
+ update=function(self, dt) str = str .. "c" end,
+ priority = 3,
+ } end)
+ sdb:addSystem{
+ update=function(self, dt) str = "a" end,
+ priority = 1,
+ }
+ local id = sdb:addSystem{
+ update=function(self, dt) str = str .. "b" end,
+ priority = 2,
+ }
+ sdb:update(0)
+ assert(str == "abc")
+
+ sdb:removeSystem(id)
+ sdb:update(1)
+ assert(str == "ac")
+end)
+
+
+print(string.format("ran %d tests, %d failed", testCount, failCount))
diff --git a/honey/ecs/node.lua b/honey/ecs/node.lua
new file mode 100644
index 0000000..39f1898
--- /dev/null
+++ b/honey/ecs/node.lua
@@ -0,0 +1,47 @@
+local module = {}
+setmetatable(module, {__index=_G})
+setfenv(1, module)
+
+--===== transform cascading =====--
+
+system = function(params)
+ return {
+ db = params.db,
+
+ priority = 2,
+ update = function(self, dt)
+ local nodes = self.db:queryComponent("node")
+
+ -- prepare nodes
+ for id, node in pairs(nodes) do
+ node._visited = false
+ end
+
+ -- helper function
+ local function recursiveTransform(node)
+ if node._visited then
+ return node._matrix
+ end
+
+ if not node.parent then
+ node._matrix = node.matrix
+ else
+ local parentTransform = self.db:getComponent(node.parent, "node")
+ local parentMatrix = recursiveTransform(parentTransform)
+ node._matrix = parentMatrix * node.matrix
+ end
+ node._visited = true
+ return node._matrix
+ end
+
+ -- compute nodes
+ for id, node in pairs(nodes) do
+ recursiveTransform(node)
+ end
+ end,
+ }
+end
+
+
+
+return module
diff --git a/honey/ecs/physics.lua b/honey/ecs/physics.lua
new file mode 100644
index 0000000..eac3846
--- /dev/null
+++ b/honey/ecs/physics.lua
@@ -0,0 +1,158 @@
+local glm = require 'honey.glm'
+local Vec3 = glm.Vec3
+local Mat4 = glm.Mat4
+local Quaternion = glm.Quaternion
+local ode = honey.ode
+
+local module = {}
+setmetatable(module, {__index=_G})
+setfenv(1, module)
+
+--===== physics =====--
+
+
+system = function(params)
+ local interval = params.interval or 0.016
+ local groupSize = params.groupSize or 20
+ local refs = {}
+ return {
+ db=params.db,
+ space=params.space,
+ world=params.world,
+ contactGroup=ode.JointGroupCreate(groupSize),
+ time=interval,
+
+ priority=1,
+ update=function(self, dt)
+ for i, ref in ipairs(refs) do
+ print(i, ref.tbl, ref.physics)
+ end
+ local query = self.db:queryComponent("physics")
+
+ for id, physics in pairs(query) do
+ if not physics._body then
+ print("add physics body for "..id)
+ local body = ode.BodyCreate(self.world)
+ physics._gc = honey.util.gc_canary(function()
+ print("releasing physics body for " .. id)
+ ode.BodyDestroy(body)
+ body = nil
+ end)
+
+ local collision = self.db:getComponent(id, "collision")
+ if collision then
+ print(id, collision.class)
+ ode.GeomSetBody(collision._geom, body)
+ end
+
+ local mass = ode.MassCreate()
+ local class = physics.mass.class
+ if not class then
+ -- configure mass manually
+ elseif class == "sphere" then
+ ode.MassSetSphere(
+ mass,
+ physics.mass.density,
+ physics.mass.radius
+ )
+ elseif class == "capsule" then
+ ode.MassSetCapsule(
+ mass,
+ physics.mass.density,
+ physics.mass.direction,
+ physics.mass.radius,
+ physics.mass.length
+ )
+ end
+ ode.BodySetMass(body, mass)
+ local m = self.db:getComponent(id, "node").matrix
+ ode.BodySetPosition(
+ body,
+ m[1][4], m[2][4], m[3][4]
+ )
+ ode.BodySetRotation(
+ body,
+ m[1][1], m[1][2], m[1][3],
+ m[2][1], m[2][2], m[2][3],
+ m[3][1], m[3][2], m[3][3]
+ )
+ local vel = physics.velocity or Vec3{0,0,0}
+ ode.BodySetLinearVel(
+ body, vel[1], vel[2], vel[3]
+ )
+ physics.velocity = vel
+
+ local avel = physics.angularVelocity or Vec3{0,0,0}
+ ode.BodySetAngularVel(
+ body, avel[1], avel[2], avel[3]
+ )
+ physics.angularVelocity = avel
+
+ if physics.maxAngularSpeed then
+ ode.BodySetMaxAngularSpeed(body, physics.maxAngularSpeed)
+ end
+
+ physics._body = body
+ end
+ end
+
+ self.time = self.time + dt
+ -- only run the update every [interval] seconds
+ if self.time > interval then
+ self.time = self.time - interval
+
+ -- check for near collisions between geoms
+ ode.SpaceCollide(self.space, function(a, b)
+ -- check for actual collisions
+ local collisions = ode.Collide(a, b, 1)
+ if #collisions > 0 then
+ -- set up the joint params
+ local contact = ode.CreateContact{ surface={
+ mode = ode.ContactBounce + ode.ContactSoftCFM,
+ mu = ode.Infinity,
+ bounce = 0.90,
+ bounce_vel = 0.1,
+ soft_cfm = 0.001,
+ }}
+ ode.ContactSetGeom(contact, collisions[1])
+ -- create the joint
+ local joint = ode.JointCreateContact(
+ self.world,
+ self.contactGroup,
+ contact
+ )
+ -- attach the two bodies
+ local bodyA = ode.GeomGetBody(a)
+ local bodyB = ode.GeomGetBody(b)
+ ode.JointAttach(joint, bodyA, bodyB)
+ end
+ end)
+ -- update the world
+ ode.WorldQuickStep(self.world, interval)
+ -- remove all contact joints
+ ode.JointGroupEmpty(self.contactGroup)
+
+ -- update entity nodes
+ for id, physics in pairs(query) do
+ local x,y,z = ode.BodyGetPosition(physics._body)
+ local d,a,b,c = ode.BodyGetQuaternion(physics._body)
+ local node = self.db:getComponent(id, "node")
+ local q = Quaternion{a,b,c,d}
+ node.matrix
+ :identity()
+ :translate(Vec3{x,y,z})
+ :mul(Quaternion{a,b,c,d}:toMat4())
+
+ local vel = physics.velocity
+ vel[1], vel[2], vel[3] = ode.BodyGetLinearVel(physics._body)
+ local avel = physics.angularVelocity
+ avel[1], avel[2], avel[3] = ode.BodyGetAngularVel(physics._body)
+ end
+ end
+ end,
+ }
+end
+
+
+
+return module
diff --git a/honey/ecs/render.lua b/honey/ecs/render.lua
new file mode 100644
index 0000000..4217422
--- /dev/null
+++ b/honey/ecs/render.lua
@@ -0,0 +1,98 @@
+local glm = require 'honey.glm'
+local Vec3 = glm.Vec3
+local Mat4 = glm.Mat4
+
+local gl = honey.gl
+local glfw = honey.glfw
+
+local module = {}
+setmetatable(module, {__index=_G})
+setfenv(1, module)
+
+--===== rendering =====--
+
+function draw(model, view, projection, textures, shader, mesh)
+ shader:use()
+
+ -- bind textures
+ local texOffset = 0
+ for name, texTbl in pairs(textures or {}) do
+ local texture = honey.image.loadImage(texTbl.filename, texTbl.params)
+ gl.BindTexture(gl.TEXTURE_2D + texOffset, texture.texture)
+ shader:setInt(name, texOffset)
+ texOffset = texOffset + 1
+ end
+
+ -- configure default uniforms
+ shader:configure{
+ float={
+ time=glfw.GetTime(),
+ },
+ matrix={
+ view=view,
+ projection=projection,
+ model=model,
+ },
+ }
+
+ -- draw mesh
+ mesh:drawElements()
+
+ -- unbind textures
+ for i=0,texOffset-1 do
+ gl.BindTexture(gl.TEXTURE_2D + i, 0)
+ end
+end
+
+system = function(params)
+ return {
+ db = params.db,
+ priority = params.priority or 99,
+ update = function(self, dt)
+ for id, camera in pairs(self.db:queryComponent("camera")) do
+ local projection = camera.projection
+ local cameraTransform = self.db:getComponent(id, "node")
+ local view = Mat4()
+ if cameraTransform then
+ honey.glm.mat4_inv(cameraTransform._matrix.data, view.data)
+ else
+ view:identity()
+ end
+
+ local entities = self.db:queryComponent("renderMesh")
+ for entity, tbl in pairs(entities) do
+ -- get model
+ local node = self.db:getComponent(entity, "node")
+ local model =
+ (node and node._matrix) or
+ Mat4():identity()
+ -- get shader
+ local shader = honey.shader.loadShader(
+ tbl.shader.vertex, tbl.shader.fragment
+ )
+ -- get mesh
+ local mesh = honey.mesh.loadCached(
+ tbl.mesh.filename, tbl.mesh.index
+ )
+ draw(model, view, projection, tbl.textures, shader, mesh)
+ end
+
+ entities = self.db:queryComponent("renderQuad")
+ local quadmesh = honey.mesh.loadCached("builtin.quad", 1)
+ for entity, tbl in pairs(entities) do
+ -- get model
+ local model = Mat4():identity()
+ -- get shader
+ local shader = honey.shader.loadShader(
+ tbl.shader.vertex, tbl.shader.fragment
+ )
+ draw(model, view, projection, tbl.textures, shader, quadmesh)
+ end
+ end
+ end,
+ }
+end
+
+
+
+return module
diff --git a/honey/ecs/script.lua b/honey/ecs/script.lua
new file mode 100644
index 0000000..9ae7d72
--- /dev/null
+++ b/honey/ecs/script.lua
@@ -0,0 +1,44 @@
+local module = {}
+setmetatable(module, {__index=_G})
+setfenv(1, module)
+
+
+-- helper function for retrieving script functions
+getFunction = function(script)
+ local f = require(script.script)
+ if script.func then
+ return f[script.func]
+ else
+ return f
+ end
+end
+
+
+--===== dispatch messages to handlers =====--
+
+dispatch = function(entities, msg, data)
+ local query = entities:queryComponent(msg)
+ for id, handler in pairs(query) do
+ local f = getFunction(handler)
+ f(entities, id, data)
+ end
+end
+
+--===== script system =====--
+
+system = function(params)
+ return {
+ db=params.db,
+ update=function(self, dt)
+ local entities = self.db:queryComponent("script")
+ for id, script in pairs(entities) do
+ local f = getFunction(script)
+ f(self.db, id, dt)
+ end
+ end
+ }
+end
+
+
+
+return module
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-23 02:53:53 +0000