libs/app/include/psemek/app/application.hpp

@@ -24,7 +24,6 @@ namespace psemek::app
 			std::string name;
 			int multisampling = 4;
 			bool highdpi = false;
-			bool srgb = false;
 #if defined(PSEMEK_GRAPHICS_API_WEBGPU)
 			std::vector<wgpu::feature> required_features = {};
 			std::optional<wgpu::limits> required_limits = {};

libs/gfx/include/psemek/gfx/program.hpp

@@ -14,39 +14,13 @@
 namespace psemek::gfx
 {
 
-	struct shader_source
-	{
-		std::vector<std::string_view> sources;
-
-		template <std::size_t N>
-		shader_source(char const (&source)[N])
-			: sources{std::string_view{source}}
-		{}
-
-		shader_source(char const * source)
-			: sources{std::string_view{source}}
-		{}
-
-		shader_source(std::string_view source)
-			: sources{source}
-		{}
-
-		shader_source(std::initializer_list<std::string_view> sources)
-			: sources(sources)
-		{}
-
-		explicit shader_source(std::vector<std::string_view> sources)
-			: sources{std::move(sources)}
-		{}
-	};
-
 	struct program
 	{
-		program(shader_source const & vertex_source, shader_source const & fragment_source);
+		program(std::string_view vertex_source, std::string_view fragment_source);
 
 #ifndef __EMSCRIPTEN__
-		program(shader_source const & compute_source);
-		program(shader_source const & vertex_source, shader_source const & geometry_source, shader_source const & fragment_source);
+		program(std::string_view compute_source);
+		program(std::string_view vertex_source, std::string_view geometry_source, std::string_view fragment_source);
 #endif
 
 		program(program && other);

libs/gfx/source/effect/blur.cpp

@@ -117,7 +117,7 @@ void main()
 		gfx::array array;
 
 		blur_impl(int size, float sigma, float gamma, bool horizontal)
-			: program({gl::sys::shader_prelude(), blur_vs}, {gl::sys::shader_prelude(), generate_blur_fs_source(size, sigma, horizontal)})
+			: program(std::string(gl::sys::shader_prelude()) + blur_vs, std::string(gl::sys::shader_prelude()) + generate_blur_fs_source(size, sigma, horizontal))
 		{
 			program.bind();
 			program["u_texture"] = 0;

libs/gfx/source/effect/fxaa.cpp

@@ -206,7 +206,7 @@ void main()
 
 	struct fxaa::impl
 	{
-		gfx::program program{{gl::sys::shader_prelude(), fxaa_vs}, {gl::sys::shader_prelude(), fxaa_fs}};
+		gfx::program program{std::string(gl::sys::shader_prelude()) + fxaa_vs, std::string(gl::sys::shader_prelude()) + fxaa_fs};
 		gfx::array array;
 	};
 

libs/gfx/source/effect/gamma.cpp

@@ -48,7 +48,7 @@ void main()
 
 	struct gamma_correction::impl
 	{
-		gfx::program program{{gl::sys::shader_prelude(), gamma_vs}, {gl::sys::shader_prelude(), gamma_fs}};
+		gfx::program program{std::string(gl::sys::shader_prelude()) + gamma_vs, std::string(gl::sys::shader_prelude()) + gamma_fs};
 		gfx::array array;
 	};
 

libs/gfx/source/effect/overlay.cpp

@@ -45,7 +45,7 @@ void main()
 
 	struct overlay::impl
 	{
-		gfx::program program{{gl::sys::shader_prelude(), overlay_vs}, {gl::sys::shader_prelude(), overlay_fs}};
+		gfx::program program{std::string(gl::sys::shader_prelude()) + overlay_vs, std::string(gl::sys::shader_prelude()) + overlay_fs};
 		gfx::array array;
 	};
 

libs/gfx/source/painter.cpp

@@ -107,7 +107,7 @@ void main()
 namespace psemek::gfx
 {
 
-	static auto const shader_prefix = gl::sys::shader_prelude();
+	static std::string shader_prefix = std::string{gl::sys::shader_prelude()};
 
 	struct painter::impl
 	{
@@ -130,9 +130,9 @@ namespace psemek::gfx
 			math::point<std::uint16_t, 2> texcoord;
 		};
 
-		gfx::program program{{shader_prefix, vertex_source}, {shader_prefix, fragment_source}};
-		gfx::program text_program{{shader_prefix, text_vertex_source}, {shader_prefix, text_fragment_source}};
-		gfx::program texture_program{{shader_prefix, texture_vertex_source}, {shader_prefix, texture_fragment_source}};
+		gfx::program program{shader_prefix + vertex_source, shader_prefix + fragment_source};
+		gfx::program text_program{shader_prefix + text_vertex_source, shader_prefix + text_fragment_source};
+		gfx::program texture_program{shader_prefix + texture_vertex_source, shader_prefix + texture_fragment_source};
 		gfx::mesh mesh;
 		gfx::mesh text_mesh;
 		gfx::mesh texture_mesh;

libs/gfx/source/program.cpp

@@ -216,46 +216,37 @@ namespace psemek::gfx
 		(*this) = q.coords;
 	}
 
-	static std::string annotated_source(shader_source const & sources)
+	static std::string annotated_source(std::string_view source)
 	{
 		std::ostringstream os;
 
 		bool first = true;
 
 		int line = 1;
-		for (auto const & source : sources.sources)
+		for (char c : source)
 		{
-			for (char c : source)
+			if (first)
 			{
-				if (first)
-				{
-					os << line << ": ";
-					first = false;
-				}
+				os << line << ": ";
+				first = false;
+			}
 
-				os.put(c);
-				if (c == '\n')
-				{
-					++line;
-					first = true;
-				}
+			os.put(c);
+			if (c == '\n')
+			{
+				++line;
+				first = true;
 			}
 		}
 
 		return os.str();
 	}
 
-	static void load_shader(GLuint shader, shader_source const & sources)
+	static void load_shader(GLuint shader, std::string_view source)
 	{
-		std::vector<char const *> source_ptrs;
-		std::vector<GLint> source_lens;
-		for (auto const & source : sources.sources)
-		{
-			source_ptrs.push_back(source.data());
-			source_lens.push_back(source.size());
-		}
-
-		gl::ShaderSource(shader, sources.sources.size(), source_ptrs.data(), source_lens.data());
+		char const * vert_sources[1] { source.data() };
+		GLint vert_sources_len[1] { static_cast<GLint>(source.size()) };
+		gl::ShaderSource(shader, 1, vert_sources, vert_sources_len);
 		gl::CompileShader(shader);
 
 		GLint status;
@@ -266,7 +257,7 @@ namespace psemek::gfx
 			gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &log_len);
 			std::unique_ptr<char[]> log(new char [log_len]);
 			gl::GetShaderInfoLog(shader, log_len, nullptr, log.get());
-			throw util::exception(util::to_string("Shader compilation failed: ", log.get(), "\nShader source: \n", annotated_source(sources)));
+			throw util::exception(util::to_string("Shader compilation failed: ", log.get(), "\nShader source: \n", annotated_source(source)));
 		}
 	}
 
@@ -291,7 +282,7 @@ namespace psemek::gfx
 			gl::DetachShader(program, s);
 	}
 
-	static GLuint create_program(std::vector<std::pair<GLenum, shader_source const *>> const & sources)
+	static GLuint create_program(std::vector<std::pair<GLenum, std::string_view>> const & sources)
 	{
 		std::vector<GLuint> shaders;
 
@@ -304,7 +295,7 @@ namespace psemek::gfx
 		{
 			GLuint sh = gl::CreateShader(p.first);
 			shaders.push_back(sh);
-			load_shader(sh, *p.second);
+			load_shader(sh, p.second);
 		}
 
 		GLuint program = gl::CreateProgram();
@@ -322,20 +313,20 @@ namespace psemek::gfx
 		return program;
 	}
 
-	program::program(shader_source const & vertex_source, shader_source const & fragment_source)
+	program::program(std::string_view vertex_source, std::string_view fragment_source)
 	{
-		program_ = create_program({{gl::VERTEX_SHADER, &vertex_source}, {gl::FRAGMENT_SHADER, &fragment_source}});
+		program_ = create_program({{gl::VERTEX_SHADER, vertex_source}, {gl::FRAGMENT_SHADER, fragment_source}});
 	}
 
 #ifndef __EMSCRIPTEN__
-	program::program(shader_source const & compute_source)
+	program::program(std::string_view compute_source)
 	{
-		program_ = create_program({{gl::COMPUTE_SHADER, &compute_source}});
+		program_ = create_program({{gl::COMPUTE_SHADER, compute_source}});
 	}
 
-	program::program(shader_source const & vertex_source, shader_source const & geometry_source, shader_source const & fragment_source)
+	program::program(std::string_view vertex_source, std::string_view geometry_source, std::string_view fragment_source)
 	{
-		program_ = create_program({{gl::VERTEX_SHADER, &vertex_source}, {gl::GEOMETRY_SHADER, &geometry_source}, {gl::FRAGMENT_SHADER, &fragment_source}});
+		program_ = create_program({{gl::VERTEX_SHADER, vertex_source}, {gl::GEOMETRY_SHADER, geometry_source}, {gl::FRAGMENT_SHADER, fragment_source}});
 	}
 #endif
 

libs/gfx/source/renderer/deferred.cpp

@@ -811,16 +811,16 @@ void main(){}
 		deferred_renderer::position_mode position_mode = deferred_renderer::position_mode::float32;
 		bool position_mode_changed = true;
 
-		gfx::program occlusion_pass_program{{occlusion_pass_vs}, {occlusion_pass_fs}};
-		gfx::program g_buffer_pass_program{{g_buffer_pass_common, g_buffer_pass_vs}, {g_buffer_pass_common, g_buffer_pass_fs}};
-		gfx::program ambient_pass_program{{fullscreen_vs}, {light_common, ambient_pass_fs}};
-		gfx::program directional_light_pass_program{{screen_vs}, {light_common, directional_light_pass_fs}};
-		gfx::program point_light_pass_program{{screen_vs}, {light_common, point_light_pass_fs}};
-		gfx::program shadow_builder_program{{g_buffer_pass_common, shadow_builder_vs}, {shadow_builder_fs}};
-		gfx::program cubemap_shadow_builder_program{{g_buffer_pass_common, shadow_builder_vs}, {shadow_builder_gs}, {shadow_builder_fs}};
-		gfx::program transparent_pass_program{{g_buffer_pass_common, transparent_pass_vs}, {g_buffer_pass_common, transparent_pass_fs}};
-		gfx::program bloom_pass_program{{g_buffer_pass_common, transparent_pass_vs}, {g_buffer_pass_common, transparent_pass_fs}};
-		gfx::program ssao_pass_program{{fullscreen_vs}, {light_common, ssao_pass_fs}};
+		gfx::program occlusion_pass_program{occlusion_pass_vs, occlusion_pass_fs};
+		gfx::program g_buffer_pass_program{std::string(g_buffer_pass_common) + g_buffer_pass_vs, std::string(g_buffer_pass_common) + g_buffer_pass_fs};
+		gfx::program ambient_pass_program{fullscreen_vs, std::string(light_common) + ambient_pass_fs};
+		gfx::program directional_light_pass_program{screen_vs, std::string(light_common) + directional_light_pass_fs};
+		gfx::program point_light_pass_program{screen_vs, std::string(light_common) + point_light_pass_fs};
+		gfx::program shadow_builder_program{std::string(g_buffer_pass_common) + shadow_builder_vs, shadow_builder_fs};
+		gfx::program cubemap_shadow_builder_program{std::string(g_buffer_pass_common) + shadow_builder_vs, shadow_builder_gs, shadow_builder_fs};
+		gfx::program transparent_pass_program{std::string(g_buffer_pass_common) + transparent_pass_vs, std::string(g_buffer_pass_common) + transparent_pass_fs};
+		gfx::program bloom_pass_program{std::string(g_buffer_pass_common) + transparent_pass_vs, std::string(g_buffer_pass_common) + transparent_pass_fs};
+		gfx::program ssao_pass_program{fullscreen_vs, std::string(light_common) + ssao_pass_fs};
 
 		// G-buffer attachments:
 		// 0 - position (rbg)

libs/math/include/psemek/math/orthographic.hpp

@@ -5,7 +5,6 @@
 #include <psemek/math/box.hpp>
 #include <psemek/math/matrix.hpp>
 #include <psemek/math/homogeneous.hpp>
-#include <psemek/math/affine_transform.hpp>
 
 namespace psemek::math
 {
@@ -15,8 +14,6 @@ namespace psemek::math
 	{
 		using vector_type = math::vector<T, D>;
 		using point_type = math::point<T, D>;
-		using affine_matrix_type = math::matrix<T, D, D + 1>;
-		using linear_matrix_type = math::matrix<T, D, D>;
 		using homogeneous_matrix_type = math::matrix<T, D + 1, D + 1>;
 		using box_type = math::box<T, D>;
 
@@ -29,13 +26,8 @@ namespace psemek::math
 		vector_type operator() (vector_type v) const;
 		point_type operator() (point_type p) const;
 
-		affine_matrix_type affine_matrix() const;
-		linear_matrix_type linear_matrix() const;
-		vector_type translation_vector() const;
 		homogeneous_matrix_type homogeneous_matrix() const;
 
-		affine_transform<T, D, D> transform() const;
-
 		orthographic inverse() const;
 
 	private:
@@ -84,24 +76,6 @@ namespace psemek::math
 		return as_point(homogeneous_matrix() * homogeneous(p));
 	}
 
-	template <typename T, std::size_t D>
-	matrix<T, D, D + 1> orthographic<T, D>::affine_matrix() const
-	{
-		return submatrix<0, 0, D, D + 1>(homogeneous_matrix());
-	}
-
-	template <typename T, std::size_t D>
-	matrix<T, D, D> orthographic<T, D>::linear_matrix() const
-	{
-		return submatrix<0, 0, D, D>(homogeneous_matrix());
-	}
-
-	template <typename T, std::size_t D>
-	vector<T, D> orthographic<T, D>::translation_vector() const
-	{
-		return column(affine_matrix(), D);
-	}
-
 	template <typename T, std::size_t D>
 	matrix<T, D + 1, D + 1> orthographic<T, D>::homogeneous_matrix() const
 	{
@@ -118,12 +92,6 @@ namespace psemek::math
 		return m;
 	}
 
-	template <typename T, std::size_t D>
-	affine_transform<T, D, D> orthographic<T, D>::transform() const
-	{
-		return {affine_matrix()};
-	}
-
 	template <typename T, std::size_t D>
 	orthographic<T, D> orthographic<T, D>::inverse() const
 	{

libs/math/include/psemek/math/shear.hpp

@@ -1,123 +0,0 @@
-#pragma once
-
-#include <psemek/math/affine_transform.hpp>
-#include <psemek/math/quaternion.hpp>
-
-#include <psemek/util/assert.hpp>
-
-namespace psemek::math
-{
-
-	// Shear in the (i,j)-plane that replaces x[i] with x[i] + x[j] * factor
-	// E.g. shear(0, 1, m) is the usual 2D horizontal shear
-	template <typename T, std::size_t N>
-	struct shear
-	{
-		std::size_t i, j;
-		T factor;
-
-		shear();
-		shear(std::size_t i, std::size_t j, T factor);
-		shear(shear const &) = default;
-
-		matrix<T, N, N + 1> affine_matrix() const;
-		matrix<T, N, N> linear_matrix() const;
-		vector<T, N> translation_vector() const;
-		matrix<T, N + 1, N + 1> homogeneous_matrix() const;
-
-		affine_transform<T, N, N> transform() const;
-
-		vector<T, N> operator()(vector<T, N> const & v) const;
-		point<T, N> operator()(point<T, N> const & p) const;
-
-	private:
-		template <typename Matrix>
-		void fill_matrix(Matrix & m) const;
-	};
-
-	template <typename T, std::size_t N>
-	shear<T, N>::shear()
-		: i{0}
-		, j{1}
-		, factor{0}
-	{
-		assert(i < N);
-		assert(j < N);
-	}
-
-	template <typename T, std::size_t N>
-	shear<T, N>::shear(std::size_t i, std::size_t j, T factor)
-		: i{i}
-		, j{j}
-		, factor{factor}
-	{
-		assert(i < N);
-		assert(j < N);
-	}
-
-	template <typename T, std::size_t N>
-	matrix<T, N, N + 1> shear<T, N>::affine_matrix() const
-	{
-		auto result = matrix<T, N, N + 1>::identity();
-		fill_matrix(result);
-		return result;
-	}
-
-	template <typename T, std::size_t N>
-	matrix<T, N, N> shear<T, N>::linear_matrix() const
-	{
-		auto result = matrix<T, N, N>::identity();
-		fill_matrix(result);
-		return result;
-	}
-
-	template <typename T, std::size_t N>
-	vector<T, N> shear<T, N>::translation_vector() const
-	{
-		return vector<T, N>::zero();
-	}
-
-	template <typename T, std::size_t N>
-	matrix<T, N + 1, N + 1> shear<T, N>::homogeneous_matrix() const
-	{
-		auto result = matrix<T, N + 1, N + 1>::identity();
-		fill_matrix(result);
-		return result;
-	}
-
-	template <typename T, std::size_t N>
-	affine_transform<T, N, N> shear<T, N>::transform() const
-	{
-		return {affine_matrix()};
-	}
-
-	template <typename T, std::size_t N>
-	vector<T, N> shear<T, N>::operator()(vector<T, N> const & v) const
-	{
-		auto result = v;
-		result[i] += result[j] * factor;
-		return result;
-	}
-
-	template <typename T, std::size_t N>
-	point<T, N> shear<T, N>::operator()(point<T, N> const & p) const
-	{
-		auto result = p;
-		result[i] += result[j] * factor;
-		return result;
-	}
-
-	template <typename T, std::size_t N>
-	template <typename Matrix>
-	void shear<T, N>::fill_matrix(Matrix & m) const
-	{
-		m[i][j] = factor;
-	}
-
-	template <typename T, std::size_t N>
-	shear<T, N> inverse(shear<T, N> const & r)
-	{
-		return {r.i, r.j, -r.factor};
-	}
-
-}

libs/sdl2/source/window.cpp

@@ -38,7 +38,6 @@ namespace psemek::sdl2
 		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
 		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
 		SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
-		SDL_GL_SetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, options.srgb ? 1 : 0);
 
 		if (options.multisampling == 0)
 		{
@@ -84,9 +83,6 @@ namespace psemek::sdl2
 		SDL_GL_MakeCurrent(window_, gl_context_);
 
 		gfx::init();
-
-		if (options.srgb)
-			gl::Enable(gl::FRAMEBUFFER_SRGB);
 #elif defined(PSEMEK_GRAPHICS_API_WEBGPU)
 		wgpu::setup_logging(log::level::error);