Skip to content
BranchesTags

Repository files navigation

Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)

Travis CI Linux Build StatusAppVeyor Windows Build status

About Perlin's "Simplex" Noise

  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations simulating natural looking variations, producing paterns all of the same size. It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working on visual special effects for the Tron movie (1982). It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid. Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values, and switches to using predefined gradients of unit lenght to the middle of each edges. Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid, based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid (think triangles instead of squares, pyramids instead of cubes...) Ken Perlin original references

Coherent noise

A coherent noise is a type of smooth pseudorandom noise with following properties:.

  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.

Fractal noise / Fractional Brownian Motion

Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise, each with higher frequency and lower amplitude.

  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).

2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project): 1 octave of 2D Simplex Noise

Code attribution

This C++ implementation is based on the speed-improved Java version 2012-03-09 by Stefan Gustavson (original Java source code in the public domain). http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:

Simplex noise demystified, Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22

License

Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)

Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt or copy at http://opensource.org/licenses/MIT)

Current Status

Features

  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion

Wishlist

  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)

How to contribute

GitHub website

The most efficient way to help and contribute to this wrapper project is to use the tools provided by GitHub:

Contact

You can also email me directly.

See Also

SRombauts GitHub website

Continuous Integration

This project is continuously tested under Ubuntu Linux with the gcc and clang compilers using the Travis CI community service with the above CMake building and testing procedure. It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler using the AppVeyor countinuous integration service.

Detailed results can be seen online:

About

A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)

Resources

Readme
MIT license
Activity

Stars

367 stars

Watchers

6 watching

Forks

43 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - SRombauts/SimplexNoise: A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D) · GitHub
Skip to content
BranchesTags
Repository files navigation
Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)
Travis CI Linux Build StatusAppVeyor Windows Build status
About Perlin's "Simplex" Noise
  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations
simulating natural looking variations, producing paterns all of the same size.
It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working
on visual special effects for the Tron movie (1982).
It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid.
Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with
a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values,
and switches to using predefined gradients of unit lenght to the middle of each edges.
Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid,
based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid
(think triangles instead of squares, pyramids instead of cubes...)
Ken Perlin original references
Coherent noise
A coherent noise is a type of smooth pseudorandom noise with following properties:.
  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.
Fractal noise / Fractional Brownian Motion
Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise,
each with higher frequency and lower amplitude.
  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).
2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project):
1 octave of 2D Simplex Noise
Code attribution
This C++ implementation is based on the speed-improved Java version 2012-03-09
by Stefan Gustavson (original Java source code in the public domain).
http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:
Simplex noise demystified,
Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22
License
Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
or copy at http://opensource.org/licenses/MIT)
Current Status
Features
  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion
Wishlist
  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)
How to contribute
GitHub website
The most efficient way to help and contribute to this wrapper project is to
use the tools provided by GitHub:
Contact
You can also email me directly.
See Also
SRombauts GitHub website
Continuous Integration
This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
using the Travis CI community service with the above CMake building and testing procedure.
It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler
using the AppVeyor countinuous integration service.
Detailed results can be seen online:
About
A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)
Resources
Readme
MIT license
Activity
Stars
367 stars
Watchers
6 watching
Forks
43 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - SRombauts/SimplexNoise: A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D) · GitHub
Skip to content
BranchesTags
Repository files navigation
Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)
Travis CI Linux Build StatusAppVeyor Windows Build status
About Perlin's "Simplex" Noise
  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations
simulating natural looking variations, producing paterns all of the same size.
It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working
on visual special effects for the Tron movie (1982).
It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid.
Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with
a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values,
and switches to using predefined gradients of unit lenght to the middle of each edges.
Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid,
based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid
(think triangles instead of squares, pyramids instead of cubes...)
Ken Perlin original references
Coherent noise
A coherent noise is a type of smooth pseudorandom noise with following properties:.
  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.
Fractal noise / Fractional Brownian Motion
Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise,
each with higher frequency and lower amplitude.
  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).
2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project):
1 octave of 2D Simplex Noise
Code attribution
This C++ implementation is based on the speed-improved Java version 2012-03-09
by Stefan Gustavson (original Java source code in the public domain).
http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:
Simplex noise demystified,
Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22
License
Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
or copy at http://opensource.org/licenses/MIT)
Current Status
Features
  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion
Wishlist
  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)
How to contribute
GitHub website
The most efficient way to help and contribute to this wrapper project is to
use the tools provided by GitHub:
Contact
You can also email me directly.
See Also
SRombauts GitHub website
Continuous Integration
This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
using the Travis CI community service with the above CMake building and testing procedure.
It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler
using the AppVeyor countinuous integration service.
Detailed results can be seen online:
About
A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)
Resources
Readme
MIT license
Activity
Stars
367 stars
Watchers
6 watching
Forks
43 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - SRombauts/SimplexNoise: A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D) · GitHub
Skip to content
BranchesTags
Repository files navigation
Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)
Travis CI Linux Build StatusAppVeyor Windows Build status
About Perlin's "Simplex" Noise
  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations
simulating natural looking variations, producing paterns all of the same size.
It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working
on visual special effects for the Tron movie (1982).
It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid.
Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with
a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values,
and switches to using predefined gradients of unit lenght to the middle of each edges.
Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid,
based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid
(think triangles instead of squares, pyramids instead of cubes...)
Ken Perlin original references
Coherent noise
A coherent noise is a type of smooth pseudorandom noise with following properties:.
  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.
Fractal noise / Fractional Brownian Motion
Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise,
each with higher frequency and lower amplitude.
  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).
2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project):
1 octave of 2D Simplex Noise
Code attribution
This C++ implementation is based on the speed-improved Java version 2012-03-09
by Stefan Gustavson (original Java source code in the public domain).
http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:
Simplex noise demystified,
Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22
License
Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
or copy at http://opensource.org/licenses/MIT)
Current Status
Features
  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion
Wishlist
  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)
How to contribute
GitHub website
The most efficient way to help and contribute to this wrapper project is to
use the tools provided by GitHub:
Contact
You can also email me directly.
See Also
SRombauts GitHub website
Continuous Integration
This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
using the Travis CI community service with the above CMake building and testing procedure.
It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler
using the AppVeyor countinuous integration service.
Detailed results can be seen online:
About
A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)
Resources
Readme
MIT license
Activity
Stars
367 stars
Watchers
6 watching
Forks
43 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - SRombauts/SimplexNoise: A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D) · GitHub
Skip to content
BranchesTags
Repository files navigation
Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)
Travis CI Linux Build StatusAppVeyor Windows Build status
About Perlin's "Simplex" Noise
  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations
simulating natural looking variations, producing paterns all of the same size.
It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working
on visual special effects for the Tron movie (1982).
It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid.
Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with
a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values,
and switches to using predefined gradients of unit lenght to the middle of each edges.
Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid,
based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid
(think triangles instead of squares, pyramids instead of cubes...)
Ken Perlin original references
Coherent noise
A coherent noise is a type of smooth pseudorandom noise with following properties:.
  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.
Fractal noise / Fractional Brownian Motion
Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise,
each with higher frequency and lower amplitude.
  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).
2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project):
1 octave of 2D Simplex Noise
Code attribution
This C++ implementation is based on the speed-improved Java version 2012-03-09
by Stefan Gustavson (original Java source code in the public domain).
http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:
Simplex noise demystified,
Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22
License
Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
or copy at http://opensource.org/licenses/MIT)
Current Status
Features
  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion
Wishlist
  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)
How to contribute
GitHub website
The most efficient way to help and contribute to this wrapper project is to
use the tools provided by GitHub:
Contact
You can also email me directly.
See Also
SRombauts GitHub website
Continuous Integration
This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
using the Travis CI community service with the above CMake building and testing procedure.
It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler
using the AppVeyor countinuous integration service.
Detailed results can be seen online:
About
A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)
Resources
Readme
MIT license
Activity
Stars
367 stars
Watchers
6 watching
Forks
43 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - SRombauts/SimplexNoise: A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D) · GitHub
Skip to content
BranchesTags
Repository files navigation
Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)
Travis CI Linux Build StatusAppVeyor Windows Build status
About Perlin's "Simplex" Noise
  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations
simulating natural looking variations, producing paterns all of the same size.
It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working
on visual special effects for the Tron movie (1982).
It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid.
Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with
a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values,
and switches to using predefined gradients of unit lenght to the middle of each edges.
Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid,
based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid
(think triangles instead of squares, pyramids instead of cubes...)
Ken Perlin original references
Coherent noise
A coherent noise is a type of smooth pseudorandom noise with following properties:.
  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.
Fractal noise / Fractional Brownian Motion
Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise,
each with higher frequency and lower amplitude.
  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).
2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project):
1 octave of 2D Simplex Noise
Code attribution
This C++ implementation is based on the speed-improved Java version 2012-03-09
by Stefan Gustavson (original Java source code in the public domain).
http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:
Simplex noise demystified,
Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22
License
Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
or copy at http://opensource.org/licenses/MIT)
Current Status
Features
  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion
Wishlist
  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)
How to contribute
GitHub website
The most efficient way to help and contribute to this wrapper project is to
use the tools provided by GitHub:
Contact
You can also email me directly.
See Also
SRombauts GitHub website
Continuous Integration
This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
using the Travis CI community service with the above CMake building and testing procedure.
It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler
using the AppVeyor countinuous integration service.
Detailed results can be seen online:
About
A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)
Resources
Readme
MIT license
Activity
Stars
367 stars
Watchers
6 watching
Forks
43 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - SRombauts/SimplexNoise: A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D) · GitHub
Skip to content
BranchesTags
Repository files navigation
Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)
Travis CI Linux Build StatusAppVeyor Windows Build status
About Perlin's "Simplex" Noise
  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations
simulating natural looking variations, producing paterns all of the same size.
It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working
on visual special effects for the Tron movie (1982).
It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid.
Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with
a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values,
and switches to using predefined gradients of unit lenght to the middle of each edges.
Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid,
based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid
(think triangles instead of squares, pyramids instead of cubes...)
Ken Perlin original references
Coherent noise
A coherent noise is a type of smooth pseudorandom noise with following properties:.
  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.
Fractal noise / Fractional Brownian Motion
Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise,
each with higher frequency and lower amplitude.
  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).
2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project):
1 octave of 2D Simplex Noise
Code attribution
This C++ implementation is based on the speed-improved Java version 2012-03-09
by Stefan Gustavson (original Java source code in the public domain).
http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:
Simplex noise demystified,
Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22
License
Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
or copy at http://opensource.org/licenses/MIT)
Current Status
Features
  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion
Wishlist
  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)
How to contribute
GitHub website
The most efficient way to help and contribute to this wrapper project is to
use the tools provided by GitHub:
Contact
You can also email me directly.
See Also
SRombauts GitHub website
Continuous Integration
This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
using the Travis CI community service with the above CMake building and testing procedure.
It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler
using the AppVeyor countinuous integration service.
Detailed results can be seen online:
About
A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)
Resources
Readme
MIT license
Activity
Stars
367 stars
Watchers
6 watching
Forks
43 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - SRombauts/SimplexNoise: A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D) · GitHub
Skip to content
BranchesTags
Repository files navigation
Perlin Simplex Noise C++ Implementation (1D, 2D, 3D)
Travis CI Linux Build StatusAppVeyor Windows Build status
About Perlin's "Simplex" Noise
  • Perlin's "Classic" Noise (1984) is an algorithm producing pseudo-random fluctuations
simulating natural looking variations, producing paterns all of the same size.
It is a kind of gradiant-noise algorithm, invented by Ken Perlin while working
on visual special effects for the Tron movie (1982).
It works by interpolating pseudo-random gradiants defined in a multi-dimensionnal grid.
Ken Perlin original references
  • Perlin's "Improved" Noise (2002) switches to a new interpolation fonction with
a 2nd derivative zero at t=0 and t=1 to remove artifacts on integer values,
and switches to using predefined gradients of unit lenght to the middle of each edges.
Ken Perlin original references
  • Perlin's "Simplex" Noise (2001) rather than placing each input point into a cubic grid,
based on the integer parts of its (x,y,z) coordinate values, placed them onto a simplicial grid
(think triangles instead of squares, pyramids instead of cubes...)
Ken Perlin original references
Coherent noise
A coherent noise is a type of smooth pseudorandom noise with following properties:.
  • same input will always return the same output.
  • small change of the input will produce small change of the output.
  • large change of the input will produce random change of the output.
Fractal noise / Fractional Brownian Motion
Fractional Brownian Motion (fBm) is the summation of successive octaves of coherent noise,
each with higher frequency and lower amplitude.
  • Frequency of an octave of noise is the "width" of the pattern
  • Amplitude of an octave of noise it the "height" of its feature
  • Lacunarity specifies the frequency multipler between successive octaves (typically 2.0).
  • Persistence is the loss of amplitude between successive octabes (usually 1/lacunarity).
2D image of fractal noise with 7 octaves of 2D Simplex Noise (from my SimplexNoiseCImg example project):
1 octave of 2D Simplex Noise
Code attribution
This C++ implementation is based on the speed-improved Java version 2012-03-09
by Stefan Gustavson (original Java source code in the public domain).
http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java:
Simplex noise demystified,
Stefan Gustavson, Linköping University, Sweden (stegu@itn.liu.se), 2005-03-22
License
Copyright (c) 2014-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
or copy at http://opensource.org/licenses/MIT)
Current Status
Features
  • 1D, 2D and 3D Perlin Simplex Noise algorithms
  • standard Fractal/Fractional Brownian Motion (fBm) noise summation of multiple octaves
  • CMake project with, cpplint to check code style, cppchek to check code sanity, Doxygen to generate code documentaion
Wishlist
  • Implement 4D Perlin Simplex Noise algorithms
  • Add a parameter for permutation (offset and mask?) of the random table (could be way better than simple offseting applied by the user application)
How to contribute
GitHub website
The most efficient way to help and contribute to this wrapper project is to
use the tools provided by GitHub:
Contact
You can also email me directly.
See Also
SRombauts GitHub website
Continuous Integration
This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
using the Travis CI community service with the above CMake building and testing procedure.
It is also tested in the same way under Windows Server 2012 R2 with Visual Studio 2013 compiler
using the AppVeyor countinuous integration service.
Detailed results can be seen online:
About
A Perlin's Simplex Noise C++ Implementation (1D, 2D, 3D)
Resources
Readme
MIT license
Activity
Stars
367 stars
Watchers
6 watching
Forks
43 forks
Report repository
Releases
Packages
Used by
Contributors
Languages