Skip to content

Commit 1cc60b8

Browse files
jubejube
committed
micro optimization
1 parent 4903ce7 commit 1cc60b8

File tree

3 files changed

+58
-63
lines changed

3 files changed

+58
-63
lines changed

‎include/gf2/core/Noises.h

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ namespace gf {
1818

1919
class GF_CORE_API ValueNoise2D : public Noise2D {
2020
public:
21-
ValueNoise2D(Random& random, Step<double> step);
21+
ValueNoise2D(Random* random, Step<double> step);
2222

2323
double value(double x, double y) final;
2424

@@ -32,7 +32,7 @@ namespace gf {
3232

3333
class GF_CORE_API GradientNoise2D : public Noise2D {
3434
public:
35-
GradientNoise2D(Random& random, Step<double> step);
35+
GradientNoise2D(Random* random, Step<double> step);
3636

3737
double value(double x, double y) final;
3838

@@ -46,7 +46,7 @@ namespace gf {
4646

4747
class GF_CORE_API GradientNoise3D : public Noise3D {
4848
public:
49-
GradientNoise3D(Random& random, Step<double> step);
49+
GradientNoise3D(Random* random, Step<double> step);
5050

5151
double value(double x, double y, double z) final;
5252

@@ -60,7 +60,7 @@ namespace gf {
6060

6161
class GF_CORE_API BetterGradientNoise2D : public Noise2D {
6262
public:
63-
BetterGradientNoise2D(Random& random);
63+
BetterGradientNoise2D(Random* random);
6464

6565
double value(double x, double y) final;
6666

@@ -104,7 +104,7 @@ namespace gf {
104104

105105
class GF_CORE_API PerlinNoise2D : public Noise2D {
106106
public:
107-
PerlinNoise2D(Random& random, double scale, int octaves = 8);
107+
PerlinNoise2D(Random* random, double scale, int octaves = 8);
108108

109109
double value(double x, double y) final;
110110

@@ -115,7 +115,7 @@ namespace gf {
115115

116116
class GF_CORE_API PerlinNoise3D : public Noise3D {
117117
public:
118-
PerlinNoise3D(Random& random, double scale, int octaves = 8);
118+
PerlinNoise3D(Random* random, double scale, int octaves = 8);
119119

120120
double value(double x, double y, double z) final;
121121

@@ -126,7 +126,7 @@ namespace gf {
126126

127127
class GF_CORE_API SimplexNoise2D : public Noise2D {
128128
public:
129-
SimplexNoise2D(Random& random);
129+
SimplexNoise2D(Random* random);
130130

131131
double value(double x, double y) final;
132132

@@ -138,7 +138,7 @@ namespace gf {
138138

139139
class GF_CORE_API WaveletNoise3D : public Noise3D {
140140
public:
141-
WaveletNoise3D(Random& random, std::ptrdiff_t wavelet_tile_size = 32);
141+
WaveletNoise3D(Random* random, std::ptrdiff_t wavelet_tile_size = 32);
142142

143143
double value(double x, double y, double z) final;
144144

@@ -149,7 +149,7 @@ namespace gf {
149149

150150
class GF_CORE_API WorleyNoise2D : public Noise2D {
151151
public:
152-
WorleyNoise2D(Random& random, std::size_t points_count, Distance2<double> distance, std::vector<double> coefficients);
152+
WorleyNoise2D(Random* random, std::size_t points_count, Distance2<double> distance, std::vector<double> coefficients);
153153

154154
double value(double x, double y) final;
155155

‎include/gf2/core/Vec2.h

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -285,7 +285,7 @@ namespace gf {
285285
template<typename T>
286286
constexpr T manhattan_distance(Vec2<T> lhs, Vec2<T> rhs)
287287
{
288-
return manhattan_length(lhs - rhs);
288+
return details::abs(lhs.x - rhs.x) + details::abs(lhs.y - rhs.y);
289289
}
290290

291291
template<typename T>
@@ -297,7 +297,7 @@ namespace gf {
297297
template<typename T>
298298
constexpr T square_distance(Vec2<T> lhs, Vec2<T> rhs)
299299
{
300-
return square_length(lhs - rhs);
300+
return square(lhs.x - rhs.x) + square(lhs.y - rhs.y);
301301
}
302302

303303
template<typename T>
@@ -309,7 +309,7 @@ namespace gf {
309309
template<typename T>
310310
inline auto euclidean_distance(Vec2<T> lhs, Vec2<T> rhs)
311311
{
312-
return euclidean_length(lhs - rhs);
312+
return std::sqrt(square_distance(lhs, rhs));
313313
}
314314

315315
template<typename T>
@@ -321,7 +321,7 @@ namespace gf {
321321
template<typename T>
322322
constexpr T chebyshev_distance(Vec2<T> lhs, Vec2<T> rhs)
323323
{
324-
return chebyshev_length(lhs - rhs);
324+
return details::max(details::abs(lhs.x - rhs.x), details::abs(lhs.y - rhs.y));
325325
}
326326

327327
template<typename T>

‎library/core/Noises.cc

Lines changed: 45 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -13,10 +13,10 @@ namespace gf {
1313

1414
namespace {
1515

16-
void generate_permutation(Random& random, std::array<uint8_t, 256>& permutation)
16+
void generate_permutation(Random* random, std::array<uint8_t, 256>& permutation)
1717
{
1818
std::iota(permutation.begin(), permutation.end(), 0);
19-
std::shuffle(permutation.begin(), permutation.end(), random.engine());
19+
std::shuffle(permutation.begin(), permutation.end(), random->engine());
2020
}
2121

2222
}
@@ -25,7 +25,7 @@ namespace gf {
2525
* ValueNoise2D
2626
*/
2727

28-
ValueNoise2D::ValueNoise2D(Random& random, Step<double> step)
28+
ValueNoise2D::ValueNoise2D(Random* random, Step<double> step)
2929
: m_step(step)
3030
{
3131
// initialize permutation
@@ -34,21 +34,21 @@ namespace gf {
3434

3535
// generate values
3636

37-
std::uniform_real_distribution<double> distribution_value(0.0, 1.0);
38-
3937
for (auto& value : m_values) {
40-
value = distribution_value(random.engine());
38+
value = random->compute_uniform_float<double>();
4139
}
4240
}
4341

4442
double ValueNoise2D::value(double x, double y)
4543
{
46-
auto qx = static_cast<uint8_t>(std::fmod(x, 256));
47-
const double rx = std::fmod(x, 1);
44+
double dummy = 0.0;
45+
46+
auto qx = static_cast<uint8_t>(x);
47+
const double rx = std::modf(x, &dummy);
4848
assert(rx >= 0.0 && rx <= 1.0);
4949

50-
auto qy = static_cast<uint8_t>(std::fmod(y, 256));
51-
const double ry = std::fmod(y, 1);
50+
auto qy = static_cast<uint8_t>(y);
51+
const double ry = std::modf(y, &dummy);
5252
assert(ry >= 0.0 && ry <= 1.0);
5353

5454
// clang-format off
@@ -75,7 +75,7 @@ namespace gf {
7575
* GradientNoise2D
7676
*/
7777

78-
GradientNoise2D::GradientNoise2D(Random& random, Step<double> step)
78+
GradientNoise2D::GradientNoise2D(Random* random, Step<double> step)
7979
: m_step(step)
8080
{
8181
// initialize permutation
@@ -84,22 +84,22 @@ namespace gf {
8484

8585
// generate 2D gradients
8686

87-
std::uniform_real_distribution<double> distribution_angle(0.0, 2.0 * constants::Pi<double>);
88-
8987
for (auto& gradient : m_gradients) {
90-
const double angle = distribution_angle(random.engine());
88+
const double angle = random->compute_uniform_float(2.0 * constants::Pi<double>);
9189
gradient = gf::unit(angle);
9290
}
9391
}
9492

9593
double GradientNoise2D::value(double x, double y)
9694
{
97-
auto qx = static_cast<uint8_t>(std::fmod(x, 256));
98-
const double rx = std::fmod(x, 1);
95+
double dummy = 0.0;
96+
97+
auto qx = static_cast<uint8_t>(x);
98+
const double rx = std::modf(x, &dummy);
9999
assert(rx >= 0.0 && rx <= 1.0);
100100

101-
auto qy = static_cast<uint8_t>(std::fmod(y, 256));
102-
const double ry = std::fmod(y, 1);
101+
auto qy = static_cast<uint8_t>(y);
102+
const double ry = std::modf(y, &dummy);
103103
assert(ry >= 0.0 && ry <= 1.0);
104104

105105
// clang-format off
@@ -130,7 +130,7 @@ namespace gf {
130130
* GradientNoise3D
131131
*/
132132

133-
GradientNoise3D::GradientNoise3D(Random& random, Step<double> step)
133+
GradientNoise3D::GradientNoise3D(Random* random, Step<double> step)
134134
: m_step(step)
135135
{
136136
// initialize permutation
@@ -139,28 +139,27 @@ namespace gf {
139139

140140
// generate 3D gradients
141141

142-
std::uniform_real_distribution<double> distribution_phi(0.0, 2.0 * constants::Pi<double>);
143-
std::uniform_real_distribution<double> distribution_theta(0.0, 2.0 * constants::Pi<double>);
144-
145142
for (auto& gradient : m_gradients) {
146-
const double phi = distribution_phi(random.engine());
147-
const double theta = distribution_theta(random.engine());
143+
const double phi = random->compute_uniform_float(2.0 * constants::Pi<double>);
144+
const double theta = random->compute_uniform_float(2.0 * constants::Pi<double>);
148145
gradient = { std::cos(phi) * std::sin(theta), std::sin(phi) * std::sin(theta), std::cos(theta) };
149146
}
150147
}
151148

152149
double GradientNoise3D::value(double x, double y, double z)
153150
{
154-
auto qx = static_cast<uint8_t>(std::fmod(x, 256));
155-
const double rx = std::fmod(x, 1);
151+
double dummy = 0.0;
152+
153+
auto qx = static_cast<uint8_t>(x);
154+
const double rx = std::modf(x, &dummy);
156155
assert(rx >= 0.0 && rx <= 1.0);
157156

158-
auto qy = static_cast<uint8_t>(std::fmod(y, 256));
159-
const double ry = std::fmod(y, 1);
157+
auto qy = static_cast<uint8_t>(y);
158+
const double ry = std::modf(y, &dummy);
160159
assert(ry >= 0.0 && ry <= 1.0);
161160

162-
auto qz = static_cast<uint8_t>(std::fmod(z, 256));
163-
const double rz = std::fmod(z, 1);
161+
auto qz = static_cast<uint8_t>(z);
162+
const double rz = std::modf(z, &dummy);
164163
assert(rz >= 0.0 && rz <= 1.0);
165164

166165
// clang-format off
@@ -203,7 +202,7 @@ namespace gf {
203202
* BetterGradientNoise2D
204203
*/
205204

206-
BetterGradientNoise2D::BetterGradientNoise2D(Random& random)
205+
BetterGradientNoise2D::BetterGradientNoise2D(Random* random)
207206
{
208207
// initialize permutation
209208

@@ -212,22 +211,22 @@ namespace gf {
212211

213212
// generate 2D gradients
214213

215-
std::uniform_real_distribution<double> distribution_angle(0.0, 2.0 * constants::Pi<double>);
216-
217214
for (auto& gradient : m_gradients) {
218-
const double angle = distribution_angle(random.engine());
215+
const double angle = random->compute_uniform_float(2.0 * constants::Pi<double>);
219216
gradient = gf::unit(angle);
220217
}
221218
}
222219

223220
double BetterGradientNoise2D::value(double x, double y)
224221
{
225-
auto qx = static_cast<uint8_t>(std::fmod(x, 256));
226-
const double rx = std::fmod(x, 1);
222+
double dummy = 0.0;
223+
224+
auto qx = static_cast<uint8_t>(x);
225+
const double rx = std::modf(x, &dummy);
227226
assert(rx >= 0.0 && rx <= 1.0);
228227

229-
auto qy = static_cast<uint8_t>(std::fmod(y, 256));
230-
const double ry = std::fmod(y, 1);
228+
auto qy = static_cast<uint8_t>(y);
229+
const double ry = std::modf(y, &dummy);
231230
assert(ry >= 0.0 && ry <= 1.0);
232231

233232
double value = 0.0f;
@@ -332,7 +331,7 @@ namespace gf {
332331
* PerlinNoise2D
333332
*/
334333

335-
PerlinNoise2D::PerlinNoise2D(Random& random, double scale, int octaves)
334+
PerlinNoise2D::PerlinNoise2D(Random* random, double scale, int octaves)
336335
: m_gradient_noise(random, gf::quintic_step)
337336
, m_fractal_noise(&m_gradient_noise, scale, octaves)
338337
{
@@ -347,7 +346,7 @@ namespace gf {
347346
* PerlinNoise3D
348347
*/
349348

350-
PerlinNoise3D::PerlinNoise3D(Random& random, double scale, int octaves)
349+
PerlinNoise3D::PerlinNoise3D(Random* random, double scale, int octaves)
351350
: m_gradient_noise(random, gf::quintic_step)
352351
, m_fractal_noise(&m_gradient_noise, scale, octaves)
353352
{
@@ -362,7 +361,7 @@ namespace gf {
362361
* SimplexNoise2D
363362
*/
364363

365-
SimplexNoise2D::SimplexNoise2D(Random& random)
364+
SimplexNoise2D::SimplexNoise2D(Random* random)
366365
{
367366
generate_permutation(random, m_permutation);
368367
}
@@ -529,7 +528,7 @@ namespace gf {
529528

530529
}
531530

532-
WaveletNoise3D::WaveletNoise3D(Random& random, std::ptrdiff_t wavelet_tile_size)
531+
WaveletNoise3D::WaveletNoise3D(Random* random, std::ptrdiff_t wavelet_tile_size)
533532
: m_wavelet_tile_size(wavelet_tile_size + (wavelet_tile_size % 2))
534533
{
535534
const std::size_t data_size = m_wavelet_tile_size * m_wavelet_tile_size * m_wavelet_tile_size;
@@ -540,10 +539,8 @@ namespace gf {
540539

541540
// step 1: fill the tile with numbers in the range -1 to 1
542541

543-
std::uniform_real_distribution<double> distribution_value(-1.0, 1.0);
544-
545542
for (auto& value : m_data) {
546-
value = distribution_value(random.engine());
543+
value = random->compute_uniform_float(-1.0, +1.0);
547544
}
548545

549546
// step 2 and 3: downsample and upsample the tile
@@ -659,7 +656,7 @@ namespace gf {
659656
* WorleyNoise2D
660657
*/
661658

662-
WorleyNoise2D::WorleyNoise2D(Random& random, std::size_t points_count, Distance2<double> distance, std::vector<double> coefficients)
659+
WorleyNoise2D::WorleyNoise2D(Random* random, std::size_t points_count, Distance2<double> distance, std::vector<double> coefficients)
663660
: m_points_count(points_count)
664661
, m_distance(distance)
665662
, m_coefficients(std::move(coefficients))
@@ -668,11 +665,9 @@ namespace gf {
668665

669666
m_cells.reserve(m_points_count * 4);
670667

671-
std::uniform_real_distribution<double> distribution_coordinate(0.0, 1.0);
672-
673668
for (std::size_t i = 0; i < m_points_count; ++i) {
674-
auto x = distribution_coordinate(random.engine());
675-
auto y = distribution_coordinate(random.engine());
669+
auto x = random->compute_uniform_float<double>();
670+
auto y = random->compute_uniform_float<double>();
676671

677672
m_cells.emplace_back(x, y);
678673

0 commit comments

Comments
 (0)