[C++ / GrAPic] Ball physics with sound

#include <SDL_audio.h>
#include <Grapic.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <queue>
#include <cmath>











// yoinked from jrok's code (https://stackoverflow.com/users/947836/jrok)

const int AMPLITUDE = 28000;
const int FREQUENCY = 44100;

struct BeepObject {
    double freq;
    int samplesLeft;
};

class Beeper {
private:
    double v;
    std::queue<BeepObject> beeps;
public:
    Beeper();
    ~Beeper();
    void beep(double freq, int duration);
    void generateSamples(Sint16 *stream, int length);
    void wait();
};

void audio_callback(void*, Uint8*, int);

Beeper::Beeper() {
    SDL_AudioSpec desiredSpec;

    desiredSpec.freq = FREQUENCY;
    desiredSpec.format = AUDIO_S16SYS;
    desiredSpec.channels = 1;
    desiredSpec.samples = 2048;
    desiredSpec.callback = audio_callback;
    desiredSpec.userdata = this;

    SDL_AudioSpec obtainedSpec;

    // you might want to look for errors here
    SDL_OpenAudio(&desiredSpec, &obtainedSpec);

    // start play audio
    SDL_PauseAudio(0);
}

Beeper::~Beeper() {
    SDL_CloseAudio();
}

double fade_out (double v, double a, double b) {
    if (v < a) return AMPLITUDE;
    if (v >= a and v <= b) return AMPLITUDE-(AMPLITUDE*(v-a)/(b-a));
    else return 0;
}

double mod (double x, double n) {
    return n-(x-n*floor(x/n));
}

void Beeper::generateSamples(Sint16 *stream, int length) {
    int i = 0;
    while (i < length) {

        if (beeps.empty()) {
            while (i < length) {
                stream[i] = 0;
                i++;
            }
            return;
        }
        BeepObject& bo = beeps.front();

        int samplesToDo = std::min(i + bo.samplesLeft, length);
        bo.samplesLeft -= samplesToDo - i;

        while (i < samplesToDo) {
            stream[i] = AMPLITUDE * (std::sin(v * 2 * M_PI / FREQUENCY));
            // vous pouvez y mettre les trucs que vous voulez, même des séries d'fourier why not
            i++;
            v += bo.freq;
        }

        if (bo.samplesLeft == 0) {
            beeps.pop();
        }
    }
}

void Beeper::beep(double freq, int duration) {
    BeepObject bo;
    bo.freq = freq;
    bo.samplesLeft = duration * FREQUENCY / 1000;

    SDL_LockAudio();
    beeps.push(bo);
    SDL_UnlockAudio();
}

void Beeper::wait() {
    int size;
    do {
        SDL_Delay(20);
        SDL_LockAudio();
        size = beeps.size();
        SDL_UnlockAudio();
    } while (size > 0);

}

void audio_callback(void *_beeper, Uint8 *_stream, int _length) {
    Sint16 *stream = (Sint16*) _stream;
    int length = _length / 2;
    Beeper* beeper = (Beeper*) _beeper;

    beeper->generateSamples(stream, length);
}



















using namespace grapic;
const int DIMW = 900;
const int MAX = 256;
const float FRICTION = 0.5;
const float G = 2.0*pow(10,-11)/3.0;

struct vec {
    float x;
    float y;
};

vec mkvec (float x, float y) {
    vec ret;
    ret.x = x; ret.y = y;
    return ret;
}
vec operator+ (vec a, vec b) { return mkvec(a.x+b.x,a.y+b.y); }
vec operator- (vec a, vec b) { return mkvec(a.x-b.x,a.y-b.y); }
void operator+= (vec &a, vec b) { a=a+b; }
bool operator== (vec a, vec b) { return (a.x == b.x) and (a.y == b.y); }
vec operator* (vec a, float b) { return mkvec(a.x*b,a.y*b); }

struct Particle {
    vec pos;
    vec v;
    vec F;
    float m;
    int r;
    int g;
    int b;
};

void partInit (Particle& p, vec pos, vec v, float m) {
    p.m = m;
    p.pos = pos;
    p.v = v;
    p.F = mkvec(0,0);
}

void partAddForce (Particle& p, vec force) {
    p.F += force;
}

float cjgsqr (vec a) { return (a.x*a.x)+(a.y*a.y); }

void partUpdatePV (Particle& p, bool& b, double &Hz) {
    float dt = 0.025;
    vec oldpos = p.pos;
    b = false;
    p.v += p.F*(dt*p.m);
    if (abs(p.pos.x + p.v.x*dt - DIMW/2) >= DIMW/2) { p.v.x = -p.v.x; p.v = p.v*FRICTION; b = true; }
    if (abs(p.pos.y + p.v.y*dt - DIMW/2) >= DIMW/2) { p.v.y = -p.v.y; p.v = p.v*FRICTION; b = true; }
    p.pos += p.v*dt; if (p.pos.y <= oldpos.y+1 and p.pos.y < 1 and oldpos.y < 1) b = false;
    Hz = cjgsqr(p.v)/30 + p.pos.y/30 + 110;
}

int main(int, char**) {

    srand(time(NULL));

    bool stop = false;
    double Hz = 0;
    Particle P[MAX];

    int nb = 100, j = 0;
    float dt = 0.1;
    Beeper boop;
    bool b = false;
    int R[MAX];

    winInit("Particules",DIMW,DIMW);
    backgroundColor(0,0,0);
    color(255,255,255);
    pressSpace();

    loop:
    for (int i = 0; i < nb; i++) {
        partInit(P[i],mkvec(DIMW/2,DIMW/2),mkvec(rand()%DIMW-DIMW/2,rand()%DIMW-DIMW/2),rand()%10+1);
        partAddForce(P[i],mkvec(0,-9.81));
        P[i].r = rand() % 256; P[i].g = rand() % 256; P[i].b = rand() % 256;
        R[i] = rand()%10+10;
    }

    while (!stop) {
        winClear();
        for (int i = 0; i < nb; i++) {
            //F(P,nb);
            partUpdatePV(P[i],b,Hz);
            color(P[i].r,P[i].g,P[i].b,200);
            circleFill(P[i].pos.x,P[i].pos.y,R[i]);
            if (b) { boop.beep(Hz,1); }
        }
        if (isKeyPressed(SDLK_SPACE)) {
            goto loop;
        }
        stop = winDisplay();
    }

    winQuit();
    return 0;

}