fix automapaper module

modules/automapaper/default.nix

@@ -5,39 +5,42 @@ in
 {
 	options.modules.automapaper = {
 		enable = lib.mkEnableOption "enable automapaper";
+		displays = lib.mkOption {
+			type = with lib.types; listOf str;
+		};
 		configurations = lib.mkOption {
 			description = "automapaper configurations per monitor";
 			type = with lib.types; attrsOf (submodule {
 				options = {
-					init = mkOption {
+					init = lib.mkOption {
 						type = str;
 						description = "the shader executed to get the state for the initialisation, and re-initialisation steps";
 					};
-					state = mkOption {
+					state = lib.mkOption {
 						type = str;
 						description = "the shader executed to increment the state to the next generation";
 					};
-					display = mkOption {
+					display = lib.mkOption {
 						type = str;
 						description = "the shader executed to display the state to the monitor";
 					};
-					horizontal = mkOption {
+					horizontal = lib.mkOption {
 						type = int;
 						description = "the amount of horizontal cells in the state";
 					};
-					vertical = mkOption {
+					vertical = lib.mkOption {
 						type = int;
 						description = "the amount of vertical cells in the state";
 					};
-					tps = {
+					tps = lib.mkOption {
 						type = int;
-						description = "the amount of ticks to simulate each second";
+						description = "the target amount of ticks to simulate each second";
 					};
-					cycles = {
+					cycles = lib.mkOption {
 						type = int;
 						description = "the amount of state increments before the init shader is called again";
 					};
-					frames_per_tick = {
+					frames_per_tick = lib.mkOption {
 						type = int;
 						description = "the amount of times to call the display shader for each iteration of the state shader";
 					};
@@ -57,27 +60,126 @@ in
 			''
 			[display]
 			name="${displayName}"
-			horizontal=${displayConfig.horizontal}
-			vertical=${displayConfig.vertical}
-			tps=${displayConfig.tps}
+			horizontal=${builtins.toString displayConfig.horizontal}
+			vertical=${builtins.toString displayConfig.vertical}
+			tps=${builtins.toString displayConfig.tps}
 			state_frag="${state}"
 			init_frag="${init}"
 			display_frag="${display}"
-			cycles=${displayConfig.cycles}
-			frames_per_tick=${displayConfig.frames_per_tick}
+			cycles=${builtins.toString displayConfig.cycles}
+			frames_per_tick=${builtins.toString displayConfig.frames_per_tick}
 			''
 		) cfg.configurations;
-	in
-	{
-		wayland.windowManager.hyprland.exec-once =
-			lib.mkIf config.modules.hyprland.enable (
-				lib.mapAttrsToList (name: config: 
-					"${
-						inputs.automapaper.packages.${pkgs.system}.default
-					}/bin/automapaper -C ${
-						builtins.toFile "${name}.toml" config
-					}") cfg.displays
-			);
-	});
+	in {
+		modules.automapaper.configurations =
+		let
+			conf = {
+				horizontal = 256;
+				vertical = 144;
+				tps = 30;
+				init = ''
+					#version 310 es
+					precision highp float;
 
+					uniform float time;
+					uniform vec2 resolution;
+
+					out vec4 stateColor;
+
+					float PHI = 1.61803398874989484820459;  // Φ = Golden Ratio   
+
+					float gold_noise(in vec2 xy, in float seed){
+								 return fract(tan(distance(xy*PHI, xy)*seed)*xy.x);
+					}
+
+					void main( void ) {
+
+							vec2 position = gl_FragCoord.xy;
+							float color = gold_noise(position.xy, fract(time));
+
+
+							stateColor = vec4(step(0.3, color), 0,0,step(0.3, color));
+					}'';
+				state= ''
+					#version 310 es
+					precision highp float;
+
+					uniform sampler2D state;
+					uniform vec2 scale;
+
+					out vec4 stateColor;
+
+					vec4 get(int x, int y) {
+							return texture(state, (gl_FragCoord.xy + vec2(x, y)) / scale);
+					}
+
+					void main() {
+							int sum = int(get(-1, -1).r +
+												get(-1,  0).r +
+												get(-1,  1).r +
+												get( 0, -1).r +
+												get( 0,  1).r +
+												get( 1, -1).r +
+												get( 1,  0).r +
+												get( 1,  1).r);
+							vec4 current = get(0,0);
+							if (sum == 3) {
+									stateColor.r = 1.0;
+									stateColor.g = 1.0;
+							} else if (sum == 2) {
+									stateColor = current;
+									if (current.r == 0.0) {
+											stateColor.g = max(current.g - 0.01, 0.0);
+									}
+							} else {
+									stateColor = vec4(0.0, max(current.g - 0.01, 0.0), 0.0, 1.0);
+							}
+
+					}'';
+				display = ''
+					#version 310 es
+					precision highp float;
+
+					uniform sampler2D tex2D;
+					uniform sampler2D old2D;
+					uniform ivec2 resolution;
+					uniform float frame_part;
+
+					in highp vec2 texCoords;
+					out vec4 stateColor;
+
+					const vec4 bgColor = vec4(38.0/255.0, 5.0/255.0, 46.0/255.0, 1.0); // #26052e
+					const vec4 fgColor = vec4(148.0/255.0, 15.0/255.0, 173.0/255.0, 1.0); // #950fad
+
+					void main() {
+							vec2 canvasSize = vec2(textureSize(tex2D, 0));
+							vec4 state = texture(tex2D, texCoords);
+							vec4 ostate = texture(old2D, texCoords);
+
+							vec2 localCoords = fract(gl_FragCoord.xy / vec2(resolution) * canvasSize);
+							localCoords = localCoords - 0.5;
+							float dist = sqrt(dot(localCoords, localCoords));
+
+							float size = smoothstep(0.0, 1.0, pow(mix(ostate.g,state.g, frame_part), 3.0)) * 0.35;
+							float mask = 1.0 - step(size, dist);
+
+							float brightness = mix(ostate.r,state.r, frame_part) + 0.2 * pow(mix(ostate.g,state.g, frame_part), 3.0);
+							stateColor = mix(bgColor, fgColor, brightness * mask);
+					}'';
+				cycles = 2500;
+				frames_per_tick = 1;
+			};
+			in
+		{
+			"DP-3" = conf;
+			"DP-2" = conf;
+		};
+		modules.automapaper.displays = 
+			lib.mapAttrsToList (name: config:
+				"${
+					inputs.automapaper.packages.${pkgs.system}.default
+				}/bin/automapaper -C ${
+					builtins.toFile "${name}.toml" config
+				}") displays;
+	});
 }