maybe working server? But idk uwu

Author: Daxode

Blobtory/Blobtory/.eggs/README.txt

@@ -0,0 +1,6 @@
+This directory contains eggs that were downloaded by setuptools to build, test, and run plug-ins.
+
+This directory caches those eggs to prevent repeated downloads.
+
+However, it is safe to delete this directory.
+

Blobtory/Blobtory/Blobtory.Scripts.planet_former.Nodes.pyd

@@ -0,0 +1,6 @@
+README.md
+setup.py
+Blobtory.egg-info/PKG-INFO
+Blobtory.egg-info/SOURCES.txt
+Blobtory.egg-info/dependency_links.txt
+Blobtory.egg-info/top_level.txt

Blobtory/Blobtory/Blobtory.egg-info/SOURCES.txt

@@ -0,0 +1 @@
+

Blobtory/Blobtory/Blobtory.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Blobtory/Blobtory/Blobtory.egg-info/top_level.txt

@@ -0,0 +1,31 @@
+#version 430
+#extension GL_ARB_compute_variable_group_size : enable
+#define SIZE 512
+layout (local_size_x = SIZE, local_size_y = 1) in;
+
+uniform int gridSize;
+uniform float radius;
+layout(rgba32f, binding = 0) uniform readonly image1D fromVertexes;
+layout(rgba32f, binding = 0) uniform writeonly image1D toVertexes;
+
+vec3 spherize(vec3 cubeCord) {
+    vec3 p = cubeCord * 2.0 / gridSize - vec3(1,1,1);
+    vec3 p2 = vec3(p.x*p.x, p.y*p.y, p.z*p.z);
+    return vec3(
+        p.x * sqrt(1.0 - 0.5 * (p2.y + p2.z) + p2.y * p2.z / 3.0),
+        p.y * sqrt(1.0 - 0.5 * (p2.z + p2.x) + p2.z * p2.x / 3.0),
+        p.z * sqrt(1.0 - 0.5 * (p2.x + p2.y) + p2.x * p2.y / 3.0)
+    )*radius;
+}
+
+void main() {
+    // Read the pixel from the first texture.
+    vec4 pixel = imageLoad(fromVertexes, int(gl_GlobalInvocationID.x));
+    // Swap the red and green channels.
+    pixel = vec4(spherize(pixel.xyz), 1);
+
+    // Now write the modified pixel to the second texture.
+    imageStore(toVertexes, int(gl_GlobalInvocationID.x), pixel);
+    //toVertexes[gl_GlobalInvocationID.x] = spherize(fromVertexes[gl_GlobalInvocationID.x]);
+    //imageStore(kage, ivec2(gl_GlobalInvocationID.x), vec3(1,1,0));
+}

Blobtory/Blobtory/Blobtory.exe

@@ -0,0 +1,51 @@
+#version 430
+
+#pragma include "three_d.glsl"
+
+// Description:
+// This is just a simple compute shader testing include, noise and buffers
+//
+// Author:  Daniel Kierkegaard Andersen (dax@daxode.dk)
+// Version: 2020-09-22
+//
+// Copyright (c) 2020 Daniel Kierkegaard Andersen. All rights reserved.
+// https://github.com/Daxode/ComplexSoftwareProject
+
+layout (local_size_x = 512, local_size_y = 1) in;
+
+// Declare the texture inputs
+layout(rgba32f, binding=0) uniform readonly image2D fromTex;
+uniform writeonly image2D toTex;
+uniform vec3[] kage;
+uniform vec2 mouse;
+
+uniform writeonly imageBuffer someimg;
+
+void main() {
+    // Acquire the coordinates to the texel we are to process.
+
+    ivec2 texelCoords = ivec2(gl_GlobalInvocationID.x / 512, gl_GlobalInvocationID.x % 512);
+    //ivec2 texelCoords = ivec2(gl_GlobalInvocationID.xy);
+
+    // Read the pixel from the first texture.
+    vec4 pixel = imageLoad(fromTex, texelCoords);
+
+    // Swap the red and green channels.
+    // pixel.rg = vec2(gl_GlobalInvocationID.xy)*0.001;
+    if (texelCoords.x < 256) {
+        vec3 samplePoint = vec3(texelCoords, kage[1].x*1000);
+        float noise = snoise(samplePoint*0.001*mouse.x)*100*mouse.y*100;
+        float warpedNoise = snoise((samplePoint+vec3(noise, noise, noise))*0.01);
+        warpedNoise = (warpedNoise+1)/2;
+        pixel = vec4(vec3(warpedNoise, 0, 0), 1);
+    } else {
+        if (texelCoords.y < 256){
+            pixel = vec4(kage[1], 1);
+        }
+    }
+    //if (texelCoords == (mouse-1)*512) {
+        // Now write the modified pixel to the second texture.
+        imageStore(toTex, texelCoords, pixel);
+    //}
+    imageStore(someimg, texelCoords.x, vec4(texelCoords.xy, kage[1].x, 2));
+}

Blobtory/Blobtory/Blobtory/Scripts/Testing/ComputeSpherizeCube.glsl

@@ -0,0 +1,104 @@
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 mod289(vec4 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 permute(vec4 x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+
+vec4 taylorInvSqrt(vec4 r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+
+float snoise(vec3 v)
+  {
+  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
+  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
+
+// First corner
+  vec3 i  = floor(v + dot(v, C.yyy) );
+  vec3 x0 =   v - i + dot(i, C.xxx) ;
+
+// Other corners
+  vec3 g = step(x0.yzx, x0.xyz);
+  vec3 l = 1.0 - g;
+  vec3 i1 = min( g.xyz, l.zxy );
+  vec3 i2 = max( g.xyz, l.zxy );
+
+  //   x0 = x0 - 0.0 + 0.0 * C.xxx;
+  //   x1 = x0 - i1  + 1.0 * C.xxx;
+  //   x2 = x0 - i2  + 2.0 * C.xxx;
+  //   x3 = x0 - 1.0 + 3.0 * C.xxx;
+  vec3 x1 = x0 - i1 + C.xxx;
+  vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+  vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
+
+// Permutations
+  i = mod289(i);
+  vec4 p = permute( permute( permute(
+             i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+           + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+           + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
+
+// Gradients: 7x7 points over a square, mapped onto an octahedron.
+// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+  float n_ = 0.142857142857; // 1.0/7.0
+  vec3  ns = n_ * D.wyz - D.xzx;
+
+  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)
+
+  vec4 x_ = floor(j * ns.z);
+  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)
+
+  vec4 x = x_ *ns.x + ns.yyyy;
+  vec4 y = y_ *ns.x + ns.yyyy;
+  vec4 h = 1.0 - abs(x) - abs(y);
+
+  vec4 b0 = vec4( x.xy, y.xy );
+  vec4 b1 = vec4( x.zw, y.zw );
+
+  //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+  //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+  vec4 s0 = floor(b0)*2.0 + 1.0;
+  vec4 s1 = floor(b1)*2.0 + 1.0;
+  vec4 sh = -step(h, vec4(0.0));
+
+  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
+  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
+
+  vec3 p0 = vec3(a0.xy,h.x);
+  vec3 p1 = vec3(a0.zw,h.y);
+  vec3 p2 = vec3(a1.xy,h.z);
+  vec3 p3 = vec3(a1.zw,h.w);
+
+//Normalise gradients
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+
+// Mix final noise value
+  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+  m = m * m;
+  return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
+                                dot(p2,x2), dot(p3,x3) ) );
+  }
+
+#pragma glslify: export(snoise)

Blobtory/Blobtory/Blobtory/Scripts/Testing/simple.glsl

@@ -0,0 +1,73 @@
+#pragma once
+//
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x*34.0)+1.0)*x);
+}
+
+float snoise(vec2 v)
+  {
+  const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+                      0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+                     -0.577350269189626,  // -1.0 + 2.0 * C.x
+                      0.024390243902439); // 1.0 / 41.0
+// First corner
+  vec2 i  = floor(v + dot(v, C.yy) );
+  vec2 x0 = v -   i + dot(i, C.xx);
+
+// Other corners
+  vec2 i1;
+  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+  //i1.y = 1.0 - i1.x;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  // x0 = x0 - 0.0 + 0.0 * C.xx ;
+  // x1 = x0 - i1 + 1.0 * C.xx ;
+  // x2 = x0 - 1.0 + 2.0 * C.xx ;
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+// Permutations
+  i = mod289(i); // Avoid truncation effects in permutation
+  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+    + i.x + vec3(0.0, i1.x, 1.0 ));
+
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m ;
+  m = m*m ;
+
+// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+// Normalise gradients implicitly by scaling m
+// Approximation of: m *= inversesqrt( a0*a0 + h*h );
+  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
+
+// Compute final noise value at P
+  vec3 g;
+  g.x  = a0.x  * x0.x  + h.x  * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+
+#pragma glslify: export(snoise)