/**
* @alsymbols
* @alfunref{GetBuffer}
* @aldefref{SIZE}
* @aldefref{FREQUENCY}
* @aldefref{BITS}
* @aldefref{CHANNELS}
*/
ALfloat Duration(void) const
{
ALfloat s = Size();
ALfloat f = Frequency();
ALfloat b = Bits()/8.0f;
ALfloat c = Channels();
ALfloat bps = f*b*c;
return bps>0.0f?ALfloat(s/bps):ALfloat(0);
}
static ALfloat _normalize_sample(ALshort v) {
return ALfloat(v) / 32768.0f;
}
static ALfloat _normalize_sample(ALubyte v) {
return (ALfloat(v) - 128.0f) / 128.0f;
}
inVector1[2]*inVector2[2];
}
static inline void aluNormalize(ALfloat *inVector)
{
ALfloat lengthsqr = aluDotproduct(inVector, inVector);
if(lengthsqr > 0.0f)
{
ALfloat inv_length = 1.0f/sqrtf(lengthsqr);
inVector[0] *= inv_length;
inVector[1] *= inv_length;
inVector[2] *= inv_length;
}
}
static inline ALvoid aluMatrixVector(ALfloat *vector, ALfloat w, ALfloat (*restrict matrix)[4])
{
ALfloat temp[4] = {
vector[0], vector[1], vector[2], w
};
vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
}
static ALvoid CalcListenerParams(ALlistener *Listener)
{
ALfloat N[3], V[3], U[3], P[3];
#include "config.h"
#include "alMain.h"
#include "alSource.h"
#include "hrtf.h"
#include "align.h"
#include "alu.h"
#include "defs.h"
static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*RESTRICT Values)[2],
const ALsizei irSize,
const ALfloat (*RESTRICT Coeffs)[2],
ALfloat left, ALfloat right);
void MixHrtf(ALfloat *RESTRICT LeftOut, ALfloat *RESTRICT RightOut,
const ALfloat *data, ALsizei Offset, ALsizei OutPos,
const ALsizei IrSize, MixHrtfParams *hrtfparams, HrtfState *hrtfstate,
ALsizei BufferSize)
{
const ALfloat (*Coeffs)[2] = ASSUME_ALIGNED(hrtfparams->Coeffs, 16);
const ALsizei Delay[2] = { hrtfparams->Delay[0], hrtfparams->Delay[1] };
const ALfloat gainstep = hrtfparams->GainStep;
const ALfloat gain = hrtfparams->Gain;
ALfloat g, stepcount = 0.0f;
ALfloat left, right;
ALsizei i;
ASSUME(IrSize >= 4);
#include "config.h"
#include <arm_neon.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "alMain.h"
#include "alu.h"
#include "hrtf.h"
static inline void SetupCoeffs(ALfloat (*restrict OutCoeffs)[2],
const HrtfParams *hrtfparams,
ALuint IrSize, ALuint Counter)
{
ALuint c;
float32x4_t counter4;
{
float32x2_t counter2 = vdup_n_f32(-(float)Counter);
counter4 = vcombine_f32(counter2, counter2);
}
for(c = 0;c < IrSize;c += 2)
{
float32x4_t step4 = vld1q_f32((float32_t*)hrtfparams->CoeffStep[c]);
float32x4_t coeffs = vld1q_f32((float32_t*)hrtfparams->Coeffs[c]);
coeffs = vmlaq_f32(coeffs, step4, counter4);
vst1q_f32((float32_t*)OutCoeffs[c], coeffs);
}
}
static inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*restrict Values)[2],
#include "config.h"
#include "alMain.h"
#include "alSource.h"
#include "hrtf.h"
#include "mixer_defs.h"
#include "align.h"
#include "alu.h"
static inline void ApplyCoeffs(ALsizei Offset, ALfloat (*restrict Values)[2],
const ALsizei irSize,
const ALfloat (*restrict Coeffs)[2],
ALfloat left, ALfloat right);
void MixHrtf(ALfloat *restrict LeftOut, ALfloat *restrict RightOut,
const ALfloat *data, ALsizei Offset, ALsizei OutPos,
const ALsizei IrSize, MixHrtfParams *hrtfparams, HrtfState *hrtfstate,
ALsizei BufferSize)
{
const ALfloat (*Coeffs)[2] = ASSUME_ALIGNED(hrtfparams->Coeffs, 16);
const ALsizei Delay[2] = { hrtfparams->Delay[0], hrtfparams->Delay[1] };
ALfloat gainstep = hrtfparams->GainStep;
ALfloat gain = hrtfparams->Gain;
ALfloat left, right;
ALsizei i;
LeftOut += OutPos;
RightOut += OutPos;
ALvoid aluInitPanning(ALCdevice *device)
{
static const ChannelMap MonoCfg[1] = {
{ FrontCenter, { 1.4142f } },
}, StereoCfg[2] = {
{ FrontLeft, { 0.7071f, 0.5f, 0.0f, 0.0f } },
{ FrontRight, { 0.7071f, -0.5f, 0.0f, 0.0f } },
}, QuadCfg[4] = {
{ FrontLeft, { 0.353553f, 0.306184f, 0.0f, 0.306184f, 0.117186f, 0.0f, 0.0f, 0.0f, 0.000000f } },
{ FrontRight, { 0.353553f, -0.306184f, 0.0f, 0.306184f, -0.117186f, 0.0f, 0.0f, 0.0f, 0.000000f } },
{ BackLeft, { 0.353553f, 0.306184f, 0.0f, -0.306184f, -0.117186f, 0.0f, 0.0f, 0.0f, 0.000000f } },
{ BackRight, { 0.353553f, -0.306184f, 0.0f, -0.306184f, 0.117186f, 0.0f, 0.0f, 0.0f, 0.000000f } },
}, X51SideCfg[5] = {
{ FrontLeft, { 0.208954f, 0.238350f, 0.0f, 0.212846f, 0.204014f, 0.0f, 0.0f, 0.0f, -0.017738f, 0.047490f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f } },
{ FrontRight, { 0.208954f, -0.238350f, 0.0f, 0.212846f, -0.204014f, 0.0f, 0.0f, 0.0f, -0.017738f, -0.047490f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f } },
{ FrontCenter, { 0.109403f, 0.000000f, 0.0f, 0.179490f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.142031f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.072024f } },
{ SideLeft, { 0.470936f, 0.349386f, 0.0f, -0.369626f, -0.058144f, 0.0f, 0.0f, 0.0f, -0.031375f, -0.043968f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f } },
{ SideRight, { 0.470936f, -0.349386f, 0.0f, -0.369626f, 0.058144f, 0.0f, 0.0f, 0.0f, -0.031375f, 0.043968f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f } },
}, X51RearCfg[5] = {
{ FrontLeft, { 0.208954f, 0.238350f, 0.0f, 0.212846f, 0.204014f, 0.0f, 0.0f, 0.0f, -0.017738f, 0.047490f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f } },
{ FrontRight, { 0.208954f, -0.238350f, 0.0f, 0.212846f, -0.204014f, 0.0f, 0.0f, 0.0f, -0.017738f, -0.047490f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f } },
{ FrontCenter, { 0.109403f, 0.000000f, 0.0f, 0.179490f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.142031f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.072024f } },
{ BackLeft, { 0.470936f, 0.349386f, 0.0f, -0.369626f, -0.058144f, 0.0f, 0.0f, 0.0f, -0.031375f, -0.043968f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f } },
{ BackRight, { 0.470936f, -0.349386f, 0.0f, -0.369626f, 0.058144f, 0.0f, 0.0f, 0.0f, -0.031375f, 0.043968f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f } },
}, X61Cfg[6] = {
{ FrontLeft, { 0.167065f, 0.172695f, 0.0f, 0.200583f, 0.186407f, 0.0f, 0.0f, 0.0f, 0.029855f, 0.068910f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f } },
{ FrontRight, { 0.167065f, -0.172695f, 0.0f, 0.200583f, -0.186407f, 0.0f, 0.0f, 0.0f, 0.029855f, -0.068910f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f } },
{ FrontCenter, { 0.109403f, 0.000000f, 0.0f, 0.179490f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.142031f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.072024f } },
{ BackCenter, { 0.353556f, 0.000000f, 0.0f, -0.461940f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.165723f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f } },
{ SideLeft, { 0.289151f, 0.401292f, 0.0f, -0.081301f, -0.071420f, 0.0f, 0.0f, 0.0f, -0.188208f, -0.032897f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.010099f } },
{ SideRight, { 0.289151f, -0.401292f, 0.0f, -0.081301f, 0.071420f, 0.0f, 0.0f, 0.0f, -0.188208f, 0.032897f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.010099f } },
}, X71Cfg[7] = {
{ FrontLeft, { 0.167065f, 0.172695f, 0.0f, 0.200583f, 0.186407f, 0.0f, 0.0f, 0.0f, 0.029855f, 0.068910f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f } },
{ FrontRight, { 0.167065f, -0.172695f, 0.0f, 0.200583f, -0.186407f, 0.0f, 0.0f, 0.0f, 0.029855f, -0.068910f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f } },
{ FrontCenter, { 0.109403f, 0.000000f, 0.0f, 0.179490f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.142031f, 0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.072024f } },
{ BackLeft, { 0.224752f, 0.170325f, 0.0f, -0.295009f, -0.182473f, 0.0f, 0.0f, 0.0f, 0.105349f, 0.065799f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f } },
{ BackRight, { 0.224752f, -0.170325f, 0.0f, -0.295009f, 0.182473f, 0.0f, 0.0f, 0.0f, 0.105349f, -0.065799f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f } },
{ SideLeft, { 0.224739f, 0.340644f, 0.0f, 0.000000f, 0.000000f, 0.0f, 0.0f, 0.0f, -0.210697f, -0.065795f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f } },
{ SideRight, { 0.224739f, -0.340644f, 0.0f, 0.000000f, 0.000000f, 0.0f, 0.0f, 0.0f, -0.210697f, 0.065795f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f } },
}, BFormat3D[4] = {
{ BFormatW, { 1.0f, 0.0f, 0.0f, 0.0f } },
{ BFormatX, { 0.0f, 0.0f, 0.0f, 1.0f } },
{ BFormatY, { 0.0f, 1.0f, 0.0f, 0.0f } },
{ BFormatZ, { 0.0f, 0.0f, 1.0f, 0.0f } },
};
const ChannelMap *chanmap = NULL;
ALfloat ambiscale = 1.0f;
size_t count = 0;
device->AmbiScale = 1.0f;
memset(device->AmbiCoeffs, 0, sizeof(device->AmbiCoeffs));
device->NumChannels = 0;
if(device->Hrtf)
{
ALfloat (*coeffs_list[4])[2];
ALuint *delay_list[4];
ALuint i;
count = COUNTOF(BFormat3D);
chanmap = BFormat3D;
ambiscale = 1.0f;
for(i = 0;i < count;i++)
device->ChannelName[i] = chanmap[i].ChanName;
for(;i < MAX_OUTPUT_CHANNELS;i++)
device->ChannelName[i] = InvalidChannel;
SetChannelMap(device, chanmap, count, ambiscale);
for(i = 0;i < 4;++i)
{
static const enum Channel inputs[4] = { BFormatW, BFormatY, BFormatZ, BFormatX };
int chan = GetChannelIdxByName(device, inputs[i]);
coeffs_list[i] = device->Hrtf_Params[chan].Coeffs;
delay_list[i] = device->Hrtf_Params[chan].Delay;
}
GetBFormatHrtfCoeffs(device->Hrtf, 4, coeffs_list, delay_list);
return;
}
if(LoadChannelSetup(device))
return;
switch(device->FmtChans)
{
case DevFmtMono:
count = COUNTOF(MonoCfg);
chanmap = MonoCfg;
ambiscale = ZERO_ORDER_SCALE;
break;
case DevFmtStereo:
count = COUNTOF(StereoCfg);
chanmap = StereoCfg;
ambiscale = FIRST_ORDER_SCALE;
break;
case DevFmtQuad:
count = COUNTOF(QuadCfg);
chanmap = QuadCfg;
ambiscale = SECOND_ORDER_SCALE;
break;
case DevFmtX51:
count = COUNTOF(X51SideCfg);
chanmap = X51SideCfg;
ambiscale = THIRD_ORDER_SCALE;
break;
case DevFmtX51Rear:
count = COUNTOF(X51RearCfg);
chanmap = X51RearCfg;
ambiscale = THIRD_ORDER_SCALE;
break;
case DevFmtX61:
count = COUNTOF(X61Cfg);
chanmap = X61Cfg;
ambiscale = THIRD_ORDER_SCALE;
break;
case DevFmtX71:
count = COUNTOF(X71Cfg);
chanmap = X71Cfg;
ambiscale = THIRD_ORDER_SCALE;
break;
case DevFmtBFormat3D:
count = COUNTOF(BFormat3D);
chanmap = BFormat3D;
ambiscale = 1.0f;
break;
}
SetChannelMap(device, chanmap, count, ambiscale);
}
void Renderer::render(const Player& player, const std::vector<Entity>& entities, const std::vector<Enemy*>& enemies, const Camera* currentCamera, const bool cameraIsFPS) {
static float scaleval{};
static bool direction{};
if(direction) {
if(scaleval<50.0f)
scaleval+=0.005f;
else
direction=false;
}
else {
if(scaleval>0.005f)
scaleval-=0.005f;
else
direction=true;
}
mat4 projection{1.0f};
const float obliqueZoom{1.0f};
if(cameraIsFPS==false)
projection*=ortho(0.0f, contextW/64.0f/obliqueZoom, 0.0f,contextH/64.0f/obliqueZoom, -20.0f, 20.0f);
else
projection*=perspective(radians(60.0f+(float)(currentCamera->getSights()*60)),aspectRatio,0.05f,400.0f);
std::stack<mat4> modelview;
modelview.push(mat4{1.0f});
if(cameraIsFPS==false) {
projection*=rotate(radians(60.0f), vec3(1.0f, 0.0f, 0.0f));
projection*=translate(currentCamera->getPosition());
//glViewport((contextW-contextH)/2.0f,0,contextH,contextH);
}
else {
projection*=lookAt(
currentCamera->getPosition(),
vec3(
currentCamera->getPosition().x-currentCamera->sinAlfa()*currentCamera->cosBeta(),
currentCamera->getPosition().y-currentCamera->sinBeta(),
currentCamera->getPosition().z+currentCamera->cosAlfa()*currentCamera->cosBeta()
),
vec3{0.0f,1.0f,0.0f}
);
glViewport(0,0,contextW,contextH);
}
//Upload camera projection matrix
program->use();
program->projectionMatrix(projection);
program->normalMatrix(modelview.top());
glUniform1f(glGetUniformLocation(program->getId(),"displacementValue"),scaleval);
glError();
//set listener position
ALfloat pos[]={currentCamera->getPosition().x,currentCamera->getPosition().y,currentCamera->getPosition().z};
ALfloat orientation[]={
ALfloat(currentCamera->sinAlfa()*currentCamera->cosBeta()),
ALfloat(currentCamera->sinBeta()),
ALfloat(currentCamera->cosAlfa()*currentCamera->cosBeta())
};
alListenerfv(AL_POSITION,pos);
alListenerfv(AL_ORIENTATION,orientation);
//Start rendering by clearing buffers
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//
// Render gun
//
modelview.push(modelview.top());
modelview.top()*=translate(currentCamera->getPosition());
modelview.top()*=rotate(radians((float)-currentCamera->getYaw()+180.0f),vec3(0.0f,1.0f,0.0f));
modelview.top()*=rotate(radians((float)-currentCamera->getPitch()),vec3(1.0f,0.0f,0.0f));
//delay effect
const double sightsCompensation{((currentCamera->getSights()+0.18)*0.2)*20};
const double delayX{currentCamera->getDelay()*sightsCompensation};
const double delayY{currentCamera->getDelayY()*sightsCompensation};
modelview.top()*=translate(
vec3{ -(delayX*5.0),
delayY*5.0,
currentCamera->getRecoil()+fabs(delayY*5.0)+fabs(5.0f*delayX)+fabs(5.0f*delayX)
});
//looking down sights
modelview.top()*=translate(vec3{currentCamera->getSights(),0.0f,0.0f-(currentCamera->getSights())});
program->modelviewMatrix(modelview.top());
for(auto m: models) {
if(m->getName()=="models/gun.obj") //"models/knife.obj"
m->render(program->getId());
}
//Update Gun Ammo Texture and don't update it every frame
for(auto m: models) {
if(m->getName()=="models/gun_display.obj") {
static Texture* temp{nullptr}; //rendered texture for ammo display
static int renderedAmmo{-1}; //last update for rendering ammo texture
const unsigned int ammo{player.getGunAmmo()}; //current ammo
if(renderedAmmo!=ammo) {
std::stringstream ss;
delete temp;
ss<<(ammo<10?" ":" ")<<ammo<<(ammo<10?" ":" ");
temp=fManager.renderToTexture(ss.str(),FontSize::MEDIUM);
m->parts[0].mat->displacement=temp;
const float ammoDivided{1.0f-((40.0f-float(ammo))/40.0f)};
//inverse colors
const vec3 green{1.0,0.0,1.0};
const vec3 red{0.0,1.0,1.0};
const vec3 yellow{0.0,0.0,1.0};
m->parts[0].mat->dcolor=glm::normalize((mix(red,yellow,ammoDivided*0.5))+(ammoDivided*green*2));
//green m->parts[0].mat->dcolor=vec3{1.0,0.0,1.0};
//red m->parts[0].mat->dcolor=vec3{0.0,1.0,1.0};
//yellow m->parts[0].mat->dcolor=vec3{0.0,0.15,1.0};
renderedAmmo=ammo;
}
glUniform1f(glGetUniformLocation(program->getId(),"renderTL"),3.0f);
m->render(program->getId());
glUniform1f(glGetUniformLocation(program->getId(),"renderTL"),0.0f);
}
}
modelview.pop();
//
// END RENDER GUN
//
const float RENDER_CLIP_DISTANCE{24.0f*10};
double asdf=0.0;
//add falling flying enemies
std::vector<Enemy*> tmpEnemies=enemies;
for(auto e: entities) {
if(e.modelName=="models/flyingenemy-spikes.obj") {
tmpEnemies.push_back(new FlyingEnemy{vec3{},vec3{},100});
tmpEnemies.back()->rotationMatrix=e.rotationMatrix;
}
}
//Render flying enemies
for(auto enemy: tmpEnemies) {
//check if in distance
if( glm::distance(currentCamera->getPosition(),enemy->position) > RENDER_CLIP_DISTANCE )
continue;
auto parts=enemy->renderableEntities();
//Render each enemy part
for(size_t i=0; i<parts.size(); ++i) {
modelview.push(modelview.top());
//modelview.top()*=glm::scale(vec3{0.5f,0.5f,0.5f});
//compensate tentacles position
if(i>0) {
modelview.top()*=translate(parts[0].position);
modelview.top()*=glm::mat4_cast(glm::quat{vec3{parts[0].rotation}});
modelview.top()*=parts[0].rotationMatrix;
}
modelview.top()*=translate(parts[i].position);
modelview.top()*=glm::mat4_cast(glm::quat{vec3{parts[i].rotation}});
modelview.top()*=parts[i].rotationMatrix;
program->modelviewMatrix(modelview.top());
if(parts[i].modelName=="models/tentacle.obj") {
asdf++;
glUniform1f(glGetUniformLocation(program->getId(),"displacementValue"),scaleval+(asdf));
glUniform1f(glGetUniformLocation(program->getId(),"renderTL"),99.0f);
}
for(auto m: models) {
if(m->getName()==parts[i].modelName) {
m->render(program->getId());
}
}
glUniform1f(glGetUniformLocation(program->getId(),"renderTL"),0.0f);
modelview.pop();
}
}
//Render other entities
for(auto entity: entities) {
//check if in distance
if( glm::distance(currentCamera->getPosition(),entity.position) > RENDER_CLIP_DISTANCE )
continue;
if(entity.modelName=="models/flyingenemy-spikes.obj")
continue;
modelview.push(modelview.top());
//modelview.top()*=translate(entity.position);
modelview.top()*=rotate(radians(entity.rotation.w),glm::vec3{entity.rotation});
modelview.top()*=entity.rotationMatrix;
program->modelviewMatrix(modelview.top());
for(auto m: models) {
if(m->getName()==entity.modelName) {
Texture* temp{nullptr};
//
// Render Traffic Light
//
if(m->getName()=="models/traffic_light_pedestrian.obj") {
static size_t ticks=SDL_GetTicks()+9000;
//FIXME move to logic classes
std::stringstream ss;
int result=ticks-SDL_GetTicks();
if(result<0)
result=0;
result/=1000;
if(result>0) {
glUniform1f(glGetUniformLocation(program->getId(),"renderTL"),1.0f);
ss<<result;
temp=fManager.renderToTexture(result<1?" ":ss.str(),FontSize::SMALL);
m->parts[1].mat->displacement=temp;
m->parts[0].mat->dcolor=vec3{0.0,0.0,0.0};
}
else {
glUniform1f(glGetUniformLocation(program->getId(),"renderTL"),2.0f);
m->parts[1].mat->dcolor=vec3{0.0,0.0,0.0};
m->parts[0].mat->dcolor=vec3{0.0,1.0,0.0};
}
}
m->render(program->getId());
glUniform1f(glGetUniformLocation(program->getId(),"renderTL"),0.0f);
delete temp;
}
}
modelview.pop();
}
}
fluid_synth_t *Synth;
int FontID;
ALboolean ForceGM2BankSelect;
} FSynth;
static void FSynth_Construct(FSynth *self, ALCdevice *device);
static void FSynth_Destruct(FSynth *self);
static ALboolean FSynth_init(FSynth *self, ALCdevice *device);
static ALboolean FSynth_isSoundfont(FSynth *self, const char *filename);
static ALenum FSynth_loadSoundfont(FSynth *self, const char *filename);
static void FSynth_setGain(FSynth *self, ALfloat gain);
static void FSynth_setState(FSynth *self, ALenum state);
static void FSynth_reset(FSynth *self);
static void FSynth_update(FSynth *self, ALCdevice *device);
static void FSynth_process(FSynth *self, ALuint SamplesToDo, ALfloat (*restrict DryBuffer)[BUFFERSIZE]);
static void FSynth_Delete(FSynth *self);
DEFINE_MIDISYNTH_VTABLE(FSynth);
static void FSynth_Construct(FSynth *self, ALCdevice *device)
{
MidiSynth_Construct(STATIC_CAST(MidiSynth, self), device);
SET_VTABLE2(FSynth, MidiSynth, self);
self->Settings = NULL;
self->Synth = NULL;
self->FontID = FLUID_FAILED;
self->ForceGM2BankSelect = AL_FALSE;
}
ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
{
static const ALfloat angles_Mono[1] = { 0.0f };
static const ALfloat angles_Stereo[2] = { -30.0f, 30.0f };
static const ALfloat angles_Rear[2] = { -150.0f, 150.0f };
static const ALfloat angles_Quad[4] = { -45.0f, 45.0f, -135.0f, 135.0f };
static const ALfloat angles_X51[6] = { -30.0f, 30.0f, 0.0f, 0.0f,
-110.0f, 110.0f };
static const ALfloat angles_X61[7] = { -30.0f, 30.0f, 0.0f, 0.0f,
180.0f, -90.0f, 90.0f };
static const ALfloat angles_X71[8] = { -30.0f, 30.0f, 0.0f, 0.0f,
-110.0f, 110.0f, -90.0f, 90.0f };
static const enum Channel chans_Mono[1] = { FRONT_CENTER };
static const enum Channel chans_Stereo[2] = { FRONT_LEFT, FRONT_RIGHT };
static const enum Channel chans_Rear[2] = { BACK_LEFT, BACK_RIGHT };
static const enum Channel chans_Quad[4] = { FRONT_LEFT, FRONT_RIGHT,
BACK_LEFT, BACK_RIGHT };
static const enum Channel chans_X51[6] = { FRONT_LEFT, FRONT_RIGHT,
FRONT_CENTER, LFE,
BACK_LEFT, BACK_RIGHT };
static const enum Channel chans_X61[7] = { FRONT_LEFT, FRONT_RIGHT,
FRONT_CENTER, LFE, BACK_CENTER,
SIDE_LEFT, SIDE_RIGHT };
static const enum Channel chans_X71[8] = { FRONT_LEFT, FRONT_RIGHT,
FRONT_CENTER, LFE,
BACK_LEFT, BACK_RIGHT,
SIDE_LEFT, SIDE_RIGHT };
ALCdevice *Device = ALContext->Device;
ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
ALbufferlistitem *BufferListItem;
enum DevFmtChannels DevChans;
enum FmtChannels Channels;
ALfloat (*SrcMatrix)[MAXCHANNELS];
ALfloat DryGain, DryGainHF;
ALfloat WetGain[MAX_SENDS];
ALfloat WetGainHF[MAX_SENDS];
ALint NumSends, Frequency;
const ALfloat *SpeakerGain;
const ALfloat *angles = NULL;
const enum Channel *chans = NULL;
enum Resampler Resampler;
ALint num_channels = 0;
ALboolean VirtualChannels;
ALfloat Pitch;
ALfloat cw;
ALuint pos;
ALint i, c;
/* Get device properties */
DevChans = ALContext->Device->FmtChans;
NumSends = ALContext->Device->NumAuxSends;
Frequency = ALContext->Device->Frequency;
/* Get listener properties */
ListenerGain = ALContext->Listener.Gain;
/* Get source properties */
SourceVolume = ALSource->flGain;
MinVolume = ALSource->flMinGain;
MaxVolume = ALSource->flMaxGain;
Pitch = ALSource->flPitch;
Resampler = ALSource->Resampler;
VirtualChannels = ALSource->VirtualChannels;
/* Calculate the stepping value */
Channels = FmtMono;
BufferListItem = ALSource->queue;
while(BufferListItem != NULL)
{
ALbuffer *ALBuffer;
if((ALBuffer=BufferListItem->buffer) != NULL)
{
ALint maxstep = STACK_DATA_SIZE / ALSource->NumChannels /
ALSource->SampleSize;
maxstep -= ResamplerPadding[Resampler] +
ResamplerPrePadding[Resampler] + 1;
maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
Pitch = Pitch * ALBuffer->Frequency / Frequency;
if(Pitch > (ALfloat)maxstep)
ALSource->Params.Step = maxstep<<FRACTIONBITS;
else
{
ALSource->Params.Step = Pitch*FRACTIONONE;
if(ALSource->Params.Step == 0)
ALSource->Params.Step = 1;
}
Channels = ALBuffer->FmtChannels;
if(ALSource->VirtualChannels && (Device->Flags&DEVICE_USE_HRTF))
ALSource->Params.DoMix = SelectHrtfMixer(ALBuffer,
(ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
Resampler);
else
ALSource->Params.DoMix = SelectMixer(ALBuffer,
(ALSource->Params.Step==FRACTIONONE) ? POINT_RESAMPLER :
Resampler);
break;
}
BufferListItem = BufferListItem->next;
}
#include "config.h"
#include <arm_neon.h>
#include "AL/al.h"
#include "AL/alc.h"
#include "alMain.h"
#include "alu.h"
#include "hrtf.h"
static inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*restrict Values)[2],
const ALuint IrSize,
ALfloat (*restrict Coeffs)[2],
const ALfloat (*restrict CoeffStep)[2],
ALfloat left, ALfloat right)
{
ALuint c;
float32x4_t leftright4;
{
float32x2_t leftright2 = vdup_n_f32(0.0);
leftright2 = vset_lane_f32(left, leftright2, 0);
leftright2 = vset_lane_f32(right, leftright2, 1);
leftright4 = vcombine_f32(leftright2, leftright2);
}
for(c = 0;c < IrSize;c += 2)
{
const ALuint o0 = (Offset+c)&HRIR_MASK;
const ALuint o1 = (o0+1)&HRIR_MASK;
float32x4_t vals = vcombine_f32(vld1_f32((float32_t*)&Values[o0][0]),
vld1_f32((float32_t*)&Values[o1][0]));
static inline void alSource3f(ALuint source, ALenum param, const LVector3 &v)
{
::alSource3f(source, param, ALfloat(v.x), ALfloat(v.y), ALfloat(v.z));
}
ALvoid aluInitPanning(ALCdevice *Device)
{
ALfloat SpeakerAngle[MAXCHANNELS];
ALfloat (*Matrix)[MAXCHANNELS];
Channel *Speaker2Chan;
ALfloat Alpha, Theta;
ALfloat *PanningLUT;
ALint pos, offset;
ALuint s, s2;
for(s = 0;s < MAXCHANNELS;s++)
{
for(s2 = 0;s2 < MAXCHANNELS;s2++)
Device->ChannelMatrix[s][s2] = ((s==s2) ? 1.0f : 0.0f);
}
Speaker2Chan = Device->Speaker2Chan;
Matrix = Device->ChannelMatrix;
switch(Device->FmtChans)
{
case DevFmtMono:
Matrix[FRONT_LEFT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[FRONT_RIGHT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[SIDE_LEFT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[SIDE_RIGHT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[BACK_LEFT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[BACK_RIGHT][FRONT_CENTER] = aluSqrt(0.5);
Matrix[BACK_CENTER][FRONT_CENTER] = 1.0f;
Device->NumChan = 1;
Speaker2Chan[0] = FRONT_CENTER;
SpeakerAngle[0] = 0.0f * M_PI/180.0f;
break;
case DevFmtStereo:
Matrix[FRONT_CENTER][FRONT_LEFT] = aluSqrt(0.5);
Matrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5);
Matrix[SIDE_LEFT][FRONT_LEFT] = 1.0f;
Matrix[SIDE_RIGHT][FRONT_RIGHT] = 1.0f;
Matrix[BACK_LEFT][FRONT_LEFT] = 1.0f;
Matrix[BACK_RIGHT][FRONT_RIGHT] = 1.0f;
Matrix[BACK_CENTER][FRONT_LEFT] = aluSqrt(0.5);
Matrix[BACK_CENTER][FRONT_RIGHT] = aluSqrt(0.5);
Device->NumChan = 2;
Speaker2Chan[0] = FRONT_LEFT;
Speaker2Chan[1] = FRONT_RIGHT;
SpeakerAngle[0] = -90.0f * M_PI/180.0f;
SpeakerAngle[1] = 90.0f * M_PI/180.0f;
SetSpeakerArrangement("layout_STEREO", SpeakerAngle, Speaker2Chan, Device->NumChan);
break;
case DevFmtQuad:
Matrix[FRONT_CENTER][FRONT_LEFT] = aluSqrt(0.5);
Matrix[FRONT_CENTER][FRONT_RIGHT] = aluSqrt(0.5);
Matrix[SIDE_LEFT][FRONT_LEFT] = aluSqrt(0.5);
Matrix[SIDE_LEFT][BACK_LEFT] = aluSqrt(0.5);
Matrix[SIDE_RIGHT][FRONT_RIGHT] = aluSqrt(0.5);
Matrix[SIDE_RIGHT][BACK_RIGHT] = aluSqrt(0.5);
Matrix[BACK_CENTER][BACK_LEFT] = aluSqrt(0.5);
Matrix[BACK_CENTER][BACK_RIGHT] = aluSqrt(0.5);
Device->NumChan = 4;
Speaker2Chan[0] = BACK_LEFT;
Speaker2Chan[1] = FRONT_LEFT;
Speaker2Chan[2] = FRONT_RIGHT;
Speaker2Chan[3] = BACK_RIGHT;
SpeakerAngle[0] = -135.0f * M_PI/180.0f;
SpeakerAngle[1] = -45.0f * M_PI/180.0f;
SpeakerAngle[2] = 45.0f * M_PI/180.0f;
SpeakerAngle[3] = 135.0f * M_PI/180.0f;
SetSpeakerArrangement("layout_QUAD", SpeakerAngle, Speaker2Chan, Device->NumChan);
break;
case DevFmtX51:
Matrix[SIDE_LEFT][FRONT_LEFT] = aluSqrt(0.5);
Matrix[SIDE_LEFT][BACK_LEFT] = aluSqrt(0.5);
Matrix[SIDE_RIGHT][FRONT_RIGHT] = aluSqrt(0.5);
Matrix[SIDE_RIGHT][BACK_RIGHT] = aluSqrt(0.5);
Matrix[BACK_CENTER][BACK_LEFT] = aluSqrt(0.5);
Matrix[BACK_CENTER][BACK_RIGHT] = aluSqrt(0.5);
Device->NumChan = 5;
Speaker2Chan[0] = BACK_LEFT;
Speaker2Chan[1] = FRONT_LEFT;
Speaker2Chan[2] = FRONT_CENTER;
Speaker2Chan[3] = FRONT_RIGHT;
Speaker2Chan[4] = BACK_RIGHT;
SpeakerAngle[0] = -110.0f * M_PI/180.0f;
SpeakerAngle[1] = -30.0f * M_PI/180.0f;
SpeakerAngle[2] = 0.0f * M_PI/180.0f;
SpeakerAngle[3] = 30.0f * M_PI/180.0f;
SpeakerAngle[4] = 110.0f * M_PI/180.0f;
SetSpeakerArrangement("layout_51CHN", SpeakerAngle, Speaker2Chan, Device->NumChan);
break;
case DevFmtX61:
Matrix[BACK_LEFT][BACK_CENTER] = aluSqrt(0.5);
Matrix[BACK_LEFT][SIDE_LEFT] = aluSqrt(0.5);
Matrix[BACK_RIGHT][BACK_CENTER] = aluSqrt(0.5);
Matrix[BACK_RIGHT][SIDE_RIGHT] = aluSqrt(0.5);
Device->NumChan = 6;
Speaker2Chan[0] = SIDE_LEFT;
Speaker2Chan[1] = FRONT_LEFT;
Speaker2Chan[2] = FRONT_CENTER;
Speaker2Chan[3] = FRONT_RIGHT;
Speaker2Chan[4] = SIDE_RIGHT;
Speaker2Chan[5] = BACK_CENTER;
SpeakerAngle[0] = -90.0f * M_PI/180.0f;
SpeakerAngle[1] = -30.0f * M_PI/180.0f;
SpeakerAngle[2] = 0.0f * M_PI/180.0f;
SpeakerAngle[3] = 30.0f * M_PI/180.0f;
SpeakerAngle[4] = 90.0f * M_PI/180.0f;
SpeakerAngle[5] = 180.0f * M_PI/180.0f;
SetSpeakerArrangement("layout_61CHN", SpeakerAngle, Speaker2Chan, Device->NumChan);
break;
case DevFmtX71:
Matrix[BACK_CENTER][BACK_LEFT] = aluSqrt(0.5);
Matrix[BACK_CENTER][BACK_RIGHT] = aluSqrt(0.5);
Device->NumChan = 7;
Speaker2Chan[0] = BACK_LEFT;
Speaker2Chan[1] = SIDE_LEFT;
Speaker2Chan[2] = FRONT_LEFT;
Speaker2Chan[3] = FRONT_CENTER;
Speaker2Chan[4] = FRONT_RIGHT;
Speaker2Chan[5] = SIDE_RIGHT;
Speaker2Chan[6] = BACK_RIGHT;
SpeakerAngle[0] = -150.0f * M_PI/180.0f;
SpeakerAngle[1] = -90.0f * M_PI/180.0f;
SpeakerAngle[2] = -30.0f * M_PI/180.0f;
SpeakerAngle[3] = 0.0f * M_PI/180.0f;
SpeakerAngle[4] = 30.0f * M_PI/180.0f;
SpeakerAngle[5] = 90.0f * M_PI/180.0f;
SpeakerAngle[6] = 150.0f * M_PI/180.0f;
SetSpeakerArrangement("layout_71CHN", SpeakerAngle, Speaker2Chan, Device->NumChan);
break;
}
if(GetConfigValueBool(NULL, "scalemix", 0))
{
ALfloat maxout = 1.0f;
for(s = 0;s < MAXCHANNELS;s++)
{
ALfloat out = 0.0f;
for(s2 = 0;s2 < MAXCHANNELS;s2++)
out += Device->ChannelMatrix[s2][s];
maxout = __max(maxout, out);
}
maxout = 1.0f/maxout;
for(s = 0;s < MAXCHANNELS;s++)
{
for(s2 = 0;s2 < MAXCHANNELS;s2++)
Device->ChannelMatrix[s2][s] *= maxout;
}
}
PanningLUT = Device->PanningLUT;
for(pos = 0; pos < LUT_NUM; pos++)
{
/* clear all values */
offset = MAXCHANNELS * pos;
for(s = 0; s < MAXCHANNELS; s++)
PanningLUT[offset+s] = 0.0f;
if(Device->NumChan == 1)
{
PanningLUT[offset + Speaker2Chan[0]] = 1.0f;
continue;
}
/* source angle */
Theta = aluLUTpos2Angle(pos);
/* set panning values */
for(s = 0; s < Device->NumChan - 1; s++)
{
if(Theta >= SpeakerAngle[s] && Theta < SpeakerAngle[s+1])
{
/* source between speaker s and speaker s+1 */
Alpha = M_PI_2 * (Theta-SpeakerAngle[s]) /
(SpeakerAngle[s+1]-SpeakerAngle[s]);
PanningLUT[offset + Speaker2Chan[s]] = cos(Alpha);
PanningLUT[offset + Speaker2Chan[s+1]] = sin(Alpha);
break;
}
}
if(s == Device->NumChan - 1)
{
/* source between last and first speaker */
if(Theta < SpeakerAngle[0])
Theta += 2.0f * M_PI;
Alpha = M_PI_2 * (Theta-SpeakerAngle[s]) /
(2.0f * M_PI + SpeakerAngle[0]-SpeakerAngle[s]);
PanningLUT[offset + Speaker2Chan[s]] = cos(Alpha);
PanningLUT[offset + Speaker2Chan[0]] = sin(Alpha);
}
}
}
inVector1[2]*inVector2[2];
}
static __inline void aluNormalize(ALfloat *inVector)
{
ALfloat lengthsqr = aluDotproduct(inVector, inVector);
if(lengthsqr > 0.0f)
{
ALfloat inv_length = 1.0f/sqrtf(lengthsqr);
inVector[0] *= inv_length;
inVector[1] *= inv_length;
inVector[2] *= inv_length;
}
}
static __inline ALvoid aluMatrixVector(ALfloat *vector, ALfloat w, ALfloat (*RESTRICT matrix)[4])
{
ALfloat temp[4] = {
vector[0], vector[1], vector[2], w
};
vector[0] = temp[0]*matrix[0][0] + temp[1]*matrix[1][0] + temp[2]*matrix[2][0] + temp[3]*matrix[3][0];
vector[1] = temp[0]*matrix[0][1] + temp[1]*matrix[1][1] + temp[2]*matrix[2][1] + temp[3]*matrix[3][1];
vector[2] = temp[0]*matrix[0][2] + temp[1]*matrix[1][2] + temp[2]*matrix[2][2] + temp[3]*matrix[3][2];
}
static ALvoid CalcListenerParams(ALlistener *Listener)
{
ALfloat N[3], V[3], U[3], P[3];
#ifdef HAVE_XMMINTRIN_H
#include <xmmintrin.h>
#endif
#include "AL/al.h"
#include "AL/alc.h"
#include "alMain.h"
#include "alu.h"
#include "alSource.h"
#include "alAuxEffectSlot.h"
#include "mixer_defs.h"
static __inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*RESTRICT Values)[2],
const ALuint IrSize,
ALfloat (*RESTRICT Coeffs)[2],
const ALfloat (*RESTRICT CoeffStep)[2],
ALfloat left, ALfloat right)
{
const __m128 lrlr = { left, right, left, right };
__m128 coeffs, deltas, imp0, imp1;
__m128 vals = _mm_setzero_ps();
ALuint i;
if((Offset&1))
{
const ALuint o0 = Offset&HRIR_MASK;
const ALuint o1 = (Offset+IrSize-1)&HRIR_MASK;
ALvoid CalcNonAttnSourceParams(ALsource *ALSource, const ALCcontext *ALContext)
{
static const struct ChanMap MonoMap[1] = { { FRONT_CENTER, 0.0f } };
static const struct ChanMap StereoMap[2] = { { FRONT_LEFT, -30.0f },
{ FRONT_RIGHT, 30.0f } };
static const struct ChanMap RearMap[2] = { { BACK_LEFT, -150.0f },
{ BACK_RIGHT, 150.0f } };
static const struct ChanMap QuadMap[4] = { { FRONT_LEFT, -45.0f },
{ FRONT_RIGHT, 45.0f },
{ BACK_LEFT, -135.0f },
{ BACK_RIGHT, 135.0f } };
static const struct ChanMap X51Map[6] = { { FRONT_LEFT, -30.0f },
{ FRONT_RIGHT, 30.0f },
{ FRONT_CENTER, 0.0f },
{ LFE, 0.0f },
{ BACK_LEFT, -110.0f },
{ BACK_RIGHT, 110.0f } };
static const struct ChanMap X61Map[7] = { { FRONT_LEFT, -30.0f },
{ FRONT_RIGHT, 30.0f },
{ FRONT_CENTER, 0.0f },
{ LFE, 0.0f },
{ BACK_CENTER, 180.0f },
{ SIDE_LEFT, -90.0f },
{ SIDE_RIGHT, 90.0f } };
static const struct ChanMap X71Map[8] = { { FRONT_LEFT, -30.0f },
{ FRONT_RIGHT, 30.0f },
{ FRONT_CENTER, 0.0f },
{ LFE, 0.0f },
{ BACK_LEFT, -110.0f },
{ BACK_RIGHT, 110.0f },
{ SIDE_LEFT, -90.0f },
{ SIDE_RIGHT, 90.0f } };
ALCdevice *Device = ALContext->Device;
ALfloat SourceVolume,ListenerGain,MinVolume,MaxVolume;
ALbufferlistitem *BufferListItem;
enum DevFmtChannels DevChans;
enum FmtChannels Channels;
ALfloat (*SrcMatrix)[MAXCHANNELS];
ALfloat DryGain, DryGainHF;
ALfloat WetGain[MAX_SENDS];
ALfloat WetGainHF[MAX_SENDS];
ALint NumSends, Frequency;
const ALfloat *SpeakerGain;
const struct ChanMap *chans = NULL;
enum Resampler Resampler;
ALint num_channels = 0;
ALboolean VirtualChannels;
ALfloat Pitch;
ALfloat cw;
ALuint pos;
ALint i, c;
/* Get device properties */
DevChans = Device->FmtChans;
NumSends = Device->NumAuxSends;
Frequency = Device->Frequency;
/* Get listener properties */
ListenerGain = ALContext->Listener.Gain;
/* Get source properties */
SourceVolume = ALSource->flGain;
MinVolume = ALSource->flMinGain;
MaxVolume = ALSource->flMaxGain;
Pitch = ALSource->flPitch;
Resampler = ALSource->Resampler;
VirtualChannels = ALSource->VirtualChannels;
/* Calculate the stepping value */
Channels = FmtMono;
BufferListItem = ALSource->queue;
while(BufferListItem != NULL)
{
ALbuffer *ALBuffer;
if((ALBuffer=BufferListItem->buffer) != NULL)
{
ALsizei maxstep = STACK_DATA_SIZE/sizeof(ALfloat) /
ALSource->NumChannels;
maxstep -= ResamplerPadding[Resampler] +
ResamplerPrePadding[Resampler] + 1;
maxstep = mini(maxstep, INT_MAX>>FRACTIONBITS);
Pitch = Pitch * ALBuffer->Frequency / Frequency;
if(Pitch > (ALfloat)maxstep)
ALSource->Params.Step = maxstep<<FRACTIONBITS;
else
{
ALSource->Params.Step = fastf2i(Pitch*FRACTIONONE);
if(ALSource->Params.Step == 0)
ALSource->Params.Step = 1;
}
Channels = ALBuffer->FmtChannels;
break;
}
BufferListItem = BufferListItem->next;
}
