Change API to use lighting table instead

.luacheckrc

@@ -33,7 +33,7 @@ stds.minetest.read_globals = {
 
 stds.monoids = {}
 stds.monoids.globals = {
-    "lighting_monoids",
+    "lighting_monoid",
     "weather"
 }
 stds.monoids.read_globals = {

compatibility/enable_shadows.lua

@@ -38,7 +38,8 @@ minetest.override_chatcommand("shadow_intensity", {
 
 		intensity = new_intensity
 		for _,player in pairs(minetest.get_connected_players()) do
-            lighting_monoids.shadows:add_change(player, new_intensity, "enable_shadows:base_value")
+			local lighting = { shadows = { intensity = new_intensity } }
+            lighting_monoid:add_change(player, lighting, "enable_shadows:base_value")
 		end
 	end
 })

compatibility/weather.lua

@@ -4,9 +4,8 @@ if weather ~= nil and weather.on_update ~= nil then
         if overrides == nil then
             return
         end
-        if overrides.shadows and overrides.shadows.intensity then
+        if overrides.shadows then
-            local intensity = overrides.shadows.intensity
+            lighting_monoid:add_change(player, { shadows = overrides.shadows }, "weather:cloud_shadows")
-            lighting_monoids.shadows:add_change(player, intensity, "weather:cloud_shadows")
         end
         overrides.lighting = nil
         return overrides

init.lua

@@ -1,51 +1,84 @@
-lighting_monoids = {}
-
 local SET_BASE_SHADOW = minetest.settings:get_bool("lighting_monoids.set_base_shadow", true)
 local BASE_SHADOW_INTENSITY = tonumber(minetest.settings:get("lighting_monoids.base_shadow_intensity") or 0.33)
 
 local MODPATH = minetest.get_modpath(minetest.get_current_modname())
 
-local function multiply(a, b)
+local monoid_definition = {
-    if a == nil then a = 1 end
+    shadows = {
-    if b == nil then b = 1 end
+        intensity = "multiply_minmax",
+    },
+    saturation = "multiply",
+    exposure = {
+        luminance_min = "add",
+        luminance_max = "add",
+        exposure_correction = "add",
+        speed_dark_bright = "multiply",
+        speed_bright_dark = "multiply",
+        center_weight_power = "multiply"
+    }
+}
+
+-- default values that don't reflect neutral operations
+local lighting_defaults = {
+    exposure = {
+        luminance_min = -3,
+        luminance_max = -3,
+        speed_dark_bright = 1000,
+        speed_bright_dark = 1000,
+    }
+}
+
+local methods = {}
+
+function methods.add(a, b)
+    return a + b
+end
+
+function methods.multiply(a, b)
     return a * b
 end
 
-local function fold_multiply(values)
+function methods.multiply_minmax(a, b)
-    local total = 1
+    return math.max(math.min(a * b, 1), 0)
-    for _, val in pairs(values) do
-        if val ~= nil then
-            total = total * val
-        end
-    end
-    return total
 end
 
--- Define monoid for shadow intensity
+-- combine tables using specified methods
-lighting_monoids.shadows = player_monoids.make_monoid({
+local function combine(definition, tabA, tabB)
-    identity = 1,
+    -- at least one table has undefined value
-    combine = multiply,
+    if tabA ~= nil and tabB == nil then return tabA end
-    fold = fold_multiply,
+    if tabB ~= nil and tabA == nil then return tabB end
-    apply = function(multiplier, player)
+    if tabA == nil and tabB == nil then return nil end
-        local lighting = player:get_lighting()
+    -- both tables define value
-        lighting.shadows = lighting.shadows or {}
+    if type(definition) == "table" then
-        lighting.shadows.intensity = multiplier
+        -- not reached leaf node yet
-        if player.set_lighting ~= nil then
+        local combined = {}
-            player:set_lighting(lighting)
+        for property, subdefinition in pairs(definition) do
+            combined[property] = combine(subdefinition, tabA[property], tabB[property])
         end
+        return combined
+    else
+        -- combine values
+        return methods[definition](tabA, tabB)
     end
-})
+end
 
--- Define monoid for color saturation
+lighting_monoid = player_monoids.make_monoid({
-lighting_monoids.saturation = player_monoids.make_monoid({
+    identity = {},
-    identity = 1,
+    combine = function(a, b)
-    combine = multiply,
+        return combine(monoid_definition, a, b)
-    fold = fold_multiply,
+    end,
-    apply = function(multiplier, player)
+    fold = function(values)
-        local lighting = player:get_lighting()
+        local total = {}
-        lighting.saturation = multiplier
+        for _, val in ipairs(values) do
+            total = combine(monoid_definition, total, val)
+        end
+        return total
+    end,
+    apply = function(value, player)
         if player.set_lighting ~= nil then
-            player:set_lighting(lighting)
+            -- incorporate default offsets
+            value = combine(monoid_definition, lighting_defaults, value)
+            player:set_lighting(value)
         end
     end
 })
@@ -60,6 +93,7 @@ if minetest.get_modpath("enable_shadows") then
 -- set base shadow
 elseif SET_BASE_SHADOW then
     minetest.register_on_joinplayer(function(player)
-        lighting_monoids.shadows:add_change(player, BASE_SHADOW_INTENSITY, "lighting_monoids:base_value")
+        local lighting = { shadows = { intensity = BASE_SHADOW_INTENSITY } }
+        lighting_monoid:add_change(player, lighting, "lighting_monoid:base_shadow")
     end)
 end

mod.conf

@@ -1,5 +1,5 @@
-name = lighting_monoids
+name = lighting_monoid
-title = Monoids for Player Lighting
+title = Lighting Monoid
 author = TestificateMods
 depends = player_monoids
 optional_depends = enable_shadows, weather