nano-pow 2.0.0 → 3.0.0

package/dist/main.d.ts

@@ -1,3 +0,0 @@
-import { NanoPow, NanoPowGl, NanoPowGpu } from "#classes";
-export { NanoPow, NanoPowGl, NanoPowGpu };
-export default NanoPow;

package/dist/main.js

@@ -1,5 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { NanoPow, NanoPowGl, NanoPowGpu } from "#classes";
-export { NanoPow, NanoPowGl, NanoPowGpu };
-export default NanoPow;

package/dist/shaders/gl-fragment.d.ts

@@ -1 +0,0 @@
-export declare const NanoPowGlFragmentShader = "#version 300 es\n#pragma vscode_glsllint_stage: frag\nprecision highp float;\nprecision highp int;\n\nin vec2 uv_pos;\nout vec4 fragColor;\n\n// blockhash - array of precalculated block hash components\n// threshold - 0xfffffff8 for send/change blocks, 0xfffffe00 for all else\n// workload - Defines canvas size\nlayout(std140) uniform UBO {\n\tuint blockhash[8];\n\tuint threshold;\n\tfloat workload;\n};\n\n// Random work values\n// First 2 bytes will be overwritten by texture pixel position\n// Second 2 bytes will be modified if the canvas size is greater than 256x256\n// Last 4 bytes remain as generated externally\nlayout(std140) uniform WORK {\n\tuvec4 work[2];\n};\n\n// Defined separately from uint v[32] below as the original value is required\n// to calculate the second uint32 of the digest for threshold comparison\nconst uint BLAKE2B_IV32_1 = 0x6A09E667u;\n\n// Both buffers represent 16 uint64s as 32 uint32s\n// because that's what GLSL offers, just like Javascript\n\n// Compression buffer, intialized to 2 instances of the initialization vector\n// The following values have been modified from the BLAKE2B_IV:\n// OUTLEN is constant 8 bytes\n// v[0] ^= 0x01010000u ^ uint(OUTLEN);\n// INLEN is constant 40 bytes: work value (8) + block hash (32)\n// v[24] ^= uint(INLEN);\n// It's always the \"last\" compression at this INLEN\n// v[28] = ~v[28];\n// v[29] = ~v[29];\nuint v[32] = uint[32](\n\t0xF2BDC900u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,\n\t0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,\n\t0xADE682D1u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,\n\t0xFB41BD6Bu, 0x1F83D9ABu, 0x137E2179u, 0x5BE0CD19u,\n\t0xF3BCC908u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,\n\t0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,\n\t0xADE682F9u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,\n\t0x04BE4294u, 0xE07C2654u, 0x137E2179u, 0x5BE0CD19u\n);\n// Input data buffer\nuint m[32];\n\n// These are offsets into the input data buffer for each mixing step.\n// They are multiplied by 2 from the original SIGMA values in\n// the C reference implementation, which refered to uint64s.\nconst uint SIGMA82[192] = uint[192](\n\t0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,\n\t28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u,\n\t22u,16u,24u,0u,10u,4u,30u,26u,20u,28u,6u,12u,14u,2u,18u,8u,\n\t14u,18u,6u,2u,26u,24u,22u,28u,4u,12u,10u,20u,8u,0u,30u,16u,\n\t18u,0u,10u,14u,4u,8u,20u,30u,28u,2u,22u,24u,12u,16u,6u,26u,\n\t4u,24u,12u,20u,0u,22u,16u,6u,8u,26u,14u,10u,30u,28u,2u,18u,\n\t24u,10u,2u,30u,28u,26u,8u,20u,0u,14u,12u,6u,18u,4u,16u,22u,\n\t26u,22u,14u,28u,24u,2u,6u,18u,10u,0u,30u,8u,16u,12u,4u,20u,\n\t12u,30u,28u,18u,22u,6u,0u,16u,24u,4u,26u,14u,2u,8u,20u,10u,\n\t20u,4u,16u,8u,14u,12u,2u,10u,30u,22u,18u,28u,6u,24u,26u,0u,\n\t0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,\n\t28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u\n);\n\n// G mixing function\nvoid G (uint ix, uint iy, uint a, uint b, uint c, uint d) {\n\tbool carry;\n\tuint o0;\n\tuint o1;\n\tuint xor0;\n\tuint xor1;\n\n\t// a = a + b;\n\to0 = v[a] + v[b];\n\to1 = v[a+1u] + v[b+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// a = a + m[sigma[r][2*i+0]];\n\to0 = v[a] + m[ix];\n\to1 = v[a+1u] + m[ix+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// d = rotr64(d ^ a, 32);\n\txor0 = v[d] ^ v[a];\n\txor1 = v[d+1u] ^ v[a+1u];\n\tv[d] = xor1;\n\tv[d+1u] = xor0;\n\n\t// c = c + d;\n\to0 = v[c] + v[d];\n\to1 = v[c+1u] + v[d+1u];\n\tcarry = o0 < v[c];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[c] = o0;\n\tv[c+1u] = o1;\n\n\t// b = rotr64(b ^ c, 24);\n\txor0 = v[b] ^ v[c];\n\txor1 = v[b+1u] ^ v[c+1u];\n\tv[b] = (xor0 >> 24u) ^ (xor1 << 8u);\n\tv[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);\n\n\t// a = a + b;\n\to0 = v[a] + v[b];\n\to1 = v[a+1u] + v[b+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// a = a + m[sigma[r][2*i+1]];\n\to0 = v[a] + m[iy];\n\to1 = v[a+1u] + m[iy+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// d = rotr64(d ^ a, 16)\n\txor0 = v[d] ^ v[a];\n\txor1 = v[d+1u] ^ v[a+1u];\n\tv[d] = (xor0 >> 16u) ^ (xor1 << 16u);\n\tv[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);\n\n\t// c = c + d;\n\to0 = v[c] + v[d];\n\to1 = v[c+1u] + v[d+1u];\n\tcarry = o0 < v[c];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[c] = o0;\n\tv[c+1u] = o1;\n\n\t// b = rotr64(b ^ c, 63)\n\txor0 = v[b] ^ v[c];\n\txor1 = v[b+1u] ^ v[c+1u];\n\tv[b] = (xor1 >> 31u) ^ (xor0 << 1u);\n\tv[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);\n}\n\nvoid main() {\n\tint i;\n\tuvec4 u_work0 = work[0u];\n\tuvec4 u_work1 = work[1u];\n\tuint uv_x = uint(uv_pos.x * workload);\n\tuint uv_y = uint(uv_pos.y * workload);\n\tuint x_pos = uv_x % 256u;\n\tuint y_pos = uv_y % 256u;\n\tuint x_index = (uv_x - x_pos) / 256u;\n\tuint y_index = (uv_y - y_pos) / 256u;\n\n\t// First 2 work bytes are the x,y pos within the 256x256 area, the next\n\t// two bytes are modified from the random generated value, XOR'd with\n\t// the x,y area index of where this pixel is located\n\tm[0u] = (x_pos ^ (y_pos << 8u) ^ ((u_work0.b ^ x_index) << 16u) ^ ((u_work0.a ^ y_index) << 24u));\n\n\t// Remaining bytes are un-modified from the random generated value\n\tm[1u] = (u_work1.r ^ (u_work1.g << 8u) ^ (u_work1.b << 16u) ^ (u_work1.a << 24u));\n\n\t// Block hash\n\tfor (uint i = 0u; i < 8u; i = i + 1u) {\n\t\tm[i+2u] = blockhash[i];\n\t}\n\n\t// twelve rounds of mixing\n\tfor(uint i = 0u; i < 12u; i = i + 1u) {\n\t\tG(SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u], 0u, 8u, 16u, 24u);\n\t\tG(SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u], 2u, 10u, 18u, 26u);\n\t\tG(SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u], 4u, 12u, 20u, 28u);\n\t\tG(SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u], 6u, 14u, 22u, 30u);\n\t\tG(SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u], 0u, 10u, 20u, 30u);\n\t\tG(SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u], 2u, 12u, 22u, 24u);\n\t\tG(SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u], 4u, 14u, 16u, 26u);\n\t\tG(SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u], 6u, 8u, 18u, 28u);\n\t}\n\n\t// Pixel data is multipled by threshold test result (0 or 1)\n\t// First 4 bytes insignificant, only calculate digest of second 4 bytes\n\tif ((BLAKE2B_IV32_1 ^ v[1u] ^ v[17u]) > threshold) {\n\t\tfragColor = vec4(\n\t\t\tfloat(x_index + 1u)/255.0, // +1 to distinguish from 0 (unsuccessful) pixels\n\t\t\tfloat(y_index + 1u)/255.0, // Same as previous\n\t\t\tfloat(x_pos)/255.0, // Return the 2 custom bytes used in work value\n\t\t\tfloat(y_pos)/255.0  // Second custom byte\n\t\t);\n\t} else {\n \t\tdiscard;\n\t}\n}\n";

package/dist/shaders/gl-fragment.js

@@ -1,206 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
-// SPDX-License-Identifier: GPL-3.0-or-later AND MIT
-export const NanoPowGlFragmentShader = `#version 300 es
-#pragma vscode_glsllint_stage: frag
-precision highp float;
-precision highp int;
-
-in vec2 uv_pos;
-out vec4 fragColor;
-
-// blockhash - array of precalculated block hash components
-// threshold - 0xfffffff8 for send/change blocks, 0xfffffe00 for all else
-// workload - Defines canvas size
-layout(std140) uniform UBO {
-	uint blockhash[8];
-	uint threshold;
-	float workload;
-};
-
-// Random work values
-// First 2 bytes will be overwritten by texture pixel position
-// Second 2 bytes will be modified if the canvas size is greater than 256x256
-// Last 4 bytes remain as generated externally
-layout(std140) uniform WORK {
-	uvec4 work[2];
-};
-
-// Defined separately from uint v[32] below as the original value is required
-// to calculate the second uint32 of the digest for threshold comparison
-const uint BLAKE2B_IV32_1 = 0x6A09E667u;
-
-// Both buffers represent 16 uint64s as 32 uint32s
-// because that's what GLSL offers, just like Javascript
-
-// Compression buffer, intialized to 2 instances of the initialization vector
-// The following values have been modified from the BLAKE2B_IV:
-// OUTLEN is constant 8 bytes
-// v[0] ^= 0x01010000u ^ uint(OUTLEN);
-// INLEN is constant 40 bytes: work value (8) + block hash (32)
-// v[24] ^= uint(INLEN);
-// It's always the "last" compression at this INLEN
-// v[28] = ~v[28];
-// v[29] = ~v[29];
-uint v[32] = uint[32](
-	0xF2BDC900u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,
-	0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,
-	0xADE682D1u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,
-	0xFB41BD6Bu, 0x1F83D9ABu, 0x137E2179u, 0x5BE0CD19u,
-	0xF3BCC908u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,
-	0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,
-	0xADE682F9u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,
-	0x04BE4294u, 0xE07C2654u, 0x137E2179u, 0x5BE0CD19u
-);
-// Input data buffer
-uint m[32];
-
-// These are offsets into the input data buffer for each mixing step.
-// They are multiplied by 2 from the original SIGMA values in
-// the C reference implementation, which refered to uint64s.
-const uint SIGMA82[192] = uint[192](
-	0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,
-	28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u,
-	22u,16u,24u,0u,10u,4u,30u,26u,20u,28u,6u,12u,14u,2u,18u,8u,
-	14u,18u,6u,2u,26u,24u,22u,28u,4u,12u,10u,20u,8u,0u,30u,16u,
-	18u,0u,10u,14u,4u,8u,20u,30u,28u,2u,22u,24u,12u,16u,6u,26u,
-	4u,24u,12u,20u,0u,22u,16u,6u,8u,26u,14u,10u,30u,28u,2u,18u,
-	24u,10u,2u,30u,28u,26u,8u,20u,0u,14u,12u,6u,18u,4u,16u,22u,
-	26u,22u,14u,28u,24u,2u,6u,18u,10u,0u,30u,8u,16u,12u,4u,20u,
-	12u,30u,28u,18u,22u,6u,0u,16u,24u,4u,26u,14u,2u,8u,20u,10u,
-	20u,4u,16u,8u,14u,12u,2u,10u,30u,22u,18u,28u,6u,24u,26u,0u,
-	0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,
-	28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u
-);
-
-// G mixing function
-void G (uint ix, uint iy, uint a, uint b, uint c, uint d) {
-	bool carry;
-	uint o0;
-	uint o1;
-	uint xor0;
-	uint xor1;
-
-	// a = a + b;
-	o0 = v[a] + v[b];
-	o1 = v[a+1u] + v[b+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// a = a + m[sigma[r][2*i+0]];
-	o0 = v[a] + m[ix];
-	o1 = v[a+1u] + m[ix+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// d = rotr64(d ^ a, 32);
-	xor0 = v[d] ^ v[a];
-	xor1 = v[d+1u] ^ v[a+1u];
-	v[d] = xor1;
-	v[d+1u] = xor0;
-
-	// c = c + d;
-	o0 = v[c] + v[d];
-	o1 = v[c+1u] + v[d+1u];
-	carry = o0 < v[c];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[c] = o0;
-	v[c+1u] = o1;
-
-	// b = rotr64(b ^ c, 24);
-	xor0 = v[b] ^ v[c];
-	xor1 = v[b+1u] ^ v[c+1u];
-	v[b] = (xor0 >> 24u) ^ (xor1 << 8u);
-	v[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);
-
-	// a = a + b;
-	o0 = v[a] + v[b];
-	o1 = v[a+1u] + v[b+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// a = a + m[sigma[r][2*i+1]];
-	o0 = v[a] + m[iy];
-	o1 = v[a+1u] + m[iy+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// d = rotr64(d ^ a, 16)
-	xor0 = v[d] ^ v[a];
-	xor1 = v[d+1u] ^ v[a+1u];
-	v[d] = (xor0 >> 16u) ^ (xor1 << 16u);
-	v[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);
-
-	// c = c + d;
-	o0 = v[c] + v[d];
-	o1 = v[c+1u] + v[d+1u];
-	carry = o0 < v[c];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[c] = o0;
-	v[c+1u] = o1;
-
-	// b = rotr64(b ^ c, 63)
-	xor0 = v[b] ^ v[c];
-	xor1 = v[b+1u] ^ v[c+1u];
-	v[b] = (xor1 >> 31u) ^ (xor0 << 1u);
-	v[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);
-}
-
-void main() {
-	int i;
-	uvec4 u_work0 = work[0u];
-	uvec4 u_work1 = work[1u];
-	uint uv_x = uint(uv_pos.x * workload);
-	uint uv_y = uint(uv_pos.y * workload);
-	uint x_pos = uv_x % 256u;
-	uint y_pos = uv_y % 256u;
-	uint x_index = (uv_x - x_pos) / 256u;
-	uint y_index = (uv_y - y_pos) / 256u;
-
-	// First 2 work bytes are the x,y pos within the 256x256 area, the next
-	// two bytes are modified from the random generated value, XOR'd with
-	// the x,y area index of where this pixel is located
-	m[0u] = (x_pos ^ (y_pos << 8u) ^ ((u_work0.b ^ x_index) << 16u) ^ ((u_work0.a ^ y_index) << 24u));
-
-	// Remaining bytes are un-modified from the random generated value
-	m[1u] = (u_work1.r ^ (u_work1.g << 8u) ^ (u_work1.b << 16u) ^ (u_work1.a << 24u));
-
-	// Block hash
-	for (uint i = 0u; i < 8u; i = i + 1u) {
-		m[i+2u] = blockhash[i];
-	}
-
-	// twelve rounds of mixing
-	for(uint i = 0u; i < 12u; i = i + 1u) {
-		G(SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u], 0u, 8u, 16u, 24u);
-		G(SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u], 2u, 10u, 18u, 26u);
-		G(SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u], 4u, 12u, 20u, 28u);
-		G(SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u], 6u, 14u, 22u, 30u);
-		G(SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u], 0u, 10u, 20u, 30u);
-		G(SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u], 2u, 12u, 22u, 24u);
-		G(SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u], 4u, 14u, 16u, 26u);
-		G(SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u], 6u, 8u, 18u, 28u);
-	}
-
-	// Pixel data is multipled by threshold test result (0 or 1)
-	// First 4 bytes insignificant, only calculate digest of second 4 bytes
-	if ((BLAKE2B_IV32_1 ^ v[1u] ^ v[17u]) > threshold) {
-		fragColor = vec4(
-			float(x_index + 1u)/255.0, // +1 to distinguish from 0 (unsuccessful) pixels
-			float(y_index + 1u)/255.0, // Same as previous
-			float(x_pos)/255.0, // Return the 2 custom bytes used in work value
-			float(y_pos)/255.0  // Second custom byte
-		);
-	} else {
- 		discard;
-	}
-}
-`;

package/dist/shaders/gl-vertex.d.ts

@@ -1 +0,0 @@
-export declare const NanoPowGlVertexShader = "#version 300 es\n#pragma vscode_glsllint_stage: vert\nprecision highp float;\nlayout (location=0) in vec4 position;\nlayout (location=1) in vec2 uv;\n\nout vec2 uv_pos;\n\nvoid main() {\n\tuv_pos = uv;\n\tgl_Position = position;\n}\n";

package/dist/shaders/gl-vertex.js

@@ -1,16 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
-// SPDX-License-Identifier: GPL-3.0-or-later AND MIT
-export const NanoPowGlVertexShader = `#version 300 es
-#pragma vscode_glsllint_stage: vert
-precision highp float;
-layout (location=0) in vec4 position;
-layout (location=1) in vec2 uv;
-
-out vec2 uv_pos;
-
-void main() {
-	uv_pos = uv;
-	gl_Position = position;
-}
-`;

package/dist/shaders/index.d.ts

@@ -1,4 +0,0 @@
-import { default as NanoPowGpuComputeShader } from "./compute.wgsl";
-import { NanoPowGlFragmentShader } from "./gl-fragment.js";
-import { NanoPowGlVertexShader } from "./gl-vertex.js";
-export { NanoPowGpuComputeShader, NanoPowGlFragmentShader, NanoPowGlVertexShader };

package/dist/shaders/index.js

@@ -1,6 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { default as NanoPowGpuComputeShader } from "./compute.wgsl";
-import { NanoPowGlFragmentShader } from "./gl-fragment.js";
-import { NanoPowGlVertexShader } from "./gl-vertex.js";
-export { NanoPowGpuComputeShader, NanoPowGlFragmentShader, NanoPowGlVertexShader };