Defold 2D 光照与特效

颜色贴图 (albedo)  → 这个像素是什么颜色
法线贴图 (normal)  → 这个像素朝向哪里

光照缓冲 = Σ 每个光源的贡献
最终颜色 = 颜色贴图 × 光照缓冲

每个光源的贡献：
diffuse = max(dot(normal, light_dir), 0)
falloff = 1 - saturate(distance / radius)
contribution = light_color × intensity × diffuse × falloff

R = (nx + 1) / 2
G = (ny + 1) / 2
B = (nz + 1) / 2

平面朝前的法线 (0, 0, 1) → RGB(128, 128, 255)   # 淡紫色

sprites.atlas
  ├── tiles.png         (颜色)
  └── tiles_normal.png  (法线)

Vertex format:  position, texcoord0, normal

// sprite_lit.vp
#version 140

in vec4 position;
in vec2 texcoord0;
in vec4 normal;

uniform mat4 mtx_worldview;
uniform mat4 mtx_proj;
uniform mat4 mtx_normal;

out vec2 var_texcoord0;
out vec3 var_normal;
out vec4 var_position;

void main()
{
    vec4 world_pos = mtx_worldview * vec4(position.xyz, 1.0);
    gl_Position = mtx_proj * world_pos;

    var_texcoord0 = texcoord0;
    var_normal = normalize((mtx_normal * vec4(normal.xyz, 0.0)).xyz);
    var_position = world_pos;
}

// sprite_lit.fp
#version 140

in vec2 var_texcoord0;
in vec3 var_normal;
in vec4 var_position;

uniform sampler2D tex0;          // 颜色图集
uniform sampler2D light_map;     // 光照缓冲

uniform fs_uniforms
{
    vec4 tint;
    vec4 light_params;           // x=环境光强度, y=法线强度, zw=光照图宽高
};

out vec4 color_out;

void main()
{
    vec4 albedo = texture(tex0, var_texcoord0);
    if (albedo.a < 0.01) {
        discard;
    }

    // 1. 解码法线
    vec3 n = normalize(var_normal * 2.0 - 1.0);

    // 2. 计算光照缓冲 UV（屏幕空间）
    vec2 light_uv = gl_FragCoord.xy / vec2(light_params.z, light_params.w);

    // 3. 采样光照缓冲
    vec3 light = texture(light_map, light_uv).rgb;

    // 4. 正向漫反射
    float ndl = max(dot(n, vec3(0.0, 0.0, 1.0)), 0.0);
    ndl = mix(1.0, ndl, light_params.y);

    // 5. 环境光兜底，避免背光全黑
    vec3 lit = albedo.rgb * (light * ndl + light_params.x);

    color_out = vec4(lit, albedo.a) * tint;
}

-- light.lua
local M = {}

function M.new_point(pos, radius, color, intensity)
    return {
        kind      = "point",
        position  = pos,
        radius    = radius,
        color     = color or vmath.vector4(1, 1, 1, 1),
        intensity = intensity or 1.0,
    }
end

-- 计算某点受到的光照强度
function M.sample(light, world_pos)
    local d = vmath.length(world_pos - light.position)
    if d > light.radius then return 0 end
    local t = 1.0 - d / light.radius      -- 平滑衰减：边缘更柔和
    return t * t * light.intensity
end

return M

function M.new_spot(pos, dir, radius, angle_deg, color)
    return {
        kind      = "spot",
        position  = pos,
        direction = vmath.normalize(dir),
        radius    = radius,
        cos_inner = math.cos(math.rad(angle_deg * 0.6)),
        cos_outer = math.cos(math.rad(angle_deg)),
        color     = color or vmath.vector4(1, 1, 1, 1),
        intensity = 1.0,
    }
end

function M.sample_spot(light, world_pos)
    local to_pixel = world_pos - light.position
    local d = vmath.length(to_pixel)
    if d > light.radius then return 0 end

    local dir = to_pixel / math.max(d, 0.0001)
    local cos_theta = vmath.dot(dir, light.direction)
    if cos_theta < light.cos_outer then return 0 end

    -- 内外锥之间平滑过渡
    local t = (cos_theta - light.cos_outer) / math.max(light.cos_inner - light.cos_outer, 0.0001)
    t = math.min(1.0, math.max(0.0, t))
    local falloff = 1.0 - d / light.radius

    return t * t * falloff * falloff * light.intensity
end

-- render/light.render_script
function init(self)
    -- 场景缓冲（全分辨率）
    self.scene_rt = render.render_target("scene_rt", {
        [render.BUFFER_COLOR_BIT] = {
            format = render.FORMAT_RGBA,
            width  = render.get_window_width(),
            height = render.get_window_height(),
        },
    })

    -- 光照缓冲（半分辨率，省一半填充率）
    self.light_rt = render.render_target("light_rt", {
        [render.BUFFER_COLOR_BIT] = {
            format = render.FORMAT_RGBA,
            width  = render.get_window_width() / 2,
            height = render.get_window_height() / 2,
            min_filter = render.FILTER_LINEAR,
            mag_filter = render.FILTER_LINEAR,
        },
    })
end

Pass 1  清空光照 RT 为环境光颜色
Pass 2  把每个光源画到光照 RT（加法混合）
Pass 3  清空场景 RT，用 lit 材质绘制精灵（采样光照 RT）
Pass 4  后处理（bloom、色调映射）
Pass 5  绘制到屏幕

function update(self)
    -- ---------- Pass 1: 清空光照缓冲 ----------
    render.set_render_target(self.light_rt)
    render.clear({ [render.BUFFER_COLOR_BIT] = { 0.12, 0.12, 0.18, 1 } })

    -- ---------- Pass 2: 累积光源 ----------
    render.set_view(self.light_view)
    render.set_projection(self.light_projection)
    render.enable_state(render.STATE_BLEND_ADD)
    render.draw(self.light_predicate)

    -- ---------- Pass 3: 绘制场景 ----------
    render.set_render_target(self.scene_rt)
    render.clear({ [render.BUFFER_COLOR_BIT] = { 0, 0, 0, 1 } })
    render.enable_texture("light_map", self.light_rt)
    render.set_view(self.scene_view)
    render.set_projection(self.scene_projection)
    render.draw(self.scene_predicate)

    -- ---------- Pass 4/5: 后处理并输出 ----------
    render.set_render_target(render.RENDER_TARGET_DEFAULT)
    render.enable_texture("scene_map", self.scene_rt)
    render.draw(self.post_predicate)

    -- 清理纹理绑定，避免下一帧冲突
    render.disable_texture("light_map")
    render.disable_texture("scene_map")
end

-- 光源对象统一打上 "light" 标签
self.light_predicate = render.predicate({ hash("light") })
self.scene_predicate = render.predicate({ hash("scene") })

-- 把 RT 尺寸作为常量传给材质
render.enable_material("sprite_lit")
render.set_constant("sprite_lit", "light_rt_size",
    vmath.vector4(render.get_window_width() / 2, render.get_window_height() / 2, 0, 0))

// 片元着色器里把屏幕坐标转成光照 UV
vec2 light_uv = gl_FragCoord.xy / light_rt_size;

1. 亮度阈值提取  → 只保留亮度 > threshold 的像素
2. 高斯模糊      → 水平 + 垂直两次模糊
3. 叠加回原图    → 加法混合

// bloom_extract.fp
#version 140
in vec2 var_texcoord0;
uniform sampler2D tex0;
uniform fs_uniforms { vec4 params; };   // x = 阈值
out vec4 color_out;

void main()
{
    vec4 c = texture(tex0, var_texcoord0);
    float luma = dot(c.rgb, vec3(0.2126, 0.7152, 0.0722));
    float factor = max(luma - params.x, 0.0) / max(luma, 0.0001);
    color_out = vec4(c.rgb * factor, c.a);
}

// blur.fp  — 通过 params.xy 控制方向
#version 140
in vec2 var_texcoord0;
uniform sampler2D tex0;
uniform fs_uniforms { vec4 params; };   // xy = 方向步长
out vec4 color_out;

const float WEIGHTS[5] = float[](0.227027, 0.194594, 0.121621, 0.054054, 0.016216);

void main()
{
    vec3 result = texture(tex0, var_texcoord0).rgb * WEIGHTS[0];
    for (int i = 1; i < 5; ++i) {
        vec2 offset = params.xy * float(i);
        result += texture(tex0, var_texcoord0 + offset).rgb * WEIGHTS[i];
        result += texture(tex0, var_texcoord0 - offset).rgb * WEIGHTS[i];
    }
    color_out = vec4(result, 1.0);
}

色调映射：简化版用 Reinhard 的 c / (c + 1)，高质量用 ACES 近似
场景 → 光照相乘 → bloom 提取 → 模糊 → 加回场景 → 色调映射 → 暗角/噪点 → 输出

-- 每个遮挡体是一个凸多边形
local function build_shadow_volume(occluder, light_pos)
    local verts = {}
    for _, p in ipairs(occluder.points) do
        local dir = vmath.normalize(p - light_pos)
        table.insert(verts, p)
        table.insert(verts, p + dir * 1000)    -- 沿光线方向延伸
    end
    return verts
end

// 简化的光线步进遮挡
float shadow_factor(sampler2D occluders, vec2 from, vec2 to, int steps)
{
    float shadow = 1.0;
    for (int i = 1; i <= steps; ++i) {
        float t = float(i) / float(steps);
        vec2 p = mix(from, to, t);
        float occ = texture(occluders, p).r;
        shadow = min(shadow, 1.0 - occ * (1.0 - t));
    }
    return shadow;
}

local QUALITY = {
    high   = { light_scale = 1.0, bloom = true,  shadows = true,  max_lights = 16 },
    medium = { light_scale = 0.5, bloom = true,  shadows = false, max_lights = 8  },
    low    = { light_scale = 0.5, bloom = false, shadows = false, max_lights = 4  },
}

function pick_quality()
    local info = sys.get_sys_info()
    if info.system_name == "Android" or info.system_name == "iPhone OS" then
        return QUALITY.medium
    end
    return QUALITY.high
end

-- 每帧按「强度 / 距离」排序，只保留前 N 个
local function select_lights(lights, camera_pos, max_count)
    table.sort(lights, function(a, b)
        local da = vmath.length(a.position - camera_pos)
        local db = vmath.length(b.position - camera_pos)
        return (a.intensity / (da + 1)) > (b.intensity / (db + 1))
    end)
    local out = {}
    for i = 1, math.min(max_count, #lights) do
        out[i] = lights[i]
    end
    return out
end

function on_message(self, message_id, message, sender)
    if message_id == hash("window_resized") then
        rebuild_render_targets(self)   -- 只在窗口尺寸变化时重建 RT
    end
end

-- ======================================
-- 完整示例：light_manager.lua 光源管理
-- 放在 /scripts/light_manager.lua
-- ======================================

local M = {
    lights     = {},
    max_lights = 8,
}

function M.add(light)
    light.intensity = light.intensity or 1.0
    table.insert(M.lights, light)
    return light
end

-- 每帧按「强度 / 距离」排序，只保留前 N 个
function M.select(camera_pos)
    table.sort(M.lights, function(a, b)
        local da = vmath.length(a.position - camera_pos)
        local db = vmath.length(b.position - camera_pos)
        return (a.intensity / (da + 1.0)) > (b.intensity / (db + 1.0))
    end)
    local out = {}
    for i = 1, math.min(M.max_lights, #M.lights) do
        out[i] = M.lights[i]
    end
    return out
end

return M