hw3sound.c

The source code of Doom legacy for windows

    {
        if (!sfx->link)
            sfx->data = I_GetSfx (sfx);
        else
        {
            sfx->data = I_GetSfx (sfx->link);
            sfx->link->data = sfx->data;
        }
    }

    sfx_data.data = sfx->data;
    sfx_data.id = sfx_id;
    //sfx_data.length = W_LumpLength(sfx->lumpnum);
    sfx_data.length = *((unsigned short*) sfx->data + 2) + 4 * sizeof(unsigned short);
    sfx_data.priority = sfx->priority;
        
    if (origin && origin == players[displayplayer].mo)
    {

        if (c_type == CT_ATTACK)
            source = &p_attack_source;
        else
            source = &p_scream_source;

        HW3DS.pfnStopSource(source->handle);

        if (source->sfxinfo != sfx)
        {
            source->handle = HW3DS.pfnReload3DSource(source->handle, &sfx_data);
            //CONS_Printf("PlayerSound data reloaded\n");
        }
    }
    else if (c_type == CT_AMBIENT)
    {
//        sfx_data_t  outphased_sfx;

        if (ambient_source.left.sfxinfo != sfx)
        {
            HW3DS.pfnStopSource(ambient_source.left.handle);
            HW3DS.pfnStopSource(ambient_source.right.handle);

            // judgecutor:
            // Outphased sfx's temporary not used!!!
/*
                outphased_sfx.data = Z_Malloc(sfx_data.length, PU_STATIC, 0);
                make_outphase_sfx(outphased_sfx.data, sfx_data.data, sfx_data.length);
                outphased_sfx.length = sfx_data.length;
                outphased_sfx.id = sfx_data.id;
*/            
            ambient_source.left.handle = HW3DS.pfnReload3DSource(ambient_source.left.handle, &sfx_data);
//              ambient_source.right.handle = HW3DS.pfnReload3DSource(ambient_source.right.handle, &outphased_sfx);
            ambient_source.right.handle = HW3DS.pfnReload3DSource(ambient_source.right.handle, &sfx_data);
            ambient_source.left.sfxinfo = ambient_source.right.sfxinfo = sfx;
//              Z_Free(outphased_sfx.data);
        }

        HW3DS.pfnUpdateSourceVolume(ambient_source.left.handle, volume);
        HW3DS.pfnUpdateSourceVolume(ambient_source.right.handle, volume);

        if (sfx->usefulness++ < 0)
            sfx->usefulness = -1;

        HW3DS.pfnStartSource(ambient_source.left.handle);
        HW3DS.pfnStartSource(ambient_source.right.handle);

        // Ambient sound is special case
        return;
    } 
    else
    {
        s_num = HW3S_GetSource(origin, sfx);

        if (s_num  < 0)
        {
            //CONS_Printf("No free source, aborting\n");
            return;
        }

        source = &sources[s_num];

        if (origin)
        {
            // It is a positional sound
            HW3S_FillSourceParameters(origin, &source3d_data, c_type);
            source3d_data.volume = volume;
            
            source->handle = HW3DS.pfnAdd3DSource(&source3d_data, &sfx_data);
        
        }
        else
        {
            // It is just an 2D sound
            source2d_data.volume = volume;
            source2d_data.sep = 128;
            source->handle = HW3DS.pfnAdd2DSource(&source2d_data, &sfx_data);
            //CONS_Printf("2D sound created (handle %d)\n", source->handle);
        }
    }
    
     // increase the usefulness
    if (sfx->usefulness++ < 0)
        sfx->usefulness = -1;

    source->sfxinfo = sfx;
    source->origin = origin;
    HW3DS.pfnStartSource(source->handle);

}


// Start normal sound
//=============================================================================
void HW3S_StartSound(void *origin, int sfx_id)
{
    HW3S_StartSoundTypeAtVolume(origin, sfx_id, CT_NORMAL, 255);
}


//=============================================================================
void S_StartAttackSound(void *origin, int sfx_id)
{
    if (hws_mode != HWS_DEFAULT_MODE)
        HW3S_StartSoundTypeAtVolume(origin, sfx_id, CT_ATTACK, 255);
    else
        S_StartSound(origin, sfx_id);
}

void S_StartScreamSound(void *origin, int sfx_id)
{   
    if (hws_mode != HWS_DEFAULT_MODE)
    {
        HW3S_StartSoundTypeAtVolume(origin, sfx_id, CT_SCREAM, 255);
    }
    else
        S_StartSound(origin, sfx_id);
}

void S_StartAmbientSound(int sfx_id, int volume)
{
    if (hws_mode != HWS_DEFAULT_MODE)
    {
        //CONS_Printf("Ambient at %d\n", volume);
        volume += 30;
        if (volume > 255)
            volume = 255;
        //CONS_Printf("Ambient amplified to %d\n", volume);
        HW3S_StartSoundTypeAtVolume(NULL, sfx_id, CT_AMBIENT, volume);
    }
    else
        S_StartSoundAtVolume(NULL, sfx_id, volume);
}



//=============================================================================
BOOL HW3S_Init(I_Error_t FatalErrorFunction, snddev_t *snd_dev)
{
    int                succ;
    int                an;
    source3D_data_t    source_data; 
  
    if (HW3DS.pfnStartup(FatalErrorFunction, snd_dev))
    {
       
        // Creating player sources
        ZeroMemory(&source_data, sizeof(source_data));
        
        // Attack source
        source_data.head_relative = 1;
        source_data.pos.y = 16;
        source_data.pos.z = -FIXED_TO_FLOAT(mobjinfo[MT_PLAYER].height >> 1);
        source_data.min_distance = MIN_DISTANCE;
        source_data.max_distance = MAX_DISTANCE;
        source_data.permanent = 1;

        p_attack_source.sfxinfo = NULL;

        p_attack_source.handle = HW3DS.pfnAdd3DSource(&source_data, NULL);

        // Scream source
        source_data.pos.y = 0;
        source_data.pos.z = 0;

        p_scream_source.sfxinfo = NULL;

        p_scream_source.handle = HW3DS.pfnAdd3DSource(&source_data, NULL);

        //FIXED_TO_FLOAT(mobjinfo[MT_PLAYER].height - (5 * FRACUNIT));
        
        // Ambient sources (left and right) at 210 and 330 degree
        // relative to listener
        ZeroMemory(&ambient_sdata, sizeof(ambient_sdata));

        an = (ANG180 + ANG90/3) >> ANGLETOFINESHIFT;

        ambient_sdata.left.head_relative = 1;
        ambient_sdata.left.pos.x 
            = FIXED_TO_FLOAT(FixedMul((MIN_DISTANCE * FRACUNIT), finecosine[an]));
        ambient_sdata.left.pos.y 
            = FIXED_TO_FLOAT(FixedMul((MIN_DISTANCE * FRACUNIT), finesine[an]));
        ambient_sdata.left.max_distance = MAX_DISTANCE;
        ambient_sdata.left.min_distance = MIN_DISTANCE;
        ambient_sdata.left.volume = 255;
        ambient_sdata.left.permanent = 1;

        CopyMemory(&ambient_sdata.right, &ambient_sdata.left, sizeof(source3D_data_t));

        ambient_sdata.right.pos.x = -ambient_sdata.left.pos.x;
        ambient_source.left.handle = HW3DS.pfnAdd3DSource(&ambient_sdata.left, NULL);
        ambient_source.right.handle = HW3DS.pfnAdd3DSource(&ambient_sdata.right, NULL);

        succ = p_attack_source.handle > -1 && p_scream_source.handle > -1 
            && ambient_source.left.handle > -1 && ambient_source.right.handle > -1;

        //CONS_Printf("Player handles: attack %d, default %d\n", p_attack_source.handle, p_scream_source.handle);
        return succ;
    }
    return 0;
}




//=============================================================================
int HW3S_GetVersion(void)
{
    return HW3DS.pfnGetHW3DSVersion();
}


//=============================================================================
void HW3S_BeginFrameUpdate(void)
{
    if (hws_mode != HWS_DEFAULT_MODE)
        HW3DS.pfnBeginFrameUpdate();
}


//=============================================================================
void HW3S_EndFrameUpdate(void)
{
    if (hws_mode != HWS_DEFAULT_MODE)
        HW3DS.pfnEndFrameUpdate();
}



//=============================================================================
int HW3S_SoundIsPlaying(int handle)
{
    return HW3DS.pfnIsPlaying(handle);
}

int HW3S_SoundPlaying(void *origin, int id)
{
    int         snum;

    for (snum=0 ; snum<num_sources; snum++)
    {
        if (origin &&  sources[snum].origin ==  origin)
          return 1;
        if (id != -1 && sources[snum].sfxinfo - S_sfx == id)
          return 1;
    }
    return 0;
}

//=============================================================================
void HW3S_UpdateListener(mobj_t *listener)
{
    listener_data_t data;

    if (!(listener && listener->player))
        return;

    data.x = FIXED_TO_FLOAT(listener->x);
    data.y = FIXED_TO_FLOAT(listener->y);
    data.z = FIXED_TO_FLOAT(listener->z + listener->height - (5 * FRACUNIT));

    data.f_angle = ANGLE2DEG(listener->angle);
    data.h_angle = ANGLE2DEG(listener->player->aiming);

    data.momx = FIXED_TO_FLOAT(listener->momx);
    data.momy = FIXED_TO_FLOAT(listener->momy);
    data.momz = FIXED_TO_FLOAT(listener->momz);
    
    HW3DS.pfnUpdateListener(&data);
}

void HW3S_SetSfxVolume(int volume)
{
    HW3DS.pfnSetGlobalSfxVolume(volume);
}


static void HW3S_Update3DSource(source_t *src)
{
    source3D_data_t data;

    HW3S_FillSourceParameters(src->origin, &data, src->type);
    HW3DS.pfnUpdate3DSource(src->handle, &data.pos);

}

void HW3S_UpdateSources(void)
{
    mobj_t      *listener = players[displayplayer].mo;
    source_t    *src;
    int         snum;

    HW3S_UpdateListener(listener);

    for (snum = 0, src = sources; snum < num_sources; src++, snum++)
    {
        if (src->sfxinfo)
        {
            if (HW3DS.pfnIsPlaying(src->handle))
            {
                if (src->origin)
                {
                    // Update positional sources
                    HW3S_Update3DSource(src);
                }
            }
            else
            {
                // Source allocated but stopped. Kill.
                HW3S_KillSource(snum);
            }
        }
    }
    
}


void HW3S_Shutdown()
{
    HW3DS.pfnShutdown();
}