rubysketch-solitaire 0.1.0 → 0.1.2

data/data/classicPSPWave.glsl

@@ -0,0 +1,94 @@
+// PSP Classic Wave by ParkingLotGames (github/ParkingLotGames)
+// https://www.shadertoy.com/view/ddV3DK
+// Original for Unity: https://github.com/ParkingLotGames/PSP-Classic-Wave-Unity-Shader
+// License: MIT
+
+/*
+MIT License
+
+Copyright (c) 2023 Parking Lot Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+    vec4 _TopColor = vec4(0.04, 0.19, 0.54, 1.0);
+    vec4 _BottomColor = vec4(0.04, 0.69, 0.87, 1.0);
+    
+    vec2 uv = fragCoord/iResolution.xy;
+    
+    float _Frequency = 4.29;
+    float _OuterWavesAmplitude = 0.5;
+    float _InnerWavesAmplitude = 0.18;
+    float _OuterWavesSpeed = 0.044;
+    float _InnerWavesSpeed = 0.064;
+    float _OuterWave1Falloff = 2.0;
+    float _OuterWave2Falloff = 2.0;
+    float _InnerWave1Falloff = 1.0;
+    float _InnerWave2Falloff = 1.0;
+
+    vec3 white = vec3(1.0, 1.0, 1.0);
+    
+    float topOuterWave = sin((uv.x + (iTime * (_OuterWavesSpeed + (0.0025 * 1.0)))) * _Frequency) * _OuterWavesAmplitude;
+    float bottomOuterWave = sin((uv.x + (iTime * (_OuterWavesSpeed + (0.0025 * 20.0)))) * _Frequency) * _OuterWavesAmplitude;
+    float topInnerWave = sin((uv.x + (iTime * (_InnerWavesSpeed + (0.0025 * 8.0)))) * _Frequency) * _InnerWavesAmplitude;
+    float bottomInnerWave = sin((uv.x + (iTime * (_InnerWavesSpeed + (0.0025 * 40.0)))) * _Frequency) * _InnerWavesAmplitude;
+
+    float topOuterWaveFalloff = topOuterWave;
+    float bottomOuterWaveFalloff = bottomOuterWave;
+    float topInnerWaveFalloff = topInnerWave;
+    float bottomInnerWaveFalloff = bottomInnerWave;
+
+    topOuterWave += 1.0 - (1.0 - uv.y) * 6.0;
+    bottomOuterWave += 1.0 - (uv.y * 6.0);
+    topInnerWave += 1.0 - (uv.y) * 2.5;
+    bottomInnerWave += 1.0 - (1.0 - uv.y) * 2.5;
+
+    topOuterWaveFalloff += 1.0 - (1.0 - uv.y - 0.2) * 6.0;
+    bottomOuterWaveFalloff += 1.0 - ((uv.y - 0.2) * 6.0);
+    topInnerWaveFalloff += 1.0 - ((uv.y - 0.1) * 2.2);
+    bottomInnerWaveFalloff += 1.0 - (((1.0 - uv.y - 0.1)) * 2.2);
+
+    float wave1 = 1.0 - smoothstep(0.0, 0.025, topOuterWave);
+    float wave2 = 1.0 - smoothstep(0.0, 0.025, bottomOuterWave);
+    float wave3 = 1.0 - smoothstep(0.0, 0.025, topInnerWave);
+    float wave4 = 1.0 - smoothstep(0.0, 0.025, bottomInnerWave);
+
+    float wave1Falloff = 1.0 - smoothstep(0.0, _OuterWave1Falloff, topOuterWaveFalloff);
+    float wave2Falloff = 1.0 - smoothstep(0.0, _OuterWave2Falloff, bottomOuterWaveFalloff);
+    float wave3Falloff = 1.0 - smoothstep(0.0, _InnerWave1Falloff, topInnerWaveFalloff);
+    float wave4Falloff = 1.0 - smoothstep(0.0, _InnerWave2Falloff, bottomInnerWaveFalloff);
+
+    wave1 -= wave1Falloff;
+    wave2 -= wave2Falloff;
+    wave3 -= wave3Falloff;
+    wave4 -= wave4Falloff;
+
+    wave1 = clamp(wave1, 0.0, 1.0);
+    wave2 = clamp(wave2, 0.0, 1.0);
+    wave3 = clamp(wave3, 0.0, 1.0);
+    wave4 = clamp(wave4, 0.0, 1.0);
+
+    float wave = wave1 + wave2 + wave3 + wave4;
+    vec4 waveContribution = vec4(white,wave);
+    vec4 background = vec4(mix(_BottomColor.rgb, _TopColor.rgb, uv.y), 1.0);
+
+    fragColor = mix(background, waveContribution, wave);
+}

data/data/colorfulUnderwaterBubbles2.glsl

@@ -0,0 +1,113 @@
+// CCO: Colorful underwater bubbles II
+//  Recoloring of earlier shader + spherical shading
+
+#define const
+
+#define TIME        iTime
+#define RESOLUTION  iResolution
+#define PI          3.141592654
+#define TAU         (2.0*PI)
+const float MaxIter = 12.0;
+
+// License: Unknown, author: Unknown, found: don't remember
+float hash(float co) {
+  return fract(sin(co*12.9898) * 13758.5453);
+}
+
+// License: Unknown, author: Unknown, found: don't remember
+float hash(vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,58.233))) * 13758.5453);
+}
+
+// License: MIT OR CC-BY-NC-4.0, author: mercury, found: https://mercury.sexy/hg_sdf/
+vec2 mod2(inout vec2 p, vec2 size) {
+  vec2 c = floor((p + size*0.5)/size);
+  p = mod(p + size*0.5,size) - size*0.5;
+  return c;
+}
+
+vec4 plane(vec2 p, float i, float zf, float z, vec3 bgcol) {
+  float sz = 0.5*zf;
+  vec2 cp = p;
+  vec2 cn = mod2(cp, vec2(2.0*sz, sz));
+  float h0 = hash(cn+i+123.4);
+  float h1 = fract(4483.0*h0);
+  float h2 = fract(8677.0*h0);
+  float h3 = fract(9677.0*h0);
+  float h4 = fract(7877.0*h0);
+  float h5 = fract(9967.0*h0);
+  if (h4 < 0.5) {
+    return vec4(0.0);
+  }
+  float fi = exp(-0.25*max(z-2.0, 0.0));
+  float aa = mix(0.0125, 2.0/RESOLUTION.y, fi); 
+  float r  = sz*mix(0.1, 0.475, h0*h0);
+  float amp = mix(0.5, 0.5, h3)*r;
+  cp.x -= amp*sin(mix(3.0, 0.25, h0)*TIME+TAU*h2);
+  cp.x += 0.95*(sz-r-amp)*sign(h3-0.5)*h3;
+  cp.y += 0.475*(sz-2.0*r)*sign(h5-0.5)*h5;
+  float d = length(cp)-r;
+  if (d > aa) {
+    return vec4(0.0);
+  }
+  vec3 ocol = (0.5+0.5*sin(vec3(0.0, 1.0, 2.0)+h1*TAU));
+  vec3 icol = sqrt(ocol);
+  ocol *= 1.5;
+  icol *= 2.0;
+  const vec3 lightDir = normalize(vec3(1.0, 1.5, 2.0));
+  float z2 = (r*r-dot(cp, cp));
+  vec3 col = ocol;
+  float t = smoothstep(aa, -aa, d);
+  if (z2 > 0.0) {
+    float z = sqrt(z2);
+    t *= mix(1.0, 0.8, z/r);
+    vec3 pp = vec3(cp, z);
+    vec3 nn = normalize(pp);
+    float dd= max(dot(lightDir, nn), 0.0);
+    
+    col = mix(ocol, icol, dd*dd*dd);
+  }
+  col *= mix(0.8, 1.0, h0);
+  col = mix(bgcol, col, fi);
+  return vec4(col, t);
+}
+
+// License: Unknown, author: Claude Brezinski, found: https://mathr.co.uk/blog/2017-09-06_approximating_hyperbolic_tangent.html
+float tanh_approx(float x) {
+  //  Found this somewhere on the interwebs
+  //  return tanh(x);
+  float x2 = x*x;
+  return clamp(x*(27.0 + x2)/(27.0+9.0*x2), -1.0, 1.0);
+}
+
+vec3 effect(vec2 p, vec2 pp) {
+  const vec3 bgcol0 = vec3(0.1, 0.0, 1.0)*0.1; 
+  const vec3 bgcol1 = vec3(0.0, 0.4, 1.0)*0.6;
+  vec3 bgcol = mix(bgcol1, bgcol0, tanh_approx(1.5*length(p)));
+  vec3 col = bgcol;
+
+  for (float i = 0.0; i < MaxIter; ++i) {
+    const float Near = 4.0;
+    float z = MaxIter - i;
+    float zf = Near/(Near + MaxIter - i);
+    vec2 sp = p;
+    float h = hash(i+1234.5); 
+    sp.y += -mix(0.2, 0.3, h*h)*TIME*zf;
+    sp += h;
+    vec4 pcol = plane(sp, i, zf, z, bgcol);
+    col = mix(col, pcol.xyz, pcol.w);
+  }
+  col *= smoothstep(1.5, 0.5, length(pp));
+  col = clamp(col, 0.0, 1.0);
+  col = sqrt(col);
+  return col;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord) {
+  vec2 q = fragCoord/RESOLUTION.xy;
+  vec2 p = -1. + 2. * q;
+  vec2 pp = p;
+  p.x *= RESOLUTION.x/RESOLUTION.y;
+  vec3 col = effect(p, pp);
+  fragColor = vec4(col, 1.0);
+}

data/data/cosmic2.glsl

@@ -0,0 +1,121 @@
+// Started as Star Nest by Pablo Román Andrioli
+// Modifications by Beibei Wang and Huw Bowles.
+// This content is under the MIT License.
+
+// On reducing the spatial high frequency noise:
+
+// We simply limit the size of each contribution of each iteration of the fractal using min():
+// a += i > 7 ? min( 12.,abs(length(p)-pa)) : abs(length(p)-pa)
+// The test on the iteration count is optional, we found that most of the problem noise is introduced in the later
+// iterations so we found that keeping the original formula for the earlier iterations helps to retain the 'volume'
+// without the noise.
+
+
+// On reducing the temporal noise:
+
+// This version has volume samples aligned along view space Z isolines. When the camera moves
+// forwards, the samples are shifted towards the viewer, allowing the camera to move forward
+// smoothly without aliasing (besides the high frequency speckle noise).
+
+// However if the  camera were to rotate around its origin, the volume samples towards
+// the sides of the image sweep in Z and aliasing would occur. To make this case work, the samples
+// need to be arranged in concentric rings around the camera. However in this configuration
+// there will be some aliasing at the sides of the screen when the camera moves forward,
+// because the motion of the camera can no longer be compensated for completely - one can
+// pull in the vert rings but they will move at different rates in Z
+
+// I had similar issues in a different context and made some diagrams etc, see
+// http://advances.realtimerendering.com/s2013/OceanShoestring_SIGGRAPH2013_Online.pptx
+// And developed a fast realtime version of adaptive stationary sampling:
+// https://www.shadertoy.com/view/XdBXWW
+
+
+// Question - the derivative can be computed for "free" using dual numbers, as in https://www.shadertoy.com/view/Xd2GzR .
+// The derivate may help to eliminate noise? Or perhaps the second derivate. It would be very interesting to see these
+// derivatives rendered.
+
+#define iterations 17
+#define formuparam 0.53
+
+#define volsteps 18
+#define stepsize 0.050
+
+#define zoom   0.800
+#define tile   0.850
+#define speed  0.10 
+
+#define brightness 0.0015
+#define darkmatter 0.300
+#define distfading 0.760
+#define saturation 0.800
+
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+	//get coords and direction
+	vec2 uv=fragCoord.xy/iResolution.xy-.5;
+	uv.y*=iResolution.y/iResolution.x;
+	vec3 dir=vec3(uv*zoom,1.);
+	float time=(iTime-3311.)*speed;
+
+	
+	vec3 from=vec3(1.,.5,0.5);
+	
+	
+	vec3 forward = vec3(0.,0.,1.);
+	
+	//mouse rotation
+	float a1 = 0.3;//3.1415926 * (iMouse.x/iResolution.x-.5);
+	mat2 rot1 = mat2(cos(a1),sin(a1),-sin(a1),cos(a1));
+	float a2 = .6;//3.1415926 * (iMouse.y/iResolution.y-.5);
+	mat2 rot2 = mat2(cos(a2),sin(a2),-sin(a2),cos(a2));
+	dir.xz*=rot1;
+	forward.xz *= rot1;
+	dir.yz*=rot1;
+	forward.yz *= rot1;
+
+	// pan (dodgy)
+	from += (iMouse.x/iResolution.x-.5)*vec3(-forward.z,0.,forward.x);
+	
+	//zoom
+	float zooom = time;
+	from += forward* zooom;
+	float sampleShift = mod( zooom, stepsize );
+	float zoffset = -sampleShift;
+	sampleShift /= stepsize; // make from 0 to 1
+	
+	//volumetric rendering
+	float s=0.1;
+	vec3 v=vec3(0.);
+	for (int r=0; r<volsteps; r++) {
+		vec3 p=from+(s+zoffset)*dir;// + vec3(0.,0.,zoffset);
+		p = abs(vec3(tile)-mod(p,vec3(tile*2.))); // tiling fold
+		float pa,a=pa=0.;
+		for (int i=0; i<iterations; i++) { 
+			p=abs(p)/dot(p,p)-formuparam; // the magic formula
+			//p=abs(p)/max(dot(p,p),0.005)-formuparam; // another interesting way to reduce noise
+            float D = abs(length(p)-pa); // absolute sum of average change
+            a += i > 7 ? min( 12., D) : D;
+			pa=length(p);
+		}
+		//float dm=max(0.,darkmatter-a*a*.001); //dark matter
+		a*=a*a; // add contrast
+		//if (r>3) fade*=1.-dm; // dark matter, don't render near
+		// brightens stuff up a bit
+		float s1 = s+zoffset;
+		// need closed form expression for this, now that we shift samples
+		float fade = pow(distfading,max(0.,float(r)-sampleShift));
+		v+=fade;
+        
+		// fade out samples as they approach the camera
+		if( r == 0 )
+			fade *= 1. - sampleShift;
+		// fade in samples as they approach from the distance
+		if( r == volsteps-1 )
+			fade *= sampleShift;
+		v+=vec3(2.*s1,4.*s1*s1,16.*s1*s1*s1*s1)*a*brightness*fade; // coloring based on distance
+		s+=stepsize;
+	}
+	v=mix(vec3(length(v)),v,saturation); //color adjust
+	fragColor = vec4(v*.01,1.);	
+}

data/data/reflectiveHexes.glsl

@@ -0,0 +1,219 @@
+// CC0: Reflective hexes
+//  Bit of weekend tinkering
+//  Some shadow artefacts which are irritating but felt it was overall good enough to share.
+
+vec2 round(vec2 v) {
+  return floor(v + 0.5);
+}
+#define const
+
+#define TIME                iTime
+#define RESOLUTION          iResolution
+
+#define PI                  3.141592654
+#define TAU                 (2.0*PI)
+
+#define TOLERANCE           0.0001
+#define MAX_RAY_LENGTH      24.0
+#define MAX_RAY_MARCHES     60
+#define MAX_SHADOW_MARCHES  20
+#define NORM_OFF            0.001
+#define ROT(a)              mat2(cos(a), sin(a), -sin(a), cos(a))
+
+// License: WTFPL, author: sam hocevar, found: https://stackoverflow.com/a/17897228/418488
+const vec4 hsv2rgb_K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+vec3 hsv2rgb(vec3 c) {
+  vec3 p = abs(fract(c.xxx + hsv2rgb_K.xyz) * 6.0 - hsv2rgb_K.www);
+  return c.z * mix(hsv2rgb_K.xxx, clamp(p - hsv2rgb_K.xxx, 0.0, 1.0), c.y);
+}
+// License: WTFPL, author: sam hocevar, found: https://stackoverflow.com/a/17897228/418488
+//  Macro version of above to enable compile-time constants
+#define HSV2RGB(c)  (c.z * mix(hsv2rgb_K.xxx, clamp(abs(fract(c.xxx + hsv2rgb_K.xyz) * 6.0 - hsv2rgb_K.www) - hsv2rgb_K.xxx, 0.0, 1.0), c.y))
+
+const float hoff      = 0.0;
+const float stepf     = 0.8;
+const vec3 skyCol     = HSV2RGB(vec3(hoff+0.57, 0.70, 0.25));
+const vec3 sunCol1    = HSV2RGB(vec3(hoff+0.60, 0.50, 0.5));
+const vec3 sunCol2    = HSV2RGB(vec3(hoff+0.05, 0.75, 25.0));
+const vec3 diffCol    = HSV2RGB(vec3(hoff+0.60, 0.75, 0.25));
+const vec3 sunDir1    = normalize(vec3(3., 3.0, -7.0));
+
+// License: Unknown, author: nmz (twitter: @stormoid), found: https://www.shadertoy.com/view/NdfyRM
+vec3 sRGB(vec3 t) {
+  return mix(1.055*pow(t, vec3(1./2.4)) - 0.055, 12.92*t, step(t, vec3(0.0031308)));
+}
+
+// License: Unknown, author: Matt Taylor (https://github.com/64), found: https://64.github.io/tonemapping/
+vec3 aces_approx(vec3 v) {
+  v = max(v, 0.0);
+  v *= 0.6;
+  float a = 2.51;
+  float b = 0.03;
+  float c = 2.43;
+  float d = 0.59;
+  float e = 0.14;
+  return clamp((v*(a*v+b))/(v*(c*v+d)+e), 0.0, 1.0);
+}
+
+// License: MIT, author: Inigo Quilez, found: https://iquilezles.org/articles/distfunctions/
+float rayPlane(vec3 ro, vec3 rd, vec4 p) {
+  return -(dot(ro,p.xyz)+p.w)/dot(rd,p.xyz);
+}
+
+// License: MIT, author: Inigo Quilez, found: https://iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm
+float box(vec2 p, vec2 b) {
+  vec2 d = abs(p)-b;
+  return length(max(d,0.0)) + min(max(d.x,d.y),0.0);
+}
+
+// License: Unknown, author: Martijn Steinrucken, found: https://www.youtube.com/watch?v=VmrIDyYiJBA
+vec2 hextile(inout vec2 p) {
+  // See Art of Code: Hexagonal Tiling Explained!
+  // https://www.youtube.com/watch?v=VmrIDyYiJBA
+  const vec2 sz       = vec2(1.0, sqrt(3.0));
+  const vec2 hsz      = 0.5*sz;
+
+  vec2 p1 = mod(p, sz)-hsz;
+  vec2 p2 = mod(p - hsz, sz)-hsz;
+  vec2 p3 = dot(p1, p1) < dot(p2, p2) ? p1 : p2;
+  vec2 n = ((p3 - p + hsz)/sz);
+  p = p3;
+
+  n -= vec2(0.5);
+  // Rounding to make hextile 0,0 well behaved
+  return round(n*2.0)*0.5;
+}
+
+// License: MIT, author: Inigo Quilez, found: https://iquilezles.org/articles/distfunctions/
+float hexPrism(vec3 p, vec2 h) {
+  const vec3 k = 0.5*vec3(-sqrt(3.0), 1.0, sqrt(4.0/3.0));
+  p = abs(p);
+  p.xy -= 2.0*min(dot(k.xy, p.xy), 0.0)*k.xy;
+  vec2 d = vec2(
+       length(p.xy-vec2(clamp(p.x,-k.z*h.x,k.z*h.x), h.x))*sign(p.y-h.x),
+       p.z-h.y );
+  return min(max(d.x,d.y),0.0) + length(max(d,0.0));
+}
+
+float df(vec3 p) {
+  vec3 p0 = p.zyx;
+  p0.xy -= 0.1*TIME;
+  vec2 n0 = hextile(p0.yx);
+  float pp = n0.x-0.25*n0.y-0.5*TIME;
+  p0.z  += 0.2*sin(pp);
+  p0.zy *= ROT(-0.2*cos(pp));
+  return hexPrism(p0, vec2(0.425, 0.25))-0.075; 
+}
+
+vec3 normal(vec3 pos) {
+  vec2  eps = vec2(NORM_OFF,0.0);
+  vec3 nor;
+  nor.x = df(pos+eps.xyy) - df(pos-eps.xyy);
+  nor.y = df(pos+eps.yxy) - df(pos-eps.yxy);
+  nor.z = df(pos+eps.yyx) - df(pos-eps.yyx);
+  return normalize(nor);
+}
+
+float rayMarch(vec3 ro, vec3 rd, float initt) {
+  float t = initt;
+  const float tol = TOLERANCE;
+  vec2 dti = vec2(1e10,0.0);
+  int i = 0;
+  for (i = 0; i < MAX_RAY_MARCHES; ++i) {
+    float d = df(ro + rd*t);
+    if (d<dti.x) { dti=vec2(d,t); }
+    if (d < TOLERANCE || t > MAX_RAY_LENGTH) {
+      break;
+    }
+    t += stepf*d;
+  }
+  if(i==MAX_RAY_MARCHES) { t=dti.y; };
+  return t;
+}
+
+float softShadow(vec3 ps, vec3 ld, float mint, float k) {
+  float res = 1.0;
+  float t = mint*3.0;
+  for (int i=0; i<MAX_SHADOW_MARCHES; ++i) {
+    vec3 p = ps + ld*t;
+    float d = df(p);
+    res = min(res, k*d/t);
+    if (res < TOLERANCE) break;
+    
+    t += max(d, mint);
+  }
+  return clamp(res, 0.0, 1.0);
+}
+
+vec3 render0(vec3 ro, vec3 rd) {
+  vec3 col = vec3(0.0);
+  float sd = max(dot(sunDir1, rd), 0.0);
+  float sf = 1.0001-sd;
+  col += 0.5*skyCol*pow((1.0-abs(rd.y)), 8.0);
+  col += sunCol1*pow(sd, 100.0);
+  col += sunCol2*pow(sd, 800.0);
+
+  float tp1  = rayPlane(ro, rd, vec4(vec3(0.0, -1.0, 0.0), 6.0));
+
+  if (tp1 > 0.0) {
+    vec3 pos  = ro + tp1*rd;
+    vec2 pp = pos.xz;
+    float db = box(pp, vec2(5.0, 9.0))-3.0;
+    
+    col += vec3(4.0)*skyCol*rd.y*rd.y*smoothstep(0.25, 0.0, db);
+    col += vec3(0.8)*skyCol*exp(-0.5*max(db, 0.0));
+    col += 0.25*sqrt(skyCol)*max(-db, 0.0);
+  }
+
+  return clamp(col, 0.0, 10.0);;
+}
+
+vec3 render(vec3 ro, vec3 rd) {
+  float initt = -(ro.x-2.0/3.0)/rd.x;
+  float t = rayMarch(ro, rd, initt);
+  vec3 p = ro+rd*t;
+  vec3 n = normal(p);
+  vec3 r = reflect(rd, n);
+  vec3 ld = sunDir1;
+  const float soff = 0.0001;
+  float sd = softShadow(p+soff*n, ld, 0.0125, 3.0);
+  float dif = max(dot(ld, n), 0.0);
+  dif *= dif;
+  dif *= dif;
+  vec3 rcol = render0(p, r);
+  vec3 col = vec3(0.0);
+  if (t < MAX_RAY_LENGTH) {
+    col = diffCol;
+    col *= mix(0.2, 1.0, dif);
+    col *= mix(0.2, 1.0, abs(sd));
+    col += rcol*sd;
+  }
+  return col;
+}
+
+vec3 effect(vec2 p) {
+  const vec3 ro = .66*vec3(5.0, -1., 1.3);
+//  const vec3 ro = 0.8*vec3(5.0, 0.0, 0.0);
+  const vec3 la = vec3(0.0, 0.0, 0.0);
+  const vec3 up = normalize(vec3(0.0, 1.0, 0.3));
+  const vec3 ww = normalize(la - ro);
+  const vec3 uu = normalize(cross(up, ww));
+  const vec3 vv = (cross(ww,uu));
+  const float fov = tan(TAU/6.);
+  vec3 rd = normalize(-p.x*uu + p.y*vv + fov*ww);
+  vec3 col = render(ro, rd);
+  return col;
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
+  vec2 q = fragCoord/RESOLUTION.xy;
+  vec2 p = -1. + 2. * q;
+  vec2 pp = p;
+  p.x *= RESOLUTION.x/RESOLUTION.y;
+  vec3 col = vec3(0.0);
+  col = effect(p);
+  col *= smoothstep(1.5, 0.75, length(pp));
+  col = aces_approx(col); 
+  col = sRGB(col);
+  fragColor = vec4(col, 1.0);
+}

data/fastlane/Fastfile

@@ -0,0 +1,76 @@
+# -*- mode: ruby -*-
+
+
+require 'yaml'
+
+
+def config(key, defval = nil)
+  $config ||= YAML.load_file(File.expand_path '../config.yml', __dir__) rescue {}
+  key = key.to_s.upcase
+  ENV[key] or $config[key] or defval or raise "missing #{key}"
+end
+
+def project()
+  "#{config :app_name}.xcodeproj"
+end
+
+def workspace()
+  "#{config :app_name}.xcworkspace"
+end
+
+
+default_platform(:ios)
+
+platform :ios do
+  lane :setup_code_signing do
+    type     = config :match_type, 'Development'
+    identity = type == 'Development' ? type : 'Distribution'
+    update_code_signing_settings(
+      path:                  project,
+      team_id:               config(:team_id),
+      code_sign_identity:    "Apple #{identity}",
+      profile_name:          "match #{type} #{config :app_id}",
+      use_automatic_signing: false)
+  end
+
+  match_params = -> {{
+    team_id:        config(:team_id),
+    app_identifier: config(:app_id),
+    git_url:        config(:certs_url),
+    git_branch:     config(:app_name)
+  }}
+
+  lane :match_update do
+    %w[development adhoc appstore].each do |type|
+      sync_code_signing type: type, **match_params.call
+    end
+  end
+
+  lane :match_fetch do
+    %w[development adhoc appstore].each do |type|
+      sync_code_signing type: type, **match_params.call, readonly: true
+    end
+  end
+
+  lane :match_delete do
+    %w[development distribution].each do |type|
+      match_nuke(type: type)
+    end
+  end
+
+  upload_params = -> {{
+    apple_id:       config(:apple_id),
+    team_id:        config(:team_id),
+    app_identifier: config(:app_id)
+  }}
+
+  desc "Upload to TestFlight"
+  lane :release_testflight do
+    params = upload_params.call
+    params.update({changelog: config(:changelog)})
+
+    sync_code_signing type: 'appstore', readonly: true, **match_params.call
+    build_app workspace: workspace, scheme: config(:app_name)
+    upload_to_testflight **params
+  end
+end

data/fastlane/metadata/copyright.txt

@@ -0,0 +1 @@
+2023 xord.org

data/fastlane/metadata/en-US/apple_tv_privacy_policy.txt

@@ -0,0 +1 @@
+

data/fastlane/metadata/en-US/description.txt

@@ -0,0 +1,5 @@
+Solitaire in Space is a card game for everyone, from beginners to experts. Clean graphics and simple controls combine to enhance your gaming experience. The game offers a pleasant and immersive gameplay that will make you lose track of time.
+
+Playing solitaire is a relaxing way to relieve everyday stress. Pleasant animations and smooth controls add to the pleasure of lining up the cards. The game also keeps track of daily scores, allowing players to compete for the best score of the day.
+
+Space Solitaire is an essential app for lovers of card games, download it from the App Store and enjoy an optimal solitaire experience. Lose track of time and relieve stress as you line up your cards. More addictive gameplay than ever awaits you.

data/fastlane/metadata/en-US/keywords.txt

@@ -0,0 +1 @@
+playing,card,cards,game,ruby,klondike,free,shader,glsl,processing

data/fastlane/metadata/en-US/marketing_url.txt

@@ -0,0 +1 @@
+https://xord.org/rubysolitaire/

data/fastlane/metadata/en-US/name.txt

@@ -0,0 +1 @@
+Solitaire in Space

data/fastlane/metadata/en-US/privacy_url.txt

@@ -0,0 +1 @@
+https://xord.org/rubysolitaire/privacy_policy.html

data/fastlane/metadata/en-US/promotional_text.txt

@@ -0,0 +1 @@
+Enjoy the best Solitaire experience with "Solitaire in Space"! Vibrant graphics, intuitive controls, and addictive gameplay await you. Lose track of time as you arrange the cards, relieving stress along the way. It's the best choice for Solitaire enthusiasts.

data/fastlane/metadata/en-US/release_notes.txt

@@ -0,0 +1 @@
+- Fixed some minor bugs

data/fastlane/metadata/en-US/subtitle.txt

@@ -0,0 +1 @@
+Several card designs and game backgrounds to choose from

data/fastlane/metadata/en-US/support_url.txt

@@ -0,0 +1 @@
+https://xord.org/rubysolitaire/

data/fastlane/metadata/ja/apple_tv_privacy_policy.txt

@@ -0,0 +1 @@
+

data/fastlane/metadata/ja/description.txt

@@ -0,0 +1,5 @@
+「宇宙ソリティア」は初心者から上級者まで、誰にでも楽しめるソリティアゲームです。美しいグラフィックとシンプルな操作性が組み合わさり、あなたのゲーム体験をさらに一層向上させます。このゲームは、時間を忘れて没頭できる心地よいゲームプレイを提供します。
+
+ソリティアをプレイすることで、日常のストレスを解消し、リラックスできるひとときを過ごせます。繊細なアニメーションと滑らかな操作により、カードを並べる喜びがさらに高まります。また、日ごとのスコアが記録されるため、その日のベストスコアを競うこともできます。
+
+「宇宙ソリティア」は、カードゲームの愛好家にとっては欠かせないアプリです。App Storeからダウンロードして、最適なソリティア体験をお楽しみください。時間を忘れ、ストレスを解消しながらカードを並べましょう。今まで以上に中毒性の高いゲームプレイがあなたを待っています。

data/fastlane/metadata/ja/keywords.txt

@@ -0,0 +1 @@
+そりてぃあ,とらんぷ,かーど,げーむ,ルビー,るびー,クロンダイク,くろんだいく,無料

data/fastlane/metadata/ja/marketing_url.txt

@@ -0,0 +1 @@
+https://xord.org/rubysolitaire/

data/fastlane/metadata/ja/name.txt

@@ -0,0 +1 @@
+宇宙ソリティア トランプカードゲーム

data/fastlane/metadata/ja/privacy_url.txt

@@ -0,0 +1 @@
+https://xord.org/rubysolitaire/privacy_policy.html