1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

[资源层]
   ├─ 音频文件解码（WAV/OGG）
   ├─ 内存缓冲区管理
   
[逻辑层]
   ├─ 音效实例池
   ├─ 混音器路由
   ├─ DSP效果链
   
[硬件层]
   ├─ OpenAL软实现
   ├─ 平台音频API适配

1
2
3
4
5
6
7
8
9

-- 播放音效
local play_id = sound.play("/sounds#explosion")

-- 暂停与恢复
sound.pause(play_id)
sound.resume(play_id)

-- 停止播放
sound.stop(play_id)

1
2
3
4
5

sound.play("/sounds#background_music", {
    loop = true,
    gain = 0.8,
    delay = 2.0  -- 延迟启动（秒）
})

1
2
3
4
5
6
7
8

-- 实时调节音量
sound.set_gain(play_id, 0.5)

-- 调节立体声平衡
sound.set_pan(play_id, -0.8)  -- 左声道偏重

-- 改变播放速度
sound.set_pitch(play_id, 1.2)  -- 提速20%

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

-- 设置声源位置
sound.set_position(play_id, vmath.vector3(10, 0, 0))

-- 配置衰减模型
sound.set_distance_model(play_id, sound.DISTANCE_MODEL_INVERSE_CLAMPED, {
    ref_distance = 5.0,  -- 参考距离（米）
    max_distance = 50.0, -- 最大可听距离
    rolloff = 1.0        -- 衰减系数
})

-- 设置听者位置（玩家角色）
sound.set_listener_position(go.get_position("player"))

1
2
3
4
5
6
7
8

-- 声源移动速度
sound.set_velocity(play_id, player_velocity)

-- 全局多普勒参数
sound.set_doppler_parameters({
    factor = 1.0,  -- 效果强度
    velocity = 343  -- 声速（m/s）
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

MixerBus = {
    buses = {
        master = { gain = 1.0 },
        music = { gain = 0.7, parent = "master" },
        sfx = { gain = 0.9, parent = "master" }
    },
    set_volume = function(self, bus_name, volume)
        local bus = self.buses[bus_name]
        bus.gain = volume
        if bus.parent then
            sound.set_group_gain(bus_name, bus.gain * self.buses[bus.parent].gain)
        else
            sound.set_group_gain(bus_name, bus.gain)
        end
    end
}

-- 调节音乐音量
MixerBus:set_volume("music", 0.5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- 添加低通滤波器
local filter_id = sound.dsp_create(
    sound.DSP_TYPE_LOWPASS, 
    { cutoff = 2000.0, resonance = 1.0 }
)

-- 应用到音轨
sound.dsp_attach(filter_id, "/mixer#sfx")

-- 动态调节参数
sound.dsp_set_parameter(filter_id, "cutoff", 1000.0)

1
2
3
4
5
6
7

-- 适合长音频（背景音乐）
sound.load_stream("/music#level1", {
    preload = 2048  -- 预加载2MB数据
})

-- 手动卸载
sound.unload_stream("/music#level1")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

SoundPool = {
    pools = {},
    create = function(self, name, template, size)
        self.pools[name] = {
            instances = {},
            index = 1
        }
        for i=1,size do
            table.insert(self.pools[name].instances, factory.create(template))
        end
    end,
    play = function(self, name)
        local pool = self.pools[name]
        local instance = pool.instances[pool.index]
        pool.index = (pool.index % #pool.instances) + 1
        sound.play(instance)
        return instance
    end
}

-- 创建包含10个实例的爆炸音效池
SoundPool:create("explosion", "/sounds#explosion", 10)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

local PRIORITY_LEVEL = {
    DIALOG = 100,
    WEAPON = 50,
    AMBIENT = 10
}

AudioScheduler = {
    active_sounds = {},
    play = function(self, sound_id, priority)
        -- 检查同优先级声音数量
        local count = 0
        for _, s in pairs(self.active_sounds) do
            if s.priority == priority then count = count +1 end
        end
        
        -- 超过限制则停止最早声音
        if count >= MAX_SAME_PRIORITY then
            self:stop_oldest(priority)
        end
        
        -- 记录新声音
        self.active_sounds[sound_id] = {
            time = socket.gettime(),
            priority = priority
        }
    end
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

MusicManager = {
    current_state = "exploration",
    states = {
        exploration = {
            intro = "music_explore_intro",
            loop = "music_explore_loop",
            bpm = 120
        },
        combat = {
            intro = "music_combat_intro",
            loop = "music_combat_loop",
            bpm = 140
        }
    },
    transition = function(self, new_state)
        -- 淡出当前音乐
        go.animate(self.current_track, "gain", go.PLAYBACK_ONCE_FORWARD, 0.0, 
                  go.EASING_INQUAD, 1.0)
        
        -- 加载新音乐
        self.current_state = new_state
        local state = self.states[new_state]
        self.current_track = sound.play(state.intro, { 
            on_complete = function() 
                self.loop_track = sound.play(state.loop, { loop = true }) 
            end
        })
    end
}

1
2
3
4
5
6
7
8

function on_music_beat()
    -- 计算节拍时间
    local beat_time = 60 / current_bpm
    
    -- 触发视觉特效同步
    particlefx.emit("#beat_effect", 50)
    go.animate("#light", "color.w", go.PLAYBACK_LOOP_PINGPONG, 1.0, go.EASING_OUTQUAD, beat_time/2)
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

AmbientZone = {
    zones = {},
    update = function(self, listener_pos)
        for _, zone in ipairs(self.zones) do
            if vmath.length(listener_pos - zone.position) < zone.radius then
                local volume = 1.0 - (distance / zone.radius)
                sound.set_gain(zone.sound_id, volume)
                
                -- 动态调整高频衰减模拟远距离
                sound.dsp_set_parameter(zone.filter_id, "cutoff", 20000 * volume)
            else
                sound.set_gain(zone.sound_id, 0.0)
            end
        end
    end
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

local AMBIENT_EVENTS = {
    { sound = "birds", probability = 0.3, delay = 5.0 },
    { sound = "wind", probability = 0.7, delay = 10.0 }
}

function update_ambient(dt)
    for _, event in ipairs(AMBIENT_EVENTS) do
        event.timer = (event.timer or 0) - dt
        if event.timer <= 0 then
            if math.random() < event.probability then
                sound.play(event.sound)
            end
            event.timer = event.delay + math.random(-2.0, 2.0)
        end
    end
end

1
2
3
4
5

; game.project
[audio]
mobile_max_voices = 12      # 同时播放音效数
mobile_buffer_size = 1024   # 音频缓冲区大小
mobile_stream_threshold = 2 # 大于2MB使用流式加载

1
2
3
4
5
6
7

if sys.get_platform() == "PS5" then
    sound.set_config({
        hrtf_enabled = true,      -- 启用头部相关传输函数
        spatial_resolution = 0.1, -- 空间化计算精度
        reverb_quality = 2        -- 混响质量级别
    })
end

1
2
3
4
5
6
7
8

function unload_unused_audio()
    local ref_counts = resource.get_reference_counts()
    for path, count in pairs(ref_counts) do
        if count == 0 and string.find(path, "^/sounds/") then
            resource.unload(path)
        end
    end
end

1
2
3
4

local platform = sys.get_platform()
local format = platform == "android" and "ogg" or "wav"
local sound_path = "/sounds/explosion."..format
sound.play(sound_path)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

DebugAudioMonitor = {
    window_open = true,
    draw = function(self)
        if self.window_open then
            imgui.Begin("Audio Monitor", self.window_open)
            
            -- 显示活动音效
            local sounds = sound.get_active()
            imgui.Text(string.format("Active Sounds: %d/%d", #sounds, sound.get_max_voices()))
            
            -- 频谱可视化
            local spectrum = sound.get_spectrum("/mixer#master")
            imgui.PlotLines("Frequency Spectrum", spectrum, 0, -1.0, 1.0, imgui.Vec2(300, 80))
            
            imgui.End()
        end
    end
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

AudioProfiler = {
    timings = {},
    begin = function(self, name)
        self.timings[name] = socket.gettime()
    end,
    end = function(self, name)
        if self.timings[name] then
            local duration = (socket.gettime() - self.timings[name]) * 1000
            print(string.format("[Audio] %s took %.2fms", name, duration))
        end
    end
}

function play_sound_with_profile(sound_id)
    AudioProfiler:begin("sound_play")
    sound.play(sound_id)
    AudioProfiler:end("sound_play")
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

WeatherSystem = {
    current_weather = "sunny",
    sound_params = {
        rain = { volume = 0.0, target = 0.0 },
        wind = { volume = 0.0, target = 0.0 }
    },
    update = function(self, dt)
        -- 根据天气变化调整目标音量
        if self.current_weather == "rain" then
            self.sound_params.rain.target = 0.8
            self.sound_params.wind.target = 0.5
        elseif self.current_weather == "storm" then
            self.sound_params.rain.target = 1.0
            self.sound_params.wind.target = 1.0
        end
        
        -- 平滑过渡
        for _, param in pairs(self.sound_params) do
            param.volume = vmath.lerp(param.volume, param.target, dt * 0.5)
            sound.set_gain(param.handle, param.volume)
        end
    end
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

FootstepSystem = {
    materials = {
        grass = { sounds = {"step_grass1", "step_grass2"}, pitch_range = {0.9, 1.1} },
        stone = { sounds = {"step_stone1", "step_stone2"}, pitch_range = {0.8, 1.2} }
    },
    play = function(self, position)
        local material = physics.query_material(position)
        local config = self.materials[material] or self.materials.default
        
        local sound = config.sounds[math.random(1, #config.sounds)]
        local pitch = math.random(config.pitch_range[1]*100, config.pitch_range[2]*100)/100
        
        sound.play(sound, {
            pitch = pitch,
            position = position,
            gain = 0.3
        })
    end
}