268 lines
7.7 KiB
C++
Executable File
268 lines
7.7 KiB
C++
Executable File
/*==============================================================================
|
|
|
|
Copyright 2018 by Roland Rabien
|
|
For more information visit www.rabiensoftware.com
|
|
|
|
==============================================================================*/
|
|
|
|
#pragma once
|
|
|
|
//==============================================================================
|
|
inline bool compareAndReset (bool& flag)
|
|
{
|
|
if (flag)
|
|
{
|
|
flag = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline float calculateRMS (const float* values, int n)
|
|
{
|
|
float rms = 0;
|
|
|
|
for (int i = 0; i < n; i++)
|
|
rms += values[i] * values[i];
|
|
|
|
return std::sqrt ((1.0f / n) * rms);
|
|
}
|
|
|
|
inline float calculateMedian (const float* values, int n)
|
|
{
|
|
Array<float> f;
|
|
f.insertArray (0, values, n);
|
|
f.sort();
|
|
|
|
if (f.size() % 2 == 0)
|
|
return (f[f.size() / 2] + f[f.size() / 2 - 1]) / 2.0f;
|
|
|
|
return f[f.size() / 2];
|
|
}
|
|
|
|
//==============================================================================
|
|
// Fisher-Yates Shuffle
|
|
template <typename T>
|
|
void shuffleArray (Random& r, T array)
|
|
{
|
|
const int n = array.size();
|
|
for (int i = n - 1; i >= 1; i--)
|
|
{
|
|
int j = r.nextInt (i + 1);
|
|
array.swap (i, j);
|
|
}
|
|
}
|
|
|
|
//==============================================================================
|
|
// Based on reference implementation of Perlin Noise by Ken Perlin
|
|
// http://mrl.nyu.edu/~perlin/paper445.pdf
|
|
template <class T>
|
|
class PerlinNoise
|
|
{
|
|
public:
|
|
PerlinNoise()
|
|
{
|
|
p = { 151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,
|
|
8,99,37,240,21,10,23,190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,
|
|
35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,
|
|
134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,
|
|
55,46,245,40,244,102,143,54, 65,25,63,161,1,216,80,73,209,76,132,187,208, 89,
|
|
18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,
|
|
250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,
|
|
189,28,42,223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167,
|
|
43,172,9,129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,
|
|
97,228,251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,
|
|
107,49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
|
|
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180 };
|
|
|
|
p.addArray (p);
|
|
}
|
|
|
|
PerlinNoise (unsigned int seed)
|
|
{
|
|
Random r (seed);
|
|
|
|
for (int i = 0; i <= 255; i++)
|
|
p.add (i);
|
|
|
|
shuffleArray (r, p);
|
|
|
|
p.addArray (p);
|
|
}
|
|
|
|
T noise (T x, T y = 0, T z = 0)
|
|
{
|
|
int X = (int) std::floor (x) & 255;
|
|
int Y = (int) std::floor (y) & 255;
|
|
int Z = (int) std::floor (z) & 255;
|
|
|
|
x -= std::floor (x);
|
|
y -= std::floor (y);
|
|
z -= std::floor (z);
|
|
|
|
T u = fade (x);
|
|
T v = fade (y);
|
|
T w = fade (z);
|
|
|
|
int A = p[X] + Y;
|
|
int AA = p[A] + Z;
|
|
int AB = p[A + 1] + Z;
|
|
int B = p[X + 1] + Y;
|
|
int BA = p[B] + Z;
|
|
int BB = p[B + 1] + Z;
|
|
|
|
// Add blended results from 8 corners of cube
|
|
T res = lerp (w,
|
|
lerp (v, lerp (u, grad(p[AA], x, y, z),
|
|
grad (p[BA], x-1, y, z)),
|
|
lerp (u, grad (p[AB], x, y-1, z),
|
|
grad (p[BB], x-1, y-1, z))),
|
|
lerp (v, lerp (u, grad (p[AA+1], x, y, z-1),
|
|
grad (p[BA+1], x-1, y, z-1)),
|
|
lerp (u, grad (p[AB+1], x, y-1, z-1),
|
|
grad (p[BB+1], x-1, y-1, z-1))));
|
|
|
|
return T ((res + 1.0) / 2.0);
|
|
}
|
|
|
|
private:
|
|
T fade (T t)
|
|
{
|
|
return t * t * t * (t * (t * 6 - 15) + 10);
|
|
}
|
|
|
|
T lerp (T t, T a, T b)
|
|
{
|
|
return a + t * (b - a);
|
|
}
|
|
|
|
T grad (int hash, T x, T y, T z)
|
|
{
|
|
int h = hash & 15;
|
|
T u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
|
|
return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
|
|
}
|
|
|
|
Array<int> p;
|
|
};
|
|
|
|
//==============================================================================
|
|
// Keeps a rolling average of a series of numbers
|
|
class RollingAverage
|
|
{
|
|
public:
|
|
RollingAverage (int numVals_)
|
|
: numVals (numVals_)
|
|
{
|
|
}
|
|
|
|
double average (double nextValue)
|
|
{
|
|
return (nextValue + numVals * currAvg) / (double)(numVals + 1);
|
|
}
|
|
|
|
double getAverage()
|
|
{
|
|
return currAvg;
|
|
}
|
|
|
|
void setAverage (double avg)
|
|
{
|
|
currAvg = avg;
|
|
}
|
|
|
|
private:
|
|
int numVals = 0;
|
|
double currAvg = 0.0;
|
|
};
|
|
|
|
//==============================================================================
|
|
// Returns the next colour in a set where the hues differ by the golden ratio.
|
|
// Good for coming up with a random set of colours
|
|
Colour goldenRatioColor (int idx);
|
|
|
|
//==============================================================================
|
|
// Async Download. Doesn't have the main thread pause the URL::downloadToFile has
|
|
class AsyncDownload : private Thread,
|
|
private AsyncUpdater
|
|
{
|
|
public:
|
|
AsyncDownload (String url_, std::function<void (AsyncDownload*, juce::MemoryBlock, bool)> cb_, int timeoutMS_ = 0)
|
|
: Thread ("AsyncDownload"), url (url_), cb (cb_), timeoutMS (timeoutMS_)
|
|
{
|
|
startThread();
|
|
}
|
|
|
|
AsyncDownload (URL url_, std::function<void (AsyncDownload*, juce::MemoryBlock, bool)> cb_, int timeoutMS_ = 0)
|
|
: Thread ("AsyncDownload"), url (url_), cb (cb_), timeoutMS (timeoutMS_)
|
|
{
|
|
startThread();
|
|
}
|
|
|
|
~AsyncDownload() override
|
|
{
|
|
stopThread (100);
|
|
}
|
|
|
|
void run() override
|
|
{
|
|
ok = readEntireBinaryStream (data);
|
|
triggerAsyncUpdate();
|
|
}
|
|
|
|
bool readEntireBinaryStream (MemoryBlock& destData, bool usePostCommand = false)
|
|
{
|
|
const std::unique_ptr<InputStream> in (url.isLocalFile() ? url.getLocalFile().createInputStream() : url.createInputStream (usePostCommand, nullptr, nullptr, {}, timeoutMS));
|
|
|
|
if (in != nullptr)
|
|
{
|
|
in->readIntoMemoryBlock (destData);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void handleAsyncUpdate() override
|
|
{
|
|
if (cb)
|
|
cb (this, data, ok);
|
|
}
|
|
|
|
URL url;
|
|
std::function<void (AsyncDownload*, juce::MemoryBlock, bool)> cb;
|
|
int timeoutMS = 0;
|
|
bool ok = false;
|
|
juce::MemoryBlock data;
|
|
};
|
|
|
|
//==============================================================================
|
|
// Time Profiler -- get a quick idea how long something takes
|
|
class TimeProfiler
|
|
{
|
|
public:
|
|
TimeProfiler (const String& name_) :
|
|
name (name_), start (Time::getMillisecondCounterHiRes()) {}
|
|
|
|
~TimeProfiler()
|
|
{
|
|
DBG (name + String::formatted (" %.2fs", (Time::getMillisecondCounterHiRes() - start) / 1000.0));
|
|
}
|
|
|
|
private:
|
|
String name;
|
|
double start;
|
|
};
|
|
|
|
//==============================================================================
|
|
template <typename T>
|
|
inline bool almostEqual (T a, T b, T precision = T (0.00001))
|
|
{
|
|
return std::abs (a - b) < precision;
|
|
}
|
|
|
|
int versionStringToInt (const String& versionString);
|
|
|
|
//==============================================================================
|
|
void delayedLambda (std::function<void ()> callback, int delayMS);
|