#include <math.h>
#include "noise.h"
#include <iostream>
+#include "debug.h"
#define NOISE_MAGIC_X 1619
#define NOISE_MAGIC_Y 31337
}
double biLinearInterpolation(double x0y0, double x1y0, double x0y1, double x1y1, double x, double y){
- /*double tx = easeCurve(x);
- double ty = easeCurve(y);*/
- double tx = x;
- double ty = y;
+ double tx = easeCurve(x);
+ double ty = easeCurve(y);
+ /*double tx = x;
+ double ty = y;*/
double u = linearInterpolation(x0y0,x1y0,tx);
double v = linearInterpolation(x0y1,x1y1,tx);
return linearInterpolation(u,v,ty);
return a;
}
+// -1->0, 0->1, 1->0
+double contour(double v)
+{
+ v = fabs(v);
+ if(v >= 1.0)
+ return 0.0;
+ return (1.0-v);
+}
+
+double noise3d_param(const NoiseParams ¶m, double x, double y, double z)
+{
+ double s = param.pos_scale;
+ x /= s;
+ y /= s;
+ z /= s;
+
+ if(param.type == NOISE_CONSTANT_ONE)
+ {
+ return 1.0;
+ }
+ else if(param.type == NOISE_PERLIN)
+ {
+ return param.noise_scale*noise3d_perlin(x,y,z, param.seed,
+ param.octaves,
+ param.persistence);
+ }
+ else if(param.type == NOISE_PERLIN_ABS)
+ {
+ return param.noise_scale*noise3d_perlin_abs(x,y,z, param.seed,
+ param.octaves,
+ param.persistence);
+ }
+ else if(param.type == NOISE_PERLIN_CONTOUR)
+ {
+ return contour(param.noise_scale*noise3d_perlin(x,y,z,
+ param.seed, param.octaves,
+ param.persistence));
+ }
+ else if(param.type == NOISE_PERLIN_CONTOUR_FLIP_YZ)
+ {
+ return contour(param.noise_scale*noise3d_perlin(x,z,y,
+ param.seed, param.octaves,
+ param.persistence));
+ }
+ else assert(0);
+}
+
+/*
+ NoiseBuffer
+*/
+
+NoiseBuffer::NoiseBuffer():
+ m_data(NULL)
+{
+}
+
+NoiseBuffer::~NoiseBuffer()
+{
+ clear();
+}
+
+void NoiseBuffer::clear()
+{
+ if(m_data)
+ delete[] m_data;
+ m_data = NULL;
+ m_size_x = 0;
+ m_size_y = 0;
+ m_size_z = 0;
+}
+
+void NoiseBuffer::create(const NoiseParams ¶m,
+ double first_x, double first_y, double first_z,
+ double last_x, double last_y, double last_z,
+ double samplelength_x, double samplelength_y, double samplelength_z)
+{
+ clear();
+
+ m_start_x = first_x - samplelength_x;
+ m_start_y = first_y - samplelength_y;
+ m_start_z = first_z - samplelength_z;
+ m_samplelength_x = samplelength_x;
+ m_samplelength_y = samplelength_y;
+ m_samplelength_z = samplelength_z;
+
+ m_size_x = (last_x - m_start_x)/samplelength_x + 2;
+ m_size_y = (last_y - m_start_y)/samplelength_y + 2;
+ m_size_z = (last_z - m_start_z)/samplelength_z + 2;
+
+ m_data = new double[m_size_x*m_size_y*m_size_z];
+
+ for(int x=0; x<m_size_x; x++)
+ for(int y=0; y<m_size_y; y++)
+ for(int z=0; z<m_size_z; z++)
+ {
+ double xd = (m_start_x + (double)x*m_samplelength_x);
+ double yd = (m_start_y + (double)y*m_samplelength_y);
+ double zd = (m_start_z + (double)z*m_samplelength_z);
+ double a = noise3d_param(param, xd,yd,zd);
+ intSet(x,y,z, a);
+ }
+}
+
+void NoiseBuffer::multiply(const NoiseParams ¶m)
+{
+ assert(m_data != NULL);
+
+ for(int x=0; x<m_size_x; x++)
+ for(int y=0; y<m_size_y; y++)
+ for(int z=0; z<m_size_z; z++)
+ {
+ double xd = (m_start_x + (double)x*m_samplelength_x);
+ double yd = (m_start_y + (double)y*m_samplelength_y);
+ double zd = (m_start_z + (double)z*m_samplelength_z);
+ double a = noise3d_param(param, xd,yd,zd);
+ intMultiply(x,y,z, a);
+ }
+}
+
+// Deprecated
+void NoiseBuffer::create(int seed, int octaves, double persistence,
+ bool abs,
+ double first_x, double first_y, double first_z,
+ double last_x, double last_y, double last_z,
+ double samplelength_x, double samplelength_y, double samplelength_z)
+{
+ NoiseParams param;
+ param.type = abs ? NOISE_PERLIN_ABS : NOISE_PERLIN;
+ param.seed = seed;
+ param.octaves = octaves;
+ param.persistence = persistence;
+
+ create(param, first_x, first_y, first_z,
+ last_x, last_y, last_z,
+ samplelength_x, samplelength_y, samplelength_z);
+}
+
+void NoiseBuffer::intSet(int x, int y, int z, double d)
+{
+ int i = m_size_x*m_size_y*z + m_size_x*y + x;
+ assert(i >= 0);
+ assert(i < m_size_x*m_size_y*m_size_z);
+ m_data[i] = d;
+}
+
+void NoiseBuffer::intMultiply(int x, int y, int z, double d)
+{
+ int i = m_size_x*m_size_y*z + m_size_x*y + x;
+ assert(i >= 0);
+ assert(i < m_size_x*m_size_y*m_size_z);
+ m_data[i] = m_data[i] * d;
+}
+
+double NoiseBuffer::intGet(int x, int y, int z)
+{
+ int i = m_size_x*m_size_y*z + m_size_x*y + x;
+ assert(i >= 0);
+ assert(i < m_size_x*m_size_y*m_size_z);
+ return m_data[i];
+}
+
+double NoiseBuffer::get(double x, double y, double z)
+{
+ x -= m_start_x;
+ y -= m_start_y;
+ z -= m_start_z;
+ x /= m_samplelength_x;
+ y /= m_samplelength_y;
+ z /= m_samplelength_z;
+ // Calculate the integer coordinates
+ int x0 = (x > 0.0 ? (int)x : (int)x - 1);
+ int y0 = (y > 0.0 ? (int)y : (int)y - 1);
+ int z0 = (z > 0.0 ? (int)z : (int)z - 1);
+ // Calculate the remaining part of the coordinates
+ double xl = x - (double)x0;
+ double yl = y - (double)y0;
+ double zl = z - (double)z0;
+ // Get values for corners of cube
+ double v000 = intGet(x0, y0, z0);
+ double v100 = intGet(x0+1, y0, z0);
+ double v010 = intGet(x0, y0+1, z0);
+ double v110 = intGet(x0+1, y0+1, z0);
+ double v001 = intGet(x0, y0, z0+1);
+ double v101 = intGet(x0+1, y0, z0+1);
+ double v011 = intGet(x0, y0+1, z0+1);
+ double v111 = intGet(x0+1, y0+1, z0+1);
+ // Interpolate
+ return triLinearInterpolation(v000,v100,v010,v110,v001,v101,v011,v111,xl,yl,zl);
+}
+
+/*bool NoiseBuffer::contains(double x, double y, double z)
+{
+ x -= m_start_x;
+ y -= m_start_y;
+ z -= m_start_z;
+ x /= m_samplelength_x;
+ y /= m_samplelength_y;
+ z /= m_samplelength_z;
+ if(x <= 0.0 || x >= m_size_x)
+}*/
+