yes

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_cast.frag

@@ -0,0 +1,58 @@
+
+// [COMBO] {"material":"ui_editor_properties_cast_type","combo":"CASTER","type":"options","default":0,"options":{"Radial":0,"Directional":1}}
+// [COMBO] {"material":"ui_editor_properties_quality","combo":"SAMPLES","type":"options","default":0,"options":{"30":0,"50":1}}
+
+#include "common.h"
+
+varying vec2 v_TexCoord;
+
+uniform sampler2D g_Texture0; // {"hidden":true}
+
+uniform float g_Length; // {"material":"raylength","label":"ui_editor_properties_ray_length","default":0.5,"range":[0.01, 1]}
+uniform float g_Intensity; // {"material":"rayintensity","label":"ui_editor_properties_ray_intensity","default":1,"range":[0.01, 2.0]}
+uniform vec3 g_ColorRays; // {"material":"color","label":"ui_editor_properties_color","default":"1 1 1","type":"color"}
+
+#if CASTER == 0
+uniform vec2 g_Center; // {"material":"center","label":"ui_editor_properties_center","default":"0.5 0.5","position":true}
+#else
+uniform float g_Direction; // {"material":"direction","label":"ui_editor_properties_direction","default":3.14159265358,"direction":true,"conversion":"rad2deg"}
+#endif
+
+void main() {
+
+	vec2 texCoords = v_TexCoord;
+	vec4 albedo = CAST4(0.0);
+	
+#if CASTER == 0
+	vec2 direction = g_Center - texCoords;
+#else
+	vec2 direction = rotateVec2(vec2(0, -0.5), g_Direction - M_PI);
+#endif
+	
+	float dist = length(direction);
+	direction /= dist;
+	
+	dist *= g_Length;
+	texCoords += direction * dist;
+	
+#if SAMPLES == 0
+	const int sampleCount = 30;
+	const float sampleIntensity = 0.1;
+#endif
+#if SAMPLES == 1
+	const int sampleCount = 50;
+	const float sampleIntensity = 0.1 * (30 / 50.0);
+#endif
+	const float sampleDrop = sampleCount - 1;
+	
+	direction = direction * dist / sampleDrop;
+	for (int i = 0; i < sampleCount; ++i)
+	{
+		vec4 sample = texSample2D(g_Texture0, texCoords);
+		texCoords -= direction;
+		albedo += sample * (i / sampleDrop);
+	}
+	
+	albedo.rgb *= g_ColorRays;
+	gl_FragColor = vec4(g_Intensity * sampleIntensity * albedo.rgb, saturate(g_Intensity * sampleIntensity * albedo.a));
+}

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_cast.vert

@@ -0,0 +1,14 @@
+
+uniform mat4 g_ModelViewProjectionMatrix;
+uniform vec4 g_Texture1Resolution;
+
+attribute vec3 a_Position;
+attribute vec2 a_TexCoord;
+
+varying vec2 v_TexCoord;
+
+void main() {
+	gl_Position = vec4(a_Position, 1.0);
+	
+	v_TexCoord = a_TexCoord;
+}

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_combine.frag

@@ -0,0 +1,37 @@
+
+// [COMBO] {"material":"ui_editor_properties_blend_mode","combo":"BLENDMODE","type":"imageblending","default":9}
+// [COMBO] {"material":"ui_editor_properties_copy_background","combo":"COPYBG","type":"options"}
+
+#include "common_blending.h"
+
+varying vec4 v_TexCoord;
+
+#if COPYBG
+varying vec3 v_ScreenCoord;
+
+uniform sampler2D g_Texture2; // {"hidden":true,"default":"_rt_FullFrameBuffer"}
+#endif
+
+uniform sampler2D g_Texture0; // {"hidden":true}
+uniform sampler2D g_Texture1; // {"hidden":true}
+
+void main() {
+
+	vec4 rays = texSample2D(g_Texture0, v_TexCoord.zw);
+	vec4 albedo = texSample2D(g_Texture1, v_TexCoord.xy);
+	
+#if COPYBG
+	vec2 screenCoord = v_ScreenCoord.xy / v_ScreenCoord.z * vec2(0.5, 0.5) + 0.5;
+	vec4 bg = texSample2D(g_Texture2, screenCoord.xy);
+	albedo.rgb = mix(bg.rgb, albedo.rgb, albedo.a);
+#endif
+
+#if BLENDMODE == 0
+	albedo = rays;
+#else
+	albedo.rgb = ApplyBlending(BLENDMODE, albedo.rgb, rays.rgb, rays.a);
+	albedo.a = saturate(albedo.a + rays.a);
+#endif
+	
+	gl_FragColor = albedo;
+}

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_combine.vert

@@ -0,0 +1,35 @@
+
+uniform mat4 g_ModelViewProjectionMatrix;
+uniform vec4 g_Texture1Resolution;
+
+attribute vec3 a_Position;
+attribute vec2 a_TexCoord;
+
+varying vec4 v_TexCoord;
+
+#if COPYBG
+uniform mat4 g_EffectModelViewProjectionMatrix;
+
+varying vec3 v_ScreenCoord;
+#endif
+
+#ifdef HLSL_SM30
+uniform vec4 g_Texture0Resolution;
+#endif
+
+void main() {
+	gl_Position = mul(vec4(a_Position, 1.0), g_ModelViewProjectionMatrix);
+	
+	v_TexCoord = a_TexCoord.xyxy;
+	
+#ifdef HLSL_SM30
+	v_TexCoord.zw += 0.5 / g_Texture0Resolution.xy;
+#endif
+
+#if COPYBG
+	v_ScreenCoord = mul(vec4((a_Position), 1.0), g_EffectModelViewProjectionMatrix).xyw;
+#if HLSL
+	v_ScreenCoord.y = -v_ScreenCoord.y;
+#endif
+#endif
+}

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_downsample2.frag

@@ -0,0 +1,40 @@
+
+// [COMBO] {"material":"ui_editor_properties_noise","combo":"NOISE","type":"options","default":1}
+
+varying vec4 v_TexCoord;
+
+uniform sampler2D g_Texture0; // {"hidden":true}
+uniform sampler2D g_Texture1; // {"label":"ui_editor_properties_opacity_mask","mode":"opacitymask","combo":"MASK","paintdefaultcolor":"0 0 0 1"}
+
+uniform float g_Threshold; // {"material":"raythreshold","label":"ui_editor_properties_ray_threshold","default":0.5,"range":[0, 1]}
+
+#if NOISE == 1
+varying vec4 v_NoiseTexCoord;
+
+uniform sampler2D g_Texture2; // {"label":"ui_editor_properties_noise","default":"util/clouds_256"}
+uniform float g_NoiseAmount; // {"material":"noiseamount","label":"ui_editor_properties_noise_amount","default":0.4,"range":[0.01, 1]}
+uniform float g_NoiseSmoothness; // {"material":"noisesmoothness","label":"ui_editor_properties_noise_smoothness","default":0.2,"range":[0.01, 0.5]}
+#endif
+
+void main() {
+#if MASK
+	float mask = texSample2D(g_Texture1, v_TexCoord.zw).r;
+#else
+	float mask = 1.0;
+#endif
+	vec4 sample = texSample2D(g_Texture0, v_TexCoord.xy);
+	
+#if NOISE
+	float noiseSample = texSample2D(g_Texture2, v_NoiseTexCoord.xy).r * texSample2D(g_Texture2, v_NoiseTexCoord.zw).r;
+	noiseSample = mix(sample.a, sample.a * noiseSample, g_NoiseAmount);
+#endif
+	
+	sample.rgb *= sample.a;
+	sample.a = 1.0;
+	
+	gl_FragColor = sample * mask * step(g_Threshold, dot(vec3(0.11, 0.59, 0.3), sample.rgb));
+
+#if NOISE
+	gl_FragColor.a *= smoothstep(0.5 - g_NoiseSmoothness, 0.5 + g_NoiseSmoothness, noiseSample);
+#endif
+}

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_downsample2.vert

@@ -0,0 +1,37 @@
+
+attribute vec3 a_Position;
+attribute vec2 a_TexCoord;
+
+varying vec4 v_TexCoord;
+
+uniform vec4 g_Texture0Resolution;
+uniform vec4 g_Texture1Resolution;
+
+#if NOISE == 1
+varying vec4 v_NoiseTexCoord;
+#endif
+
+uniform float g_Time;
+uniform float g_NoiseSpeed; // {"material":"noisespeed","label":"ui_editor_properties_noise_speed","default":0.15,"range":[0.01, 1]}
+uniform float g_NoiseScale; // {"material":"noisescale","label":"ui_editor_properties_noise_scale","default":3,"range":[0.01, 10]}
+
+void main() {
+	gl_Position = vec4(a_Position, 1.0);
+	v_TexCoord = a_TexCoord.xyxy;
+
+#if MASK
+	v_TexCoord.z *= g_Texture1Resolution.z / g_Texture1Resolution.x;
+	v_TexCoord.w *= g_Texture1Resolution.w / g_Texture1Resolution.y;
+#endif
+
+#ifdef HLSL_SM30
+	vec2 offsets = 0.5 / g_Texture0Resolution.xy;
+	v_TexCoord.xy += offsets;
+#endif
+	
+#if NOISE == 1
+	v_NoiseTexCoord.xy = a_TexCoord + g_Time * g_NoiseSpeed;
+	v_NoiseTexCoord.wz = vec2(a_TexCoord.y, -a_TexCoord.x) * 0.633 + vec2(-g_Time, g_Time) * 0.5 * g_NoiseSpeed;
+	v_NoiseTexCoord *= g_NoiseScale;
+#endif
+}

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_gaussian.frag

@@ -0,0 +1,18 @@
+
+uniform sampler2D g_Texture0; // {"hidden":true}
+
+#include "common_blur.h"
+
+varying vec4 v_TexCoord;
+
+void main() {
+#if KERNEL == 0
+	gl_FragColor = blur13a(v_TexCoord.xy, v_TexCoord.zw);
+#endif
+#if KERNEL == 1
+	gl_FragColor = blur7a(v_TexCoord.xy, v_TexCoord.zw);
+#endif
+#if KERNEL == 2
+	gl_FragColor = blur3a(v_TexCoord.xy, v_TexCoord.zw);
+#endif
+}

modules/wallpaper-engine/effects/godrays/shaders/effects/godrays_gaussian.vert

@@ -0,0 +1,25 @@
+
+// [COMBO] {"material":"ui_editor_properties_kernel_size","combo":"KERNEL","type":"options","default":1,"options":{"13x13":0,"7x7":1,"3x3":2}}
+
+uniform vec2 g_Scale; // {"material":"blurscale","label":"ui_editor_properties_blur_scale","default":"1 1","linked":true,"range":[0.01, 2.0]}
+
+attribute vec3 a_Position;
+attribute vec2 a_TexCoord;
+
+varying vec4 v_TexCoord;
+
+uniform vec4 g_Texture0Resolution;
+
+void main() {
+	gl_Position = vec4(a_Position, 1.0);
+	
+	v_TexCoord.xy = a_TexCoord;
+	
+#if VERTICAL
+	v_TexCoord.z = 0;
+	v_TexCoord.w = g_Scale.y / g_Texture0Resolution.w;
+#else
+	v_TexCoord.z = g_Scale.x / g_Texture0Resolution.z;
+	v_TexCoord.w = 0;
+#endif
+}