Texture Generation (#3)

Example Addition - texture2d
This implementation example takes arguments, in particular, count, step, and image_size_factor, which is multiplied by 256 for the final image resolution.
The library polls for noise at the scaled coordinates of each pixel of the image, then writes it to a generated ppm file.

added Perlin's fade function to the detail::interpolate function

argument_parsing.hpp added to common/
 common argument parsing amongst all examples

---------

Co-authored-by: Karn Kaul <karnkaul@gmail.com>

Author: GDBobby

.gitignore

@@ -5,6 +5,7 @@ out/*
 screenshots
 .cache
 .DS_Store
+*.bak
 
 CMakeSettings.json
 compile_commands.json

examples/CMakeLists.txt

@@ -1 +1,2 @@
 add_subdirectory(histogram)
+add_subdirectory(texture2d)

examples/common/argument_parsing.hpp

@@ -0,0 +1,46 @@
+#include <noiz/noise2.hpp>
+
+#include <charconv>
+#include <format>
+#include <iostream>
+
+namespace {
+template <typename Type>
+concept NumberT = std::integral<Type> || std::floating_point<Type>;
+
+template <NumberT Type>
+auto parse_as(Type& out, std::string_view const value) -> bool {
+	if (value.empty()) { return false; }
+
+	auto const* end = value.data() + value.size();
+	auto const [ptr, ec] = std::from_chars(value.data(), end, out);
+
+	return ec == std::errc{} && ptr == end;
+}
+
+struct Args {
+	std::span<char const* const> args{};
+
+	[[nodiscard]] constexpr auto next() -> std::string_view {
+		if (args.empty()) { return {}; }
+		auto const* ret = args.front();
+		args = args.subspan(1);
+		return ret;
+	}
+
+	template <NumberT Type>
+	auto next_as(Type& out, std::string_view const key) -> bool {
+		auto value = next();
+		if (value.empty()) { return true; }
+
+		if (!parse_as(out, value)) {
+			std::cerr << std::format("invalid argument: '{}' for '{}'\n", value, key);
+			return false;
+		}
+
+		return true;
+	}
+};
+} // namespace
+
+//the config function is implemented per-example, currently have 2 implementations

examples/histogram/CMakeLists.txt

@@ -10,3 +10,7 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
 target_sources(${PROJECT_NAME} PRIVATE
   histogram.cpp
 )
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+  ../common
+)

examples/histogram/histogram.cpp

@@ -5,43 +5,9 @@
 #include <iostream>
 #include <vector>
 
-namespace {
-template <typename Type>
-concept NumberT = std::integral<Type> || std::floating_point<Type>;
-
-template <NumberT Type>
-auto parse_as(Type& out, std::string_view const value) -> bool {
-	if (value.empty()) { return false; }
-
-	auto const* end = value.data() + value.size();
-	auto const [ptr, ec] = std::from_chars(value.data(), end, out);
-
-	return ec == std::errc{} && ptr == end;
-}
-
-struct Args {
-	std::span<char const* const> args{};
-
-	[[nodiscard]] constexpr auto next() -> std::string_view {
-		if (args.empty()) { return {}; }
-		auto const* ret = args.front();
-		args = args.subspan(1);
-		return ret;
-	}
+#include <argument_parsing.hpp>
 
-	template <NumberT Type>
-	auto next_as(Type& out, std::string_view const key) -> bool {
-		auto value = next();
-		if (value.empty()) { return true; }
-
-		if (!parse_as(out, value)) {
-			std::cerr << std::format("invalid argument: '{}' for '{}'\n", value, key);
-			return false;
-		}
-
-		return true;
-	}
-};
+namespace {
 
 struct Config {
 	noiz::Seed seed{noiz::detail::Generator::make_random_seed()};

examples/texture2d/CMakeLists.txt

@@ -0,0 +1,16 @@
+project(noiz-texture2d)
+
+add_executable(${PROJECT_NAME})
+
+target_link_libraries(${PROJECT_NAME} PRIVATE
+  noiz::noiz-lib
+  noiz::noiz-compile-options
+)
+
+target_sources(${PROJECT_NAME} PRIVATE
+  texture2d.cpp
+)
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+  ../common
+)

examples/texture2d/texture2d.cpp

@@ -0,0 +1,99 @@
+#include <noiz/noise2.hpp>
+
+#include <argument_parsing.hpp>
+
+
+#include <charconv>
+#include <filesystem>
+#include <format>
+#include <iostream>
+#include <vector>
+#include <fstream>
+
+constexpr int32_t constant_base_resolution = 256;
+constexpr int32_t constant_max_resolution_factor = 16;
+
+void write_ppm_file_header(std::ofstream& out_file, uint16_t image_size){
+	out_file << "P6" << std::endl;
+	out_file << image_size << " " << image_size << std::endl;
+	out_file << 255 << std::endl; //255 is max color value, 8 bits
+}
+
+struct Config {
+	noiz::Seed seed{noiz::detail::Generator::make_random_seed()};
+	noiz::GridExtent2 grid_extent{50, 1}; // NOLINT
+	float step{0.1f};					  // NOLINT
+	int image_size_factor{1};
+
+	// syntax: [count] [step]
+	auto parse_args(Args args) -> bool {
+		if (!args.next_as(step, "step")) { return false; }
+		if (!args.next_as(image_size_factor, "image_size_factor")) { return false; }
+		if (image_size_factor < 0 || image_size_factor > constant_max_resolution_factor) {
+			std::cerr << std::format("invalid image size factor: '{}'\n", image_size_factor);
+			return false;
+		}
+		if (!args.args.empty()) {
+			return false;
+		}
+		grid_extent.x = constant_base_resolution * image_size_factor;
+		grid_extent.y = constant_base_resolution * image_size_factor;
+		return true;
+	}
+};
+
+// pulls noise from noiz::lib, writes a pixel to ppm file
+class Texture_2D {
+	public:
+		explicit Texture_2D(int image_size_factor) : image_size{static_cast<uint16_t>(constant_base_resolution * image_size_factor)} {}
+
+		void build_and_write_image_noise(noiz::Noise2f& noise, float const& step) const {
+
+			std::ofstream out_file{"noise.ppm", std::ios::binary};
+			write_ppm_file_header(out_file, image_size);
+			uint8_t grayscale_color; //0 is black, 255 is white
+			for (int y = 0; y < image_size; y++) {
+				for(int x = 0; x < image_size; x++) {
+				// add noise at point
+					float adjusted_noise = noise.at(noiz::Vec2f{.x = static_cast<float>(x) * step, .y = static_cast<float>(y) * step});
+					adjusted_noise = (adjusted_noise + 1.f) * 0.5f;
+					grayscale_color = static_cast<uint8_t>((adjusted_noise) * 255.f);
+					for(int i = 0; i < 3; i++) {
+						//ppm cant use 1 channel grayscale, forced to 3 channel
+						out_file.write(reinterpret_cast<char*>(&grayscale_color), sizeof(char)); //sizeof(char) == 1
+					}
+				}
+			}
+			out_file.close();
+		}
+
+	private:
+		uint16_t image_size;
+};
+
+auto main(int argc, char** argv) -> int {
+	auto config = Config{};
+
+	// skip exe name (argv[0])
+	auto const args = Args{std::span{argv, static_cast<std::size_t>(argc)}.subspan(1)};
+
+	// handle --help
+	if (!args.args.empty() && args.args.front() == std::string_view{"--help"}) {
+		std::cout << std::format("Usage: {} [step(=0.1)] [image_size_factor(=1)]\n", std::filesystem::path{*argv}.stem().string());
+		std::cout << "\t output image resolution is 256x256, with each dimension multiplied by image_size_factor, maximum scaling factor is 16[image size of 4096]" << std::endl;
+		return EXIT_SUCCESS;
+	}
+
+	// parse args, if any
+	if (!config.parse_args(args)) { 
+		std::cout << args.args.front() << std::endl;
+		return EXIT_FAILURE; 
+	}
+
+
+	auto noise = noiz::Noise2f{noiz::Seed{config.seed}, config.grid_extent};
+
+	// build and write noise to image
+	auto texture2d = Texture_2D{config.image_size_factor};
+	texture2d.build_and_write_image_noise(noise, config.step);
+}

noiz/include/noiz/detail/data2.hpp

@@ -33,7 +33,7 @@ constexpr auto compute_dot_products(CornerCell2<Type> const& corner, Cell2<Type>
 
 template <std::floating_point Type>
 constexpr auto interpolate(Vec2<Type> const point, TCell2<Type> const& dot_products) -> Type {
-	auto const uv = point.fract();
+	auto const uv = point.fract().fade(); 
 	auto const a = std::lerp(dot_products.left_top, dot_products.right_top, uv.x);
 	auto const b = std::lerp(dot_products.left_bottom, dot_products.right_bottom, uv.x);
 	return std::lerp(a, b, uv.y);

noiz/include/noiz/noise2.hpp

@@ -17,9 +17,10 @@ class Noise2 {
 
 	[[nodiscard]] auto at(Vec2<Type> point) const -> Type {
 		point = point.modulo(detail::to_vec2<Type>(m_grid.grid_extent));
-		auto const corner = m_grid.at(detail::to_index2(point));
-		auto const offset = detail::compute_offsets(corner, point);
-		auto const dots = detail::compute_dot_products(corner, offset);
+		auto const corners = m_grid.at(detail::to_index2(point));
+		auto const offsets = detail::compute_offsets(corners, point);
+		auto const dots = detail::compute_dot_products(corners, offsets);
+		
 		return detail::interpolate(point, dots);
 	}
 

noiz/include/noiz/vec2.hpp

@@ -39,6 +39,13 @@ struct Vec2 {
 
 	[[nodiscard]] constexpr auto fract() const -> Vec2<Type> { return Vec2<Type>{.x = x - std::floor(x), .y = y - std::floor(y)}; }
 
+	[[nodiscard]] constexpr auto fade() const -> Vec2<Type> {
+		return Vec2<Type>{
+			.x = x * x * x * (x * (x * 6 - 15) + 10),
+			.y = y * y * y * (y * (y * 6 - 15) + 10)
+		};
+	}
+
 	constexpr auto operator+=(Vec2 const rhs) -> Vec2& {
 		x += rhs.x;
 		y += rhs.y;