ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2#include "ImprovedNoise.h"
3
4ImprovedNoise::ImprovedNoise()
5{
6 Random random;
7 init(&random);
8}
9
10ImprovedNoise::ImprovedNoise(Random *random)
11{
12 init(random);
13}
14
15void ImprovedNoise::init(Random *random)
16{
17 p = new int[512];
18
19 xo = random->nextDouble() * 256;
20 yo = random->nextDouble() * 256;
21 zo = random->nextDouble() * 256;
22 for (int i = 0; i < 256; i++)
23 {
24 p[i] = i;
25 }
26
27 for (int i = 0; i < 256; i++)
28 {
29 int j = random->nextInt(256 - i) + i;
30 int tmp = p[i];
31 p[i] = p[j];
32 p[j] = tmp;
33
34 p[i + 256] = p[i];
35 }
36}
37
38ImprovedNoise::~ImprovedNoise()
39{
40 delete [] p;
41}
42
43double ImprovedNoise::noise(double _x, double _y, double _z)
44{
45 double x = _x + xo;
46 double y = _y + yo;
47 double z = _z + zo;
48
49 int xf = (int) x;
50 int yf = (int) y;
51 int zf = (int) z;
52
53 if (x < xf) xf--;
54 if (y < yf) yf--;
55 if (z < zf) zf--;
56
57 int X = xf & 255, // FIND UNIT CUBE THAT
58 Y = yf & 255, // CONTAINS POINT.
59 Z = zf & 255;
60
61 x -= xf; // FIND RELATIVE X,Y,Z
62 y -= yf; // OF POINT IN CUBE.
63 z -= zf;
64
65 double u = x * x * x * (x * (x * 6 - 15) + 10), // COMPUTE FADE CURVES
66 v = y * y * y * (y * (y * 6 - 15) + 10), // FOR EACH OF X,Y,Z.
67 w = z * z * z * (z * (z * 6 - 15) + 10);
68
69 int A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z, // HASH COORDINATES OF
70 B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z; // THE 8 CUBE CORNERS,
71
72 return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), // AND ADD
73 grad(p[BA], x - 1, y, z)), // BLENDED
74 lerp(u, grad(p[AB], x, y - 1, z), // RESULTS
75 grad(p[BB], x - 1, y - 1, z))),// FROM 8
76 lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), // CORNERS
77 grad(p[BA + 1], x - 1, y, z - 1)), // OF CUBE
78 lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1))));
79
80}
81
82double ImprovedNoise::lerp(double t, double a, double b)
83{
84 return a + t * (b - a);
85}
86
87double ImprovedNoise::grad2(int hash, double x, double z)
88{
89 int h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
90
91 double u = (1-((h&8)>>3))*x, // INTO 12 GRADIENT DIRECTIONS.
92 v = h < 4 ? 0 : h == 12 || h == 14 ? x : z;
93
94 return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
95}
96
97double ImprovedNoise::grad(int hash, double x, double y, double z)
98{
99 int h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
100
101 double u = h < 8 ? x : y, // INTO 12 GRADIENT DIRECTIONS.
102 v = h < 4 ? y : h == 12 || h == 14 ? x : z;
103
104 return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
105}
106
107double ImprovedNoise::getValue(double x, double y)
108{
109 return noise(x, y, 0);
110}
111
112double ImprovedNoise::getValue(double x, double y, double z)
113{
114 return noise(x, y, z);
115}
116
117void ImprovedNoise::add(doubleArray buffer, double _x, double _y, double _z, int xSize, int ySize, int zSize, double xs, double ys, double zs, double pow)
118{
119 if (ySize==1)
120 {
121 int A = 0, AA = 0, B = 0, BA = 0;
122 double vv0 = 0, vv2 = 0;
123 int pp = 0;
124 double scale = 1.0 / pow;
125 for (int xx = 0; xx < xSize; xx++)
126 {
127 double x = _x + (xx) * xs + xo;
128 int xf = (int) x;
129 if (x < xf) xf--;
130 int X = xf & 255;
131 x -= xf;
132 double u = x * x * x * (x * (x * 6 - 15) + 10);
133
134 for (int zz = 0; zz < zSize; zz++)
135 {
136 double z = _z + (zz) * zs + zo;
137 int zf = (int) z;
138 if (z < zf) zf--;
139 int Z = zf & 255;
140 z -= zf;
141 double w = z * z * z * (z * (z * 6 - 15) + 10);
142
143 A = p[X] + 0;
144 AA = p[A] + Z;
145 B = p[X + 1] + 0;
146 BA = p[B] + Z;
147 vv0 = lerp(u, grad2(p[AA], x, z), grad(p[BA], x - 1, 0, z));
148 vv2 = lerp(u, grad(p[AA + 1], x, 0, z - 1), grad(p[BA + 1], x - 1, 0, z - 1));
149
150 double val = lerp(w, vv0, vv2);
151
152 buffer[pp++] += val * scale;
153 }
154 }
155 return;
156 }
157 int pp = 0;
158 double scale = 1 / pow;
159 int yOld = -1;
160 int A = 0, AA = 0, AB = 0, B = 0, BA = 0, BB = 0;
161 double vv0 = 0, vv1 = 0, vv2 = 0, vv3 = 0;
162
163 for (int xx = 0; xx < xSize; xx++)
164 {
165 double x = _x + (xx) * xs + xo;
166 int xf = (int) x;
167 if (x < xf) xf--;
168 int X = xf & 255;
169 x -= xf;
170 double u = x * x * x * (x * (x * 6 - 15) + 10);
171
172
173 for (int zz = 0; zz < zSize; zz++)
174 {
175 double z = _z + (zz) * zs + zo;
176 int zf = (int) z;
177 if (z < zf) zf--;
178 int Z = zf & 255;
179 z -= zf;
180 double w = z * z * z * (z * (z * 6 - 15) + 10);
181
182
183 for (int yy = 0; yy < ySize; yy++)
184 {
185 double y = _y + (yy) * ys + yo;
186 int yf = (int) y;
187 if (y < yf) yf--;
188 int Y = yf & 255;
189 y -= yf;
190 double v = y * y * y * (y * (y * 6 - 15) + 10);
191
192 if (yy == 0 || Y != yOld)
193 {
194 yOld = Y;
195 A = p[X] + Y;
196 AA = p[A] + Z;
197 AB = p[A + 1] + Z;
198 B = p[X + 1] + Y;
199 BA = p[B] + Z;
200 BB = p[B + 1] + Z;
201 vv0 = lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z));
202 vv1 = lerp(u, grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z));
203 vv2 = lerp(u, grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1));
204 vv3 = lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1));
205 }
206
207
208 double v0 = lerp(v, vv0, vv1);
209 double v1 = lerp(v, vv2, vv3);
210 double val = lerp(w, v0, v1);
211
212 buffer[pp++] += val * scale;
213 }
214 }
215 }
216}