Get perlin noise generator working with tessellation shaders

shaders/terrain/terrain.frag

@@ -0,0 +1,42 @@
+#version 450
+#extension GL_EXT_nonuniform_qualifier: enable
+#extension GL_EXT_debug_printf: enable
+
+layout (location = 0) in vec3 in_normal;
+layout (location = 1) in vec2 in_tex_coord;
+layout (location = 2) in vec3 in_world_pos;
+layout (location = 3) in flat uint in_tex_idx;
+
+//layout (location = 0) out vec4 out_color; // Out color is unused. This would be the final render image
+layout (location = 1) out vec4 out_position;
+layout (location = 2) out vec4 out_normal;
+layout (location = 3) out vec4 out_albedo;
+
+layout (set = 0, binding = 0) uniform CameraInfo {
+    mat4 projection;
+    mat4 view;
+    mat4 inverse_view;
+} ubo;
+
+layout (set = 1, binding = 0) uniform sampler2D tex[];
+
+#define NEAR_PLANE 0.01f
+#define FAR_PLANE 1000.0f
+
+
+float linearDepth(float depth)
+{
+    float z = depth * 2.0f - 1.0f;
+    return (2.0f * NEAR_PLANE * FAR_PLANE) / (FAR_PLANE + NEAR_PLANE - z * (FAR_PLANE - NEAR_PLANE));
+}
+
+void main()
+{
+    out_position = vec4(in_world_pos, 1.0f);
+
+    vec3 N = normalize(in_normal);
+
+    out_normal = vec4(N, 1.0);
+
+    out_albedo = texture(tex[in_tex_idx], in_tex_coord);
+}

shaders/terrain/terrain.tese

@@ -24,20 +24,26 @@ layout (set = 1, binding = 0) uniform sampler2D tex[];
 
 void main()
 {
+    // Mix new UV
     vec2 uv1 = mix(in_uv[0], in_uv[1], gl_TessCoord.x);
     vec2 uv2 = mix(in_uv[3], in_uv[2], gl_TessCoord.x);
     out_uv = mix(uv1, uv2, gl_TessCoord.y);
 
+    // Mix new normal
     vec3 n1 = mix(in_normal[0], in_normal[1], gl_TessCoord.x);
     vec3 n2 = mix(in_normal[3], in_normal[2], gl_TessCoord.x);
     out_normal = mix(n1, n2, gl_TessCoord.y);
 
+    // Mix new position
     vec4 pos1 = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);
     vec4 pos2 = mix(gl_in[3].gl_Position, gl_in[2].gl_Position, gl_TessCoord.x);
     vec4 pos = mix(pos1, pos2, gl_TessCoord.y);
 
+    // Passthrough Tex ID to fragment shader
     out_tex_idx = in_tex_idx[0];
 
+    vec4 texel = texture(tex[out_tex_idx], out_uv);
+
     // Doesn't matter which in_scale_z we take since it'll be the same for the entire model.
     pos.z += (texture(tex[out_tex_idx], out_uv).r - 0.5) * in_scale_z[0];
 

src/engine/EngineContext.cpp

@@ -295,7 +295,7 @@ namespace fgl::engine
 			};
 
 			//Texture texture { Texture::loadFromFile( "models/Vally/textures/heightmap.png" ) };
-			Texture texture { Texture::generateFromPerlinNoise( 1024, 1024 ) };
+			Texture texture { Texture::generateFromPerlinNoise( 1024, 1024, 120 ) };
 
 			Sampler sampler { vk::Filter::eLinear,
 				              vk::Filter::eLinear,

src/engine/KeyboardMovementController.cpp

@@ -108,7 +108,7 @@ namespace fgl::engine
 		}
 
 		const Vector forward_dir { target.m_transform.rotation.forward() };
-		const Vector up_dir { constants::WORLD_UP };
+		const Vector up_dir { target.m_transform.rotation.up() };
 		const Vector right_dir { target.m_transform.rotation.right() };
 
 		Vector move_dir { 0.0f };

src/engine/math/noise/perlin/generator.cpp

@@ -8,6 +8,7 @@
 
 namespace fgl::engine
 {
+	//TODO: Figure out how this magic works.
 	glm::vec2 randomGradient( int ix, int iy )
 	{
 		constexpr unsigned w { 8 * sizeof( unsigned ) };

src/engine/systems/TerrainSystem.hpp

@@ -18,7 +18,7 @@ namespace fgl::engine
 	class TerrainSystem
 	{
 		using VertexShader = VertexShaderT< "shaders/terrain/terrain.vert.spv" >;
-		using FragmentShader = FragmentShaderT< "shaders/gbuffer.frag.spv" >;
+		using FragmentShader = FragmentShaderT< "shaders/terrain/terrain.frag.spv" >;
 		using TessCShader = TesselationControlShaderT< "shaders/terrain/terrain.tesc.spv" >;
 		using TessEShader = TesselationEvaluationShaderT< "shaders/terrain/terrain.tese.spv" >;
 

src/engine/texture/Texture.cpp

@@ -77,9 +77,9 @@ namespace fgl::engine
 		return std::move( tex );
 	}
 
-	Texture Texture::generateFromPerlinNoise( int x_size, int y_size )
+	Texture Texture::generateFromPerlinNoise( int x_size, int y_size, std::size_t seed )
 	{
-		const std::vector< std::byte > data { generatePerlinImage( { x_size, y_size }, 15 ) };
+		const std::vector< std::byte > data { generatePerlinImage( { x_size, y_size }, 15, seed ) };
 
 		Texture tex { data, x_size, y_size, 4 };
 

src/engine/texture/Texture.hpp

@@ -50,7 +50,7 @@ namespace fgl::engine
 
 		void createImGuiSet();
 
-		[[nodiscard]] static Texture generateFromPerlinNoise( int x_size, int y_size );
+		[[nodiscard]] static Texture generateFromPerlinNoise( int x_size, int y_size, std::size_t seed = 0 );
 		[[nodiscard]] static Texture loadFromFile( const std::filesystem::path& path );
 
 		static DescriptorSet& getTextureDescriptorSet();