Source.cpp

// Include necessary headers
#include <AL/al.h>
#include <AL/alc.h>
#include <vector>
#include <iostream>
#include <cmath>

// Function to initialize OpenAL and create a context
ALCdevice* InitOpenAL(ALCcontext*& context) {
    ALCdevice* device = alcOpenDevice(nullptr); // Open default device
    if (!device) {
        std::cerr << "Failed to open OpenAL device." << std::endl;
        return nullptr;
    }

    context = alcCreateContext(device, nullptr);
    if (!context) {
        std::cerr << "Failed to create OpenAL context." << std::endl;
        alcCloseDevice(device);
        return nullptr;
    }

    alcMakeContextCurrent(context);
    return device;
}

// Function to clean up OpenAL resources
void CleanUpOpenAL(ALCdevice* device, ALCcontext* context) {
    alcMakeContextCurrent(nullptr);
    alcDestroyContext(context);
    alcCloseDevice(device);
}

// Function to configure 3D listener properties
void ConfigureListener() {
    ALfloat listenerPos[] = { 0.0f, 0.0f, 0.0f };
    ALfloat listenerVel[] = { 0.0f, 0.0f, 0.0f };
    ALfloat listenerOri[] = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; // Forward and Up vectors

    alListenerfv(AL_POSITION, listenerPos);
    alListenerfv(AL_VELOCITY, listenerVel);
    alListenerfv(AL_ORIENTATION, listenerOri);
}

// Function to load and play a sound buffer in 3D space
ALuint LoadSoundBuffer(const std::string& filename) {
    // Dummy implementation: You would normally load data here using libraries like libsndfile
    ALuint buffer;
    alGenBuffers(1, &buffer);
    // Load audio data into buffer... (omitted for simplicity)
    return buffer;
}

// Function to create a source for 3D playback
void Create3DSource(ALuint buffer, const ALfloat* sourcePos, const ALfloat* sourceVel) {
    ALuint source;
    alGenSources(1, &source);

    alSourcef(source, AL_PITCH, 1.0f);
    alSourcef(source, AL_GAIN, 1.0f);
    alSourcefv(source, AL_POSITION, sourcePos);
    alSourcefv(source, AL_VELOCITY, sourceVel);
    alSourcei(source, AL_LOOPING, AL_FALSE);
    alSourcei(source, AL_BUFFER, buffer);

    alSourcePlay(source);
}

// Implement reverberation effect using OpenAL EFX (OpenAL Effects Extension)
void ApplyReverb(ALuint source) {
    ALuint effect;
    alGenEffects(1, &effect);
    alEffecti(effect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
    alEffectf(effect, AL_REVERB_DECAY_TIME, 2.0f); // Example reverb parameters

    ALuint effectSlot;
    alGenAuxiliaryEffectSlots(1, &effectSlot);
    alAuxiliaryEffectSloti(effectSlot, AL_EFFECTSLOT_EFFECT, effect);

    alSource3i(source, AL_AUXILIARY_SEND_FILTER, effectSlot, 0, AL_FILTER_NULL);
}

// Simulating beamforming for spatial audio accuracy
void BeamformAudio(ALuint source, float angle) {
    // Set directional parameters to simulate beamforming
    ALfloat direction[] = { std::cos(angle), 0.0f, std::sin(angle) };
    alSourcefv(source, AL_DIRECTION, direction);
    alSourcef(source, AL_CONE_INNER_ANGLE, 30.0f);  // Narrow cone for focused sound
    alSourcef(source, AL_CONE_OUTER_ANGLE, 60.0f);  // Wider cone for fading sound
    alSourcef(source, AL_CONE_OUTER_GAIN, 0.1f);    // Attenuate outside the cone
}

// Entry point
int main() {
    ALCcontext* context;
    ALCdevice* device = InitOpenAL(context);
    if (!device) {
        return -1;
    }

    ConfigureListener();

    // Example source setup
    ALfloat sourcePos[] = { 2.0f, 0.0f, -5.0f };
    ALfloat sourceVel[] = { 0.0f, 0.0f, 0.0f };
    ALuint buffer = LoadSoundBuffer("sound.wav");
    Create3DSource(buffer, sourcePos, sourceVel);

    // Apply reverberation
    ApplyReverb(buffer);

    // Apply beamforming simulation
    BeamformAudio(buffer, 45.0f * (3.14159f / 180.0f));

    // Main loop
    while (true) {
        // Placeholder for a real-time rendering loop
    }

    // Clean up OpenAL resources
    CleanUpOpenAL(device, context);
    return 0;
}