s_ds3d.c

The source code of Doom legacy for windows

}

/******************************************************************************
 *
 * Creates 3D source
 *
 ******************************************************************************/

EXPORT int HWRAPI ( Add3DSource ) (source3D_data_t *src, sfx_data_t *sfx)
{
    stack_t                 *snd;
   
    snd = setup_source(NEW_HANDLE, sfx, IS_3DSOURCE);
    
    if (snd)
    {
     
        /*x = src->pos.x;
        y = src->pos.z;
        z = src->pos.y;

        IDirectSound3DBuffer_SetPosition(source, x, y, z, update_mode);
        IDirectSound3DBuffer_SetVelocity(source, src->pos.momx, src->pos.momz, src->pos.momy, update_mode);
        IDirectSound3DBuffer_SetMode(source, src->head_relative?DS3DMODE_HEADRELATIVE:DS3DMODE_NORMAL, update_mode);*/

        snd->parameters.vPosition.x = src->pos.x;
        snd->parameters.vPosition.y = src->pos.z;
        snd->parameters.vPosition.z = src->pos.y;

        snd->parameters.vVelocity.x = src->pos.momx;
        snd->parameters.vVelocity.y = src->pos.momz;
        snd->parameters.vVelocity.z = src->pos.momy;

        snd->parameters.dwMode = src->head_relative ? DS3DMODE_HEADRELATIVE : DS3DMODE_NORMAL;

        snd->parameters.flMinDistance = src->min_distance;
        snd->parameters.flMaxDistance = src->max_distance;

        snd->permanent = src->permanent;

        UpdateSoundVolume(snd->dsbuffer, src->volume);
        IDirectSound3DBuffer_SetAllParameters(snd->dsbuffer3D, &snd->parameters, DS3D_IMMEDIATE);
        
        IDirectSoundBuffer_SetCurrentPosition(snd->dsbuffer, 0);
            
    }
        
    return (snd - _stack);
}

/******************************************************************************
 *
 * Destroy source and remove it from stack if it is a 2D source.
 * Otherwise put source into cache
 *
 *****************************************************************************/
EXPORT void HWRAPI (KillSource) (int handle)
{

    if (handle < 0 || handle >= allocated_sounds)
        return;
/*
     if (_stack[handle].dsbuffer3D)
    {
        // It's a 3D source so let him chance to be reused :-)
        _stack[handle].LRU = 1;
    }
    else
    { */
        // No, it is a 2D source so kill him
        kill_sound(_stack + handle);
    //}
}


/******************************************************************************
 *
 * Update volume and separation (panning) of 2D source
 *
 *****************************************************************************/
EXPORT void HWRAPI (Update2DSoundParms) (int handle, int vol, int sep)
{
    LPDIRECTSOUNDBUFFER dsbuffer;

    if (handle < 0 || handle >= allocated_sounds)
        return;

    if ((_stack+handle)->dsbuffer3D)
        return;
    dsbuffer = (_stack + handle)->dsbuffer;
    UpdateSoundVolume(dsbuffer, vol);
    Update2DSoundPanning(dsbuffer, sep);
}



// --------------------------------------------------------------------------
// Set the global volume for sound effects
// --------------------------------------------------------------------------
EXPORT void HWRAPI (SetGlobalSfxVolume) (int volume)
{
    int     vol;
    HRESULT hr;
   
    // use the last quarter of volume range
    if (volume)
        vol = recalc_volume(volume, 31);
    else
        vol = DSBVOLUME_MIN;
    
    hr = IDirectSoundBuffer_SetVolume (PrimaryBuffer, vol);
    
}

EXPORT void HWRAPI ( StopSource) (int handle)
{
    LPDIRECTSOUNDBUFFER dsbuffer;
    
    if (handle < 0 || handle >= allocated_sounds)
        return;
    dsbuffer = (_stack + handle)->dsbuffer;

    if (dsbuffer)
    {
        IDirectSoundBuffer_Stop(dsbuffer);
        IDirectSoundBuffer_SetCurrentPosition(dsbuffer, 0);
    }
}

EXPORT int HWRAPI ( GetHW3DSVersion) (void)
{
    return VERSION;
}


EXPORT void HWRAPI (BeginFrameUpdate) (void)
{
    update_mode = DS3D_DEFERRED;
}

EXPORT void HWRAPI (EndFrameUpdate) (void)
{
    if (update_mode == DS3D_DEFERRED)
        IDirectSound3DListener_CommitDeferredSettings(Listener);

    update_mode = DS3D_IMMEDIATE;
}


/******************************************************************************
 * UpdateListener
 *
 * Set up main listener properties:
 * - position
 * - orientation
 * - velocity
 *****************************************************************************/
EXPORT void HWRAPI (UpdateListener) (listener_data_t* data)
{
    D3DVECTOR pos;
    D3DVECTOR face;
    D3DVECTOR head;
    D3DVECTOR velocity;
    
    double      f_angle, h_angle, t_angle;
    double      f_cos, f_sin, t_sin;

    pos.x = data->x;
    pos.y = data->z;
    pos.z = data->y;

    velocity.x = data->momx;
    velocity.y = data->momz;
    velocity.z = data->momy;

    f_angle = data->f_angle / 180 * PI;
    h_angle = data->h_angle / 180 * PI;

    // Treat listener orientation angles as spherical coordinates.

    // Front vector
    t_angle = PI/2 - h_angle;
    //t_angle = h_angle;
    
    face.x = 48 * (t_sin = sin(t_angle)) * (f_cos = cos(f_angle));
    face.z = 48 * t_sin * (f_sin = sin(f_angle));
    face.y = 48 * cos(t_angle);
    
    /*
    face.z = sin(t_angle) * cos(f_angle);
    face.x = sin(t_angle) * sin(f_angle);
    face.y = cos
    (t_angle);
    */

    //face.y = sin(t_angle) * cos(f_angle);

    // Top vector
    //h_angle = (-data->h_angle) / 180 * PI;
    t_angle = -h_angle;
    
    head.x = 48 * (t_sin = sin(t_angle)) * f_cos;
    head.z = 48 * t_sin * f_sin;
    head.y = 48 * cos(t_angle);
    
    /*
    head.z = sin(t_angle) * cos(f_angle);
    head.x = sin(t_angle) * sin(f_angle);
    head.z = cos(t_angle);
    */
/*
    DBG_Printf("Listener data:\n\tPosition (x,y,z) %f, %f, %f\n\tAngles (f, h) %f, %f\n",
        data->x, data->y, data->z,
        data->f_angle, data->h_angle);
*/
/*
    DBG_Printf("\tCalculated vectors:\n\t\tFace (x,y,z) %f, %f, %f\n",
        face.x, face.y, face.z);
    DBG_Printf("\t\tHead (x, y, z): %f. %f. %f\n", head.x, head.y, head.z);
*/
    // Update at once
    memcpy(&listener_parms.vPosition, &pos, sizeof(D3DVECTOR));
    memcpy(&listener_parms.vOrientFront, &face, sizeof(D3DVECTOR));
    memcpy(&listener_parms.vOrientTop, &head, sizeof(D3DVECTOR));
    memcpy(&listener_parms.vVelocity, &velocity, sizeof(D3DVECTOR));
    IDirectSound3DListener_SetAllParameters(Listener, &listener_parms, update_mode);

}

EXPORT int HWRAPI (SetCone) (int handle, cone_def_t *cone_def)
{
    stack_t     *snd;
    //DS3DBUFFER  parms;

    if (handle < 0 || handle >= allocated_sounds)
        return -1;

    snd = _stack + handle;

    if (snd->dsbuffer3D)
    {
        
     /*f_angle = cone_def->f_angle / 180 * PI;
        h_angle = (90 - cone_def->h_angle) / 180 * PI;
        parms.vConeOrientation.x = sin(h_angle) * cos(f_angle);
        parms.vConeOrientation.z = sin(h_angle) * sin(f_angle);
        parms.vConeOrientation.y = cos(h_angle);*/

        snd->parameters.dwInsideConeAngle = cone_def->inner;
        snd->parameters.dwOutsideConeAngle = cone_def->outer;
        snd->parameters.lConeOutsideVolume = recalc_volume(cone_def->outer_gain, 256);

        return IDirectSound3DBuffer_SetAllParameters(snd->dsbuffer3D, &snd->parameters, update_mode);
    }

    return -1;
}

EXPORT void HWRAPI (Update3DSource) (int handle, source3D_pos_t *data)
{
    stack_t     *snd;   
    
    if (handle < 0 || handle >= allocated_sounds)
        return;

    snd = _stack + handle;
    if (snd->dsbuffer3D)
    {
    
        /*parms.dwSize = sizeof(DS3DBUFFER);
        IDirectSound3DBuffer_GetAllParameters(snd, &parms);*/

        //angle = data->angle * 180 / PI;

        snd->parameters.vPosition.x = data->x;
        snd->parameters.vPosition.y = data->z;
        snd->parameters.vPosition.z = data->y;

        /*parms.vConeOrientation.x = cos(angle);
        parms.vConeOrientation.z = sin(angle);
        parms.vConeOrientation.y = 0;*/

        snd->parameters.vVelocity.x = data->momx;
        snd->parameters.vVelocity.y = data->momz;
        snd->parameters.vVelocity.z = data->momy;

        //snd->parameters.flMinDistance = data->min_distance;
        //snd->parameters.flMaxDistance = data->max_distance;
        //snd->parameters.dwMode = pos->head_realtive?DS3DMODE_HEADREALTIVE:DS3DMODE_NORMAL;

        IDirectSound3DBuffer_SetAllParameters(snd->dsbuffer3D, &snd->parameters, update_mode);
    }
}


EXPORT int HWRAPI (StartSource) (int handle)
{
    LPDIRECTSOUNDBUFFER snd;

    if (handle < 0 || handle >= allocated_sounds)
        return -1;
   
    snd = (_stack + handle)->dsbuffer;
    IDirectSoundBuffer_SetCurrentPosition(snd, 0);
    return IDirectSoundBuffer_Play(snd, 0, 0, 0);

}

//-------------------------------------------------------------
// Load new sound data into source
//-------------------------------------------------------------
EXPORT int HWRAPI (Reload3DSource) (int handle, sfx_data_t *data)
{
    DS3DBUFFER  temp;
    stack_t     *snd;
    int         perm;

    // DirectX could not load new sound data into source
    // so recreate sound buffers
    if (handle < 0 || handle >= allocated_sounds)
        return -1;

    snd = _stack + handle;
    CopyMemory(&temp, &snd->parameters, sizeof(DS3DBUFFER));
    perm = snd->permanent;

    kill_sound(snd);

    snd = setup_source(handle, data, IS_3DSOURCE);
    /*snd->dsbuffer = create_buffer(data->data, data->length, true);
    if (snd->dsbuffer == NULL)
        return -1;
    snd->dsbuffer3D = create_3dbuffer(snd->dsbuffer, snd->dsbuffer3D);
    if (snd->dsbuffer3D == NULL)
    {
        RELEASE_BUFFER(snd->dsbuffer);
        return -1;
    }

    snd->sfx_id = data->id;
    snd->LRU = 0;*/
    if (snd)
    {
        snd->permanent = perm;
        IDirectSound3DBuffer_SetAllParameters(snd->dsbuffer3D, &temp, DS3D_IMMEDIATE);
        CopyMemory(&snd->parameters, &temp, sizeof(DS3DBUFFER));
    }

    return (snd - _stack);
}

EXPORT void HWRAPI (UpdateSourceVolume) (int handle, int volume)
{
    if (handle < 0 || handle >= allocated_sounds)
        return;
    UpdateSoundVolume((_stack + handle)->dsbuffer, volume);
}