i did a lot

author: Freya Murphy <freya@freyacat.org> 2025-12-11 10:49:50 -0500
committer: Freya Murphy <freya@freyacat.org> 2025-12-11 10:51:40 -0500
commit: fa8fa6784559ed0fc8d780e36880273f77e272c4 (patch)
tree: 7456a4e9148d47e409ba837bafdc6238b6c757db
parent: add ubos (diff)
download: voxel-fa8fa6784559ed0fc8d780e36880273f77e272c4.tar.gz
voxel-fa8fa6784559ed0fc8d780e36880273f77e272c4.tar.bz2
voxel-fa8fa6784559ed0fc8d780e36880273f77e272c4.zip
26 files changed, 4111 insertions, 418 deletions
diff --git a/.clang-format b/.clang-format
index acfa476..4fb7b29 100644
--- a/.clang-format
+++ b/.clang-format
@@ -47,8 +47,8 @@ ColumnLimit: 92
 CommentPragmas: '^ IWYU pragma:'
 CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 8
-ContinuationIndentWidth: 8
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
 Cpp11BracedListStyle: false
 DerivePointerAlignment: false
 DisableFormat: false
@@ -62,7 +62,7 @@ IncludeIsMainRegex: '(Test)?$'
 IndentCaseLabels: false
 IndentGotoLabels: false
 IndentPPDirectives: None
-IndentWidth: 8
+IndentWidth: 4
 IndentWrappedFunctionNames: false
 JavaScriptQuotes: Leave
 JavaScriptWrapImports: true
@@ -72,7 +72,7 @@ MacroBlockEnd: ''
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
 ObjCBinPackProtocolList: Auto
-ObjCBlockIndentWidth: 8
+ObjCBlockIndentWidth: 4
 ObjCSpaceAfterProperty: true
 ObjCSpaceBeforeProtocolList: true
 PenaltyBreakAssignment: 10
@@ -101,7 +101,7 @@ SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 Standard: Cpp03
-TabWidth: 8
+TabWidth: 4
 UseTab: Always
 ...
 
diff --git a/Makefile b/Makefile
index c8e3fc2..cb40a19 100644
--- a/Makefile
+++ b/Makefile
@@ -5,13 +5,23 @@ CC ?= cc
 CFLAGS += -O2
 CFLAGS += -std=gnu23
 CFLAGS += -Wall -Wextra -pedantic
+CFLAGS += -Isrc -Ilib
 
 LDFLAGS += -lglfw -lGL -lGLEW -lcglm -lm -lc
 
+ifdef USE_VSYNC
+CFLAGS += -DUSE_VSYNC
+endif
+
+ifdef ASAN
+CFLAGS += -fsanitize=address -g
+LDFLAGS += -fsanitize=address
+endif
+
 .PHONY: build clean run fmt
 .SILENT:
 
-SRC := src
+SRC := src lib
 BIN := bin
 OUT := voxel
 
diff --git a/assets/fragment.glsl b/assets/fragment.glsl
index 4065771..5ce136e 100755
--- a/assets/fragment.glsl
+++ b/assets/fragment.glsl
@@ -1,6 +1,6 @@
 #version 330 core
 
-flat in uint pass_data;
+flat in uvec2 pass_data;
 
 out vec4 color;
 
@@ -15,8 +15,8 @@ const float TINT[6] = float[](
 
 void main(void)
 {
-	uint face = pass_data >> 2u;
-	uint block = pass_data & 3u;
+	uint block = (pass_data.x >> 28) & 15u;
+	uint face = (pass_data.x >> 25) & 7u;
 	float tint = TINT[face];
-	color = vec4(tint, tint, tint, 1);
+	color = vec4(vec3(tint), 1);
 }
diff --git a/assets/vertex.glsl b/assets/vertex.glsl
index d14d852..f4c3fde 100755
--- a/assets/vertex.glsl
+++ b/assets/vertex.glsl
@@ -1,14 +1,83 @@
 #version 330 core
 
-in vec3 position;
-in uint data;
+layout (location = 0) in vec3 quad;
 
-uniform mat4 proj_view;
+layout (std140) uniform Matrices {
+	mat4 proj;
+	mat4 view;
+};
 
-flat out uint pass_data;
+// world chunk position
+const int CHUNK_SIZE = 16;
+uniform ivec3 chunk_position;
+
+const int MAX_FACES = CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE;
+layout (std140) uniform Face {
+	// normaly a uint but std140 layout
+	// requires 16-byte alignment
+	uvec4 face_data[MAX_FACES / 4];
+};
+
+flat out uvec2 pass_data;
+
+uint get_half(int index)
+{
+	int arr_index = index / 4;
+	int vec_index = index % 4;
+	return face_data[arr_index][vec_index];
+}
+
+uvec2 get_data(int index)
+{
+	uint lower = get_half(index * 2);
+	uint upper = get_half(index * 2 + 1);
+	return uvec2(lower, upper);
+}
+
+vec3 get_quad(uint face, uint width, uint height)
+{
+	vec3 squad = quad;
+	squad.x *= width;
+	squad.y *= height;
+
+	switch(face) {
+		case 0u: // PX
+			return squad.yzx + vec3(1, 0, 0);
+		case 1u: // NX
+			return squad.yxz;
+		case 2u: // PY
+			return squad.xyz + vec3(0, 1, 0);
+		case 3u: // NY
+			return squad.zyx;
+		case 4u: // PZ
+			return squad.zxy + vec3(0, 0, 1);
+		case 5u: // NZ
+			return squad.xzy;
+	}
+	// should not happen
+	return vec3(0);
+}
 
 void main(void)
 {
-	gl_Position = proj_view * vec4(position, 1.0);
+	// get face data
+	uvec2 data = get_data(gl_InstanceID);
+	uint x = (data.x >> 0) & 31u;
+	uint y = (data.x >> 5) & 31u;
+	uint z = (data.x >> 10) & 31u;
+	uint width = (data.x >> 15) & 31u;
+	uint height = (data.x >> 20) & 31u;
+	uint face = (data.x >> 25) & 7u;
+
+	// get quad verts
+	vec3 quad = get_quad(face, width, height);
+
+	// get position
+	vec3 position = vec3(x, y, z);
+	position += chunk_position * CHUNK_SIZE;
+	position += quad;
+
+	// draw
+	gl_Position = proj * view * vec4(position, 1.0);
 	pass_data = data;
 }
diff --git a/compile_flags.txt b/compile_flags.txt
index c5bde68..4afe3e1 100644
--- a/compile_flags.txt
+++ b/compile_flags.txt
@@ -3,3 +3,6 @@
 -Wall
 -Wextra
 -Wpedantic
+-Isrc
+-Ilib
+-DUSE_VSYNC
diff --git a/lib/noise.c b/lib/noise.c
new file mode 100644
index 0000000..501e826
--- /dev/null
+++ b/lib/noise.c
@@ -0,0 +1,2 @@
+#define FNL_IMPL
+#include "noise.h"
diff --git a/lib/noise.h b/lib/noise.h
new file mode 100644
index 0000000..6765ed9
--- /dev/null
+++ b/lib/noise.h
@@ -0,0 +1,2774 @@
+// MIT License
+//
+// Copyright(c) 2023 Jordan Peck (jordan.me2@gmail.com)
+// Copyright(c) 2023 Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// .'',;:cldxkO00KKXXNNWWWNNXKOkxdollcc::::::;:::ccllloooolllllllllooollc:,'...        ...........',;cldxkO000Okxdlc::;;;,,;;;::cclllllll
+// ..',;:ldxO0KXXNNNNNNNNXXK0kxdolcc::::::;;;,,,,,,;;;;;;;;;;:::cclllllc:;'....       ...........',;:ldxO0KXXXK0Okxdolc::;;;;::cllodddddo
+// ...',:loxO0KXNNNNNXXKK0Okxdolc::;::::::::;;;,,'''''.....''',;:clllllc:;,'............''''''''',;:loxO0KXNNNNNXK0Okxdollccccllodxxxxxxd
+// ....';:ldkO0KXXXKK00Okxdolcc:;;;;;::cclllcc:;;,''..... ....',;clooddolcc:;;;;,,;;;;;::::;;;;;;:cloxk0KXNWWWWWWNXKK0Okxddoooddxxkkkkkxx
+// .....';:ldxkOOOOOkxxdolcc:;;;,,,;;:cllooooolcc:;'...      ..,:codxkkkxddooollloooooooollcc:::::clodkO0KXNWWWWWWNNXK00Okxxxxxxxxkkkkxxx
+// . ....';:cloddddo___________,,,,;;:clooddddoolc:,...      ..,:ldx__00OOOkkk___kkkkkkxxdollc::::cclodkO0KXXNNNNNNXXK0OOkxxxxxxxxxxxxddd
+// .......',;:cccc:|           |,,,;;:cclooddddoll:;'..     ..';cox|  \KKK000|   |KK00OOkxdocc___;::clldxxkO0KKKKK00Okkxdddddddddddddddoo
+// .......'',,,,,''|   ________|',,;;::cclloooooolc:;'......___:ldk|   \KK000|   |XKKK0Okxolc|   |;;::cclodxxkkkkxxdoolllcclllooodddooooo
+// ''......''''....|   |  ....'',,,,;;;::cclloooollc:;,''.'|   |oxk|    \OOO0|   |KKK00Oxdoll|___|;;;;;::ccllllllcc::;;,,;;;:cclloooooooo
+// ;;,''.......... |   |_____',,;;;____:___cllo________.___|   |___|     \xkk|   |KK_______ool___:::;________;;;_______...'',;;:ccclllloo
+// c:;,''......... |         |:::/     '   |lo/        |           |      \dx|   |0/       \d|   |cc/        |'/       \......',,;;:ccllo
+// ol:;,'..........|    _____|ll/    __    |o/   ______|____    ___|   |   \o|   |/   ___   \|   |o/   ______|/   ___   \ .......'',;:clo
+// dlc;,...........|   |::clooo|    /  |   |x\___   \KXKKK0|   |dol|   |\   \|   |   |   |   |   |d\___   \..|   |  /   /       ....',:cl
+// xoc;'...  .....'|   |llodddd|    \__|   |_____\   \KKK0O|   |lc:|   |'\       |   |___|   |   |_____\   \.|   |_/___/...      ...',;:c
+// dlc;'... ....',;|   |oddddddo\          |          |Okkx|   |::;|   |..\      |\         /|   |          | \         |...    ....',;:c
+// ol:,'.......',:c|___|xxxddollc\_____,___|_________/ddoll|___|,,,|___|...\_____|:\ ______/l|___|_________/...\________|'........',;::cc
+// c:;'.......';:codxxkkkkxxolc::;::clodxkOO0OOkkxdollc::;;,,''''',,,,''''''''''',,'''''',;:loxkkOOkxol:;,'''',,;:ccllcc:;,'''''',;::ccll
+// ;,'.......',:codxkOO0OOkxdlc:;,,;;:cldxxkkxxdolc:;;,,''.....'',;;:::;;,,,'''''........,;cldkO0KK0Okdoc::;;::cloodddoolc:;;;;;::ccllooo
+// .........',;:lodxOO0000Okdoc:,,',,;:clloddoolc:;,''.......'',;:clooollc:;;,,''.......',:ldkOKXNNXX0Oxdolllloddxxxxxxdolccccccllooodddd
+// .    .....';:cldxkO0000Okxol:;,''',,;::cccc:;,,'.......'',;:cldxxkkxxdolc:;;,'.......';coxOKXNWWWNXKOkxddddxxkkkkkkxdoollllooddxxxxkkk
+//       ....',;:codxkO000OOxdoc:;,''',,,;;;;,''.......',,;:clodkO00000Okxolc::;,,''..',;:ldxOKXNWWWNNK0OkkkkkkkkkkkxxddooooodxxkOOOOO000
+//       ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX
+//
+// VERSION: 1.1.1
+// https://github.com/Auburn/FastNoiseLite
+
+// In *one* C or C++ file, use #define FNL_IMPL to generate implementation
+
+#ifndef FASTNOISELITE_H
+#define FASTNOISELITE_H
+
+// Switch between using floats or doubles for input position
+typedef float FNLfloat;
+//typedef double FNLfloat;
+
+#include <math.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <float.h>
+
+// Enums
+typedef enum {
+	FNL_NOISE_OPENSIMPLEX2,
+	FNL_NOISE_OPENSIMPLEX2S,
+	FNL_NOISE_CELLULAR,
+	FNL_NOISE_PERLIN,
+	FNL_NOISE_VALUE_CUBIC,
+	FNL_NOISE_VALUE
+} fnl_noise_type;
+
+typedef enum {
+	FNL_ROTATION_NONE,
+	FNL_ROTATION_IMPROVE_XY_PLANES,
+	FNL_ROTATION_IMPROVE_XZ_PLANES
+} fnl_rotation_type_3d;
+
+typedef enum {
+	FNL_FRACTAL_NONE,
+	FNL_FRACTAL_FBM,
+	FNL_FRACTAL_RIDGED,
+	FNL_FRACTAL_PINGPONG,
+	FNL_FRACTAL_DOMAIN_WARP_PROGRESSIVE,
+	FNL_FRACTAL_DOMAIN_WARP_INDEPENDENT
+} fnl_fractal_type;
+
+typedef enum {
+	FNL_CELLULAR_DISTANCE_EUCLIDEAN,
+	FNL_CELLULAR_DISTANCE_EUCLIDEANSQ,
+	FNL_CELLULAR_DISTANCE_MANHATTAN,
+	FNL_CELLULAR_DISTANCE_HYBRID
+} fnl_cellular_distance_func;
+
+typedef enum {
+	FNL_CELLULAR_RETURN_TYPE_CELLVALUE,
+	FNL_CELLULAR_RETURN_TYPE_DISTANCE,
+	FNL_CELLULAR_RETURN_TYPE_DISTANCE2,
+	FNL_CELLULAR_RETURN_TYPE_DISTANCE2ADD,
+	FNL_CELLULAR_RETURN_TYPE_DISTANCE2SUB,
+	FNL_CELLULAR_RETURN_TYPE_DISTANCE2MUL,
+	FNL_CELLULAR_RETURN_TYPE_DISTANCE2DIV,
+} fnl_cellular_return_type;
+
+typedef enum {
+	FNL_DOMAIN_WARP_OPENSIMPLEX2,
+	FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED,
+	FNL_DOMAIN_WARP_BASICGRID
+} fnl_domain_warp_type;
+
+/**
+ * Structure containing entire noise system state.
+ * @note Must only be created using fnlCreateState(optional: seed). To ensure defaults are set.
+ */
+typedef struct fnl_state {
+	/**
+     * Seed used for all noise types.
+     * @remark Default: 1337
+     */
+	int seed;
+
+	/**
+     * The frequency for all noise types.
+     * @remark Default: 0.01
+     */
+	float frequency;
+
+	/**
+     * The noise algorithm to be used by GetNoise(...).
+     * @remark Default: FNL_NOISE_OPENSIMPLEX2
+     */
+	fnl_noise_type noise_type;
+
+	/**
+     * Sets noise rotation type for 3D.
+     * @remark Default: FNL_ROTATION_NONE
+     */
+	fnl_rotation_type_3d rotation_type_3d;
+
+	/**
+     * The method used for combining octaves for all fractal noise types.
+     * @remark Default: None
+     * @remark FNL_FRACTAL_DOMAIN_WARP_... only effects fnlDomainWarp...
+     */
+	fnl_fractal_type fractal_type;
+
+	/**
+     * The octave count for all fractal noise types.
+     * @remark Default: 3
+     */
+	int octaves;
+
+	/**
+     * The octave lacunarity for all fractal noise types.
+     * @remark Default: 2.0
+     */
+	float lacunarity;
+
+	/**
+     * The octave gain for all fractal noise types.
+     * @remark Default: 0.5
+     */
+	float gain;
+
+	/**
+     * The octave weighting for all none Domaain Warp fractal types.
+     * @remark Default: 0.0
+     * @remark
+     */
+	float weighted_strength;
+
+	/**
+     * The strength of the fractal ping pong effect.
+     * @remark Default: 2.0
+     */
+	float ping_pong_strength;
+
+	/**
+     * The distance function used in cellular noise calculations.
+     * @remark Default: FNL_CELLULAR_DISTANCE_EUCLIDEANSQ
+     */
+	fnl_cellular_distance_func cellular_distance_func;
+
+	/**
+     * The cellular return type from cellular noise calculations.
+     * @remark Default: FNL_CELLULAR_RETURN_TYPE_DISTANCE
+     */
+	fnl_cellular_return_type cellular_return_type;
+
+	/**
+     * The maximum distance a cellular point can move from it's grid position.
+     * @remark Default: 1.0
+     * @note Setting this higher than 1 will cause artifacts.
+     */
+	float cellular_jitter_mod;
+
+	/**
+     * The warp algorithm when using fnlDomainWarp...
+     * @remark Default: OpenSimplex2
+     */
+	fnl_domain_warp_type domain_warp_type;
+
+	/**
+     * The maximum warp distance from original position when using fnlDomainWarp...
+     * @remark Default: 1.0
+     */
+	float domain_warp_amp;
+} fnl_state;
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * Creates a noise state with default values.
+ * @param seed Optionally set the state seed.
+ */
+fnl_state fnlCreateState();
+
+/**
+ * 2D noise at given position using the state settings
+ * @returns Noise output bounded between -1 and 1.
+ */
+float fnlGetNoise2D(const fnl_state *state, FNLfloat x, FNLfloat y);
+
+/**
+ * 3D noise at given position using the state settings
+ * @returns Noise output bounded between -1 and 1.
+ */
+float fnlGetNoise3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z);
+
+/**
+ * 2D warps the input position using current domain warp settings.
+ *
+ * Example usage with fnlGetNoise2D:
+ * ```
+ * fnlDomainWarp2D(&state, &x, &y);
+ * noise = fnlGetNoise2D(&state, x, y);
+ * ```
+ */
+void fnlDomainWarp2D(const fnl_state *state, FNLfloat *x, FNLfloat *y);
+
+/**
+ * 3D warps the input position using current domain warp settings.
+ *
+ * Example usage with fnlGetNoise3D:
+ * ```
+ * fnlDomainWarp3D(&state, &x, &y, &z);
+ * noise = fnlGetNoise3D(&state, x, y, z);
+ * ```
+ */
+void fnlDomainWarp3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // FASTNOISELITE_H
+
+// ====================
+// Below this line is the implementation
+// ====================
+
+#if defined(FNL_IMPL)
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+// Constants
+
+static const float GRADIENTS_2D[] = {
+	0.130526192220052f,	 0.99144486137381f,	  0.38268343236509f,   0.923879532511287f,
+	0.608761429008721f,	 0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+	0.923879532511287f,	 0.38268343236509f,	  0.99144486137381f,   0.130526192220051f,
+	0.99144486137381f,	 -0.130526192220051f, 0.923879532511287f,  -0.38268343236509f,
+	0.793353340291235f,	 -0.60876142900872f,  0.608761429008721f,  -0.793353340291235f,
+	0.38268343236509f,	 -0.923879532511287f, 0.130526192220052f,  -0.99144486137381f,
+	-0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f,
+	-0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+	-0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f,
+	-0.99144486137381f,	 0.130526192220051f,  -0.923879532511287f, 0.38268343236509f,
+	-0.793353340291235f, 0.608761429008721f,  -0.608761429008721f, 0.793353340291235f,
+	-0.38268343236509f,	 0.923879532511287f,  -0.130526192220052f, 0.99144486137381f,
+	0.130526192220052f,	 0.99144486137381f,	  0.38268343236509f,   0.923879532511287f,
+	0.608761429008721f,	 0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+	0.923879532511287f,	 0.38268343236509f,	  0.99144486137381f,   0.130526192220051f,
+	0.99144486137381f,	 -0.130526192220051f, 0.923879532511287f,  -0.38268343236509f,
+	0.793353340291235f,	 -0.60876142900872f,  0.608761429008721f,  -0.793353340291235f,
+	0.38268343236509f,	 -0.923879532511287f, 0.130526192220052f,  -0.99144486137381f,
+	-0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f,
+	-0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+	-0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f,
+	-0.99144486137381f,	 0.130526192220051f,  -0.923879532511287f, 0.38268343236509f,
+	-0.793353340291235f, 0.608761429008721f,  -0.608761429008721f, 0.793353340291235f,
+	-0.38268343236509f,	 0.923879532511287f,  -0.130526192220052f, 0.99144486137381f,
+	0.130526192220052f,	 0.99144486137381f,	  0.38268343236509f,   0.923879532511287f,
+	0.608761429008721f,	 0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+	0.923879532511287f,	 0.38268343236509f,	  0.99144486137381f,   0.130526192220051f,
+	0.99144486137381f,	 -0.130526192220051f, 0.923879532511287f,  -0.38268343236509f,
+	0.793353340291235f,	 -0.60876142900872f,  0.608761429008721f,  -0.793353340291235f,
+	0.38268343236509f,	 -0.923879532511287f, 0.130526192220052f,  -0.99144486137381f,
+	-0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f,
+	-0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+	-0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f,
+	-0.99144486137381f,	 0.130526192220051f,  -0.923879532511287f, 0.38268343236509f,
+	-0.793353340291235f, 0.608761429008721f,  -0.608761429008721f, 0.793353340291235f,
+	-0.38268343236509f,	 0.923879532511287f,  -0.130526192220052f, 0.99144486137381f,
+	0.130526192220052f,	 0.99144486137381f,	  0.38268343236509f,   0.923879532511287f,
+	0.608761429008721f,	 0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+	0.923879532511287f,	 0.38268343236509f,	  0.99144486137381f,   0.130526192220051f,
+	0.99144486137381f,	 -0.130526192220051f, 0.923879532511287f,  -0.38268343236509f,
+	0.793353340291235f,	 -0.60876142900872f,  0.608761429008721f,  -0.793353340291235f,
+	0.38268343236509f,	 -0.923879532511287f, 0.130526192220052f,  -0.99144486137381f,
+	-0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f,
+	-0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+	-0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f,
+	-0.99144486137381f,	 0.130526192220051f,  -0.923879532511287f, 0.38268343236509f,
+	-0.793353340291235f, 0.608761429008721f,  -0.608761429008721f, 0.793353340291235f,
+	-0.38268343236509f,	 0.923879532511287f,  -0.130526192220052f, 0.99144486137381f,
+	0.130526192220052f,	 0.99144486137381f,	  0.38268343236509f,   0.923879532511287f,
+	0.608761429008721f,	 0.793353340291235f,  0.793353340291235f,  0.608761429008721f,
+	0.923879532511287f,	 0.38268343236509f,	  0.99144486137381f,   0.130526192220051f,
+	0.99144486137381f,	 -0.130526192220051f, 0.923879532511287f,  -0.38268343236509f,
+	0.793353340291235f,	 -0.60876142900872f,  0.608761429008721f,  -0.793353340291235f,
+	0.38268343236509f,	 -0.923879532511287f, 0.130526192220052f,  -0.99144486137381f,
+	-0.130526192220052f, -0.99144486137381f,  -0.38268343236509f,  -0.923879532511287f,
+	-0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f,
+	-0.923879532511287f, -0.38268343236509f,  -0.99144486137381f,  -0.130526192220052f,
+	-0.99144486137381f,	 0.130526192220051f,  -0.923879532511287f, 0.38268343236509f,
+	-0.793353340291235f, 0.608761429008721f,  -0.608761429008721f, 0.793353340291235f,
+	-0.38268343236509f,	 0.923879532511287f,  -0.130526192220052f, 0.99144486137381f,
+	0.38268343236509f,	 0.923879532511287f,  0.923879532511287f,  0.38268343236509f,
+	0.923879532511287f,	 -0.38268343236509f,  0.38268343236509f,   -0.923879532511287f,
+	-0.38268343236509f,	 -0.923879532511287f, -0.923879532511287f, -0.38268343236509f,
+	-0.923879532511287f, 0.38268343236509f,	  -0.38268343236509f,  0.923879532511287f,
+};
+
+static const float RAND_VECS_2D[] = {
+	-0.2700222198f,	  -0.9628540911f,  0.3863092627f,	-0.9223693152f,	 0.04444859006f,
+	-0.999011673f,	  -0.5992523158f,  -0.8005602176f,	-0.7819280288f,	 0.6233687174f,
+	0.9464672271f,	  0.3227999196f,   -0.6514146797f,	-0.7587218957f,	 0.9378472289f,
+	0.347048376f,	  -0.8497875957f,  -0.5271252623f,	-0.879042592f,	 0.4767432447f,
+	-0.892300288f,	  -0.4514423508f,  -0.379844434f,	-0.9250503802f,	 -0.9951650832f,
+	0.0982163789f,	  0.7724397808f,   -0.6350880136f,	0.7573283322f,	 -0.6530343002f,
+	-0.9928004525f,	  -0.119780055f,   -0.0532665713f,	0.9985803285f,	 0.9754253726f,
+	-0.2203300762f,	  -0.7665018163f,  0.6422421394f,	0.991636706f,	 0.1290606184f,
+	-0.994696838f,	  0.1028503788f,   -0.5379205513f,	-0.84299554f,	 0.5022815471f,
+	-0.8647041387f,	  0.4559821461f,   -0.8899889226f,	-0.8659131224f,	 -0.5001944266f,
+	0.0879458407f,	  -0.9961252577f,  -0.5051684983f,	0.8630207346f,	 0.7753185226f,
+	-0.6315704146f,	  -0.6921944612f,  0.7217110418f,	-0.5191659449f,	 -0.8546734591f,
+	0.8978622882f,	  -0.4402764035f,  -0.1706774107f,	0.9853269617f,	 -0.9353430106f,
+	-0.3537420705f,	  -0.9992404798f,  0.03896746794f,	-0.2882064021f,	 -0.9575683108f,
+	-0.9663811329f,	  0.2571137995f,   -0.8759714238f,	-0.4823630009f,	 -0.8303123018f,
+	-0.5572983775f,	  0.05110133755f,  -0.9986934731f,	-0.8558373281f,	 -0.5172450752f,
+	0.09887025282f,	  0.9951003332f,   0.9189016087f,	0.3944867976f,	 -0.2439375892f,
+	-0.9697909324f,	  -0.8121409387f,  -0.5834613061f,	-0.9910431363f,	 0.1335421355f,
+	0.8492423985f,	  -0.5280031709f,  -0.9717838994f,	-0.2358729591f,	 0.9949457207f,
+	0.1004142068f,	  0.6241065508f,   -0.7813392434f,	0.662910307f,	 0.7486988212f,
+	-0.7197418176f,	  0.6942418282f,   -0.8143370775f,	-0.5803922158f,	 0.104521054f,
+	-0.9945226741f,	  -0.1065926113f,  -0.9943027784f,	0.445799684f,	 -0.8951327509f,
+	0.105547406f,	  0.9944142724f,   -0.992790267f,	0.1198644477f,	 -0.8334366408f,
+	0.552615025f,	  0.9115561563f,   -0.4111755999f,	0.8285544909f,	 -0.5599084351f,
+	0.7217097654f,	  -0.6921957921f,  0.4940492677f,	-0.8694339084f,	 -0.3652321272f,
+	-0.9309164803f,	  -0.9696606758f,  0.2444548501f,	0.08925509731f,	 -0.996008799f,
+	0.5354071276f,	  -0.8445941083f,  -0.1053576186f,	0.9944343981f,	 -0.9890284586f,
+	0.1477251101f,	  0.004856104961f, 0.9999882091f,	0.9885598478f,	 0.1508291331f,
+	0.9286129562f,	  -0.3710498316f,  -0.5832393863f,	-0.8123003252f,	 0.3015207509f,
+	0.9534596146f,	  -0.9575110528f,  0.2883965738f,	0.9715802154f,	 -0.2367105511f,
+	0.229981792f,	  0.9731949318f,   0.955763816f,	-0.2941352207f,	 0.740956116f,
+	0.6715534485f,	  -0.9971513787f,  -0.07542630764f, 0.6905710663f,	 -0.7232645452f,
+	-0.290713703f,	  -0.9568100872f,  0.5912777791f,	-0.8064679708f,	 -0.9454592212f,
+	-0.325740481f,	  0.6664455681f,   0.74555369f,		0.6236134912f,	 0.7817328275f,
+	0.9126993851f,	  -0.4086316587f,  -0.8191762011f,	0.5735419353f,	 -0.8812745759f,
+	-0.4726046147f,	  0.9953313627f,   0.09651672651f,	0.9855650846f,	 -0.1692969699f,
+	-0.8495980887f,	  0.5274306472f,   0.6174853946f,	-0.7865823463f,	 0.8508156371f,
+	0.52546432f,	  0.9985032451f,   -0.05469249926f, 0.1971371563f,	 -0.9803759185f,
+	0.6607855748f,	  -0.7505747292f,  -0.03097494063f, 0.9995201614f,	 -0.6731660801f,
+	0.739491331f,	  -0.7195018362f,  -0.6944905383f,	0.9727511689f,	 0.2318515979f,
+	0.9997059088f,	  -0.0242506907f,  0.4421787429f,	-0.8969269532f,	 0.9981350961f,
+	-0.061043673f,	  -0.9173660799f,  -0.3980445648f,	-0.8150056635f,	 -0.5794529907f,
+	-0.8789331304f,	  0.4769450202f,   0.0158605829f,	0.999874213f,	 -0.8095464474f,
+	0.5870558317f,	  -0.9165898907f,  -0.3998286786f,	-0.8023542565f,	 0.5968480938f,
+	-0.5176737917f,	  0.8555780767f,   -0.8154407307f,	-0.5788405779f,	 0.4022010347f,
+	-0.9155513791f,	  -0.9052556868f,  -0.4248672045f,	0.7317445619f,	 0.6815789728f,
+	-0.5647632201f,	  -0.8252529947f,  -0.8403276335f,	-0.5420788397f,	 -0.9314281527f,
+	0.363925262f,	  0.5238198472f,   0.8518290719f,	0.7432803869f,	 -0.6689800195f,
+	-0.985371561f,	  -0.1704197369f,  0.4601468731f,	0.88784281f,	 0.825855404f,
+	0.5638819483f,	  0.6182366099f,   0.7859920446f,	0.8331502863f,	 -0.553046653f,
+	0.1500307506f,	  0.9886813308f,   -0.662330369f,	-0.7492119075f,	 -0.668598664f,
+	0.743623444f,	  0.7025606278f,   0.7116238924f,	-0.5419389763f,	 -0.8404178401f,
+	-0.3388616456f,	  0.9408362159f,   0.8331530315f,	0.5530425174f,	 -0.2989720662f,
+	-0.9542618632f,	  0.2638522993f,   0.9645630949f,	0.124108739f,	 -0.9922686234f,
+	-0.7282649308f,	  -0.6852956957f,  0.6962500149f,	0.7177993569f,	 -0.9183535368f,
+	0.3957610156f,	  -0.6326102274f,  -0.7744703352f,	-0.9331891859f,	 -0.359385508f,
+	-0.1153779357f,	  -0.9933216659f,  0.9514974788f,	-0.3076565421f,	 -0.08987977445f,
+	-0.9959526224f,	  0.6678496916f,   0.7442961705f,	0.7952400393f,	 -0.6062947138f,
+	-0.6462007402f,	  -0.7631674805f,  -0.2733598753f,	0.9619118351f,	 0.9669590226f,
+	-0.254931851f,	  -0.9792894595f,  0.2024651934f,	-0.5369502995f,	 -0.8436138784f,
+	-0.270036471f,	  -0.9628500944f,  -0.6400277131f,	0.7683518247f,	 -0.7854537493f,
+	-0.6189203566f,	  0.06005905383f,  -0.9981948257f,	-0.02455770378f, 0.9996984141f,
+	-0.65983623f,	  0.751409442f,	   -0.6253894466f,	-0.7803127835f,	 -0.6210408851f,
+	-0.7837781695f,	  0.8348888491f,   0.5504185768f,	-0.1592275245f,	 0.9872419133f,
+	0.8367622488f,	  0.5475663786f,   -0.8675753916f,	-0.4973056806f,	 -0.2022662628f,
+	-0.9793305667f,	  0.9399189937f,   0.3413975472f,	0.9877404807f,	 -0.1561049093f,
+	-0.9034455656f,	  0.4287028224f,   0.1269804218f,	-0.9919052235f,	 -0.3819600854f,
+	0.924178821f,	  0.9754625894f,   0.2201652486f,	-0.3204015856f,	 -0.9472818081f,
+	-0.9874760884f,	  0.1577687387f,   0.02535348474f,	-0.9996785487f,	 0.4835130794f,
+	-0.8753371362f,	  -0.2850799925f,  -0.9585037287f,	-0.06805516006f, -0.99768156f,
+	-0.7885244045f,	  -0.6150034663f,  0.3185392127f,	-0.9479096845f,	 0.8880043089f,
+	0.4598351306f,	  0.6476921488f,   -0.7619021462f,	0.9820241299f,	 0.1887554194f,
+	0.9357275128f,	  -0.3527237187f,  -0.8894895414f,	0.4569555293f,	 0.7922791302f,
+	0.6101588153f,	  0.7483818261f,   0.6632681526f,	-0.7288929755f,	 -0.6846276581f,
+	0.8729032783f,	  -0.4878932944f,  0.8288345784f,	0.5594937369f,	 0.08074567077f,
+	0.9967347374f,	  0.9799148216f,   -0.1994165048f,	-0.580730673f,	 -0.8140957471f,
+	-0.4700049791f,	  -0.8826637636f,  0.2409492979f,	0.9705377045f,	 0.9437816757f,
+	-0.3305694308f,	  -0.8927998638f,  -0.4504535528f,	-0.8069622304f,	 0.5906030467f,
+	0.06258973166f,	  0.9980393407f,   -0.9312597469f,	0.3643559849f,	 0.5777449785f,
+	0.8162173362f,	  -0.3360095855f,  -0.941858566f,	0.697932075f,	 -0.7161639607f,
+	-0.002008157227f, -0.9999979837f,  -0.1827294312f,	-0.9831632392f,	 -0.6523911722f,
+	0.7578824173f,	  -0.4302626911f,  -0.9027037258f,	-0.9985126289f,	 -0.05452091251f,
+	-0.01028102172f,  -0.9999471489f,  -0.4946071129f,	0.8691166802f,	 -0.2999350194f,
+	0.9539596344f,	  0.8165471961f,   0.5772786819f,	0.2697460475f,	 0.962931498f,
+	-0.7306287391f,	  -0.6827749597f,  -0.7590952064f,	-0.6509796216f,	 -0.907053853f,
+	0.4210146171f,	  -0.5104861064f,  -0.8598860013f,	0.8613350597f,	 0.5080373165f,
+	0.5007881595f,	  -0.8655698812f,  -0.654158152f,	0.7563577938f,	 -0.8382755311f,
+	-0.545246856f,	  0.6940070834f,   0.7199681717f,	0.06950936031f,	 0.9975812994f,
+	0.1702942185f,	  -0.9853932612f,  0.2695973274f,	0.9629731466f,	 0.5519612192f,
+	-0.8338697815f,	  0.225657487f,	   -0.9742067022f,	0.4215262855f,	 -0.9068161835f,
+	0.4881873305f,	  -0.8727388672f,  -0.3683854996f,	-0.9296731273f,	 -0.9825390578f,
+	0.1860564427f,	  0.81256471f,	   0.5828709909f,	0.3196460933f,	 -0.9475370046f,
+	0.9570913859f,	  0.2897862643f,   -0.6876655497f,	-0.7260276109f,	 -0.9988770922f,
+	-0.047376731f,	  -0.1250179027f,  0.992154486f,	-0.8280133617f,	 0.560708367f,
+	0.9324863769f,	  -0.3612051451f,  0.6394653183f,	0.7688199442f,	 -0.01623847064f,
+	-0.9998681473f,	  -0.9955014666f,  -0.09474613458f, -0.81453315f,	 0.580117012f,
+	0.4037327978f,	  -0.9148769469f,  0.9944263371f,	0.1054336766f,	 -0.1624711654f,
+	0.9867132919f,	  -0.9949487814f,  -0.100383875f,	-0.6995302564f,	 0.7146029809f,
+	0.5263414922f,	  -0.85027327f,	   -0.5395221479f,	0.841971408f,	 0.6579370318f,
+	0.7530729462f,	  0.01426758847f,  -0.9998982128f,	-0.6734383991f,	 0.7392433447f,
+	0.639412098f,	  -0.7688642071f,  0.9211571421f,	0.3891908523f,	 -0.146637214f,
+	-0.9891903394f,	  -0.782318098f,   0.6228791163f,	-0.5039610839f,	 -0.8637263605f,
+	-0.7743120191f,	  -0.6328039957f,
+};
+
+static const float GRADIENTS_3D[] = {
+	0, 1, 1,  0, 0,	 -1, 1,	 0, 0,	1, -1, 0, 0,  -1, -1, 0, 1, 0,	1, 0, -1, 0,  1, 0,
+	1, 0, -1, 0, -1, 0,	 -1, 0, 1,	1, 0,  0, -1, 1,  0,  0, 1, -1, 0, 0, -1, -1, 0, 0,
+	0, 1, 1,  0, 0,	 -1, 1,	 0, 0,	1, -1, 0, 0,  -1, -1, 0, 1, 0,	1, 0, -1, 0,  1, 0,
+	1, 0, -1, 0, -1, 0,	 -1, 0, 1,	1, 0,  0, -1, 1,  0,  0, 1, -1, 0, 0, -1, -1, 0, 0,
+	0, 1, 1,  0, 0,	 -1, 1,	 0, 0,	1, -1, 0, 0,  -1, -1, 0, 1, 0,	1, 0, -1, 0,  1, 0,
+	1, 0, -1, 0, -1, 0,	 -1, 0, 1,	1, 0,  0, -1, 1,  0,  0, 1, -1, 0, 0, -1, -1, 0, 0,
+	0, 1, 1,  0, 0,	 -1, 1,	 0, 0,	1, -1, 0, 0,  -1, -1, 0, 1, 0,	1, 0, -1, 0,  1, 0,
+	1, 0, -1, 0, -1, 0,	 -1, 0, 1,	1, 0,  0, -1, 1,  0,  0, 1, -1, 0, 0, -1, -1, 0, 0,
+	0, 1, 1,  0, 0,	 -1, 1,	 0, 0,	1, -1, 0, 0,  -1, -1, 0, 1, 0,	1, 0, -1, 0,  1, 0,
+	1, 0, -1, 0, -1, 0,	 -1, 0, 1,	1, 0,  0, -1, 1,  0,  0, 1, -1, 0, 0, -1, -1, 0, 0,
+	1, 1, 0,  0, 0,	 -1, 1,	 0, -1, 1, 0,  0, 0,  -1, -1, 0
+};
+
+static const float RAND_VECS_3D[] = {
+	-0.7292736885f,	 -0.6618439697f,	0.1735581948f,	  0,
+	0.790292081f,	 -0.5480887466f,	-0.2739291014f,	  0,
+	0.7217578935f,	 0.6226212466f,		-0.3023380997f,	  0,
+	0.565683137f,	 -0.8208298145f,	-0.0790000257f,	  0,
+	0.760049034f,	 -0.5555979497f,	-0.3370999617f,	  0,
+	0.3713945616f,	 0.5011264475f,		0.7816254623f,	  0,
+	-0.1277062463f,	 -0.4254438999f,	-0.8959289049f,	  0,
+	-0.2881560924f,	 -0.5815838982f,	0.7607405838f,	  0,
+	0.5849561111f,	 -0.662820239f,		-0.4674352136f,	  0,
+	0.3307171178f,	 0.0391653737f,		0.94291689f,	  0,
+	0.8712121778f,	 -0.4113374369f,	-0.2679381538f,	  0,
+	0.580981015f,	 0.7021915846f,		0.4115677815f,	  0,
+	0.503756873f,	 0.6330056931f,		-0.5878203852f,	  0,
+	0.4493712205f,	 0.601390195f,		0.6606022552f,	  0,
+	-0.6878403724f,	 0.09018890807f,	-0.7202371714f,	  0,
+	-0.5958956522f,	 -0.6469350577f,	0.475797649f,	  0,
+	-0.5127052122f,	 0.1946921978f,		-0.8361987284f,	  0,
+	-0.9911507142f,	 -0.05410276466f,	-0.1212153153f,	  0,
+	-0.2149721042f,	 0.9720882117f,		-0.09397607749f,  0,
+	-0.7518650936f,	 -0.5428057603f,	0.3742469607f,	  0,
+	0.5237068895f,	 0.8516377189f,		-0.02107817834f,  0,
+	0.6333504779f,	 0.1926167129f,		-0.7495104896f,	  0,
+	-0.06788241606f, 0.3998305789f,		0.9140719259f,	  0,
+	-0.5538628599f,	 -0.4729896695f,	-0.6852128902f,	  0,
+	-0.7261455366f,	 -0.5911990757f,	0.3509933228f,	  0,
+	-0.9229274737f,	 -0.1782808786f,	0.3412049336f,	  0,
+	-0.6968815002f,	 0.6511274338f,		0.3006480328f,	  0,
+	0.9608044783f,	 -0.2098363234f,	-0.1811724921f,	  0,
+	0.06817146062f,	 -0.9743405129f,	0.2145069156f,	  0,
+	-0.3577285196f,	 -0.6697087264f,	-0.6507845481f,	  0,
+	-0.1868621131f,	 0.7648617052f,		-0.6164974636f,	  0,
+	-0.6541697588f,	 0.3967914832f,		0.6439087246f,	  0,
+	0.6993340405f,	 -0.6164538506f,	0.3618239211f,	  0,
+	-0.1546665739f,	 0.6291283928f,		0.7617583057f,	  0,
+	-0.6841612949f,	 -0.2580482182f,	-0.6821542638f,	  0,
+	0.5383980957f,	 0.4258654885f,		0.7271630328f,	  0,
+	-0.5026987823f,	 -0.7939832935f,	-0.3418836993f,	  0,
+	0.3202971715f,	 0.2834415347f,		0.9039195862f,	  0,
+	0.8683227101f,	 -0.0003762656404f, -0.4959995258f,	  0,
+	0.791120031f,	 -0.08511045745f,	0.6057105799f,	  0,
+	-0.04011016052f, -0.4397248749f,	0.8972364289f,	  0,
+	0.9145119872f,	 0.3579346169f,		-0.1885487608f,	  0,
+	-0.9612039066f,	 -0.2756484276f,	0.01024666929f,	  0,
+	0.6510361721f,	 -0.2877799159f,	-0.7023778346f,	  0,
+	-0.2041786351f,	 0.7365237271f,		0.644859585f,	  0,
+	-0.7718263711f,	 0.3790626912f,		0.5104855816f,	  0,
+	-0.3060082741f,	 -0.7692987727f,	0.5608371729f,	  0,
+	0.454007341f,	 -0.5024843065f,	0.7357899537f,	  0,
+	0.4816795475f,	 0.6021208291f,		-0.6367380315f,	  0,
+	0.6961980369f,	 -0.3222197429f,	0.641469197f,	  0,
+	-0.6532160499f,	 -0.6781148932f,	0.3368515753f,	  0,
+	0.5089301236f,	 -0.6154662304f,	-0.6018234363f,	  0,
+	-0.1635919754f,	 -0.9133604627f,	-0.372840892f,	  0,
+	0.52408019f,	 -0.8437664109f,	0.1157505864f,	  0,
+	0.5902587356f,	 0.4983817807f,		-0.6349883666f,	  0,
+	0.5863227872f,	 0.494764745f,		0.6414307729f,	  0,
+	0.6779335087f,	 0.2341345225f,		0.6968408593f,	  0,
+	0.7177054546f,	 -0.6858979348f,	0.120178631f,	  0,
+	-0.5328819713f,	 -0.5205125012f,	0.6671608058f,	  0,
+	-0.8654874251f,	 -0.0700727088f,	-0.4960053754f,	  0,
+	-0.2861810166f,	 0.7952089234f,		0.5345495242f,	  0,
+	-0.04849529634f, 0.9810836427f,		-0.1874115585f,	  0,
+	-0.6358521667f,	 0.6058348682f,		0.4781800233f,	  0,
+	0.6254794696f,	 -0.2861619734f,	0.7258696564f,	  0,
+	-0.2585259868f,	 0.5061949264f,		-0.8227581726f,	  0,
+	0.02136306781f,	 0.5064016808f,		-0.8620330371f,	  0,
+	0.200111773f,	 0.8599263484f,		0.4695550591f,	  0,
+	0.4743561372f,	 0.6014985084f,		-0.6427953014f,	  0,
+	0.6622993731f,	 -0.5202474575f,	-0.5391679918f,	  0,
+	0.08084972818f,	 -0.6532720452f,	0.7527940996f,	  0,
+	-0.6893687501f,	 0.0592860349f,		0.7219805347f,	  0,
+	-0.1121887082f,	 -0.9673185067f,	0.2273952515f,	  0,
+	0.7344116094f,	 0.5979668656f,		-0.3210532909f,	  0,
+	0.5789393465f,	 -0.2488849713f,	0.7764570201f,	  0,
+	0.6988182827f,	 0.3557169806f,		-0.6205791146f,	  0,
+	-0.8636845529f,	 -0.2748771249f,	-0.4224826141f,	  0,
+	-0.4247027957f,	 -0.4640880967f,	0.777335046f,	  0,
+	0.5257722489f,	 -0.8427017621f,	0.1158329937f,	  0,
+	0.9343830603f,	 0.316302472f,		-0.1639543925f,	  0,
+	-0.1016836419f,	 -0.8057303073f,	-0.5834887393f,	  0,
+	-0.6529238969f,	 0.50602126f,		-0.5635892736f,	  0,
+	-0.2465286165f,	 -0.9668205684f,	-0.06694497494f,  0,
+	-0.9776897119f,	 -0.2099250524f,	-0.007368825344f, 0,
+	0.7736893337f,	 0.5734244712f,		0.2694238123f,	  0,
+	-0.6095087895f,	 0.4995678998f,		0.6155736747f,	  0,
+	0.5794535482f,	 0.7434546771f,		0.3339292269f,	  0,
+	-0.8226211154f,	 0.08142581855f,	0.5627293636f,	  0,
+	-0.510385483f,	 0.4703667658f,		0.7199039967f,	  0,
+	-0.5764971849f,	 -0.07231656274f,	-0.8138926898f,	  0,
+	0.7250628871f,	 0.3949971505f,		-0.5641463116f,	  0,
+	-0.1525424005f,	 0.4860840828f,		-0.8604958341f,	  0,
+	-0.5550976208f,	 -0.4957820792f,	0.667882296f,	  0,
+	-0.1883614327f,	 0.9145869398f,		0.357841725f,	  0,
+	0.7625556724f,	 -0.5414408243f,	-0.3540489801f,	  0,
+	-0.5870231946f,	 -0.3226498013f,	-0.7424963803f,	  0,
+	0.3051124198f,	 0.2262544068f,		-0.9250488391f,	  0,
+	0.6379576059f,	 0.577242424f,		-0.5097070502f,	  0,
+	-0.5966775796f,	 0.1454852398f,		-0.7891830656f,	  0,
+	-0.658330573f,	 0.6555487542f,		-0.3699414651f,	  0,
+	0.7434892426f,	 0.2351084581f,		0.6260573129f,	  0,
+	0.5562114096f,	 0.8264360377f,		-0.0873632843f,	  0,
+	-0.3028940016f,	 -0.8251527185f,	0.4768419182f,	  0,
+	0.1129343818f,	 -0.985888439f,		-0.1235710781f,	  0,
+	0.5937652891f,	 -0.5896813806f,	0.5474656618f,	  0,
+	0.6757964092f,	 -0.5835758614f,	-0.4502648413f,	  0,
+	0.7242302609f,	 -0.1152719764f,	0.6798550586f,	  0,
+	-0.9511914166f,	 0.0753623979f,		-0.2992580792f,	  0,
+	0.2539470961f,	 -0.1886339355f,	0.9486454084f,	  0,
+	0.571433621f,	 -0.1679450851f,	-0.8032795685f,	  0,
+	-0.06778234979f, 0.3978269256f,		0.9149531629f,	  0,
+	0.6074972649f,	 0.733060024f,		-0.3058922593f,	  0,
+	-0.5435478392f,	 0.1675822484f,		0.8224791405f,	  0,
+	-0.5876678086f,	 -0.3380045064f,	-0.7351186982f,	  0,
+	-0.7967562402f,	 0.04097822706f,	-0.6029098428f,	  0,
+	-0.1996350917f,	 0.8706294745f,		0.4496111079f,	  0,
+	-0.02787660336f, -0.9106232682f,	-0.4122962022f,	  0,
+	-0.7797625996f,	 -0.6257634692f,	0.01975775581f,	  0,
+	-0.5211232846f,	 0.7401644346f,		-0.4249554471f,	  0,
+	0.8575424857f,	 0.4053272873f,		-0.3167501783f,	  0,
+	0.1045223322f,	 0.8390195772f,		-0.5339674439f,	  0,
+	0.3501822831f,	 0.9242524096f,		-0.1520850155f,	  0,
+	0.1987849858f,	 0.07647613266f,	0.9770547224f,	  0,
+	0.7845996363f,	 0.6066256811f,		-0.1280964233f,	  0,
+	0.09006737436f,	 -0.9750989929f,	-0.2026569073f,	  0,
+	-0.8274343547f,	 -0.542299559f,		0.1458203587f,	  0,
+	-0.3485797732f,	 -0.415802277f,		0.840000362f,	  0,
+	-0.2471778936f,	 -0.7304819962f,	-0.6366310879f,	  0,
+	-0.3700154943f,	 0.8577948156f,		0.3567584454f,	  0,
+	0.5913394901f,	 -0.548311967f,		-0.5913303597f,	  0,
+	0.1204873514f,	 -0.7626472379f,	-0.6354935001f,	  0,
+	0.616959265f,	 0.03079647928f,	0.7863922953f,	  0,
+	0.1258156836f,	 -0.6640829889f,	-0.7369967419f,	  0,
+	-0.6477565124f,	 -0.1740147258f,	-0.7417077429f,	  0,
+	0.6217889313f,	 -0.7804430448f,	-0.06547655076f,  0,
+	0.6589943422f,	 -0.6096987708f,	0.4404473475f,	  0,
+	-0.2689837504f,	 -0.6732403169f,	-0.6887635427f,	  0,
+	-0.3849775103f,	 0.5676542638f,		0.7277093879f,	  0,
+	0.5754444408f,	 0.8110471154f,		-0.1051963504f,	  0,
+	0.9141593684f,	 0.3832947817f,		0.131900567f,	  0,
+	-0.107925319f,	 0.9245493968f,		0.3654593525f,	  0,
+	0.377977089f,	 0.3043148782f,		0.8743716458f,	  0,
+	-0.2142885215f,	 -0.8259286236f,	0.5214617324f,	  0,
+	0.5802544474f,	 0.4148098596f,		-0.7008834116f,	  0,
+	-0.1982660881f,	 0.8567161266f,		-0.4761596756f,	  0,
+	-0.03381553704f, 0.3773180787f,		-0.9254661404f,	  0,
+	-0.6867922841f,	 -0.6656597827f,	0.2919133642f,	  0,
+	0.7731742607f,	 -0.2875793547f,	-0.5652430251f,	  0,
+	-0.09655941928f, 0.9193708367f,		-0.3813575004f,	  0,
+	0.2715702457f,	 -0.9577909544f,	-0.09426605581f,  0,
+	0.2451015704f,	 -0.6917998565f,	-0.6792188003f,	  0,
+	0.977700782f,	 -0.1753855374f,	0.1155036542f,	  0,
+	-0.5224739938f,	 0.8521606816f,		0.02903615945f,	  0,
+	-0.7734880599f,	 -0.5261292347f,	0.3534179531f,	  0,
+	-0.7134492443f,	 -0.269547243f,		0.6467878011f,	  0,
+	0.1644037271f,	 0.5105846203f,		-0.8439637196f,	  0,
+	0.6494635788f,	 0.05585611296f,	0.7583384168f,	  0,
+	-0.4711970882f,	 0.5017280509f,		-0.7254255765f,	  0,
+	-0.6335764307f,	 -0.2381686273f,	-0.7361091029f,	  0,
+	-0.9021533097f,	 -0.270947803f,		-0.3357181763f,	  0,
+	-0.3793711033f,	 0.872258117f,		0.3086152025f,	  0,
+	-0.6855598966f,	 -0.3250143309f,	0.6514394162f,	  0,
+	0.2900942212f,	 -0.7799057743f,	-0.5546100667f,	  0,
+	-0.2098319339f,	 0.85037073f,		0.4825351604f,	  0,
+	-0.4592603758f,	 0.6598504336f,		-0.5947077538f,	  0,
+	0.8715945488f,	 0.09616365406f,	-0.4807031248f,	  0,
+	-0.6776666319f,	 0.7118504878f,		-0.1844907016f,	  0,
+	0.7044377633f,	 0.312427597f,		0.637304036f,	  0,
+	-0.7052318886f,	 -0.2401093292f,	-0.6670798253f,	  0,
+	0.081921007f,	 -0.7207336136f,	-0.6883545647f,	  0,
+	-0.6993680906f,	 -0.5875763221f,	-0.4069869034f,	  0,
+	-0.1281454481f,	 0.6419895885f,		0.7559286424f,	  0,
+	-0.6337388239f,	 -0.6785471501f,	-0.3714146849f,	  0,
+	0.5565051903f,	 -0.2168887573f,	-0.8020356851f,	  0,
+	-0.5791554484f,	 0.7244372011f,		-0.3738578718f,	  0,
+	0.1175779076f,	 -0.7096451073f,	0.6946792478f,	  0,
+	-0.6134619607f,	 0.1323631078f,		0.7785527795f,	  0,
+	0.6984635305f,	 -0.02980516237f,	-0.715024719f,	  0,
+	0.8318082963f,	 -0.3930171956f,	0.3919597455f,	  0,
+	0.1469576422f,	 0.05541651717f,	-0.9875892167f,	  0,
+	0.708868575f,	 -0.2690503865f,	0.6520101478f,	  0,
+	0.2726053183f,	 0.67369766f,		-0.68688995f,	  0,
+	-0.6591295371f,	 0.3035458599f,		-0.6880466294f,	  0,
+	0.4815131379f,	 -0.7528270071f,	0.4487723203f,	  0,
+	0.9430009463f,	 0.1675647412f,		-0.2875261255f,	  0,
+	0.434802957f,	 0.7695304522f,		-0.4677277752f,	  0,
+	0.3931996188f,	 0.594473625f,		0.7014236729f,	  0,
+	0.7254336655f,	 -0.603925654f,		0.3301814672f,	  0,
+	0.7590235227f,	 -0.6506083235f,	0.02433313207f,	  0,
+	-0.8552768592f,	 -0.3430042733f,	0.3883935666f,	  0,
+	-0.6139746835f,	 0.6981725247f,		0.3682257648f,	  0,
+	-0.7465905486f,	 -0.5752009504f,	0.3342849376f,	  0,
+	0.5730065677f,	 0.810555537f,		-0.1210916791f,	  0,
+	-0.9225877367f,	 -0.3475211012f,	-0.167514036f,	  0,
+	-0.7105816789f,	 -0.4719692027f,	-0.5218416899f,	  0,
+	-0.08564609717f, 0.3583001386f,		0.929669703f,	  0,
+	-0.8279697606f,	 -0.2043157126f,	0.5222271202f,	  0,
+	0.427944023f,	 0.278165994f,		0.8599346446f,	  0,
+	0.5399079671f,	 -0.7857120652f,	-0.3019204161f,	  0,
+	0.5678404253f,	 -0.5495413974f,	-0.6128307303f,	  0,
+	-0.9896071041f,	 0.1365639107f,		-0.04503418428f,  0,
+	-0.6154342638f,	 -0.6440875597f,	0.4543037336f,	  0,
+	0.1074204368f,	 -0.7946340692f,	0.5975094525f,	  0,
+	-0.3595449969f,	 -0.8885529948f,	0.28495784f,	  0,
+	-0.2180405296f,	 0.1529888965f,		0.9638738118f,	  0,
+	-0.7277432317f,	 -0.6164050508f,	-0.3007234646f,	  0,
+	0.7249729114f,	 -0.00669719484f,	0.6887448187f,	  0,
+	-0.5553659455f,	 -0.5336586252f,	0.6377908264f,	  0,
+	0.5137558015f,	 0.7976208196f,		-0.3160000073f,	  0,
+	-0.3794024848f,	 0.9245608561f,		-0.03522751494f,  0,
+	0.8229248658f,	 0.2745365933f,		-0.4974176556f,	  0,
+	-0.5404114394f,	 0.6091141441f,		0.5804613989f,	  0,
+	0.8036581901f,	 -0.2703029469f,	0.5301601931f,	  0,
+	0.6044318879f,	 0.6832968393f,		0.4095943388f,	  0,
+	0.06389988817f,	 0.9658208605f,		-0.2512108074f,	  0,
+	0.1087113286f,	 0.7402471173f,		-0.6634877936f,	  0,
+	-0.713427712f,	 -0.6926784018f,	0.1059128479f,	  0,
+	0.6458897819f,	 -0.5724548511f,	-0.5050958653f,	  0,
+	-0.6553931414f,	 0.7381471625f,		0.159995615f,	  0,
+	0.3910961323f,	 0.9188871375f,		-0.05186755998f,  0,
+	-0.4879022471f,	 -0.5904376907f,	0.6429111375f,	  0,
+	0.6014790094f,	 0.7707441366f,		-0.2101820095f,	  0,
+	-0.5677173047f,	 0.7511360995f,		0.3368851762f,	  0,
+	0.7858573506f,	 0.226674665f,		0.5753666838f,	  0,
+	-0.4520345543f,	 -0.604222686f,		-0.6561857263f,	  0,
+	0.002272116345f, 0.4132844051f,		-0.9105991643f,	  0,
+	-0.5815751419f,	 -0.5162925989f,	0.6286591339f,	  0,
+	-0.03703704785f, 0.8273785755f,		0.5604221175f,	  0,
+	-0.5119692504f,	 0.7953543429f,		-0.3244980058f,	  0,
+	-0.2682417366f,	 -0.9572290247f,	-0.1084387619f,	  0,
+	-0.2322482736f,	 -0.9679131102f,	-0.09594243324f,  0,
+	0.3554328906f,	 -0.8881505545f,	0.2913006227f,	  0,
+	0.7346520519f,	 -0.4371373164f,	0.5188422971f,	  0,
+	0.9985120116f,	 0.04659011161f,	-0.02833944577f,  0,
+	-0.3727687496f,	 -0.9082481361f,	0.1900757285f,	  0,
+	0.91737377f,	 -0.3483642108f,	0.1925298489f,	  0,
+	0.2714911074f,	 0.4147529736f,		-0.8684886582f,	  0,
+	0.5131763485f,	 -0.7116334161f,	0.4798207128f,	  0,
+	-0.8737353606f,	 0.18886992f,		-0.4482350644f,	  0,
+	0.8460043821f,	 -0.3725217914f,	0.3814499973f,	  0,
+	0.8978727456f,	 -0.1780209141f,	-0.4026575304f,	  0,
+	0.2178065647f,	 -0.9698322841f,	-0.1094789531f,	  0,
+	-0.1518031304f,	 -0.7788918132f,	-0.6085091231f,	  0,
+	-0.2600384876f,	 -0.4755398075f,	-0.8403819825f,	  0,
+	0.572313509f,	 -0.7474340931f,	-0.3373418503f,	  0,
+	-0.7174141009f,	 0.1699017182f,		-0.6756111411f,	  0,
+	-0.684180784f,	 0.02145707593f,	-0.7289967412f,	  0,
+	-0.2007447902f,	 0.06555605789f,	-0.9774476623f,	  0,
+	-0.1148803697f,	 -0.8044887315f,	0.5827524187f,	  0,
+	-0.7870349638f,	 0.03447489231f,	0.6159443543f,	  0,
+	-0.2015596421f,	 0.6859872284f,		0.6991389226f,	  0,
+	-0.08581082512f, -0.10920836f,		-0.9903080513f,	  0,
+	0.5532693395f,	 0.7325250401f,		-0.396610771f,	  0,
+	-0.1842489331f,	 -0.9777375055f,	-0.1004076743f,	  0,
+	0.0775473789f,	 -0.9111505856f,	0.4047110257f,	  0,
+	0.1399838409f,	 0.7601631212f,		-0.6344734459f,	  0,
+	0.4484419361f,	 -0.845289248f,		0.2904925424f,	  0
+};
+
+// Utilities
+
+static inline float _fnlFastMin(float x, float y)
+{
+	return x < y ? x : y;
+}
+
+static inline float _fnlFastMax(float x, float y)
+{
+	return x > y ? x : y;
+}
+
+static inline float _fnlFastAbs(float f)
+{
+	return f < 0 ? -f : f;
+}
+
+static inline float _fnlCasti32Tof32(int i)
+{
+	union {
+		float f;
+		int32_t i;
+	} u;
+	u.i = i;
+	return u.f;
+}
+
+static inline int _fnlCastf32Toi32(float f)
+{
+	union {
+		float f;
+		int32_t i;
+	} u;
+	u.f = f;
+	return u.i;
+}
+
+static inline float _fnlInvSqrt(float a)
+{
+	float xhalf = 0.5f * a;
+	a = _fnlCasti32Tof32(0x5f3759df - (_fnlCastf32Toi32(a) >> 1));
+	a = a * (1.5f - xhalf * a * a);
+	return a;
+}
+
+// NOTE: If your language does not support this method (seen above), then simply use the native sqrt function.
+static inline float _fnlFastSqrt(float a)
+{
+	return a * _fnlInvSqrt(a);
+}
+
+static inline int _fnlFastFloor(FNLfloat f)
+{
+	return (f >= 0 ? (int)f : (int)f - 1);
+}
+
+static inline int _fnlFastRound(FNLfloat f)
+{
+	return (f >= 0) ? (int)(f + 0.5f) : (int)(f - 0.5f);
+}
+
+static inline float _fnlLerp(float a, float b, float t)
+{
+	return a + t * (b - a);
+}
+
+static inline float _fnlInterpHermite(float t)
+{
+	return t * t * (3 - 2 * t);
+}
+
+static inline float _fnlInterpQuintic(float t)
+{
+	return t * t * t * (t * (t * 6 - 15) + 10);
+}
+
+static inline float _fnlCubicLerp(float a, float b, float c, float d, float t)
+{
+	float p = (d - c) - (a - b);
+	return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b;
+}
+
+static inline float _fnlPingPong(float t)
+{
+	t -= (int)(t * 0.5f) * 2;
+	return t < 1 ? t : 2 - t;
+}
+
+static float _fnlCalculateFractalBounding(const fnl_state *state)
+{
+	float gain = _fnlFastAbs(state->gain);
+	float amp = gain;
+	float ampFractal = 1.0f;
+	for (int i = 1; i < state->octaves; i++) {
+		ampFractal += amp;
+		amp *= gain;
+	}
+	return 1.0f / ampFractal;
+}
+
+// Hashing
+
+static const int PRIME_X = 501125321;
+static const int PRIME_Y = 1136930381;
+static const int PRIME_Z = 1720413743;
+
+static inline int _fnlHash2D(int seed, int xPrimed, int yPrimed)
+{
+	int hash = seed ^ xPrimed ^ yPrimed;
+
+	hash *= 0x27d4eb2d;
+	return hash;
+}
+
+static inline int _fnlHash3D(int seed, int xPrimed, int yPrimed, int zPrimed)
+{
+	int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed;
+
+	hash *= 0x27d4eb2d;
+	return hash;
+}
+
+static inline float _fnlValCoord2D(int seed, int xPrimed, int yPrimed)
+{
+	int hash = _fnlHash2D(seed, xPrimed, yPrimed);
+	hash *= hash;
+	hash ^= hash << 19;
+	return hash * (1 / 2147483648.0f);
+}
+
+static inline float _fnlValCoord3D(int seed, int xPrimed, int yPrimed, int zPrimed)
+{
+	int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed);
+	hash *= hash;
+	hash ^= hash << 19;
+	return hash * (1 / 2147483648.0f);
+}
+
+static inline float _fnlGradCoord2D(int seed, int xPrimed, int yPrimed, float xd, float yd)
+{
+	int hash = _fnlHash2D(seed, xPrimed, yPrimed);
+	hash ^= hash >> 15;
+	hash &= 127 << 1;
+	return xd * GRADIENTS_2D[hash] + yd * GRADIENTS_2D[hash | 1];
+}
+
+static inline float _fnlGradCoord3D(int seed, int xPrimed, int yPrimed, int zPrimed,
+									float xd, float yd, float zd)
+{
+	int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed);
+	hash ^= hash >> 15;
+	hash &= 63 << 2;
+	return xd * GRADIENTS_3D[hash] + yd * GRADIENTS_3D[hash | 1] +
+		   zd * GRADIENTS_3D[hash | 2];
+}
+
+static inline void _fnlGradCoordOut2D(int seed, int xPrimed, int yPrimed, float *xo,
+									  float *yo)
+{
+	int hash = _fnlHash2D(seed, xPrimed, yPrimed) & (255 << 1);
+
+	*xo = RAND_VECS_2D[hash];
+	*yo = RAND_VECS_2D[hash | 1];
+}
+
+static inline void _fnlGradCoordOut3D(int seed, int xPrimed, int yPrimed, int zPrimed,
+									  float *xo, float *yo, float *zo)
+{
+	int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed) & (255 << 2);
+
+	*xo = RAND_VECS_3D[hash];
+	*yo = RAND_VECS_3D[hash | 1];
+	*zo = RAND_VECS_3D[hash | 2];
+}
+
+static inline void _fnlGradCoordDual2D(int seed, int xPrimed, int yPrimed, float xd,
+									   float yd, float *xo, float *yo)
+{
+	int hash = _fnlHash2D(seed, xPrimed, yPrimed);
+	int index1 = hash & (127 << 1);
+	int index2 = (hash >> 7) & (255 << 1);
+
+	float xg = GRADIENTS_2D[index1];
+	float yg = GRADIENTS_2D[index1 | 1];
+	float value = xd * xg + yd * yg;
+
+	float xgo = RAND_VECS_2D[index2];
+	float ygo = RAND_VECS_2D[index2 | 1];
+
+	*xo = value * xgo;
+	*yo = value * ygo;
+}
+
+static inline void _fnlGradCoordDual3D(int seed, int xPrimed, int yPrimed, int zPrimed,
+									   float xd, float yd, float zd, float *xo, float *yo,
+									   float *zo)
+{
+	int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed);
+	int index1 = hash & (63 << 2);
+	int index2 = (hash >> 6) & (255 << 2);
+
+	float xg = GRADIENTS_3D[index1];
+	float yg = GRADIENTS_3D[index1 | 1];
+	float zg = GRADIENTS_3D[index1 | 2];
+	float value = xd * xg + yd * yg + zd * zg;
+
+	float xgo = RAND_VECS_3D[index2];
+	float ygo = RAND_VECS_3D[index2 | 1];
+	float zgo = RAND_VECS_3D[index2 | 2];
+
+	*xo = value * xgo;
+	*yo = value * ygo;
+	*zo = value * zgo;
+}
+
+// Generic Noise Gen
+
+static float _fnlSingleSimplex2D(int seed, FNLfloat x, FNLfloat y);
+static float _fnlSingleOpenSimplex23D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
+static float _fnlSingleOpenSimplex2S2D(int seed, FNLfloat x, FNLfloat y);
+static float _fnlSingleOpenSimplex2S3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
+static float _fnlSingleCellular2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y);
+static float _fnlSingleCellular3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y,
+								  FNLfloat z);
+static float _fnlSinglePerlin2D(int seed, FNLfloat x, FNLfloat y);
+static float _fnlSinglePerlin3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
+static float _fnlSingleValueCubic2D(int seed, FNLfloat x, FNLfloat y);
+static float _fnlSingleValueCubic3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
+static float _fnlSingleValue2D(int seed, FNLfloat x, FNLfloat y);
+static float _fnlSingleValue3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z);
+
+static float _fnlGenNoiseSingle2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y)
+{
+	switch (state->noise_type) {
+	case FNL_NOISE_OPENSIMPLEX2:
+		return _fnlSingleSimplex2D(seed, x, y);
+	case FNL_NOISE_OPENSIMPLEX2S:
+		return _fnlSingleOpenSimplex2S2D(seed, x, y);
+	case FNL_NOISE_CELLULAR:
+		return _fnlSingleCellular2D(state, seed, x, y);
+	case FNL_NOISE_PERLIN:
+		return _fnlSinglePerlin2D(seed, x, y);
+	case FNL_NOISE_VALUE_CUBIC:
+		return _fnlSingleValueCubic2D(seed, x, y);
+	case FNL_NOISE_VALUE:
+		return _fnlSingleValue2D(seed, x, y);
+	default:
+		return 0;
+	}
+}
+
+static float _fnlGenNoiseSingle3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y,
+								  FNLfloat z)
+{
+	switch (state->noise_type) {
+	case FNL_NOISE_OPENSIMPLEX2:
+		return _fnlSingleOpenSimplex23D(seed, x, y, z);
+	case FNL_NOISE_OPENSIMPLEX2S:
+		return _fnlSingleOpenSimplex2S3D(seed, x, y, z);
+	case FNL_NOISE_CELLULAR:
+		return _fnlSingleCellular3D(state, seed, x, y, z);
+	case FNL_NOISE_PERLIN:
+		return _fnlSinglePerlin3D(seed, x, y, z);
+	case FNL_NOISE_VALUE_CUBIC:
+		return _fnlSingleValueCubic3D(seed, x, y, z);
+	case FNL_NOISE_VALUE:
+		return _fnlSingleValue3D(seed, x, y, z);
+	default:
+		return 0;
+	}
+}
+
+// Noise Coordinate Transforms (frequency, and possible skew or rotation)
+
+static void _fnlTransformNoiseCoordinate2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
+{
+	*x *= state->frequency;
+	*y *= state->frequency;
+
+	switch (state->noise_type) {
+	case FNL_NOISE_OPENSIMPLEX2:
+	case FNL_NOISE_OPENSIMPLEX2S: {
+		const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059;
+		const FNLfloat F2 = 0.5f * (SQRT3 - 1);
+		FNLfloat t = (*x + *y) * F2;
+		*x += t;
+		*y += t;
+	} break;
+	default:
+		break;
+	}
+}
+
+static void _fnlTransformNoiseCoordinate3D(const fnl_state *state, FNLfloat *x, FNLfloat *y,
+										   FNLfloat *z)
+{
+	*x *= state->frequency;
+	*y *= state->frequency;
+	*z *= state->frequency;
+
+	switch (state->rotation_type_3d) {
+	case FNL_ROTATION_IMPROVE_XY_PLANES: {
+		FNLfloat xy = *x + *y;
+		FNLfloat s2 = xy * -(FNLfloat)0.211324865405187;
+		*z *= (FNLfloat)0.577350269189626;
+		*x += s2 - *z;
+		*y = *y + s2 - *z;
+		*z += xy * (FNLfloat)0.577350269189626;
+	} break;
+	case FNL_ROTATION_IMPROVE_XZ_PLANES: {
+		FNLfloat xz = *x + *z;
+		FNLfloat s2 = xz * -(FNLfloat)0.211324865405187;
+		*y *= (FNLfloat)0.577350269189626;
+		*x += s2 - *y;
+		*z += s2 - *y;
+		*y += xz * (FNLfloat)0.577350269189626;
+	} break;
+	default:
+		switch (state->noise_type) {
+		case FNL_NOISE_OPENSIMPLEX2:
+		case FNL_NOISE_OPENSIMPLEX2S: {
+			const FNLfloat R3 = (FNLfloat)(2.0 / 3.0);
+			FNLfloat r = (*x + *y + *z) * R3; // Rotation, not skew
+			*x = r - *x;
+			*y = r - *y;
+			*z = r - *z;
+		} break;
+		default:
+			break;
+		}
+	}
+}
+
+// Domain Warp Coordinate Transforms
+
+static void _fnlTransformDomainWarpCoordinate2D(const fnl_state *state, FNLfloat *x,
+												FNLfloat *y)
+{
+	switch (state->domain_warp_type) {
+	case FNL_DOMAIN_WARP_OPENSIMPLEX2:
+	case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED: {
+		const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059;
+		const FNLfloat F2 = 0.5f * (SQRT3 - 1);
+		FNLfloat t = (*x + *y) * F2;
+		*x += t;
+		*y += t;
+	} break;
+	default:
+		break;
+	}
+}
+
+static void _fnlTransformDomainWarpCoordinate3D(const fnl_state *state, FNLfloat *x,
+												FNLfloat *y, FNLfloat *z)
+{
+	switch (state->rotation_type_3d) {
+	case FNL_ROTATION_IMPROVE_XY_PLANES: {
+		FNLfloat xy = *x + *y;
+		FNLfloat s2 = xy * -(FNLfloat)0.211324865405187;
+		*z *= (FNLfloat)0.577350269189626;
+		*x += s2 - *z;
+		*y = *y + s2 - *z;
+		*z += xy * (FNLfloat)0.577350269189626;
+	} break;
+	case FNL_ROTATION_IMPROVE_XZ_PLANES: {
+		FNLfloat xz = *x + *z;
+		FNLfloat s2 = xz * -(FNLfloat)0.211324865405187;
+		*y *= (FNLfloat)0.577350269189626;
+		*x += s2 - *y;
+		*z += s2 - *y;
+		*y += xz * (FNLfloat)0.577350269189626;
+	} break;
+	default:
+		switch (state->domain_warp_type) {
+		case FNL_DOMAIN_WARP_OPENSIMPLEX2:
+		case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED: {
+			const FNLfloat R3 = (FNLfloat)(2.0 / 3.0);
+			FNLfloat r = (*x + *y + *z) * R3; // Rotation, not skew
+			*x = r - *x;
+			*y = r - *y;
+			*z = r - *z;
+		} break;
+		default:
+			break;
+		}
+	}
+}
+
+// Fractal FBm
+static float _fnlGenFractalFBM2D(const fnl_state *state, FNLfloat x, FNLfloat y)
+{
+	int seed = state->seed;
+	float sum = 0;
+	float amp = _fnlCalculateFractalBounding(state);
+
+	for (int i = 0; i < state->octaves; i++) {
+		float noise = _fnlGenNoiseSingle2D(state, seed++, x, y);
+		sum += noise * amp;
+		amp *= _fnlLerp(1.0f, _fnlFastMin(noise + 1, 2) * 0.5f, state->weighted_strength);
+
+		x *= state->lacunarity;
+		y *= state->lacunarity;
+		amp *= state->gain;
+	}
+
+	return sum;
+}
+
+static float _fnlGenFractalFBM3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
+{
+	int seed = state->seed;
+	float sum = 0;
+	float amp = _fnlCalculateFractalBounding(state);
+
+	for (int i = 0; i < state->octaves; i++) {
+		float noise = _fnlGenNoiseSingle3D(state, seed++, x, y, z);
+		sum += noise * amp;
+		amp *= _fnlLerp(1.0f, (noise + 1) * 0.5f, state->weighted_strength);
+
+		x *= state->lacunarity;
+		y *= state->lacunarity;
+		z *= state->lacunarity;
+		amp *= state->gain;
+	}
+
+	return sum;
+}
+
+// Fractal Ridged
+
+static float _fnlGenFractalRidged2D(const fnl_state *state, FNLfloat x, FNLfloat y)
+{
+	int seed = state->seed;
+	float sum = 0;
+	float amp = _fnlCalculateFractalBounding(state);
+
+	for (int i = 0; i < state->octaves; i++) {
+		float noise = _fnlFastAbs(_fnlGenNoiseSingle2D(state, seed++, x, y));
+		sum += (noise * -2 + 1) * amp;
+		amp *= _fnlLerp(1.0f, 1 - noise, state->weighted_strength);
+
+		x *= state->lacunarity;
+		y *= state->lacunarity;
+		amp *= state->gain;
+	}
+
+	return sum;
+}
+
+static float _fnlGenFractalRidged3D(const fnl_state *state, FNLfloat x, FNLfloat y,
+									FNLfloat z)
+{
+	int seed = state->seed;
+	float sum = 0;
+	float amp = _fnlCalculateFractalBounding(state);
+
+	for (int i = 0; i < state->octaves; i++) {
+		float noise = _fnlFastAbs(_fnlGenNoiseSingle3D(state, seed++, x, y, z));
+		sum += (noise * -2 + 1) * amp;
+		amp *= _fnlLerp(1.0f, 1 - noise, state->weighted_strength);
+
+		x *= state->lacunarity;
+		y *= state->lacunarity;
+		z *= state->lacunarity;
+		amp *= state->gain;
+	}
+
+	return sum;
+}
+
+// Fractal PingPong
+
+static float _fnlGenFractalPingPong2D(const fnl_state *state, FNLfloat x, FNLfloat y)
+{
+	int seed = state->seed;
+	float sum = 0;
+	float amp = _fnlCalculateFractalBounding(state);
+
+	for (int i = 0; i < state->octaves; i++) {
+		float noise = _fnlPingPong((_fnlGenNoiseSingle2D(state, seed++, x, y) + 1) *
+								   state->ping_pong_strength);
+		sum += (noise - 0.5f) * 2 * amp;
+		amp *= _fnlLerp(1.0f, noise, state->weighted_strength);
+
+		x *= state->lacunarity;
+		y *= state->lacunarity;
+		amp *= state->gain;
+	}
+
+	return sum;
+}
+
+static float _fnlGenFractalPingPong3D(const fnl_state *state, FNLfloat x, FNLfloat y,
+									  FNLfloat z)
+{
+	int seed = state->seed;
+	float sum = 0;
+	float amp = _fnlCalculateFractalBounding(state);
+
+	for (int i = 0; i < state->octaves; i++) {
+		float noise = _fnlPingPong((_fnlGenNoiseSingle3D(state, seed++, x, y, z) + 1) *
+								   state->ping_pong_strength);
+		sum += (noise - 0.5f) * 2 * amp;
+		amp *= _fnlLerp(1.0f, noise, state->weighted_strength);
+
+		x *= state->lacunarity;
+		y *= state->lacunarity;
+		z *= state->lacunarity;
+		amp *= state->gain;
+	}
+
+	return sum;
+}
+
+// Simplex/OpenSimplex2 Noise
+
+static float _fnlSingleSimplex2D(int seed, FNLfloat x, FNLfloat y)
+{
+	// 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.
+
+	const float SQRT3 = 1.7320508075688772935274463415059f;
+	const float G2 = (3 - SQRT3) / 6;
+
+	/*
+     * --- Skew moved to TransformNoiseCoordinate method ---
+     * const FNLfloat F2 = 0.5f * (SQRT3 - 1);
+     * FNLfloat s = (x + y) * F2;
+     * x += s; y += s;
+     */
+
+	int i = _fnlFastFloor(x);
+	int j = _fnlFastFloor(y);
+	float xi = (float)(x - i);
+	float yi = (float)(y - j);
+
+	float t = (xi + yi) * G2;
+	float x0 = (float)(xi - t);
+	float y0 = (float)(yi - t);
+
+	i *= PRIME_X;
+	j *= PRIME_Y;
+
+	float n0, n1, n2;
+
+	float a = 0.5f - x0 * x0 - y0 * y0;
+	if (a <= 0)
+		n0 = 0;
+	else {
+		n0 = (a * a) * (a * a) * _fnlGradCoord2D(seed, i, j, x0, y0);
+	}
+
+	float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t +
+			  ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
+	if (c <= 0)
+		n2 = 0;
+	else {
+		float x2 = x0 + (2 * (float)G2 - 1);
+		float y2 = y0 + (2 * (float)G2 - 1);
+		n2 = (c * c) * (c * c) * _fnlGradCoord2D(seed, i + PRIME_X, j + PRIME_Y, x2, y2);
+	}
+
+	if (y0 > x0) {
+		float x1 = x0 + (float)G2;
+		float y1 = y0 + ((float)G2 - 1);
+		float b = 0.5f - x1 * x1 - y1 * y1;
+		if (b <= 0)
+			n1 = 0;
+		else {
+			n1 = (b * b) * (b * b) * _fnlGradCoord2D(seed, i, j + PRIME_Y, x1, y1);
+		}
+	} else {
+		float x1 = x0 + ((float)G2 - 1);
+		float y1 = y0 + (float)G2;
+		float b = 0.5f - x1 * x1 - y1 * y1;
+		if (b <= 0)
+			n1 = 0;
+		else {
+			n1 = (b * b) * (b * b) * _fnlGradCoord2D(seed, i + PRIME_X, j, x1, y1);
+		}
+	}
+
+	return (n0 + n1 + n2) * 99.83685446303647f;
+}
+
+static float _fnlSingleOpenSimplex23D(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+{
+	// 3D OpenSimplex2 case uses two offset rotated cube grids.
+
+	/*
+     * --- Rotation moved to TransformNoiseCoordinate method ---
+     * const FNLfloat R3 = (FNLfloat)(2.0 / 3.0);
+     * FNLfloat r = (x + y + z) * R3; // Rotation, not skew
+     * x = r - x; y = r - y; z = r - z;
+     */
+
+	int i = _fnlFastRound(x);
+	int j = _fnlFastRound(y);
+	int k = _fnlFastRound(z);
+	float x0 = (float)(x - i);
+	float y0 = (float)(y - j);
+	float z0 = (float)(z - k);
+
+	int xNSign = (int)(-1.0f - x0) | 1;
+	int yNSign = (int)(-1.0f - y0) | 1;
+	int zNSign = (int)(-1.0f - z0) | 1;
+
+	float ax0 = xNSign * -x0;
+	float ay0 = yNSign * -y0;
+	float az0 = zNSign * -z0;
+
+	i *= PRIME_X;
+	j *= PRIME_Y;
+	k *= PRIME_Z;
+
+	float value = 0;
+	float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
+
+	for (int l = 0;; l++) {
+		if (a > 0) {
+			value += (a * a) * (a * a) * _fnlGradCoord3D(seed, i, j, k, x0, y0, z0);
+		}
+
+		float b = a + 1;
+		int i1 = i;
+		int j1 = j;
+		int k1 = k;
+		float x1 = x0;
+		float y1 = y0;
+		float z1 = z0;
+		if (ax0 >= ay0 && ax0 >= az0) {
+			x1 += xNSign;
+			b -= xNSign * 2 * x1;
+			i1 -= xNSign * PRIME_X;
+		} else if (ay0 > ax0 && ay0 >= az0) {
+			y1 += yNSign;
+			b -= yNSign * 2 * y1;
+			j1 -= yNSign * PRIME_Y;
+		} else {
+			z1 += zNSign;
+			b -= zNSign * 2 * z1;
+			k1 -= zNSign * PRIME_Z;
+		}
+
+		if (b > 0) {
+			value += (b * b) * (b * b) * _fnlGradCoord3D(seed, i1, j1, k1, x1, y1, z1);
+		}
+
+		if (l == 1)
+			break;
+
+		ax0 = 0.5f - ax0;
+		ay0 = 0.5f - ay0;
+		az0 = 0.5f - az0;
+
+		x0 = xNSign * ax0;
+		y0 = yNSign * ay0;
+		z0 = zNSign * az0;
+
+		a += (0.75f - ax0) - (ay0 + az0);
+
+		i += (xNSign >> 1) & PRIME_X;
+		j += (yNSign >> 1) & PRIME_Y;
+		k += (zNSign >> 1) & PRIME_Z;
+
+		xNSign = -xNSign;
+		yNSign = -yNSign;
+		zNSign = -zNSign;
+
+		seed = ~seed;
+	}
+
+	return value * 32.69428253173828125f;
+}
+
+// OpenSimplex2S Noise
+
+static float _fnlSingleOpenSimplex2S2D(int seed, FNLfloat x, FNLfloat y)
+{
+	// 2D OpenSimplex2S case is a modified 2D simplex noise.
+
+	const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059;
+	const FNLfloat G2 = (3 - SQRT3) / 6;
+
+	/*
+     * --- Skew moved to TransformNoiseCoordinate method ---
+     * const FNLfloat F2 = 0.5f * (SQRT3 - 1);
+     * FNLfloat s = (x + y) * F2;
+     * x += s; y += s;
+    */
+
+	int i = _fnlFastFloor(x);
+	int j = _fnlFastFloor(y);
+	float xi = (float)(x - i);
+	float yi = (float)(y - j);
+
+	i *= PRIME_X;
+	j *= PRIME_Y;
+	int i1 = i + PRIME_X;
+	int j1 = j + PRIME_Y;
+
+	float t = (xi + yi) * (float)G2;
+	float x0 = xi - t;
+	float y0 = yi - t;
+
+	float a0 = (2.0f / 3.0f) - x0 * x0 - y0 * y0;
+	float value = (a0 * a0) * (a0 * a0) * _fnlGradCoord2D(seed, i, j, x0, y0);
+
+	float a1 = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t +
+			   ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0);
+	float x1 = x0 - (float)(1 - 2 * G2);
+	float y1 = y0 - (float)(1 - 2 * G2);
+	value += (a1 * a1) * (a1 * a1) * _fnlGradCoord2D(seed, i1, j1, x1, y1);
+
+	// Nested conditionals were faster than compact bit logic/arithmetic.
+	float xmyi = xi - yi;
+	if (t > G2) {
+		if (xi + xmyi > 1) {
+			float x2 = x0 + (float)(3 * G2 - 2);
+			float y2 = y0 + (float)(3 * G2 - 1);
+			float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+			if (a2 > 0) {
+				value += (a2 * a2) * (a2 * a2) *
+						 _fnlGradCoord2D(seed, i + (PRIME_X << 1), j + PRIME_Y, x2, y2);
+			}
+		} else {
+			float x2 = x0 + (float)G2;
+			float y2 = y0 + (float)(G2 - 1);
+			float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+			if (a2 > 0) {
+				value +=
+					(a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i, j + PRIME_Y, x2, y2);
+			}
+		}
+
+		if (yi - xmyi > 1) {
+			float x3 = x0 + (float)(3 * G2 - 1);
+			float y3 = y0 + (float)(3 * G2 - 2);
+			float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3;
+			if (a3 > 0) {
+				value += (a3 * a3) * (a3 * a3) *
+						 _fnlGradCoord2D(seed, i + PRIME_X, j + (PRIME_Y << 1), x3, y3);
+			}
+		} else {
+			float x3 = x0 + (float)(G2 - 1);
+			float y3 = y0 + (float)G2;
+			float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3;
+			if (a3 > 0) {
+				value +=
+					(a3 * a3) * (a3 * a3) * _fnlGradCoord2D(seed, i + PRIME_X, j, x3, y3);
+			}
+		}
+	} else {
+		if (xi + xmyi < 0) {
+			float x2 = x0 + (float)(1 - G2);
+			float y2 = y0 - (float)G2;
+			float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+			if (a2 > 0) {
+				value +=
+					(a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i - PRIME_X, j, x2, y2);
+			}
+		} else {
+			float x2 = x0 + (float)(G2 - 1);
+			float y2 = y0 + (float)G2;
+			float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+			if (a2 > 0) {
+				value +=
+					(a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i + PRIME_X, j, x2, y2);
+			}
+		}
+
+		if (yi < xmyi) {
+			float x2 = x0 - (float)G2;
+			float y2 = y0 - (float)(G2 - 1);
+			float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+			if (a2 > 0) {
+				value +=
+					(a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i, j - PRIME_Y, x2, y2);
+			}
+		} else {
+			float x2 = x0 + (float)G2;
+			float y2 = y0 + (float)(G2 - 1);
+			float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2;
+			if (a2 > 0) {
+				value +=
+					(a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i, j + PRIME_Y, x2, y2);
+			}
+		}
+	}
+
+	return value * 18.24196194486065f;
+}
+
+static float _fnlSingleOpenSimplex2S3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+{
+	// 3D OpenSimplex2S case uses two offset rotated cube grids.
+
+	/*
+     * --- Rotation moved to TransformNoiseCoordinate method ---
+     * const FNLfloat R3 = (FNLfloat)(2.0 / 3.0);
+     * FNLfloat r = (x + y + z) * R3; // Rotation, not skew
+     * x = r - x; y = r - y; z = r - z;
+     */
+
+	int i = _fnlFastFloor(x);
+	int j = _fnlFastFloor(y);
+	int k = _fnlFastFloor(z);
+	float xi = (float)(x - i);
+	float yi = (float)(y - j);
+	float zi = (float)(z - k);
+
+	i *= PRIME_X;
+	j *= PRIME_Y;
+	k *= PRIME_Z;
+	int seed2 = seed + 1293373;
+
+	int xNMask = (int)(-0.5f - xi);
+	int yNMask = (int)(-0.5f - yi);
+	int zNMask = (int)(-0.5f - zi);
+
+	float x0 = xi + xNMask;
+	float y0 = yi + yNMask;
+	float z0 = zi + zNMask;
+	float a0 = 0.75f - x0 * x0 - y0 * y0 - z0 * z0;
+	float value = (a0 * a0) * (a0 * a0) *
+				  _fnlGradCoord3D(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y),
+								  k + (zNMask & PRIME_Z), x0, y0, z0);
+
+	float x1 = xi - 0.5f;
+	float y1 = yi - 0.5f;
+	float z1 = zi - 0.5f;
+	float a1 = 0.75f - x1 * x1 - y1 * y1 - z1 * z1;
+	value += (a1 * a1) * (a1 * a1) *
+			 _fnlGradCoord3D(seed2, i + PRIME_X, j + PRIME_Y, k + PRIME_Z, x1, y1, z1);
+
+	float xAFlipMask0 = ((xNMask | 1) << 1) * x1;
+	float yAFlipMask0 = ((yNMask | 1) << 1) * y1;
+	float zAFlipMask0 = ((zNMask | 1) << 1) * z1;
+	float xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0f;
+	float yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0f;
+	float zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0f;
+
+	bool skip5 = false;
+	float a2 = xAFlipMask0 + a0;
+	if (a2 > 0) {
+		float x2 = x0 - (xNMask | 1);
+		float y2 = y0;
+		float z2 = z0;
+		value += (a2 * a2) * (a2 * a2) *
+				 _fnlGradCoord3D(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y),
+								 k + (zNMask & PRIME_Z), x2, y2, z2);
+	} else {
+		float a3 = yAFlipMask0 + zAFlipMask0 + a0;
+		if (a3 > 0) {
+			float x3 = x0;
+			float y3 = y0 - (yNMask | 1);
+			float z3 = z0 - (zNMask | 1);
+			value += (a3 * a3) * (a3 * a3) *
+					 _fnlGradCoord3D(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y),
+									 k + (~zNMask & PRIME_Z), x3, y3, z3);
+		}
+
+		float a4 = xAFlipMask1 + a1;
+		if (a4 > 0) {
+			float x4 = (xNMask | 1) + x1;
+			float y4 = y1;
+			float z4 = z1;
+			value += (a4 * a4) * (a4 * a4) *
+					 _fnlGradCoord3D(seed2, i + (xNMask & (PRIME_X * 2)), j + PRIME_Y,
+									 k + PRIME_Z, x4, y4, z4);
+			skip5 = true;
+		}
+	}
+
+	bool skip9 = false;
+	float a6 = yAFlipMask0 + a0;
+	if (a6 > 0) {
+		float x6 = x0;
+		float y6 = y0 - (yNMask | 1);
+		float z6 = z0;
+		value += (a6 * a6) * (a6 * a6) *
+				 _fnlGradCoord3D(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y),
+								 k + (zNMask & PRIME_Z), x6, y6, z6);
+	} else {
+		float a7 = xAFlipMask0 + zAFlipMask0 + a0;
+		if (a7 > 0) {
+			float x7 = x0 - (xNMask | 1);
+			float y7 = y0;
+			float z7 = z0 - (zNMask | 1);
+			value += (a7 * a7) * (a7 * a7) *
+					 _fnlGradCoord3D(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y),
+									 k + (~zNMask & PRIME_Z), x7, y7, z7);
+		}
+
+		float a8 = yAFlipMask1 + a1;
+		if (a8 > 0) {
+			float x8 = x1;
+			float y8 = (yNMask | 1) + y1;
+			float z8 = z1;
+			value += (a8 * a8) * (a8 * a8) *
+					 _fnlGradCoord3D(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)),
+									 k + PRIME_Z, x8, y8, z8);
+			skip9 = true;
+		}
+	}
+
+	bool skipD = false;
+	float aA = zAFlipMask0 + a0;
+	if (aA > 0) {
+		float xA = x0;
+		float yA = y0;
+		float zA = z0 - (zNMask | 1);
+		value += (aA * aA) * (aA * aA) *
+				 _fnlGradCoord3D(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y),
+								 k + (~zNMask & PRIME_Z), xA, yA, zA);
+	} else {
+		float aB = xAFlipMask0 + yAFlipMask0 + a0;
+		if (aB > 0) {
+			float xB = x0 - (xNMask | 1);
+			float yB = y0 - (yNMask | 1);
+			float zB = z0;
+			value += (aB * aB) * (aB * aB) *
+					 _fnlGradCoord3D(seed, i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y),
+									 k + (zNMask & PRIME_Z), xB, yB, zB);
+		}
+
+		float aC = zAFlipMask1 + a1;
+		if (aC > 0) {
+			float xC = x1;
+			float yC = y1;
+			float zC = (zNMask | 1) + z1;
+			value += (aC * aC) * (aC * aC) *
+					 _fnlGradCoord3D(seed2, i + PRIME_X, j + PRIME_Y,
+									 k + (zNMask & (PRIME_Z << 1)), xC, yC, zC);
+			skipD = true;
+		}
+	}
+
+	if (!skip5) {
+		float a5 = yAFlipMask1 + zAFlipMask1 + a1;
+		if (a5 > 0) {
+			float x5 = x1;
+			float y5 = (yNMask | 1) + y1;
+			float z5 = (zNMask | 1) + z1;
+			value += (a5 * a5) * (a5 * a5) *
+					 _fnlGradCoord3D(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)),
+									 k + (zNMask & (PRIME_Z << 1)), x5, y5, z5);
+		}
+	}
+
+	if (!skip9) {
+		float a9 = xAFlipMask1 + zAFlipMask1 + a1;
+		if (a9 > 0) {
+			float x9 = (xNMask | 1) + x1;
+			float y9 = y1;
+			float z9 = (zNMask | 1) + z1;
+			value += (a9 * a9) * (a9 * a9) *
+					 _fnlGradCoord3D(seed2, i + (xNMask & (PRIME_X * 2)), j + PRIME_Y,
+									 k + (zNMask & (PRIME_Z << 1)), x9, y9, z9);
+		}
+	}
+
+	if (!skipD) {
+		float aD = xAFlipMask1 + yAFlipMask1 + a1;
+		if (aD > 0) {
+			float xD = (xNMask | 1) + x1;
+			float yD = (yNMask | 1) + y1;
+			float zD = z1;
+			value += (aD * aD) * (aD * aD) *
+					 _fnlGradCoord3D(seed2, i + (xNMask & (PRIME_X << 1)),
+									 j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z, xD, yD,
+									 zD);
+		}
+	}
+
+	return value * 9.046026385208288f;
+}
+
+// Cellular Noise
+
+static float _fnlSingleCellular2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y)
+{
+	int xr = _fnlFastRound(x);
+	int yr = _fnlFastRound(y);
+
+	float distance0 = FLT_MAX;
+	float distance1 = FLT_MAX;
+	int closestHash = 0;
+
+	float cellularJitter = 0.43701595f * state->cellular_jitter_mod;
+
+	int xPrimed = (xr - 1) * PRIME_X;
+	int yPrimedBase = (yr - 1) * PRIME_Y;
+
+	switch (state->cellular_distance_func) {
+	default:
+	case FNL_CELLULAR_DISTANCE_EUCLIDEAN:
+	case FNL_CELLULAR_DISTANCE_EUCLIDEANSQ:
+		for (int xi = xr - 1; xi <= xr + 1; xi++) {
+			int yPrimed = yPrimedBase;
+
+			for (int yi = yr - 1; yi <= yr + 1; yi++) {
+				int hash = _fnlHash2D(seed, xPrimed, yPrimed);
+				int idx = hash & (255 << 1);
+
+				float vecX = (float)(xi - x) + RAND_VECS_2D[idx] * cellularJitter;
+				float vecY = (float)(yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
+
+				float newDistance = vecX * vecX + vecY * vecY;
+
+				distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0);
+				if (newDistance < distance0) {
+					distance0 = newDistance;
+					closestHash = hash;
+				}
+				yPrimed += PRIME_Y;
+			}
+			xPrimed += PRIME_X;
+		}
+		break;
+	case FNL_CELLULAR_DISTANCE_MANHATTAN:
+		for (int xi = xr - 1; xi <= xr + 1; xi++) {
+			int yPrimed = yPrimedBase;
+
+			for (int yi = yr - 1; yi <= yr + 1; yi++) {
+				int hash = _fnlHash2D(seed, xPrimed, yPrimed);
+				int idx = hash & (255 << 1);
+
+				float vecX = (float)(xi - x) + RAND_VECS_2D[idx] * cellularJitter;
+				float vecY = (float)(yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
+
+				float newDistance = _fnlFastAbs(vecX) + _fnlFastAbs(vecY);
+
+				distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0);
+				if (newDistance < distance0) {
+					distance0 = newDistance;
+					closestHash = hash;
+				}
+				yPrimed += PRIME_Y;
+			}
+			xPrimed += PRIME_X;
+		}
+		break;
+	case FNL_CELLULAR_DISTANCE_HYBRID:
+		for (int xi = xr - 1; xi <= xr + 1; xi++) {
+			int yPrimed = yPrimedBase;
+			for (int yi = yr - 1; yi <= yr + 1; yi++) {
+				int hash = _fnlHash2D(seed, xPrimed, yPrimed);
+				int idx = hash & (255 << 1);
+
+				float vecX = (float)(xi - x) + RAND_VECS_2D[idx] * cellularJitter;
+				float vecY = (float)(yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
+
+				float newDistance =
+					(_fnlFastAbs(vecX) + _fnlFastAbs(vecY)) + (vecX * vecX + vecY * vecY);
+
+				distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0);
+				if (newDistance < distance0) {
+					distance0 = newDistance;
+					closestHash = hash;
+				}
+				yPrimed += PRIME_Y;
+			}
+			xPrimed += PRIME_X;
+		}
+		break;
+	}
+
+	if (state->cellular_distance_func == FNL_CELLULAR_DISTANCE_EUCLIDEAN &&
+		state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE) {
+		distance0 = _fnlFastSqrt(distance0);
+		if (state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE2)
+			distance1 = _fnlFastSqrt(distance1);
+	}
+
+	switch (state->cellular_return_type) {
+	case FNL_CELLULAR_RETURN_TYPE_CELLVALUE:
+		return closestHash * (1 / 2147483648.0f);
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE:
+		return distance0 - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2:
+		return distance1 - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2ADD:
+		return (distance1 + distance0) * 0.5f - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2SUB:
+		return distance1 - distance0 - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2MUL:
+		return distance1 * distance0 * 0.5f - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2DIV:
+		return distance0 / distance1 - 1;
+	default:
+		return 0;
+	}
+}
+
+static float _fnlSingleCellular3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y,
+								  FNLfloat z)
+{
+	int xr = _fnlFastRound(x);
+	int yr = _fnlFastRound(y);
+	int zr = _fnlFastRound(z);
+
+	float distance0 = FLT_MAX;
+	float distance1 = FLT_MAX;
+	int closestHash = 0;
+
+	float cellularJitter = 0.39614353f * state->cellular_jitter_mod;
+
+	int xPrimed = (xr - 1) * PRIME_X;
+	int yPrimedBase = (yr - 1) * PRIME_Y;
+	int zPrimedBase = (zr - 1) * PRIME_Z;
+
+	switch (state->cellular_distance_func) {
+	default:
+	case FNL_CELLULAR_DISTANCE_EUCLIDEAN:
+	case FNL_CELLULAR_DISTANCE_EUCLIDEANSQ:
+		for (int xi = xr - 1; xi <= xr + 1; xi++) {
+			int yPrimed = yPrimedBase;
+
+			for (int yi = yr - 1; yi <= yr + 1; yi++) {
+				int zPrimed = zPrimedBase;
+
+				for (int zi = zr - 1; zi <= zr + 1; zi++) {
+					int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed);
+					int idx = hash & (255 << 2);
+
+					float vecX = (float)(xi - x) + RAND_VECS_3D[idx] * cellularJitter;
+					float vecY = (float)(yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
+					float vecZ = (float)(zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
+
+					float newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ;
+
+					distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0);
+					if (newDistance < distance0) {
+						distance0 = newDistance;
+						closestHash = hash;
+					}
+					zPrimed += PRIME_Z;
+				}
+				yPrimed += PRIME_Y;
+			}
+			xPrimed += PRIME_X;
+		}
+		break;
+	case FNL_CELLULAR_DISTANCE_MANHATTAN:
+		for (int xi = xr - 1; xi <= xr + 1; xi++) {
+			int yPrimed = yPrimedBase;
+
+			for (int yi = yr - 1; yi <= yr + 1; yi++) {
+				int zPrimed = zPrimedBase;
+
+				for (int zi = zr - 1; zi <= zr + 1; zi++) {
+					int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed);
+					int idx = hash & (255 << 2);
+
+					float vecX = (float)(xi - x) + RAND_VECS_3D[idx] * cellularJitter;
+					float vecY = (float)(yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
+					float vecZ = (float)(zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
+
+					float newDistance =
+						_fnlFastAbs(vecX) + _fnlFastAbs(vecY) + _fnlFastAbs(vecZ);
+
+					distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0);
+					if (newDistance < distance0) {
+						distance0 = newDistance;
+						closestHash = hash;
+					}
+					zPrimed += PRIME_Z;
+				}
+				yPrimed += PRIME_Y;
+			}
+			xPrimed += PRIME_X;
+		}
+		break;
+	case FNL_CELLULAR_DISTANCE_HYBRID:
+		for (int xi = xr - 1; xi <= xr + 1; xi++) {
+			int yPrimed = yPrimedBase;
+
+			for (int yi = yr - 1; yi <= yr + 1; yi++) {
+				int zPrimed = zPrimedBase;
+
+				for (int zi = zr - 1; zi <= zr + 1; zi++) {
+					int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed);
+					int idx = hash & (255 << 2);
+
+					float vecX = (float)(xi - x) + RAND_VECS_3D[idx] * cellularJitter;
+					float vecY = (float)(yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
+					float vecZ = (float)(zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
+
+					float newDistance =
+						(_fnlFastAbs(vecX) + _fnlFastAbs(vecY) + _fnlFastAbs(vecZ)) +
+						(vecX * vecX + vecY * vecY + vecZ * vecZ);
+
+					distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0);
+					if (newDistance < distance0) {
+						distance0 = newDistance;
+						closestHash = hash;
+					}
+					zPrimed += PRIME_Z;
+				}
+				yPrimed += PRIME_Y;
+			}
+			xPrimed += PRIME_X;
+		}
+		break;
+	}
+
+	if (state->cellular_distance_func == FNL_CELLULAR_DISTANCE_EUCLIDEAN &&
+		state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE) {
+		distance0 = _fnlFastSqrt(distance0);
+		if (state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE2)
+			distance1 = _fnlFastSqrt(distance1);
+	}
+
+	switch (state->cellular_return_type) {
+	case FNL_CELLULAR_RETURN_TYPE_CELLVALUE:
+		return closestHash * (1 / 2147483648.0f);
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE:
+		return distance0 - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2:
+		return distance1 - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2ADD:
+		return (distance1 + distance0) * 0.5f - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2SUB:
+		return distance1 - distance0 - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2MUL:
+		return distance1 * distance0 * 0.5f - 1;
+	case FNL_CELLULAR_RETURN_TYPE_DISTANCE2DIV:
+		return distance0 / distance1 - 1;
+	default:
+		return 0;
+	}
+}
+
+// Perlin Noise
+
+static float _fnlSinglePerlin2D(int seed, FNLfloat x, FNLfloat y)
+{
+	int x0 = _fnlFastFloor(x);
+	int y0 = _fnlFastFloor(y);
+
+	float xd0 = (float)(x - x0);
+	float yd0 = (float)(y - y0);
+	float xd1 = xd0 - 1;
+	float yd1 = yd0 - 1;
+
+	float xs = _fnlInterpQuintic(xd0);
+	float ys = _fnlInterpQuintic(yd0);
+
+	x0 *= PRIME_X;
+	y0 *= PRIME_Y;
+	int x1 = x0 + PRIME_X;
+	int y1 = y0 + PRIME_Y;
+
+	float xf0 = _fnlLerp(_fnlGradCoord2D(seed, x0, y0, xd0, yd0),
+						 _fnlGradCoord2D(seed, x1, y0, xd1, yd0), xs);
+	float xf1 = _fnlLerp(_fnlGradCoord2D(seed, x0, y1, xd0, yd1),
+						 _fnlGradCoord2D(seed, x1, y1, xd1, yd1), xs);
+
+	return _fnlLerp(xf0, xf1, ys) * 1.4247691104677813f;
+}
+
+static float _fnlSinglePerlin3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+{
+	int x0 = _fnlFastFloor(x);
+	int y0 = _fnlFastFloor(y);
+	int z0 = _fnlFastFloor(z);
+
+	float xd0 = (float)(x - x0);
+	float yd0 = (float)(y - y0);
+	float zd0 = (float)(z - z0);
+	float xd1 = xd0 - 1;
+	float yd1 = yd0 - 1;
+	float zd1 = zd0 - 1;
+
+	float xs = _fnlInterpQuintic(xd0);
+	float ys = _fnlInterpQuintic(yd0);
+	float zs = _fnlInterpQuintic(zd0);
+
+	x0 *= PRIME_X;
+	y0 *= PRIME_Y;
+	z0 *= PRIME_Z;
+	int x1 = x0 + PRIME_X;
+	int y1 = y0 + PRIME_Y;
+	int z1 = z0 + PRIME_Z;
+
+	float xf00 = _fnlLerp(_fnlGradCoord3D(seed, x0, y0, z0, xd0, yd0, zd0),
+						  _fnlGradCoord3D(seed, x1, y0, z0, xd1, yd0, zd0), xs);
+	float xf10 = _fnlLerp(_fnlGradCoord3D(seed, x0, y1, z0, xd0, yd1, zd0),
+						  _fnlGradCoord3D(seed, x1, y1, z0, xd1, yd1, zd0), xs);
+	float xf01 = _fnlLerp(_fnlGradCoord3D(seed, x0, y0, z1, xd0, yd0, zd1),
+						  _fnlGradCoord3D(seed, x1, y0, z1, xd1, yd0, zd1), xs);
+	float xf11 = _fnlLerp(_fnlGradCoord3D(seed, x0, y1, z1, xd0, yd1, zd1),
+						  _fnlGradCoord3D(seed, x1, y1, z1, xd1, yd1, zd1), xs);
+
+	float yf0 = _fnlLerp(xf00, xf10, ys);
+	float yf1 = _fnlLerp(xf01, xf11, ys);
+
+	return _fnlLerp(yf0, yf1, zs) * 0.964921414852142333984375f;
+}
+
+// Value Cubic
+
+static float _fnlSingleValueCubic2D(int seed, FNLfloat x, FNLfloat y)
+{
+	int x1 = _fnlFastFloor(x);
+	int y1 = _fnlFastFloor(y);
+
+	float xs = x - (float)x1;
+	float ys = y - (float)y1;
+
+	x1 *= PRIME_X;
+	y1 *= PRIME_Y;
+
+	int x0 = x1 - PRIME_X;
+	int y0 = y1 - PRIME_Y;
+	int x2 = x1 + PRIME_X;
+	int y2 = y1 + PRIME_Y;
+	int x3 = x1 + (int)((long)PRIME_X << 1);
+	int y3 = y1 + (int)((long)PRIME_Y << 1);
+
+	return _fnlCubicLerp(
+			   _fnlCubicLerp(_fnlValCoord2D(seed, x0, y0), _fnlValCoord2D(seed, x1, y0),
+							 _fnlValCoord2D(seed, x2, y0), _fnlValCoord2D(seed, x3, y0),
+							 xs),
+			   _fnlCubicLerp(_fnlValCoord2D(seed, x0, y1), _fnlValCoord2D(seed, x1, y1),
+							 _fnlValCoord2D(seed, x2, y1), _fnlValCoord2D(seed, x3, y1),
+							 xs),
+			   _fnlCubicLerp(_fnlValCoord2D(seed, x0, y2), _fnlValCoord2D(seed, x1, y2),
+							 _fnlValCoord2D(seed, x2, y2), _fnlValCoord2D(seed, x3, y2),
+							 xs),
+			   _fnlCubicLerp(_fnlValCoord2D(seed, x0, y3), _fnlValCoord2D(seed, x1, y3),
+							 _fnlValCoord2D(seed, x2, y3), _fnlValCoord2D(seed, x3, y3),
+							 xs),
+			   ys) *
+		   (1 / (1.5f * 1.5f));
+}
+
+static float _fnlSingleValueCubic3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+{
+	int x1 = _fnlFastFloor(x);
+	int y1 = _fnlFastFloor(y);
+	int z1 = _fnlFastFloor(z);
+
+	float xs = x - (float)x1;
+	float ys = y - (float)y1;
+	float zs = z - (float)z1;
+
+	x1 *= PRIME_X;
+	y1 *= PRIME_Y;
+	z1 *= PRIME_Z;
+
+	int x0 = x1 - PRIME_X;
+	int y0 = y1 - PRIME_Y;
+	int z0 = z1 - PRIME_Z;
+	int x2 = x1 + PRIME_X;
+	int y2 = y1 + PRIME_Y;
+	int z2 = z1 + PRIME_Z;
+	int x3 = x1 + (int)((long)PRIME_X << 1);
+	int y3 = y1 + (int)((long)PRIME_Y << 1);
+	int z3 = z1 + (int)((long)PRIME_Z << 1);
+
+	return _fnlCubicLerp(_fnlCubicLerp(_fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z0),
+													 _fnlValCoord3D(seed, x1, y0, z0),
+													 _fnlValCoord3D(seed, x2, y0, z0),
+													 _fnlValCoord3D(seed, x3, y0, z0), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z0),
+													 _fnlValCoord3D(seed, x1, y1, z0),
+													 _fnlValCoord3D(seed, x2, y1, z0),
+													 _fnlValCoord3D(seed, x3, y1, z0), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z0),
+													 _fnlValCoord3D(seed, x1, y2, z0),
+													 _fnlValCoord3D(seed, x2, y2, z0),
+													 _fnlValCoord3D(seed, x3, y2, z0), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z0),
+													 _fnlValCoord3D(seed, x1, y3, z0),
+													 _fnlValCoord3D(seed, x2, y3, z0),
+													 _fnlValCoord3D(seed, x3, y3, z0), xs),
+									   ys),
+						 _fnlCubicLerp(_fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z1),
+													 _fnlValCoord3D(seed, x1, y0, z1),
+													 _fnlValCoord3D(seed, x2, y0, z1),
+													 _fnlValCoord3D(seed, x3, y0, z1), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z1),
+													 _fnlValCoord3D(seed, x1, y1, z1),
+													 _fnlValCoord3D(seed, x2, y1, z1),
+													 _fnlValCoord3D(seed, x3, y1, z1), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z1),
+													 _fnlValCoord3D(seed, x1, y2, z1),
+													 _fnlValCoord3D(seed, x2, y2, z1),
+													 _fnlValCoord3D(seed, x3, y2, z1), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z1),
+													 _fnlValCoord3D(seed, x1, y3, z1),
+													 _fnlValCoord3D(seed, x2, y3, z1),
+													 _fnlValCoord3D(seed, x3, y3, z1), xs),
+									   ys),
+						 _fnlCubicLerp(_fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z2),
+													 _fnlValCoord3D(seed, x1, y0, z2),
+													 _fnlValCoord3D(seed, x2, y0, z2),
+													 _fnlValCoord3D(seed, x3, y0, z2), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z2),
+													 _fnlValCoord3D(seed, x1, y1, z2),
+													 _fnlValCoord3D(seed, x2, y1, z2),
+													 _fnlValCoord3D(seed, x3, y1, z2), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z2),
+													 _fnlValCoord3D(seed, x1, y2, z2),
+													 _fnlValCoord3D(seed, x2, y2, z2),
+													 _fnlValCoord3D(seed, x3, y2, z2), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z2),
+													 _fnlValCoord3D(seed, x1, y3, z2),
+													 _fnlValCoord3D(seed, x2, y3, z2),
+													 _fnlValCoord3D(seed, x3, y3, z2), xs),
+									   ys),
+						 _fnlCubicLerp(_fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z3),
+													 _fnlValCoord3D(seed, x1, y0, z3),
+													 _fnlValCoord3D(seed, x2, y0, z3),
+													 _fnlValCoord3D(seed, x3, y0, z3), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z3),
+													 _fnlValCoord3D(seed, x1, y1, z3),
+													 _fnlValCoord3D(seed, x2, y1, z3),
+													 _fnlValCoord3D(seed, x3, y1, z3), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z3),
+													 _fnlValCoord3D(seed, x1, y2, z3),
+													 _fnlValCoord3D(seed, x2, y2, z3),
+													 _fnlValCoord3D(seed, x3, y2, z3), xs),
+									   _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z3),
+													 _fnlValCoord3D(seed, x1, y3, z3),
+													 _fnlValCoord3D(seed, x2, y3, z3),
+													 _fnlValCoord3D(seed, x3, y3, z3), xs),
+									   ys),
+						 zs) *
+		   (1 / 1.5f * 1.5f * 1.5f);
+}
+
+// Value noise
+
+static float _fnlSingleValue2D(int seed, FNLfloat x, FNLfloat y)
+{
+	int x0 = _fnlFastFloor(x);
+	int y0 = _fnlFastFloor(y);
+
+	float xs = _fnlInterpHermite((float)(x - x0));
+	float ys = _fnlInterpHermite((float)(y - y0));
+
+	x0 *= PRIME_X;
+	y0 *= PRIME_Y;
+	int x1 = x0 + PRIME_X;
+	int y1 = y0 + PRIME_Y;
+
+	float xf0 = _fnlLerp(_fnlValCoord2D(seed, x0, y0), _fnlValCoord2D(seed, x1, y0), xs);
+	float xf1 = _fnlLerp(_fnlValCoord2D(seed, x0, y1), _fnlValCoord2D(seed, x1, y1), xs);
+
+	return _fnlLerp(xf0, xf1, ys);
+}
+
+static float _fnlSingleValue3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z)
+{
+	int x0 = _fnlFastFloor(x);
+	int y0 = _fnlFastFloor(y);
+	int z0 = _fnlFastFloor(z);
+
+	float xs = _fnlInterpHermite((float)(x - x0));
+	float ys = _fnlInterpHermite((float)(y - y0));
+	float zs = _fnlInterpHermite((float)(z - z0));
+
+	x0 *= PRIME_X;
+	y0 *= PRIME_Y;
+	z0 *= PRIME_Z;
+	int x1 = x0 + PRIME_X;
+	int y1 = y0 + PRIME_Y;
+	int z1 = z0 + PRIME_Z;
+
+	float xf00 =
+		_fnlLerp(_fnlValCoord3D(seed, x0, y0, z0), _fnlValCoord3D(seed, x1, y0, z0), xs);
+	float xf10 =
+		_fnlLerp(_fnlValCoord3D(seed, x0, y1, z0), _fnlValCoord3D(seed, x1, y1, z0), xs);
+	float xf01 =
+		_fnlLerp(_fnlValCoord3D(seed, x0, y0, z1), _fnlValCoord3D(seed, x1, y0, z1), xs);
+	float xf11 =
+		_fnlLerp(_fnlValCoord3D(seed, x0, y1, z1), _fnlValCoord3D(seed, x1, y1, z1), xs);
+
+	float yf0 = _fnlLerp(xf00, xf10, ys);
+	float yf1 = _fnlLerp(xf01, xf11, ys);
+
+	return _fnlLerp(yf0, yf1, zs);
+}
+
+// Domain Warp
+
+// Forward declare
+static void _fnlSingleDomainWarpBasicGrid2D(int seed, float warpAmp, float frequency,
+											FNLfloat x, FNLfloat y, FNLfloat *xp,
+											FNLfloat *yp);
+static void _fnlSingleDomainWarpBasicGrid3D(int seed, float warpAmp, float frequency,
+											FNLfloat x, FNLfloat y, FNLfloat z,
+											FNLfloat *xp, FNLfloat *yp, FNLfloat *zp);
+static void _fnlSingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency,
+												FNLfloat x, FNLfloat y, FNLfloat *xr,
+												FNLfloat *yr, bool outGradOnly);
+static void _fnlSingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp,
+													 float frequency, FNLfloat x,
+													 FNLfloat y, FNLfloat z, FNLfloat *xr,
+													 FNLfloat *yr, FNLfloat *zr,
+													 bool outGradOnly);
+
+static inline void _fnlDoSingleDomainWarp2D(const fnl_state *state, int seed, float amp,
+											float freq, FNLfloat x, FNLfloat y,
+											FNLfloat *xp, FNLfloat *yp)
+{
+	switch (state->domain_warp_type) {
+	case FNL_DOMAIN_WARP_OPENSIMPLEX2:
+		_fnlSingleDomainWarpSimplexGradient(seed, amp * 38.283687591552734375f, freq, x, y,
+											xp, yp, false);
+		break;
+	case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED:
+		_fnlSingleDomainWarpSimplexGradient(seed, amp * 16.0f, freq, x, y, xp, yp, true);
+		break;
+	case FNL_DOMAIN_WARP_BASICGRID:
+		_fnlSingleDomainWarpBasicGrid2D(seed, amp, freq, x, y, xp, yp);
+		break;
+	}
+}
+
+static inline void _fnlDoSingleDomainWarp3D(const fnl_state *state, int seed, float amp,
+											float freq, FNLfloat x, FNLfloat y, FNLfloat z,
+											FNLfloat *xp, FNLfloat *yp, FNLfloat *zp)
+{
+	switch (state->domain_warp_type) {
+	case FNL_DOMAIN_WARP_OPENSIMPLEX2:
+		_fnlSingleDomainWarpOpenSimplex2Gradient(seed, amp * 32.69428253173828125f, freq, x,
+												 y, z, xp, yp, zp, false);
+		break;
+	case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED:
+		_fnlSingleDomainWarpOpenSimplex2Gradient(seed, amp * 7.71604938271605f, freq, x, y,
+												 z, xp, yp, zp, true);
+		break;
+	case FNL_DOMAIN_WARP_BASICGRID:
+		_fnlSingleDomainWarpBasicGrid3D(seed, amp, freq, x, y, z, xp, yp, zp);
+		break;
+	}
+}
+
+// Domain Warp Single Wrapper
+
+static void _fnlDomainWarpSingle2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
+{
+	int seed = state->seed;
+	float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
+	float freq = state->frequency;
+
+	FNLfloat xs = *x;
+	FNLfloat ys = *y;
+	_fnlTransformDomainWarpCoordinate2D(state, &xs, &ys);
+
+	_fnlDoSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y);
+}
+
+static void _fnlDomainWarpSingle3D(const fnl_state *state, FNLfloat *x, FNLfloat *y,
+								   FNLfloat *z)
+{
+	int seed = state->seed;
+	float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
+	float freq = state->frequency;
+
+	FNLfloat xs = *x;
+	FNLfloat ys = *y;
+	FNLfloat zs = *z;
+	_fnlTransformDomainWarpCoordinate3D(state, &xs, &ys, &zs);
+
+	_fnlDoSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z);
+}
+
+// Domain Warp Fractal Progressive
+
+static void _fnlDomainWarpFractalProgressive2D(const fnl_state *state, FNLfloat *x,
+											   FNLfloat *y)
+{
+	int seed = state->seed;
+	float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
+	float freq = state->frequency;
+
+	for (int i = 0; i < state->octaves; i++) {
+		FNLfloat xs = *x;
+		FNLfloat ys = *y;
+		_fnlTransformDomainWarpCoordinate2D(state, &xs, &ys);
+
+		_fnlDoSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y);
+
+		seed++;
+		amp *= state->gain;
+		freq *= state->lacunarity;
+	}
+}
+
+static void _fnlDomainWarpFractalProgressive3D(const fnl_state *state, FNLfloat *x,
+											   FNLfloat *y, FNLfloat *z)
+{
+	int seed = state->seed;
+	float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
+	float freq = state->frequency;
+
+	for (int i = 0; i < state->octaves; i++) {
+		FNLfloat xs = *x;
+		FNLfloat ys = *y;
+		FNLfloat zs = *z;
+		_fnlTransformDomainWarpCoordinate3D(state, &xs, &ys, &zs);
+
+		_fnlDoSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z);
+
+		seed++;
+		amp *= state->gain;
+		freq *= state->lacunarity;
+	}
+}
+
+// Domain Warp Fractal Independent
+
+static void _fnlDomainWarpFractalIndependent2D(const fnl_state *state, FNLfloat *x,
+											   FNLfloat *y)
+{
+	FNLfloat xs = *x;
+	FNLfloat ys = *y;
+	_fnlTransformDomainWarpCoordinate2D(state, &xs, &ys);
+
+	int seed = state->seed;
+	float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
+	float freq = state->frequency;
+
+	for (int i = 0; i < state->octaves; i++) {
+		_fnlDoSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y);
+
+		seed++;
+		amp *= state->gain;
+		freq *= state->lacunarity;
+	}
+}
+
+static void _fnlDomainWarpFractalIndependent3D(const fnl_state *state, FNLfloat *x,
+											   FNLfloat *y, FNLfloat *z)
+{
+	FNLfloat xs = *x;
+	FNLfloat ys = *y;
+	FNLfloat zs = *z;
+	_fnlTransformDomainWarpCoordinate3D(state, &xs, &ys, &zs);
+
+	int seed = state->seed;
+	float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state);
+	float freq = state->frequency;
+
+	for (int i = 0; i < state->octaves; i++) {
+		_fnlDoSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z);
+
+		seed++;
+		amp *= state->gain;
+		freq *= state->lacunarity;
+	}
+}
+
+// Domain Warp Basic Grid
+
+static void _fnlSingleDomainWarpBasicGrid2D(int seed, float warpAmp, float frequency,
+											FNLfloat x, FNLfloat y, FNLfloat *xp,
+											FNLfloat *yp)
+{
+	FNLfloat xf = x * frequency;
+	FNLfloat yf = y * frequency;
+
+	int x0 = _fnlFastFloor(xf);
+	int y0 = _fnlFastFloor(yf);
+
+	float xs = _fnlInterpHermite((float)(xf - x0));
+	float ys = _fnlInterpHermite((float)(yf - y0));
+
+	x0 *= PRIME_X;
+	y0 *= PRIME_Y;
+	int x1 = x0 + PRIME_X;
+	int y1 = y0 + PRIME_Y;
+
+	int idx0 = _fnlHash2D(seed, x0, y0) & (255 << 1);
+	int idx1 = _fnlHash2D(seed, x1, y0) & (255 << 1);
+
+	float lx0x = _fnlLerp(RAND_VECS_2D[idx0], RAND_VECS_2D[idx1], xs);
+	float ly0x = _fnlLerp(RAND_VECS_2D[idx0 | 1], RAND_VECS_2D[idx1 | 1], xs);
+
+	idx0 = _fnlHash2D(seed, x0, y1) & (255 << 1);
+	idx1 = _fnlHash2D(seed, x1, y1) & (255 << 1);
+
+	float lx1x = _fnlLerp(RAND_VECS_2D[idx0], RAND_VECS_2D[idx1], xs);
+	float ly1x = _fnlLerp(RAND_VECS_2D[idx0 | 1], RAND_VECS_2D[idx1 | 1], xs);
+
+	*xp += _fnlLerp(lx0x, lx1x, ys) * warpAmp;
+	*yp += _fnlLerp(ly0x, ly1x, ys) * warpAmp;
+}
+
+static void _fnlSingleDomainWarpBasicGrid3D(int seed, float warpAmp, float frequency,
+											FNLfloat x, FNLfloat y, FNLfloat z,
+											FNLfloat *xp, FNLfloat *yp, FNLfloat *zp)
+{
+	FNLfloat xf = x * frequency;
+	FNLfloat yf = y * frequency;
+	FNLfloat zf = z * frequency;
+
+	int x0 = _fnlFastFloor(xf);
+	int y0 = _fnlFastFloor(yf);
+	int z0 = _fnlFastFloor(zf);
+
+	float xs = _fnlInterpHermite((float)(xf - x0));
+	float ys = _fnlInterpHermite((float)(yf - y0));
+	float zs = _fnlInterpHermite((float)(zf - z0));
+
+	x0 *= PRIME_X;
+	y0 *= PRIME_Y;
+	z0 *= PRIME_Z;
+	int x1 = x0 + PRIME_X;
+	int y1 = y0 + PRIME_Y;
+	int z1 = z0 + PRIME_Z;
+
+	int idx0 = _fnlHash3D(seed, x0, y0, z0) & (255 << 2);
+	int idx1 = _fnlHash3D(seed, x1, y0, z0) & (255 << 2);
+
+	float lx0x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs);
+	float ly0x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs);
+	float lz0x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs);
+
+	idx0 = _fnlHash3D(seed, x0, y1, z0) & (255 << 2);
+	idx1 = _fnlHash3D(seed, x1, y1, z0) & (255 << 2);
+
+	float lx1x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs);
+	float ly1x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs);
+	float lz1x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs);
+
+	float lx0y = _fnlLerp(lx0x, lx1x, ys);
+	float ly0y = _fnlLerp(ly0x, ly1x, ys);
+	float lz0y = _fnlLerp(lz0x, lz1x, ys);
+
+	idx0 = _fnlHash3D(seed, x0, y0, z1) & (255 << 2);
+	idx1 = _fnlHash3D(seed, x1, y0, z1) & (255 << 2);
+
+	lx0x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs);
+	ly0x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs);
+	lz0x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs);
+
+	idx0 = _fnlHash3D(seed, x0, y1, z1) & (255 << 2);
+	idx1 = _fnlHash3D(seed, x1, y1, z1) & (255 << 2);
+
+	lx1x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs);
+	ly1x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs);
+	lz1x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs);
+
+	*xp += _fnlLerp(lx0y, _fnlLerp(lx0x, lx1x, ys), zs) * warpAmp;
+	*yp += _fnlLerp(ly0y, _fnlLerp(ly0x, ly1x, ys), zs) * warpAmp;
+	*zp += _fnlLerp(lz0y, _fnlLerp(lz0x, lz1x, ys), zs) * warpAmp;
+}
+
+// Domain Warp Simplex/OpenSimplex2
+
+static void _fnlSingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency,
+												FNLfloat x, FNLfloat y, FNLfloat *xr,
+												FNLfloat *yr, bool outGradOnly)
+{
+	const float SQRT3 = 1.7320508075688772935274463415059f;
+	const float G2 = (3 - SQRT3) / 6;
+
+	x *= frequency;
+	y *= frequency;
+
+	/*
+     * --- Skew moved to TransformNoiseCoordinate method ---
+     * const FNLfloat F2 = 0.5f * (SQRT3 - 1);
+     * FNLfloat s = (x + y) * F2;
+     * x += s; y += s;
+     */
+
+	int i = _fnlFastFloor(x);
+	int j = _fnlFastFloor(y);
+	float xi = (float)(x - i);
+	float yi = (float)(y - j);
+
+	float t = (xi + yi) * G2;
+	float x0 = (float)(xi - t);
+	float y0 = (float)(yi - t);
+
+	i *= PRIME_X;
+	j *= PRIME_Y;
+
+	float vx, vy;
+	vx = vy = 0;
+
+	float a = 0.5f - x0 * x0 - y0 * y0;
+	if (a > 0) {
+		float aaaa = (a * a) * (a * a);
+		float xo, yo;
+		if (outGradOnly)
+			_fnlGradCoordOut2D(seed, i, j, &xo, &yo);
+		else
+			_fnlGradCoordDual2D(seed, i, j, x0, y0, &xo, &yo);
+		vx += aaaa * xo;
+		vy += aaaa * yo;
+	}
+
+	float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t +
+			  ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
+	if (c > 0) {
+		float x2 = x0 + (2 * (float)G2 - 1);
+		float y2 = y0 + (2 * (float)G2 - 1);
+		float cccc = (c * c) * (c * c);
+		float xo, yo;
+		if (outGradOnly)
+			_fnlGradCoordOut2D(seed, i + PRIME_X, j + PRIME_Y, &xo, &yo);
+		else
+			_fnlGradCoordDual2D(seed, i + PRIME_X, j + PRIME_Y, x2, y2, &xo, &yo);
+		vx += cccc * xo;
+		vy += cccc * yo;
+	}
+
+	if (y0 > x0) {
+		float x1 = x0 + (float)G2;
+		float y1 = y0 + ((float)G2 - 1);
+		float b = 0.5f - x1 * x1 - y1 * y1;
+		if (b > 0) {
+			float bbbb = (b * b) * (b * b);
+			float xo, yo;
+			if (outGradOnly)
+				_fnlGradCoordOut2D(seed, i, j + PRIME_Y, &xo, &yo);
+			else
+				_fnlGradCoordDual2D(seed, i, j + PRIME_Y, x1, y1, &xo, &yo);
+			vx += bbbb * xo;
+			vy += bbbb * yo;
+		}
+	} else {
+		float x1 = x0 + ((float)G2 - 1);
+		float y1 = y0 + (float)G2;
+		float b = 0.5f - x1 * x1 - y1 * y1;
+		if (b > 0) {
+			float bbbb = (b * b) * (b * b);
+			float xo, yo;
+			if (outGradOnly)
+				_fnlGradCoordOut2D(seed, i + PRIME_X, j, &xo, &yo);
+			else
+				_fnlGradCoordDual2D(seed, i + PRIME_X, j, x1, y1, &xo, &yo);
+			vx += bbbb * xo;
+			vy += bbbb * yo;
+		}
+	}
+
+	*xr += vx * warpAmp;
+	*yr += vy * warpAmp;
+}
+
+static void _fnlSingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp,
+													 float frequency, FNLfloat x,
+													 FNLfloat y, FNLfloat z, FNLfloat *xr,
+													 FNLfloat *yr, FNLfloat *zr,
+													 bool outGradOnly)
+{
+	x *= frequency;
+	y *= frequency;
+	z *= frequency;
+
+	/*
+     * --- Rotation moved to TransformDomainWarpCoordinate method ---
+     * const FNLfloat R3 = (FNLfloat)(2.0 / 3.0);
+     * FNLfloat r = (x + y + z) * R3; // Rotation, not skew
+     * x = r - x; y = r - y; z = r - z;
+     */
+
+	int i = _fnlFastRound(x);
+	int j = _fnlFastRound(y);
+	int k = _fnlFastRound(z);
+	float x0 = (float)x - i;
+	float y0 = (float)y - j;
+	float z0 = (float)z - k;
+
+	int xNSign = (int)(-x0 - 1.0f) | 1;
+	int yNSign = (int)(-y0 - 1.0f) | 1;
+	int zNSign = (int)(-z0 - 1.0f) | 1;
+
+	float ax0 = xNSign * -x0;
+	float ay0 = yNSign * -y0;
+	float az0 = zNSign * -z0;
+
+	i *= PRIME_X;
+	j *= PRIME_Y;
+	k *= PRIME_Z;
+
+	float vx, vy, vz;
+	vx = vy = vz = 0;
+
+	float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
+	for (int l = 0; l < 2; l++) {
+		if (a > 0) {
+			float aaaa = (a * a) * (a * a);
+			float xo, yo, zo;
+			if (outGradOnly)
+				_fnlGradCoordOut3D(seed, i, j, k, &xo, &yo, &zo);
+			else
+				_fnlGradCoordDual3D(seed, i, j, k, x0, y0, z0, &xo, &yo, &zo);
+			vx += aaaa * xo;
+			vy += aaaa * yo;
+			vz += aaaa * zo;
+		}
+
+		float b = a + 1;
+		int i1 = i;
+		int j1 = j;
+		int k1 = k;
+		float x1 = x0;
+		float y1 = y0;
+		float z1 = z0;
+		if (ax0 >= ay0 && ax0 >= az0) {
+			x1 += xNSign;
+			b -= xNSign * 2 * x1;
+			i1 -= xNSign * PRIME_X;
+		} else if (ay0 > ax0 && ay0 >= az0) {
+			y1 += yNSign;
+			b -= yNSign * 2 * y1;
+			j1 -= yNSign * PRIME_Y;
+		} else {
+			z1 += zNSign;
+			b -= zNSign * 2 * z1;
+			k1 -= zNSign * PRIME_Z;
+		}
+
+		if (b > 0) {
+			float bbbb = (b * b) * (b * b);
+			float xo, yo, zo;
+			if (outGradOnly)
+				_fnlGradCoordOut3D(seed, i1, j1, k1, &xo, &yo, &zo);
+			else
+				_fnlGradCoordDual3D(seed, i1, j1, k1, x1, y1, z1, &xo, &yo, &zo);
+			vx += bbbb * xo;
+			vy += bbbb * yo;
+			vz += bbbb * zo;
+		}
+
+		if (l == 1)
+			break;
+
+		ax0 = 0.5f - ax0;
+		ay0 = 0.5f - ay0;
+		az0 = 0.5f - az0;
+
+		x0 = xNSign * ax0;
+		y0 = yNSign * ay0;
+		z0 = zNSign * az0;
+
+		a += (0.75f - ax0) - (ay0 + az0);
+
+		i += (xNSign >> 1) & PRIME_X;
+		j += (yNSign >> 1) & PRIME_Y;
+		k += (zNSign >> 1) & PRIME_Z;
+
+		xNSign = -xNSign;
+		yNSign = -yNSign;
+		zNSign = -zNSign;
+
+		seed += 1293373;
+	}
+
+	*xr += vx * warpAmp;
+	*yr += vy * warpAmp;
+	*zr += vz * warpAmp;
+}
+
+// ====================
+// Public API
+// ====================
+
+fnl_state fnlCreateState()
+{
+	fnl_state newState;
+	newState.seed = 1337;
+	newState.frequency = 0.01f;
+	newState.noise_type = FNL_NOISE_OPENSIMPLEX2;
+	newState.rotation_type_3d = FNL_ROTATION_NONE;
+	newState.fractal_type = FNL_FRACTAL_NONE;
+	newState.octaves = 3;
+	newState.lacunarity = 2.0f;
+	newState.gain = 0.5f;
+	newState.weighted_strength = 0.0f;
+	newState.ping_pong_strength = 2.0f;
+	newState.cellular_distance_func = FNL_CELLULAR_DISTANCE_EUCLIDEANSQ;
+	newState.cellular_return_type = FNL_CELLULAR_RETURN_TYPE_DISTANCE;
+	newState.cellular_jitter_mod = 1.0f;
+	newState.domain_warp_amp = 30.0f;
+	newState.domain_warp_type = FNL_DOMAIN_WARP_OPENSIMPLEX2;
+	return newState;
+}
+
+float fnlGetNoise2D(const fnl_state *state, FNLfloat x, FNLfloat y)
+{
+	_fnlTransformNoiseCoordinate2D(state, &x, &y);
+
+	switch (state->fractal_type) {
+	default:
+		return _fnlGenNoiseSingle2D(state, state->seed, x, y);
+	case FNL_FRACTAL_FBM:
+		return _fnlGenFractalFBM2D(state, x, y);
+	case FNL_FRACTAL_RIDGED:
+		return _fnlGenFractalRidged2D(state, x, y);
+	case FNL_FRACTAL_PINGPONG:
+		return _fnlGenFractalPingPong2D(state, x, y);
+	}
+}
+
+float fnlGetNoise3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z)
+{
+	_fnlTransformNoiseCoordinate3D(state, &x, &y, &z);
+
+	// Select a noise type
+	switch (state->fractal_type) {
+	default:
+		return _fnlGenNoiseSingle3D(state, state->seed, x, y, z);
+	case FNL_FRACTAL_FBM:
+		return _fnlGenFractalFBM3D(state, x, y, z);
+	case FNL_FRACTAL_RIDGED:
+		return _fnlGenFractalRidged3D(state, x, y, z);
+	case FNL_FRACTAL_PINGPONG:
+		return _fnlGenFractalPingPong3D(state, x, y, z);
+	}
+}
+
+void fnlDomainWarp2D(const fnl_state *state, FNLfloat *x, FNLfloat *y)
+{
+	switch (state->fractal_type) {
+	default:
+		_fnlDomainWarpSingle2D(state, x, y);
+		break;
+	case FNL_FRACTAL_DOMAIN_WARP_PROGRESSIVE:
+		_fnlDomainWarpFractalProgressive2D(state, x, y);
+		break;
+	case FNL_FRACTAL_DOMAIN_WARP_INDEPENDENT:
+		_fnlDomainWarpFractalIndependent2D(state, x, y);
+		break;
+	}
+}
+
+void fnlDomainWarp3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z)
+{
+	switch (state->fractal_type) {
+	default:
+		_fnlDomainWarpSingle3D(state, x, y, z);
+		break;
+	case FNL_FRACTAL_DOMAIN_WARP_PROGRESSIVE:
+		_fnlDomainWarpFractalProgressive3D(state, x, y, z);
+		break;
+	case FNL_FRACTAL_DOMAIN_WARP_INDEPENDENT:
+		_fnlDomainWarpFractalIndependent3D(state, x, y, z);
+		break;
+	}
+}
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // FNL_IMPL
diff --git a/src/camera.c b/src/camera.c
index ec486d7..a841faa 100644
--- a/src/camera.c
+++ b/src/camera.c
@@ -1,18 +1,19 @@
-#include "cglm/vec3.h"
+#include <GLFW/glfw3.h>
 #include <math.h>
 
 #include "voxel.h"
 #include "window.h"
 
-Camera camera_init(void)
+void camera_init(Camera *camera)
 {
-	Camera camera = { 0 };
-	camera.fov = 70;
-	camera.near = 0.1;
-	camera.far = 1000;
-	camera.look_speed = 100;
-	camera.move_speed = 4.317;
-	return camera;
+	camera->fov = 70;
+	camera->near = 0.1;
+	camera->far = 1000;
+	camera->look_speed = 100;
+	camera->move_speed = 4.317 * 10;
+	glm_vec3_zero(camera->position);
+	glm_vec3_zero(camera->rotation);
+	camera->frustum = camera_frustum(camera);
 }
 
 void camera_proj(Camera *camera, mat4 proj)
@@ -143,4 +144,54 @@ void camera_update(Camera *camera)
 {
 	camera_update_rotation(camera);
 	camera_update_movement(camera);
+	camera->frustum = camera_frustum(camera);
+}
+
+Frustum camera_frustum(Camera *camera)
+{
+	Frustum frustum;
+	mat4 proj_view;
+
+	camera_proj_view(camera, proj_view);
+	glm_mat4_transpose(proj_view);
+
+	// left
+	glm_vec4_add(proj_view[3], proj_view[0], frustum.left);
+
+	// right
+	glm_vec4_sub(proj_view[3], proj_view[0], frustum.right);
+
+	// bottom
+	glm_vec4_add(proj_view[3], proj_view[1], frustum.bottom);
+
+	// top
+	glm_vec4_sub(proj_view[3], proj_view[1], frustum.top);
+
+	// near
+	glm_vec4_add(proj_view[3], proj_view[2], frustum.near);
+
+	// far
+	glm_vec4_sub(proj_view[3], proj_view[2], frustum.far);
+
+	return frustum;
+}
+
+bool aabb_in_plane(AABB *aabb, Plane plane)
+{
+	vec3 p;
+	float f;
+
+	p[0] = plane[0] >= 0 ? aabb->max[0] : aabb->min[0];
+	p[1] = plane[1] >= 0 ? aabb->max[1] : aabb->min[1];
+	p[2] = plane[2] >= 0 ? aabb->max[2] : aabb->min[2];
+	f = glm_vec3_dot(p, plane) + plane[3];
+
+	return f >= 0.0f;
+}
+
+bool aabb_in_frustum(AABB *aabb, Frustum *frustum)
+{
+	return aabb_in_plane(aabb, frustum->near) && aabb_in_plane(aabb, frustum->far) &&
+		   aabb_in_plane(aabb, frustum->left) && aabb_in_plane(aabb, frustum->right) &&
+		   aabb_in_plane(aabb, frustum->top) && aabb_in_plane(aabb, frustum->bottom);
 }
diff --git a/src/chunk.c b/src/chunk.c
index 50fe5c3..f142788 100644
--- a/src/chunk.c
+++ b/src/chunk.c
@@ -1,98 +1,183 @@
-#include <stdio.h>
+#include <cglm/vec3.h>
 #include <stdlib.h>
-#include <string.h>
 
+#include "utils.h"
 #include "voxel.h"
 #include "list.h"
-#include "cube.h"
-#include "mesh.h"
+#include "gl.h"
+#include "noise.h"
 
-Chunk *chunk_init(int x, int y, int z)
+void chunk_init(Chunk *chunk, i32 x, i32 y, i32 z)
 {
-	Chunk *chunk = malloc(sizeof(Chunk));
-	chunk->x = x;
-	chunk->y = y;
-	chunk->z = z;
-	memset(chunk->blocks, AIR, sizeof(chunk->blocks));
-	return chunk;
+	chunk->blocks = xzalloc(sizeof(Block) * CHUNK_BLOCKS);
+	chunk->pos[0] = x;
+	chunk->pos[1] = y;
+	chunk->pos[2] = z;
+	chunk->state = CHUNK_NEW;
+	chunk->has_mesh = false;
 }
 
 void chunk_free(Chunk *chunk)
 {
-	free(chunk);
+	if (chunk->state >= CHUNK_MESHED)
+		uniform_free(&chunk->mesh);
+	free(chunk->blocks);
 }
 
-void chunk_generate(Chunk *chunk)
+void chunk_generate(Chunk *chunk, seed_t seed)
 {
-	int size = sizeof(chunk->blocks);
-	for (int i = 0; i < size; i++) {
-		int x = i % CHUNK_SIZE;
-		int z = (i / CHUNK_SIZE) % CHUNK_SIZE;
-		int y = i / (CHUNK_SIZE * CHUNK_SIZE);
+	fnl_state noise;
 
-		char block = AIR;
-		int temp = x + z - y;
-		if (temp > 16)
-			block = DIRT;
+	if (chunk->state != CHUNK_NEW)
+		return;
 
-		chunk->blocks[i] = block;
+	chunk->state = CHUNK_GENERATING;
+
+	noise = fnlCreateState();
+	noise.seed = seed;
+	noise.noise_type = FNL_NOISE_PERLIN;
+
+	for (i32 i = 0; i < CHUNK_BLOCKS; i++) {
+		i32 lx = i % CHUNK_SIZE;
+		i32 lz = (i / CHUNK_SIZE) % CHUNK_SIZE;
+		i32 ly = i / (CHUNK_SIZE * CHUNK_SIZE);
+
+		i32 gx = lx + chunk->pos[0] * CHUNK_SIZE;
+		i32 gy = ly + chunk->pos[1] * CHUNK_SIZE;
+		i32 gz = lz + chunk->pos[2] * CHUNK_SIZE;
+
+		double data = fnlGetNoise3D(&noise, gx, gy, gz);
+		data -= gy * 0.01;
+		if (data < 0.1)
+			continue;
+
+		chunk->blocks[i] = A;
 	}
+
+	chunk->state = CHUNK_GENERATED;
 }
 
 typedef struct {
-	Chunk *chunk;
-	List pos;
 	List data;
-	int vertex_count;
+	RcChunk *rc_chunks[7];
 } MeshState;
 
-static void add_vertex(MeshState *state, const vec3 pos, const vec3 xyz, unsigned int data)
+typedef union {
+	struct {
+		u64 x	   : 5;
+		u64 y	   : 5;
+		u64 z	   : 5;
+		u64 width  : 5;
+		u64 height : 5;
+		u64 face   : 3;
+		u64 block  : 4;
+		u64		   : 32;
+	};
+	u64 raw;
+} Quad;
+
+static void mesh_state_init(MeshState *state, World *world, Chunk *chunk)
+{
+	i32 cx, cy, cz;
+
+	cx = chunk->pos[0];
+	cy = chunk->pos[1];
+	cz = chunk->pos[2];
+
+	state->rc_chunks[0] = world_get_chunk(world, cx, cy, cz);
+	state->rc_chunks[1] = world_get_chunk(world, cx - 1, cy, cz);
+	state->rc_chunks[2] = world_get_chunk(world, cx + 1, cy, cz);
+	state->rc_chunks[3] = world_get_chunk(world, cx, cy - 1, cz);
+	state->rc_chunks[4] = world_get_chunk(world, cx, cy + 1, cz);
+	state->rc_chunks[5] = world_get_chunk(world, cx, cy, cz - 1);
+	state->rc_chunks[6] = world_get_chunk(world, cx, cy, cz + 1);
+
+	list_init_u64(&state->data);
+}
+
+static void mesh_state_free(MeshState *state)
+{
+	for (i32 i = 0; i < 7; i++) {
+		RcChunk *rc_chunk = state->rc_chunks[i];
+		if (rc_chunk != NULL)
+			rcchunk_drop(rc_chunk);
+	}
+
+	list_free(&state->data);
+}
+
+static Block mesh_state_get_block(MeshState *state, i32 lx, i32 ly, i32 lz)
 {
-	list_pushf(&state->pos, pos[0] + xyz[0]);
-	list_pushf(&state->pos, pos[1] + xyz[1]);
-	list_pushf(&state->pos, pos[2] + xyz[2]);
-	list_pushu(&state->data, data);
-	state->vertex_count++;
+	RcChunk *rc_chunk;
+	i32 index = 0;
+
+	if (lx < 0) {
+		index = 1;
+		lx += CHUNK_SIZE;
+	} else if (lx >= CHUNK_SIZE) {
+		index = 2;
+		lx -= CHUNK_SIZE;
+	} else if (ly < 0) {
+		index = 3;
+		ly += CHUNK_SIZE;
+	} else if (ly >= CHUNK_SIZE) {
+		index = 4;
+		ly -= CHUNK_SIZE;
+	} else if (lz < 0) {
+		index = 5;
+		lz += CHUNK_SIZE;
+	} else if (lz >= CHUNK_SIZE) {
+		index = 6;
+		lz -= CHUNK_SIZE;
+	}
+
+	rc_chunk = state->rc_chunks[index];
+	if (rc_chunk == NULL)
+		return AIR;
+
+	return chunk_at(&rc_chunk->chunk, lx, ly, lz);
 }
 
-static void add_quad(MeshState *state, const vec3 xyz, Face face, Block block)
+static void add_quad(MeshState *state, const ivec3 xyz, Face face, Block block)
 {
-	unsigned int data = (face << 2) | block;
-	const vec3 *verts = CUBE[face];
+	Quad quad = { 0 };
+	quad.x = xyz[0];
+	quad.y = xyz[1];
+	quad.z = xyz[2];
+	quad.width = 1;
+	quad.height = 1;
+	quad.face = face;
+	quad.block = block;
 
-	add_vertex(state, verts[0], xyz, data);
-	add_vertex(state, verts[1], xyz, data);
-	add_vertex(state, verts[2], xyz, data);
-	add_vertex(state, verts[3], xyz, data);
-	add_vertex(state, verts[4], xyz, data);
-	add_vertex(state, verts[5], xyz, data);
+	list_push_u64(&state->data, quad.raw);
 }
 
-Mesh chunk_mesh(Chunk *chunk)
+void chunk_mesh(Chunk *chunk, World *world)
 {
 	MeshState state;
-	state.chunk = chunk;
-	state.vertex_count = 0;
-	list_initf(&state.pos);
-	list_initu(&state.data);
 
-	int size = sizeof(chunk->blocks);
-	for (int i = 0; i < size; i++) {
-		int x = i % CHUNK_SIZE;
-		int z = (i / CHUNK_SIZE) % CHUNK_SIZE;
-		int y = i / (CHUNK_SIZE * CHUNK_SIZE);
-		vec3 xyz = { x, y, z };
+	if (chunk->state != CHUNK_GENERATED)
+		return;
+
+	chunk->state = CHUNK_MESHING;
+	mesh_state_init(&state, world, chunk);
+
+	for (i32 i = 0; i < CHUNK_BLOCKS; i++) {
+		i32 lx = i % CHUNK_SIZE;
+		i32 lz = (i / CHUNK_SIZE) % CHUNK_SIZE;
+		i32 ly = i / (CHUNK_SIZE * CHUNK_SIZE);
+		ivec3 xyz = { lx, ly, lz };
 
 		Block block = chunk->blocks[i];
 		if (block == AIR)
 			continue;
 
-		Block px = chunk_at(chunk, x + 1, y, z);
-		Block nx = chunk_at(chunk, x - 1, y, z);
-		Block py = chunk_at(chunk, x, y + 1, z);
-		Block ny = chunk_at(chunk, x, y - 1, z);
-		Block pz = chunk_at(chunk, x, y, z + 1);
-		Block nz = chunk_at(chunk, x, y, z - 1);
+		Block px = mesh_state_get_block(&state, lx + 1, ly, lz);
+		Block nx = mesh_state_get_block(&state, lx - 1, ly, lz);
+		Block py = mesh_state_get_block(&state, lx, ly + 1, lz);
+		Block ny = mesh_state_get_block(&state, lx, ly - 1, lz);
+		Block pz = mesh_state_get_block(&state, lx, ly, lz + 1);
+		Block nz = mesh_state_get_block(&state, lx, ly, lz - 1);
 
 		if (px == AIR)
 			add_quad(&state, xyz, POS_X, block);
@@ -108,19 +193,20 @@ Mesh chunk_mesh(Chunk *chunk)
 			add_quad(&state, xyz, NEG_Z, block);
 	}
 
-	Mesh mesh;
-	mesh_init(&mesh, state.vertex_count);
-	mesh_storef(&mesh, state.pos.fdata, state.pos.len, 3);
-	mesh_storeu(&mesh, state.data.udata, state.data.len, 1);
-	mesh_finish();
+	if (chunk->has_mesh)
+		uniform_free(&chunk->mesh);
 
-	list_free(&state.pos);
-	list_free(&state.data);
+	Uniform uniform;
+	uniform_init(&uniform, state.data.len * sizeof(Quad));
+	uniform_store(&uniform, 0, state.data.len * sizeof(Quad), state.data.data);
+	mesh_state_free(&state);
 
-	return mesh;
+	chunk->mesh = uniform;
+	chunk->has_mesh = true;
+	chunk->state = CHUNK_MESHED;
 }
 
-Block chunk_at(Chunk *chunk, int x, int y, int z)
+Block chunk_at(Chunk *chunk, i32 x, i32 y, i32 z)
 {
 	if (x < 0 || x >= CHUNK_SIZE)
 		return AIR;
@@ -129,10 +215,25 @@ Block chunk_at(Chunk *chunk, int x, int y, int z)
 	if (z < 0 || z >= CHUNK_SIZE)
 		return AIR;
 
-	int i = 0;
+	i32 i = 0;
 	i += x;
 	i += z * CHUNK_SIZE;
 	i += y * CHUNK_SIZE * CHUNK_SIZE;
 
 	return chunk->blocks[i];
 }
+
+AABB chunk_aabb(Chunk *chunk)
+{
+	AABB aabb = { 0 };
+
+	// min
+	aabb.min[0] = chunk->pos[0] * CHUNK_SIZE;
+	aabb.min[1] = chunk->pos[1] * CHUNK_SIZE;
+	aabb.min[2] = chunk->pos[2] * CHUNK_SIZE;
+
+	// max
+	glm_vec3_adds(aabb.min, CHUNK_SIZE, aabb.max);
+
+	return aabb;
+}
diff --git a/src/cube.h b/src/cube.h
deleted file mode 100644
index fd071d0..0000000
--- a/src/cube.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include <cglm/cglm.h>
-
-static const vec3 CUBE[6][6] = {
-	{
-		// PX
-		{ 1, 1, 1 },
-		{ 1, 0, 1 },
-		{ 1, 0, 0 },
-		{ 1, 0, 0 },
-		{ 1, 1, 0 },
-		{ 1, 1, 1 },
-	},
-	{
-		// NX
-		{ 0, 1, 0 },
-		{ 0, 0, 0 },
-		{ 0, 0, 1 },
-		{ 0, 0, 1 },
-		{ 0, 1, 1 },
-		{ 0, 1, 0 },
-	},
-	{
-		// PY
-		{ 1, 1, 0 },
-		{ 0, 1, 0 },
-		{ 0, 1, 1 },
-		{ 0, 1, 1 },
-		{ 1, 1, 1 },
-		{ 1, 1, 0 },
-	},
-	{
-		// NY
-		{ 0, 0, 1 },
-		{ 0, 0, 0 },
-		{ 1, 0, 0 },
-		{ 1, 0, 0 },
-		{ 1, 0, 1 },
-		{ 0, 0, 1 },
-	},
-	{
-		// PZ
-		{ 0, 1, 1 },
-		{ 0, 0, 1 },
-		{ 1, 0, 1 },
-		{ 1, 0, 1 },
-		{ 1, 1, 1 },
-		{ 0, 1, 1 },
-	},
-	{
-		// NZ
-		{ 1, 1, 0 },
-		{ 1, 0, 0 },
-		{ 0, 0, 0 },
-		{ 0, 0, 0 },
-		{ 0, 1, 0 },
-		{ 1, 1, 0 },
-	},
-};
diff --git a/src/gl.h b/src/gl.h
new file mode 100644
index 0000000..58809c9
--- /dev/null
+++ b/src/gl.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <GL/gl.h>
+#include <cglm/cglm.h>
+
+#include "list.h"
+
+#define GL_OK	  0
+#define GL_ERROR  1
+#define GL_RESULT int
+
+#define MAX_VBOS 4
+
+typedef struct {
+	u32 vao;
+	u32 vbos[MAX_VBOS];
+	i32 vbos_count;
+	i32 vertex_count;
+} Mesh;
+
+void mesh_init(Mesh *mesh, u32 vertex_count);
+void mesh_store_float(Mesh *mesh, float *data, u32 count, u32 dimensions);
+void mesh_store_i32(Mesh *mesh, i32 *data, u32 count, u32 dimensions);
+void mesh_store_u8(Mesh *mesh, u8 *data, u32 count, u32 dimensions);
+void mesh_store_u32(Mesh *mesh, u32 *data, u32 count, u32 dimensions);
+void mesh_finish(void);
+void mesh_bind(Mesh *mesh);
+void mesh_unbind(Mesh *mesh);
+void mesh_draw(Mesh *mesh);
+void mesh_draw_instanced(Mesh *mesh, u32 count);
+void mesh_free(Mesh *mesh);
+
+typedef struct {
+	u32 id;
+	u32 len;
+} Uniform;
+
+void uniform_init(Uniform *uniform, u32 len);
+void uniform_store(Uniform *uniform, u32 offset, u32 len, void *data);
+void uniform_bind(Uniform *uniform, u32 binding);
+void uniform_unbind(u32 binding);
+void uniform_free(Uniform *uniform);
+
+typedef struct {
+	u32 program_id;
+	u32 vertex_id;
+	u32 fragment_id;
+	/* vertex attributes */
+	List attribute_names;
+	List attribute_locations;
+	/* uniforms */
+	List uniform_names;
+	List uniform_locations;
+	/* uniform blocks */
+	List uniform_block_names;
+	List uniform_block_indicies;
+} Shader;
+
+GL_RESULT shader_init(Shader *shader, const char *vertexFile, const char *fragmentFile);
+void shader_bind(Shader *shader);
+void shader_unbind(void);
+void shader_free(Shader *shader);
+
+i32 shader_attribute_location(Shader *shader, const char *name);
+i32 shader_uniform_location(Shader *shader, const char *name);
+i32 shader_uniform_block_index(Shader *shader, const char *name);
+
+void shader_load_float(Shader *shader, const char *name, float value);
+void shader_load_int(Shader *shader, const char *name, int value);
+void shader_load_vec3(Shader *shader, const char *name, vec3 value);
+void shader_load_ivec3(Shader *shader, const char *name, ivec3 value);
+void shader_load_mat4(Shader *shader, const char *name, mat4 value);
+void shader_load_ubo(Shader *shader, const char *name, u32 binding);
diff --git a/src/list.c b/src/list.c
index 0f00cdd..a9c6a2e 100644
--- a/src/list.c
+++ b/src/list.c
@@ -3,7 +3,7 @@
 
 #include "list.h"
 
-static void list_init(List *list, int elmSize)
+static void list_init(List *list, i32 elmSize)
 {
 	list->data = NULL;
 	list->capacity = 0;
@@ -11,27 +11,37 @@ static void list_init(List *list, int elmSize)
 	list->elmSize = elmSize;
 }
 
-void list_initf(List *list)
+void list_init_float(List *list)
 {
 	list_init(list, sizeof(float));
 }
 
-void list_initi(List *list)
+void list_init_i32(List *list)
 {
-	list_init(list, sizeof(int));
+	list_init(list, sizeof(i32));
 }
 
-void list_initu(List *list)
+void list_init_u8(List *list)
 {
-	list_init(list, sizeof(unsigned int));
+	list_init(list, sizeof(u8));
 }
 
-void list_initb(List *list)
+void list_init_u32(List *list)
 {
-	list_init(list, sizeof(unsigned char));
+	list_init(list, sizeof(u32));
 }
 
-static void list_push(List *list, const void *elm)
+void list_init_u64(List *list)
+{
+	list_init(list, sizeof(u64));
+}
+
+void list_init_string(List *list)
+{
+	list_init(list, sizeof(char *));
+}
+
+static void list_push(List *list, const void *restrict elm)
 {
 	if (list->len == list->capacity) {
 		list->capacity *= 2;
@@ -45,24 +55,34 @@ static void list_push(List *list, const void *elm)
 	list->len++;
 }
 
-void list_pushf(List *list, float f)
+void list_push_float(List *list, float f)
 {
 	list_push(list, &f);
 }
 
-void list_pushi(List *list, int i)
+void list_push_i32(List *list, i32 i)
 {
 	list_push(list, &i);
 }
 
-void list_pushu(List *list, unsigned int u)
+void list_push_u8(List *list, u8 b)
+{
+	list_push(list, &b);
+}
+
+void list_push_u32(List *list, u32 u)
 {
 	list_push(list, &u);
 }
 
-void list_pushb(List *list, unsigned char b)
+void list_push_u64(List *list, u64 u)
 {
-	list_push(list, &b);
+	list_push(list, &u);
+}
+
+void list_push_string(List *list, char *s)
+{
+	list_push(list, &s);
 }
 
 void list_free(List *list)
diff --git a/src/list.h b/src/list.h
index 6d2211b..a22f3da 100644
--- a/src/list.h
+++ b/src/list.h
@@ -1,26 +1,33 @@
 #pragma once
 
+#include "types.h"
+
 typedef struct {
 	union {
-		float *fdata;
-		int *idata;
-		unsigned int *udata;
-		unsigned char *bdata;
+		float *floats;
+		int *ints;
+		unsigned int *uints;
+		unsigned char *bytes;
+		char **strings;
 		void *data;
 	};
-	int len;
-	int capacity;
-	int elmSize;
+	u32 len;
+	u32 capacity;
+	u32 elmSize;
 } List;
 
-void list_initf(List *list);
-void list_initi(List *list);
-void list_initu(List *list);
-void list_initb(List *list);
+void list_init_float(List *list);
+void list_init_i32(List *list);
+void list_init_u8(List *list);
+void list_init_u32(List *list);
+void list_init_u64(List *list);
+void list_init_string(List *list);
 
-void list_pushf(List *list, float f);
-void list_pushi(List *list, int i);
-void list_pushu(List *list, unsigned int u);
-void list_pushb(List *list, unsigned char u);
+void list_push_float(List *list, float f);
+void list_push_i32(List *list, i32 i);
+void list_push_u8(List *list, u8 u);
+void list_push_u32(List *list, u32 u);
+void list_push_u64(List *list, u64 u);
+void list_push_string(List *list, char *s);
 
 void list_free(List *list);
diff --git a/src/main.c b/src/main.c
index 4ba34e5..ce01357 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,51 +1,118 @@
 #include <GLFW/glfw3.h>
+#include <threads.h>
 
 #include "voxel.h"
 #include "window.h"
-#include "shader.h"
-#include "mesh.h"
 
-int main(void)
+World world;
+Camera camera;
+
+void sleep(double seconds)
+{
+	struct timespec req, rem;
+	req.tv_sec = seconds;
+	req.tv_nsec = 0;
+
+	if (seconds < 0)
+		return;
+
+	while (thrd_sleep(&req, &rem) == thrd_error)
+		req = rem;
+}
+
+/// handles rendering
+VOXEL_RESULT render_main(void *)
+{
+	Renderer renderer;
+
+	if (window_init_gl() != VOXEL_OK)
+		return VOXEL_ERROR;
+
+	if (renderer_init(&renderer) != VOXEL_OK)
+		return VOXEL_ERROR;
+
+	while (!window_closed()) {
+		if (window.resize) {
+			glViewport(0, 0, window.width, window.height);
+			window.resize = false;
+		}
+
+		renderer_start(&renderer, &camera);
+		world_render(&world, &renderer);
+		renderer_stop(&renderer);
+
+		window_swap();
+	}
+
+	renderer_free(&renderer);
+	return VOXEL_OK;
+}
+
+#define TPS 20
+
+/// handles game logic
+VOXEL_RESULT logic_main(void *)
 {
-	Shader *shader;
-	Chunk *chunk;
-	Mesh mesh;
-	Camera camera;
-	mat4 proj_view;
+	double last_tick, next_tick;
+	last_tick = 0;
+	next_tick = 0;
 
-	if (window_init())
-		return 1;
+	while (!window_closed()) {
+		world_update(&world, &camera);
 
-	shader = shader_init("assets/vertex.glsl", "assets/fragment.glsl");
-	if (!shader)
-		return 1;
+		next_tick = last_tick + (1.0 / TPS);
+		sleep(next_tick - last_tick);
+		last_tick = next_tick;
+	}
 
-	chunk = chunk_init(0, 0, 0);
-	chunk_generate(chunk);
-	mesh = chunk_mesh(chunk);
+	return VOXEL_OK;
+}
 
-	camera = camera_init();
+/// handles user input
+VOXEL_RESULT input_main(void *)
+{
+	double last_tick, next_tick;
+	last_tick = 0;
+	next_tick = 0;
 
 	while (!window_closed()) {
 		window_update();
 
-		if (key_down(GLFW_KEY_ESCAPE))
+		if (key_down(GLFW_KEY_ESCAPE)) {
+			window.close = true;
 			break;
+		}
 
 		camera_update(&camera);
-		camera_proj_view(&camera, proj_view);
-
-		shader_bind(shader);
-		shader_load_mat4(0, proj_view);
-		mesh_bind(&mesh);
-		mesh_draw(&mesh);
-		mesh_unbind(&mesh);
-		shader_unbind();
 
-		// main game loop
-		window_swap();
+		next_tick = last_tick + (1.0 / TPS);
+		sleep(next_tick - last_tick);
+		last_tick = next_tick;
 	}
 
+	return VOXEL_OK;
+}
+
+VOXEL_RESULT main(void)
+{
+	thrd_t render_thread, logic_thread, input_thread;
+
+	if (window_init() != VOXEL_OK)
+		return VOXEL_ERROR;
+
+	camera_init(&camera);
+	world_init(&world, 0);
+
+	thrd_create(&logic_thread, logic_main, NULL);
+	thrd_create(&input_thread, input_main, NULL);
+	thrd_create(&render_thread, render_main, NULL);
+
+	thrd_join(logic_thread, NULL);
+	thrd_join(input_thread, NULL);
+	thrd_join(render_thread, NULL);
+
+	world_free(&world);
 	window_close();
-	return 0;
+
+	return VOXEL_OK;
 }
diff --git a/src/mesh.c b/src/mesh.c
index 8ee5ace..2ffe61b 100644
--- a/src/mesh.c
+++ b/src/mesh.c
@@ -1,8 +1,8 @@
 #include <GL/glew.h>
 
-#include "mesh.h"
+#include "gl.h"
 
-void mesh_init(Mesh *mesh, int vertex_count)
+void mesh_init(Mesh *mesh, u32 vertex_count)
 {
 	glGenVertexArrays(1, &mesh->vao);
 	mesh->vbos_count = 0;
@@ -10,7 +10,7 @@ void mesh_init(Mesh *mesh, int vertex_count)
 	glBindVertexArray(mesh->vao);
 }
 
-static void mesh_store(Mesh *mesh, void *data, int len, int dimensions, GLenum type)
+static void mesh_store(Mesh *mesh, void *data, u32 len, u32 dimensions, GLenum type)
 {
 	GLuint vbo;
 	GLint index = mesh->vbos_count;
@@ -25,24 +25,24 @@ static void mesh_store(Mesh *mesh, void *data, int len, int dimensions, GLenum t
 	mesh->vbos[mesh->vbos_count++] = vbo;
 }
 
-void mesh_storef(Mesh *mesh, float *data, int count, int dimensions)
+void mesh_store_float(Mesh *mesh, float *data, u32 count, u32 dimensions)
 {
 	mesh_store(mesh, data, count * sizeof(float), dimensions, GL_FLOAT);
 }
 
-void mesh_storei(Mesh *mesh, int *data, int count, int dimensions)
+void mesh_store_i32(Mesh *mesh, i32 *data, u32 count, u32 dimensions)
 {
-	mesh_store(mesh, data, count * sizeof(int), dimensions, GL_INT);
+	mesh_store(mesh, data, count * sizeof(i32), dimensions, GL_INT);
 }
 
-void mesh_storeu(Mesh *mesh, unsigned int *data, int count, int dimensions)
+void mesh_store_u8(Mesh *mesh, u8 *data, u32 count, u32 dimensions)
 {
-	mesh_store(mesh, data, count * sizeof(unsigned int), dimensions, GL_UNSIGNED_INT);
+	mesh_store(mesh, data, count * sizeof(u8), dimensions, GL_UNSIGNED_BYTE);
 }
 
-void mesh_storeb(Mesh *mesh, unsigned char *data, int count, int dimensions)
+void mesh_store_u32(Mesh *mesh, u32 *data, u32 count, u32 dimensions)
 {
-	mesh_store(mesh, data, count * sizeof(unsigned char), dimensions, GL_UNSIGNED_BYTE);
+	mesh_store(mesh, data, count * sizeof(u32), dimensions, GL_UNSIGNED_INT);
 }
 
 void mesh_finish(void)
@@ -69,7 +69,7 @@ void mesh_draw(Mesh *mesh)
 	glDrawArrays(GL_TRIANGLES, 0, mesh->vertex_count);
 }
 
-void mesh_draw_instanced(Mesh *mesh, int count)
+void mesh_draw_instanced(Mesh *mesh, u32 count)
 {
 	glDrawArraysInstanced(GL_TRIANGLES, 0, mesh->vertex_count, count);
 }
@@ -80,14 +80,32 @@ void mesh_free(Mesh *mesh)
 	glDeleteVertexArrays(1, &mesh->vao);
 }
 
-void uniform_init(Uniform *uniform, void *data, int len)
+void uniform_init(Uniform *uniform, u32 len)
 {
+	uniform->len = len;
 	glGenBuffers(1, &uniform->id);
 	glBindBuffer(GL_UNIFORM_BUFFER, uniform->id);
-	glBufferData(GL_UNIFORM_BUFFER, len, data, GL_STATIC_DRAW);
+	glBufferData(GL_UNIFORM_BUFFER, len, NULL, GL_DYNAMIC_DRAW);
 	glBindBuffer(GL_UNIFORM_BUFFER, 0);
 }
 
+void uniform_store(Uniform *uniform, u32 offset, u32 len, void *data)
+{
+	glBindBuffer(GL_UNIFORM_BUFFER, uniform->id);
+	glBufferSubData(GL_UNIFORM_BUFFER, offset, len, data);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+}
+
+void uniform_bind(Uniform *uniform, u32 binding)
+{
+	glBindBufferBase(GL_UNIFORM_BUFFER, binding, uniform->id);
+}
+
+void uniform_unbind(u32 binding)
+{
+	glBindBufferBase(GL_UNIFORM_BUFFER, binding, 0);
+}
+
 void uniform_free(Uniform *uniform)
 {
 	glDeleteBuffers(1, &uniform->id);
diff --git a/src/mesh.h b/src/mesh.h
deleted file mode 100644
index 451803e..0000000
--- a/src/mesh.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <GL/gl.h>
-
-#define MAX_VBOS 4
-
-typedef struct {
-	GLuint vao;
-	GLuint vbos[MAX_VBOS];
-	int vbos_count;
-	int vertex_count;
-} Mesh;
-
-void mesh_init(Mesh *mesh, int vertex_count);
-void mesh_storef(Mesh *mesh, float *data, int count, int dimensions);
-void mesh_storei(Mesh *mesh, int *data, int count, int dimensions);
-void mesh_storeu(Mesh *mesh, unsigned int *data, int count, int dimensions);
-void mesh_storeb(Mesh *mesh, unsigned char *data, int count, int dimensions);
-void mesh_finish(void);
-void mesh_bind(Mesh *mesh);
-void mesh_unbind(Mesh *mesh);
-void mesh_draw(Mesh *mesh);
-void mesh_draw_instanced(Mesh *mesh, int count);
-void mesh_free(Mesh *mesh);
-
-typedef struct {
-	GLuint id;
-} Uniform;
-
-void uniform_init(Uniform *uniform, void *data, int len);
-void uniform_free(Uniform *uniform);
diff --git a/src/render.c b/src/render.c
new file mode 100644
index 0000000..b70832b
--- /dev/null
+++ b/src/render.c
@@ -0,0 +1,79 @@
+#include <cglm/cglm.h>
+
+#include "voxel.h"
+#include "gl.h"
+
+#define MATS_UBO_BINDING 1
+#define FACE_UBO_BINDING 2
+
+VOXEL_RESULT renderer_init(Renderer *renderer)
+{
+	// load quad mesh
+	float quad_verts[] = {
+		0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0,
+	};
+	mesh_init(&renderer->quad, 6);
+	mesh_store_float(&renderer->quad, quad_verts, 6 * 3, 3);
+	mesh_finish();
+
+	// load shader
+	if (shader_init(&renderer->shader, "assets/vertex.glsl", "assets/fragment.glsl") !=
+		GL_OK)
+		return VOXEL_ERROR;
+
+	// load matricies uniform
+	uniform_init(&renderer->matrices, sizeof(mat4) * 2);
+	uniform_bind(&renderer->matrices, 1);
+	shader_load_ubo(&renderer->shader, "Matrices", MATS_UBO_BINDING);
+	shader_load_ubo(&renderer->shader, "Face", FACE_UBO_BINDING);
+
+	return VOXEL_OK;
+}
+
+void renderer_start(Renderer *renderer, Camera *camera)
+{
+	mat4 proj, view;
+
+	camera_proj(camera, proj);
+	camera_view(camera, view);
+	uniform_store(&renderer->matrices, 0, sizeof(mat4), proj);
+	uniform_store(&renderer->matrices, sizeof(mat4), sizeof(mat4), view);
+
+	shader_bind(&renderer->shader);
+	mesh_bind(&renderer->quad);
+
+	renderer->frustum = camera->frustum;
+}
+
+void renderer_draw(Renderer *renderer, Chunk *chunk)
+{
+	Uniform mesh;
+	AABB aabb;
+
+	if (chunk->has_mesh == false)
+		return;
+
+	aabb = chunk_aabb(chunk);
+	if (!aabb_in_frustum(&aabb, &renderer->frustum))
+		return;
+
+	mesh = chunk->mesh;
+	uniform_bind(&mesh, FACE_UBO_BINDING);
+	shader_load_ivec3(&renderer->shader, "chunk_position", chunk->pos);
+	mesh_draw_instanced(&renderer->quad, mesh.len / sizeof(u64));
+	uniform_unbind(FACE_UBO_BINDING);
+}
+
+void renderer_stop(Renderer *renderer)
+{
+	mesh_unbind(&renderer->quad);
+	shader_unbind();
+}
+
+void renderer_free(Renderer *renderer)
+{
+	uniform_unbind(MATS_UBO_BINDING);
+	uniform_free(&renderer->matrices);
+	shader_free(&renderer->shader);
+	mesh_free(&renderer->quad);
+}
diff --git a/src/shader.c b/src/shader.c
index 26bb92b..abb62a2 100644
--- a/src/shader.c
+++ b/src/shader.c
@@ -1,60 +1,28 @@
 #include <GL/glew.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "voxel.h"
-#include "shader.h"
+#include "utils.h"
+#include "list.h"
+#include "gl.h"
 
-static GLint current_program;
-
-static char *read_file(const char *filename)
+static void print_shader_log(const char *filename, u32 id)
 {
-	FILE *file;
-	long length, read;
-	char *buffer;
-
-	file = fopen(filename, "r");
-	if (file == NULL) {
-		ERROR("could not read file: %s", filename);
-		return NULL;
-	}
-
-	fseek(file, 0, SEEK_END);
-	length = ftell(file);
-	fseek(file, 0, SEEK_SET);
-
-	buffer = malloc(length + 1);
-	read = fread(buffer, 1, length, file);
-	buffer[length] = 0;
-
-	if (read < length) {
-		ERROR("could not read file: %s", filename);
-		free(buffer);
-		return NULL;
-	}
-
-	fclose(file);
-	return buffer;
-}
-
-static void print_shader_log(const char *filename, GLuint id)
-{
-	GLint log_len;
+	i32 log_len;
 	char *log;
 	glGetShaderiv(id, GL_INFO_LOG_LENGTH, &log_len);
-	log = malloc(log_len + 1);
+	log = xalloc(log_len + 1);
 	glGetShaderInfoLog(id, log_len, &log_len, log);
 	log[log_len] = 0;
 	ERROR("failed to compile shader: '%s'\n%s", filename, log);
 	free(log);
 }
 
-static int compile_shader(GLuint *out, const char *filename, const char *code, GLenum type)
+static GL_RESULT compile_shader(u32 *out, const char *filename, const char *code, u32 type)
 {
-	GLuint id;
-	GLint status;
-	int code_len;
+	u32 id;
+	i32 status, code_len;
 
 	id = glCreateShader(type);
 	code_len = strlen(code);
@@ -64,41 +32,112 @@ static int compile_shader(GLuint *out, const char *filename, const char *code, G
 	if (status == GL_FALSE) {
 		print_shader_log(filename, id);
 		glDeleteShader(id);
-		return 1;
+		return GL_ERROR;
 	}
 
 	*out = id;
-	return 0;
+	return GL_OK;
 }
 
-static void parse_bind_attributes(Shader *shader, char *code)
+static void locate_attributes(Shader *shader)
 {
-	char *line, *last_line;
-	char *token, *last_token;
-	int attribute = 0;
+	i32 count, max_len;
+	List names, locations;
+
+	list_init_string(&names);
+	list_init_i32(&locations);
+
+	glGetProgramiv(shader->program_id, GL_ACTIVE_ATTRIBUTES, &count);
+	glGetProgramiv(shader->program_id, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
+	DEBUG("shader %d has %d attributes", shader->program_id, count);
 
-	line = strtok_r(code, "\n", &last_line);
-	for (; line != NULL; line = strtok_r(NULL, "\n", &last_line)) {
-		token = strtok_r(line, " \t", &last_token);
-		if (strcmp(token, "in") != 0)
-			continue;
+	for (i32 i = 0; i < count; i++) {
+		i32 size, location;
+		u32 type;
+		char *name;
 
-		token = strtok_r(NULL, " \t", &last_token);
-		token = strtok_r(NULL, " \t", &last_token);
-		*strchr(token, ';') = 0;
+		name = xalloc(max_len + 1);
+		glGetActiveAttrib(shader->program_id, i, max_len, NULL, &size, &type, name);
 
-		glBindAttribLocation(shader->program_id, attribute, token);
-		attribute++;
+		location = glGetAttribLocation(shader->program_id, name);
+		DEBUG("shader %d located attribute %s at location %d", shader->program_id, name,
+			  location);
+
+		list_push_string(&names, name);
+		list_push_i32(&locations, location);
 	}
+
+	shader->attribute_names = names;
+	shader->attribute_locations = locations;
 }
 
-Shader *shader_init(const char *vertex_file, const char *fragment_file)
+static void locate_uniforms(Shader *shader)
 {
-	Shader *shader;
-	char *vertex, *fragment;
+	i32 count, max_len;
+	List names, locations;
+
+	list_init_string(&names);
+	list_init_i32(&locations);
+
+	glGetProgramiv(shader->program_id, GL_ACTIVE_UNIFORMS, &count);
+	glGetProgramiv(shader->program_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_len);
+	DEBUG("shader %d has %d uniforms", shader->program_id, count);
+
+	for (i32 i = 0; i < count; i++) {
+		i32 size, location;
+		u32 type;
+		char *name;
+
+		name = xalloc(max_len + 1);
+		glGetActiveUniform(shader->program_id, i, max_len, NULL, &size, &type, name);
+
+		location = glGetUniformLocation(shader->program_id, name);
+		DEBUG("shader %d located uniform %s at location %d", shader->program_id, name,
+			  location);
+
+		list_push_string(&names, name);
+		list_push_i32(&locations, location);
+	}
+
+	shader->uniform_names = names;
+	shader->uniform_locations = locations;
+}
+
+static void locate_uniform_blocks(Shader *shader)
+{
+	i32 count;
+	List names, indicies;
+
+	list_init_string(&names);
+	list_init_i32(&indicies);
+
+	glGetProgramiv(shader->program_id, GL_ACTIVE_UNIFORM_BLOCKS, &count);
+	DEBUG("shader %d has %d uniform blocks", shader->program_id, count);
+
+	for (i32 i = 0; i < count; i++) {
+		i32 index, name_len;
+		char *name;
 
-	shader = malloc(sizeof(Shader));
-	memset(shader, 0, sizeof(Shader));
+		glGetActiveUniformBlockiv(shader->program_id, i, GL_UNIFORM_BLOCK_NAME_LENGTH,
+								  &name_len);
+		name = xalloc(name_len + 1);
+		glGetActiveUniformBlockName(shader->program_id, i, name_len, NULL, name);
+
+		index = glGetUniformBlockIndex(shader->program_id, name);
+		DEBUG("shader %d located uniform block %s at index %d", shader->program_id, name,
+			  index);
+
+		list_push_string(&names, name);
+		list_push_i32(&indicies, index);
+	}
+
+	shader->uniform_block_names = names;
+	shader->uniform_block_indicies = indicies;
+}
+
+GL_RESULT shader_init(Shader *shader, const char *vertex_file, const char *fragment_file)
+{
+	char *vertex, *fragment;
 
 	// read shader code from file
 	vertex = read_file(vertex_file);
@@ -109,23 +148,25 @@ Shader *shader_init(const char *vertex_file, const char *fragment_file)
 	// compile shaders
 	if (compile_shader(&shader->vertex_id, vertex_file, vertex, GL_VERTEX_SHADER))
 		goto failure;
-	if (compile_shader(&shader->fragment_id, fragment_file, fragment,
-			   GL_FRAGMENT_SHADER))
+	if (compile_shader(&shader->fragment_id, fragment_file, fragment, GL_FRAGMENT_SHADER))
 		goto failure;
 
 	shader->program_id = glCreateProgram();
 	glAttachShader(shader->program_id, shader->vertex_id);
 	glAttachShader(shader->program_id, shader->fragment_id);
-	parse_bind_attributes(shader, vertex);
 	glLinkProgram(shader->program_id);
 	glValidateProgram(shader->program_id);
 
+	locate_attributes(shader);
+	locate_uniforms(shader);
+	locate_uniform_blocks(shader);
+
 	if (vertex)
 		free(vertex);
 	if (fragment)
 		free(fragment);
 
-	return shader;
+	return GL_OK;
 
 failure:
 	if (vertex)
@@ -133,12 +174,11 @@ failure:
 	if (fragment)
 		free(fragment);
 	free(shader);
-	return NULL;
+	return GL_ERROR;
 }
 
 void shader_bind(Shader *shader)
 {
-	current_program = shader->program_id;
 	glEnable(GL_DEPTH_TEST);
 	glEnable(GL_CULL_FACE);
 	glCullFace(GL_BACK);
@@ -149,7 +189,6 @@ void shader_bind(Shader *shader)
 
 void shader_unbind(void)
 {
-	current_program = 0;
 	glDisable(GL_CULL_FACE);
 	glUseProgram(0);
 }
@@ -161,36 +200,85 @@ void shader_free(Shader *shader)
 	glDeleteShader(shader->vertex_id);
 	glDeleteShader(shader->fragment_id);
 	glDeleteProgram(shader->program_id);
-	free(shader);
+	for (u32 i = 0; i < shader->attribute_names.len; i++)
+		free(shader->attribute_names.strings[i]);
+	list_free(&shader->attribute_names);
+	list_free(&shader->attribute_locations);
+	for (u32 i = 0; i < shader->uniform_names.len; i++)
+		free(shader->uniform_names.strings[i]);
+	list_free(&shader->uniform_names);
+	list_free(&shader->uniform_locations);
+	for (u32 i = 0; i < shader->uniform_block_names.len; i++)
+		free(shader->uniform_block_names.strings[i]);
+	list_free(&shader->uniform_block_names);
+	list_free(&shader->uniform_block_indicies);
 }
 
-GLint shader_uniform_location(Shader *shader, const char *name)
+int shader_attribute_location(Shader *shader, const char *name)
 {
-	return glGetUniformLocation(shader->program_id, name);
+	for (u32 i = 0; i < shader->attribute_names.len; i++) {
+		const char *attribute = shader->attribute_names.strings[i];
+		if (strcmp(attribute, name) == 0)
+			return shader->attribute_locations.ints[i];
+	}
+	WARN("unknown attribute '%s'", name);
+	return -1;
 }
 
-void shader_load_float(GLint location, float value)
+int shader_uniform_location(Shader *shader, const char *name)
 {
+	for (u32 i = 0; i < shader->uniform_names.len; i++) {
+		const char *uniform = shader->uniform_names.strings[i];
+		if (strcmp(uniform, name) == 0)
+			return shader->uniform_locations.ints[i];
+	}
+	WARN("unknown uniform '%s'", name);
+	return -1;
+}
+
+int shader_uniform_block_index(Shader *shader, const char *name)
+{
+	for (u32 i = 0; i < shader->uniform_block_names.len; i++) {
+		const char *uniform_block = shader->uniform_block_names.strings[i];
+		if (strcmp(uniform_block, name) == 0)
+			return shader->uniform_block_indicies.ints[i];
+	}
+	WARN("unknown uniform block '%s'", name);
+	return -1;
+}
+
+void shader_load_float(Shader *shader, const char *name, float value)
+{
+	int location = shader_uniform_location(shader, name);
 	glUniform1f(location, value);
 }
 
-void shader_load_int(GLint location, int value)
+void shader_load_int(Shader *shader, const char *name, int value)
 {
+	int location = shader_uniform_location(shader, name);
 	glUniform1i(location, value);
 }
 
-void shader_load_vec3(GLint location, vec3 value)
+void shader_load_vec3(Shader *shader, const char *name, vec3 value)
 {
+	int location = shader_uniform_location(shader, name);
 	glUniform3f(location, value[0], value[1], value[2]);
 }
 
-void shader_load_mat4(GLint location, mat4 value)
+void shader_load_ivec3(Shader *shader, const char *name, ivec3 value)
+{
+	int location = shader_uniform_location(shader, name);
+	glUniform3i(location, value[0], value[1], value[2]);
+}
+
+void shader_load_mat4(Shader *shader, const char *name, mat4 value)
 {
+	int location = shader_uniform_location(shader, name);
 	glUniformMatrix4fv(location, 1, GL_FALSE, (float *)value);
 }
 
-void shader_load_ubo(GLint location, GLuint index, Uniform *uniform)
+void shader_load_ubo(Shader *shader, const char *name, u32 binding)
 {
-	glUniformBlockBinding(current_program, index, location);
-	glBindBufferBase(GL_UNIFORM_BUFFER, location, uniform->id);
+	int index = shader_uniform_block_index(shader, name);
+	glUniformBlockBinding(shader->program_id, index, binding);
 }
diff --git a/src/shader.h b/src/shader.h
deleted file mode 100644
index e6f794e..0000000
--- a/src/shader.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <GL/gl.h>
-#include <cglm/cglm.h>
-
-#include "mesh.h"
-
-typedef struct {
-	GLuint program_id;
-	GLuint vertex_id;
-	GLuint fragment_id;
-	int attributes;
-} Shader;
-
-Shader *shader_init(const char *vertexFile, const char *fragmentFile);
-void shader_bind(Shader *shader);
-void shader_unbind(void);
-void shader_free(Shader *shader);
-
-GLint shader_uniform_location(Shader *shader, const char *name);
-void shader_load_float(GLint location, float value);
-void shader_load_int(GLint location, int value);
-void shader_load_vec3(GLint location, vec3 value);
-void shader_load_mat4(GLint location, mat4 value);
-void shader_load_ubo(GLint location, GLuint index, Uniform *uniform);
diff --git a/src/types.h b/src/types.h
new file mode 100644
index 0000000..739828c
--- /dev/null
+++ b/src/types.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <sys/types.h>
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef unsigned long long u64;
+typedef size_t usize;
+
+typedef signed char i8;
+typedef signed short i16;
+typedef signed int i32;
+typedef signed long long i64;
+typedef ssize_t isize;
diff --git a/src/utils.c b/src/utils.c
new file mode 100644
index 0000000..fdc6aea
--- /dev/null
+++ b/src/utils.c
@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "types.h"
+#include "voxel.h"
+#include "utils.h"
+
+char *read_file(const char *filename)
+{
+	FILE *file;
+	long length, read;
+	char *buffer;
+
+	file = fopen(filename, "r");
+	if (file == NULL) {
+		ERROR("could not read file: %s", filename);
+		return NULL;
+	}
+
+	fseek(file, 0, SEEK_END);
+	length = ftell(file);
+	fseek(file, 0, SEEK_SET);
+
+	buffer = malloc(length + 1);
+	read = fread(buffer, 1, length, file);
+	buffer[length] = 0;
+
+	if (read < length) {
+		ERROR("could not read file: %s", filename);
+		free(buffer);
+		return NULL;
+	}
+
+	fclose(file);
+	return buffer;
+}
+
+_Noreturn void die(void)
+{
+	exit(1);
+}
+
+void *xalloc(usize size)
+{
+	void *ptr = malloc(size);
+	if (ptr == NULL && size != 0)
+		die();
+	return ptr;
+}
+
+void *xrealloc(void *ptr, usize size)
+{
+	ptr = realloc(ptr, size);
+	if (ptr == NULL && size != 0)
+		die();
+	return ptr;
+}
+
+void *xzalloc(usize size)
+{
+	void *ptr = xalloc(size);
+	memset(ptr, 0, size);
+	return ptr;
+}
diff --git a/src/utils.h b/src/utils.h
new file mode 100644
index 0000000..d8feef4
--- /dev/null
+++ b/src/utils.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "types.h"
+
+char *read_file(const char *filename);
+
+_Noreturn void die(void);
+void *xalloc(usize size);
+void *xrealloc(void *ptr, usize size);
+void *xzalloc(usize size);
diff --git a/src/voxel.h b/src/voxel.h
index 9a3b237..12480b2 100644
--- a/src/voxel.h
+++ b/src/voxel.h
@@ -1,12 +1,13 @@
 #pragma once
 
 #include <cglm/cglm.h>
-#include <stdio.h>
+#include <threads.h>
 
-#include "mesh.h"
+#include "types.h"
+#include "gl.h"
 
-#define LOG(level, ...)              \
-	do {                         \
+#define LOG(level, ...)      \
+	do {                     \
 		printf("%s", level); \
 		printf(__VA_ARGS__); \
 		printf("\n");        \
@@ -15,6 +16,13 @@
 #define INFO(...)  LOG("INFO  ", __VA_ARGS__)
 #define WARN(...)  LOG("WARN  ", __VA_ARGS__)
 #define ERROR(...) LOG("ERROR ", __VA_ARGS__)
+#define DEBUG(...) LOG("DEBUG ", __VA_ARGS__)
+
+#define VOXEL_OK	 0
+#define VOXEL_ERROR	 1
+#define VOXEL_TRUE	 0
+#define VOXEL_FALSE	 1
+#define VOXEL_RESULT int
 
 typedef enum : char {
 	POS_X = 0,
@@ -25,24 +33,61 @@ typedef enum : char {
 	NEG_Z = 5,
 } Face;
 
-typedef enum : char { AIR = 0, DIRT } Block;
+typedef enum : char { AIR = 0, A, B, C, D } Block;
+
+#define CHUNK_SIZE	 16
+#define CHUNK_BLOCKS CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE
+
+#define LOCAL_POS(n)		  (((n) % CHUNK_SIZE + CHUNK_SIZE) % CHUNK_SIZE)
+#define LOCAL_VEC(gx, gy, gz) { LOCAL_POS(gx), LOCAL_POS(gy), LOCAL_POS(gz) }
+#define LOCAL_VEC_V(vec)	  LOCAL_VEC((int)(vec)[0], (int)(vec)[1], (int)(vec)[2])
+
+#define CHUNK_POS(n)		  (((n) - LOCAL_POS(n)) / CHUNK_SIZE)
+#define CHUNK_VEC(gx, gy, gz) { CHUNK_POS(gx), CHUNK_POS(gy), CHUNK_POS(gz) }
+#define CHUNK_VEC_V(vec)	  CHUNK_VEC((int)(vec)[0], (int)(vec)[1], (int)(vec)[2])
 
-#define CHUNK_SIZE 32
+typedef enum chunk_state {
+	CHUNK_NEW = 0,
+	CHUNK_GENERATING,
+	CHUNK_GENERATED,
+	CHUNK_MESHING,
+	CHUNK_MESHED,
+} ChunkState;
 
-typedef struct {
-	int x;
-	int y;
-	int z;
-	Block blocks[CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE];
+typedef struct chunk {
+	ivec3 pos;
+	Block *blocks;
+	_Atomic ChunkState state;
+	/* cached mesh */
+	_Atomic bool has_mesh;
+	Uniform mesh;
 } Chunk;
 
-Chunk *chunk_init(int x, int y, int z);
+void chunk_init(Chunk *chunk, i32 cx, i32 cy, i32 cz);
 void chunk_free(Chunk *chunk);
-void chunk_generate(Chunk *chunk);
-Mesh chunk_mesh(Chunk *chunk);
-Block chunk_at(Chunk *chunk, int x, int y, int z);
+void chunk_generate(Chunk *chunk, i32 seed);
+Block chunk_at(Chunk *chunk, i32 lx, i32 ly, i32 lz);
 
-typedef struct {
+typedef vec4 Plane;
+typedef struct frustum {
+	Plane left;
+	Plane right;
+	Plane bottom;
+	Plane top;
+	Plane near;
+	Plane far;
+} Frustum;
+
+typedef struct aabb {
+	vec3 min;
+	vec3 max;
+} AABB;
+
+bool aabb_in_plane(AABB *aabb, Plane plane);
+bool aabb_in_frustum(AABB *aabb, Frustum *frustum);
+AABB chunk_aabb(Chunk *chunk);
+
+typedef struct camera {
 	vec3 position;
 	vec3 rotation;
 	int fov;
@@ -50,10 +95,55 @@ typedef struct {
 	float far;
 	float look_speed;
 	float move_speed;
+	Frustum frustum;
 } Camera;
 
-Camera camera_init(void);
+void camera_init(Camera *camera);
 void camera_proj(Camera *camera, mat4 proj);
 void camera_view(Camera *camera, mat4 view);
 void camera_proj_view(Camera *camera, mat4 proj_view);
 void camera_update(Camera *camera);
+Frustum camera_frustum(Camera *camera);
+
+typedef struct renderer {
+	Mesh quad;
+	Shader shader;
+	Uniform matrices;
+	Frustum frustum;
+} Renderer;
+
+VOXEL_RESULT renderer_init(Renderer *renderer);
+void renderer_start(Renderer *renderer, Camera *camera);
+void renderer_draw(Renderer *renderer, Chunk *chunk);
+void renderer_stop(Renderer *renderer);
+void renderer_free(Renderer *renderer);
+
+#define RENDER_DISTANCE 10
+
+typedef struct rc_chunk {
+	Chunk chunk;
+	_Atomic u32 rc;
+} RcChunk;
+
+void rcchunk_drop(RcChunk *chunk);
+
+typedef i32 seed_t;
+
+typedef struct world {
+	seed_t seed;
+	bool loaded;
+	ivec3 center;
+	RcChunk **chunks;
+	mtx_t lock;
+} World;
+
+void world_init(World *world, seed_t seed);
+void world_lock(World *world);
+void world_unlock(World *world);
+void world_free(World *world);
+void world_update(World *world, Camera *camera);
+void world_render(World *world, Renderer *renderer);
+RcChunk *world_get_chunk(World *world, i32 cx, i32 cy, i32 cz);
+bool world_is_generated(World *world, i32 cx, i32 cy, i32 cz);
+Block world_get_block(World *world, i32 gx, i32 gy, i32 gz);
+void chunk_mesh(Chunk *chunk, World *world);
diff --git a/src/window.c b/src/window.c
index c7e83c6..559dcc2 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1,14 +1,15 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <string.h>
+#include <threads.h>
 
 #include "voxel.h"
 #include "window.h"
 
 Window window;
-double delta_time;
+_Atomic double delta_time;
 
-static void key_callback(GLFWwindow *, int key, int, int action, int)
+static void key_callback(GLFWwindow *, i32 key, i32, i32 action, i32)
 {
 	switch (action) {
 	case GLFW_PRESS:
@@ -29,7 +30,7 @@ static void mouse_move_callback(GLFWwindow *, double xpos, double ypos)
 	window.mouse_y = ypos;
 }
 
-static void mouse_button_callback(GLFWwindow *, int button, int action, int)
+static void mouse_button_callback(GLFWwindow *, i32 button, i32 action, i32)
 {
 	switch (action) {
 	case GLFW_PRESS:
@@ -42,59 +43,69 @@ static void mouse_button_callback(GLFWwindow *, int button, int action, int)
 	}
 }
 
-static void framebuffer_callback(GLFWwindow *, int width, int height)
+static void framebuffer_callback(GLFWwindow *, i32 width, i32 height)
 {
 	window.width = width;
 	window.height = height;
-	glViewport(0, 0, width, height);
+	window.resize = true;
 }
 
-int window_init(void)
+VOXEL_RESULT window_init(void)
 {
 	if (glfwInit() == GLFW_FALSE) {
 		ERROR("GLFW failed to initalize");
-		return 1;
+		return VOXEL_ERROR;
 	}
 
 	memset(&window, 0, sizeof(Window));
 	delta_time = 0;
 
 	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
 	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 
-	window.monitor = glfwGetPrimaryMonitor();
-	window.window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE,
-					 window.monitor, NULL);
+	window.window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE, NULL, NULL);
 	if (window.window == NULL) {
 		ERROR("failed to create window");
-		return 1;
+		return VOXEL_ERROR;
 	}
 
+	glfwSetKeyCallback(window.window, key_callback);
+	glfwSetCursorPosCallback(window.window, mouse_move_callback);
+	glfwSetMouseButtonCallback(window.window, mouse_button_callback);
+	glfwSetFramebufferSizeCallback(window.window, framebuffer_callback);
+
+	mtx_init(&window.lock, mtx_plain);
+
+	return VOXEL_OK;
+}
+
+VOXEL_RESULT window_init_gl(void)
+{
 	glfwMakeContextCurrent(window.window);
+
+#ifndef USE_VSYNC
 	glfwSwapInterval(0);
+#endif
 
 	glewExperimental = GL_TRUE;
 	if (glewInit() != GLEW_OK) {
 		ERROR("GLEW failed to initalize");
-		return 1;
+		return VOXEL_ERROR;
 	}
 
-	glfwSetKeyCallback(window.window, key_callback);
-	glfwSetCursorPosCallback(window.window, mouse_move_callback);
-	glfwSetMouseButtonCallback(window.window, mouse_button_callback);
-	glfwSetFramebufferSizeCallback(window.window, framebuffer_callback);
-
-	return 0;
+	return VOXEL_OK;
 }
 
 bool window_closed(void)
 {
-	return glfwWindowShouldClose(window.window) == GLFW_TRUE;
+	return window.close || glfwWindowShouldClose(window.window) == GLFW_TRUE;
 }
 
 void window_update(void)
 {
+	mtx_lock(&window.lock);
+
 	// reset "pressed"
 	memset(&window.key_pressed, 0, sizeof(window.key_pressed));
 	memset(&window.btn_pressed, 0, sizeof(window.btn_pressed));
@@ -110,6 +121,8 @@ void window_update(void)
 		ERROR("OpenGL error: %d", error);
 
 	glfwPollEvents();
+
+	mtx_unlock(&window.lock);
 }
 
 void window_swap(void)
@@ -119,29 +132,44 @@ void window_swap(void)
 
 void window_close(void)
 {
+	mtx_lock(&window.lock);
 	glfwDestroyWindow(window.window);
 	glfwTerminate();
+	mtx_destroy(&window.lock);
 }
 
-int window_grab_cursor(void);
-int window_release_cursor(void);
-
-bool key_down(int key)
+bool key_down(i32 key)
 {
-	return window.key_down[key];
+	bool down;
+	mtx_lock(&window.lock);
+	down = window.key_down[key];
+	mtx_unlock(&window.lock);
+	return down;
 }
 
-bool key_pressed(int key)
+bool key_pressed(i32 key)
 {
-	return window.key_pressed[key];
+	bool pressed;
+	mtx_lock(&window.lock);
+	pressed = window.key_pressed[key];
+	mtx_unlock(&window.lock);
+	return pressed;
 }
 
-bool btn_down(int btn)
+bool btn_down(i32 btn)
 {
-	return window.btn_down[btn];
+	bool down;
+	mtx_lock(&window.lock);
+	down = window.btn_down[btn];
+	mtx_unlock(&window.lock);
+	return down;
 }
 
-bool btn_pressed(int btn)
+bool btn_pressed(i32 btn)
 {
-	return window.btn_pressed[btn];
+	bool pressed;
+	mtx_lock(&window.lock);
+	pressed = window.btn_pressed[btn];
+	mtx_unlock(&window.lock);
+	return pressed;
 }
diff --git a/src/window.h b/src/window.h
index 3690781..5fc3197 100644
--- a/src/window.h
+++ b/src/window.h
@@ -1,6 +1,9 @@
 #pragma once
 
 #include <GLFW/glfw3.h>
+#include <threads.h>
+
+#include "voxel.h"
 
 #define WINDOW_WIDTH  640
 #define WINDOW_HEIGHT 480
@@ -8,8 +11,8 @@
 
 typedef struct {
 	// screen size
-	int width;
-	int height;
+	u32 width;
+	u32 height;
 	// input
 	bool key_down[GLFW_KEY_LAST];
 	bool key_pressed[GLFW_KEY_LAST];
@@ -24,23 +27,25 @@ typedef struct {
 	double last_time;
 	// glfw
 	GLFWwindow *window;
-	GLFWmonitor *monitor;
+	// sync
+	mtx_t lock;
+	// flags
+	_Atomic bool close;
+	_Atomic bool resize;
 } Window;
 
 extern Window window;
-extern double delta_time;
+extern _Atomic double delta_time;
 
-int window_init(void);
+VOXEL_RESULT window_init(void);
+VOXEL_RESULT window_init_gl(void);
 bool window_closed(void);
 void window_update(void);
 void window_swap(void);
 void window_close(void);
 
-int window_grab_cursor(void);
-int window_release_cursor(void);
-
-bool key_down(int key);
-bool key_pressed(int key);
+bool key_down(i32 key);
+bool key_pressed(i32 key);
 
-bool btn_down(int button);
-bool btn_pressed(int button);
+bool btn_down(i32 button);
+bool btn_pressed(i32 button);
diff --git a/src/world.c b/src/world.c
new file mode 100644
index 0000000..a53055d
--- /dev/null
+++ b/src/world.c
@@ -0,0 +1,234 @@
+#include <cglm/cglm.h>
+#include <threads.h>
+
+#include "utils.h"
+#include "voxel.h"
+
+static RcChunk **world_get_chunk_entry(World *world, int cx, int cy, int cz)
+{
+	int side = RENDER_DISTANCE * 2 + 1;
+
+	ivec3 min, max;
+	glm_ivec3_subs(world->center, RENDER_DISTANCE, min);
+	glm_ivec3_adds(world->center, RENDER_DISTANCE, max);
+
+	if (cx < min[0] || cy < min[1] || cz < min[2])
+		return NULL;
+
+	if (cx > max[0] || cy > max[1] || cz > max[2])
+		return NULL;
+
+	int index = 0;
+	index += ((cx % side + side) % side);
+	index += ((cy % side + side) % side) * side;
+	index += ((cz % side + side) % side) * side * side;
+
+	return &world->chunks[index];
+}
+
+static void world_mark_chunk_for_update(World *world, int cx, int cy, int cz)
+{
+	RcChunk **entry, *inner;
+
+	entry = world_get_chunk_entry(world, cx, cy, cz);
+	if (entry == NULL)
+		return;
+
+	inner = *entry;
+	if (inner == NULL)
+		return;
+
+	if (inner->chunk.state >= CHUNK_MESHED)
+		inner->chunk.state = CHUNK_GENERATED;
+}
+
+static void world_reload_chunk(World *world, int cx, int cy, int cz)
+{
+	ivec3 pos = { cx, cy, cz };
+	RcChunk **entry, *inner;
+
+	entry = world_get_chunk_entry(world, cx, cy, cz);
+	if (entry == NULL)
+		return;
+
+	inner = *entry;
+	if (inner != NULL) {
+		if (glm_ivec3_eqv(inner->chunk.pos, pos)) {
+			return;
+		} else {
+			*entry = NULL;
+			world_lock(world);
+			rcchunk_drop(inner);
+			world_unlock(world);
+		}
+	}
+
+	inner = xalloc(sizeof(RcChunk));
+	inner->rc = 1;
+	chunk_init(&inner->chunk, cx, cy, cz);
+	chunk_generate(&inner->chunk, world->seed);
+	*entry = inner;
+
+	// mark neighboring chunks as mesh update needed
+	world_mark_chunk_for_update(world, cx - 1, cy, cz);
+	world_mark_chunk_for_update(world, cx + 1, cy, cz);
+	world_mark_chunk_for_update(world, cx, cy - 1, cz);
+	world_mark_chunk_for_update(world, cx, cy + 1, cz);
+	world_mark_chunk_for_update(world, cx, cy, cz - 1);
+	world_mark_chunk_for_update(world, cx, cy, cz + 1);
+}
+
+static void world_reload_chunks(World *world)
+{
+	ivec3 min, max;
+	glm_ivec3_subs(world->center, RENDER_DISTANCE, min);
+	glm_ivec3_adds(world->center, RENDER_DISTANCE, max);
+
+	// clang-format off
+	for (int cx = min[0]; cx <= max[0]; cx++)
+	for (int cy = min[1]; cy <= max[1]; cy++)
+	for (int cz = min[2]; cz <= max[2]; cz++) {
+		world_reload_chunk(world, cx, cy, cz);
+	}
+	// clang-format on
+}
+
+void world_init(World *world, int seed)
+{
+	int side = RENDER_DISTANCE * 2 + 1;
+	int size = side * side * side;
+	world->seed = seed;
+	world->loaded = false;
+	world->chunks = xzalloc(size * sizeof(RcChunk *));
+	glm_ivec3_zero(world->center);
+	mtx_init(&world->lock, mtx_plain);
+}
+
+void world_free(World *world)
+{
+	int side = RENDER_DISTANCE * 2 + 1;
+	int size = side * side * side;
+	world_lock(world);
+	for (int i = 0; i < size; i++) {
+		RcChunk **entry = &world->chunks[i];
+		if (entry == NULL)
+			continue;
+		rcchunk_drop(*entry);
+	}
+	free(world->chunks);
+	mtx_destroy(&world->lock);
+}
+
+void world_lock(World *world)
+{
+	mtx_lock(&world->lock);
+}
+
+void world_unlock(World *world)
+{
+	mtx_unlock(&world->lock);
+}
+
+void world_update(World *world, Camera *camera)
+{
+	ivec3 cp = CHUNK_VEC_V(camera->position);
+	if (!world->loaded || !glm_ivec3_eqv(world->center, cp)) {
+		// camera has moved, load new chunks
+		glm_ivec3_copy(cp, world->center);
+		world_reload_chunks(world);
+	}
+}
+
+void world_render(World *world, Renderer *renderer)
+{
+	RcChunk *rc_chunk;
+	ivec3 min, max;
+	int world_size, mesh_quota;
+
+	glm_ivec3_subs(world->center, RENDER_DISTANCE, min);
+	glm_ivec3_adds(world->center, RENDER_DISTANCE, max);
+
+	// how many chunk we want to mesh at most
+	world_size = RENDER_DISTANCE * 2 + 1;
+	mesh_quota = world_size * world_size / 10;
+
+	// clang-format off
+	for (int cx = min[0]; cx <= max[0]; cx++)
+	for (int cy = min[1]; cy <= max[1]; cy++)
+	for (int cz = min[2]; cz <= max[2]; cz++) {
+		rc_chunk = world_get_chunk(world, cx, cy, cz);
+		if (rc_chunk == NULL)
+			continue;
+
+		if (rc_chunk->chunk.state < CHUNK_MESHING && mesh_quota > 0) {
+			chunk_mesh(&rc_chunk->chunk, world);
+			mesh_quota--;
+		}
+
+		if (rc_chunk->chunk.has_mesh)
+			renderer_draw(renderer, &rc_chunk->chunk);
+
+		rcchunk_drop(rc_chunk);
+	}
+	// clang-format on
+}
+
+RcChunk *world_get_chunk(World *world, int cx, int cy, int cz)
+{
+	RcChunk **entry, *inner;
+	world_lock(world);
+	entry = world_get_chunk_entry(world, cx, cy, cz);
+	if (entry == NULL)
+		goto not_found;
+	inner = *entry;
+	if (inner == NULL)
+		goto not_found;
+	inner->rc += 1;
+	world_unlock(world);
+	return inner;
+
+not_found:
+	world_unlock(world);
+	return NULL;
+}
+
+bool world_is_generated(World *world, int cx, int cy, int cz)
+{
+	RcChunk *rc_chunk;
+	bool generated;
+
+	rc_chunk = world_get_chunk(world, cx, cy, cz);
+	if (rc_chunk == NULL)
+		return false;
+
+	generated = rc_chunk->chunk.state >= CHUNK_GENERATED;
+	rcchunk_drop(rc_chunk);
+
+	return generated;
+}
+
+Block world_get_block(World *world, int gx, int gy, int gz)
+{
+	RcChunk *rc_chunk;
+	Block block;
+	ivec3 lp = LOCAL_VEC(gx, gy, gz);
+	ivec3 cp = CHUNK_VEC(gx, gy, gz);
+
+	rc_chunk = world_get_chunk(world, cp[0], cp[1], cp[2]);
+	if (rc_chunk == NULL)
+		return AIR;
+
+	block = chunk_at(&rc_chunk->chunk, lp[0], lp[1], lp[2]);
+	rcchunk_drop(rc_chunk);
+
+	return block;
+}
+
+void rcchunk_drop(RcChunk *rc_chunk)
+{
+	rc_chunk->rc -= 1;
+	if (rc_chunk->rc == 0) {
+		chunk_free(&rc_chunk->chunk);
+		free(rc_chunk);
+	}
+}
author	Freya Murphy <freya@freyacat.org>	2025-12-11 10:49:50 -0500
committer	Freya Murphy <freya@freyacat.org>	2025-12-11 10:51:40 -0500
commit	fa8fa6784559ed0fc8d780e36880273f77e272c4 (patch)
tree	7456a4e9148d47e409ba837bafdc6238b6c757db
parent	add ubos (diff)
download	voxel-fa8fa6784559ed0fc8d780e36880273f77e272c4.tar.gz voxel-fa8fa6784559ed0fc8d780e36880273f77e272c4.tar.bz2 voxel-fa8fa6784559ed0fc8d780e36880273f77e272c4.zip