blob: 4b675861e7914fbfd2cffbcbbf66cb249b86eb33 [file] [log] [blame]
/*
* This implementation of the noise functions was ported from the Java
* implementation by Jerry Huxtable (http://www.jhlabs.com) under
* Apache License 2.0 (see http://jhlabs.com/ip/filters/download.html)
*
* Original header:
*
* Copyright 2006 Jerry Huxtable
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "rsNoise.h"
#include <math.h>
#include <stdlib.h>
#include <time.h>
namespace android {
namespace renderscript {
#define B 0x100
#define BM 0xff
#define N 0x1000
static int p[B + B + 2];
static float g3[B + B + 2][3];
static float g2[B + B + 2][2];
static float g1[B + B + 2];
static bool noise_start = true;
#define lerpf(start, stop, amount) start + (stop - start) * amount
static inline float noise_sCurve(float t)
{
return t * t * (3.0f - 2.0f * t);
}
inline void SC_normalizef2(float v[])
{
float s = (float)sqrtf(v[0] * v[0] + v[1] * v[1]);
v[0] = v[0] / s;
v[1] = v[1] / s;
}
inline void SC_normalizef3(float v[])
{
float s = (float)sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
v[0] = v[0] / s;
v[1] = v[1] / s;
v[2] = v[2] / s;
}
static void noise_init()
{
int i, j, k;
for (i = 0; i < B; i++) {
p[i] = i;
g1[i] = (float)((rand() % (B + B)) - B) / B;
for (j = 0; j < 2; j++)
g2[i][j] = (float)((rand() % (B + B)) - B) / B;
SC_normalizef2(g2[i]);
for (j = 0; j < 3; j++)
g3[i][j] = (float)((rand() % (B + B)) - B) / B;
SC_normalizef3(g3[i]);
}
for (i = B-1; i >= 0; i--) {
k = p[i];
p[i] = p[j = rand() % B];
p[j] = k;
}
for (i = 0; i < B + 2; i++) {
p[B + i] = p[i];
g1[B + i] = g1[i];
for (j = 0; j < 2; j++)
g2[B + i][j] = g2[i][j];
for (j = 0; j < 3; j++)
g3[B + i][j] = g3[i][j];
}
}
float SC_noisef(float x)
{
srand(time(NULL));
int bx0, bx1;
float rx0, rx1, sx, t, u, v;
if (noise_start) {
noise_start = false;
noise_init();
}
t = x + N;
bx0 = ((int)t) & BM;
bx1 = (bx0+1) & BM;
rx0 = t - (int)t;
rx1 = rx0 - 1.0f;
sx = noise_sCurve(rx0);
u = rx0 * g1[p[bx0]];
v = rx1 * g1[p[bx1]];
return 2.3f * lerpf(u, v, sx);
}
float SC_noisef2(float x, float y)
{
srand(time(NULL));
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, sx, sy, a, b, t, u, v;
float *q;
int i, j;
if (noise_start) {
noise_start = false;
noise_init();
}
t = x + N;
bx0 = ((int)t) & BM;
bx1 = (bx0+1) & BM;
rx0 = t - (int)t;
rx1 = rx0 - 1.0f;
t = y + N;
by0 = ((int)t) & BM;
by1 = (by0+1) & BM;
ry0 = t - (int)t;
ry1 = ry0 - 1.0f;
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = noise_sCurve(rx0);
sy = noise_sCurve(ry0);
q = g2[b00]; u = rx0 * q[0] + ry0 * q[1];
q = g2[b10]; v = rx1 * q[0] + ry0 * q[1];
a = lerpf(u, v, sx);
q = g2[b01]; u = rx0 * q[0] + ry1 * q[1];
q = g2[b11]; v = rx1 * q[0] + ry1 * q[1];
b = lerpf(u, v, sx);
return 1.5f*lerpf(a, b, sy);
}
float SC_noisef3(float x, float y, float z)
{
srand(time(NULL));
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, rz0, rz1, sy, sz, a, b, c, d, t, u, v;
float *q;
int i, j;
if (noise_start) {
noise_start = false;
noise_init();
}
t = x + N;
bx0 = ((int)t) & BM;
bx1 = (bx0+1) & BM;
rx0 = t - (int)t;
rx1 = rx0 - 1.0f;
t = y + N;
by0 = ((int)t) & BM;
by1 = (by0+1) & BM;
ry0 = t - (int)t;
ry1 = ry0 - 1.0f;
t = z + N;
bz0 = ((int)t) & BM;
bz1 = (bz0+1) & BM;
rz0 = t - (int)t;
rz1 = rz0 - 1.0f;
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
t = noise_sCurve(rx0);
sy = noise_sCurve(ry0);
sz = noise_sCurve(rz0);
q = g3[b00 + bz0]; u = rx0 * q[0] + ry0 * q[1] + rz0 * q[2];
q = g3[b10 + bz0]; v = rx1 * q[0] + ry0 * q[1] + rz0 * q[2];
a = lerpf(u, v, t);
q = g3[b01 + bz0]; u = rx0 * q[0] + ry1 * q[1] + rz0 * q[2];
q = g3[b11 + bz0]; v = rx1 * q[0] + ry1 * q[1] + rz0 * q[2];
b = lerpf(u, v, t);
c = lerpf(a, b, sy);
q = g3[b00 + bz1]; u = rx0 * q[0] + ry0 * q[1] + rz1 * q[2];
q = g3[b10 + bz1]; v = rx1 * q[0] + ry0 * q[1] + rz1 * q[2];
a = lerpf(u, v, t);
q = g3[b01 + bz1]; u = rx0 * q[0] + ry1 * q[1] + rz1 * q[2];
q = g3[b11 + bz1]; v = rx1 * q[0] + ry1 * q[1] + rz1 * q[2];
b = lerpf(u, v, t);
d = lerpf(a, b, sy);
return 1.5f*lerpf(c, d, sz);
}
float SC_turbulencef2(float x, float y, float octaves)
{
srand(time(NULL));
float t = 0.0f;
for (float f = 1.0f; f <= octaves; f *= 2)
t += fabs(SC_noisef2(f * x, f * y)) / f;
return t;
}
float SC_turbulencef3(float x, float y, float z, float octaves)
{
srand(time(NULL));
float t = 0.0f;
for (float f = 1.0f; f <= octaves; f *= 2)
t += fabs(SC_noisef3(f * x, f * y, f * z)) / f;
return t;
}
}
}