starruler-linux/data/shaders/source/system_plane_ps.txt

#define pi 3.141592653589793238462643383279

const float pipRads = 2.0 * pi / 72.0;
const float pipMargin = 0.15 * pipRads;

const float gridWidth = 8.0;
const float gridSize = 500.0;
const float gridFadeDist = 100000.0;

const float subGridWidth = 4.0;
const float subGridSize = 250.0;
const float subGridFadeDist = 30000.0;

const float subsubGridWidth = 2.0;
const float subsubGridSize = 50.0;
const float subsubGridFadeDist = 10000.0;

uniform float radius;
uniform float inner_radius;
uniform float planeDist;
//uniform float visible;
uniform float cycle;
//uniform vec3 planeColor;
uniform vec4 glowColor;

varying vec2 uv;
varying vec2 rcoords;

//uniform float emp1_endrad;
//uniform float emp2_endrad;
//uniform float emp3_endrad;
//uniform float emp4_endrad;

//uniform float emp2_startrad;
//uniform float emp3_startrad;
//uniform float emp4_startrad;

//uniform vec3 emp1_col;
//uniform vec3 emp2_col;
//uniform vec3 emp3_col;
//uniform vec3 emp4_col;

//vec4 strengthPips(float distance, float bordMult) {
	//float ang = atan(gl_TexCoord[0].y, gl_TexCoord[0].x) + pi;
	//if(ang > emp4_endrad)
		//return vec4(0, 0, 0, 0);
	
	//if(bordMult < 1.5 && mod(ang, pipRads) * bordMult < pipMargin)
		//return vec4(0, 0, 0, 0);

	//vec3 col;
	//if (ang < emp1_endrad) {
		//col = emp1_col;
	//}
	//else if (ang < emp2_endrad) {
		//if (ang < emp2_startrad)
			//return vec4(0, 0, 0, 0);
		//col = emp2_col;
	//}
	//else if (ang < emp3_endrad) {
		//if (ang < emp3_startrad)
			//return vec4(0, 0, 0, 0);
		//col = emp3_col;
	//}
	//else if (ang < emp4_endrad) {
		//if (ang < emp4_startrad)
			//return vec4(0, 0, 0, 0);
		//col = emp4_col;
	//}

	//if (visible == 0.0)
		//return vec4(col, (1.0 - distance) / (0.04 * bordMult) * 0.4);
	//return vec4(col, 1.0);
//}

vec4 grid(float distance, float bordMult) {
	if(distance >= 1.0)
		return vec4(0, 0, 0, 0);

	//float innerPipBorder = 1.0 - (0.04 * bordMult);
	//if (distance > innerPipBorder) {
		//return strengthPips(distance, bordMult);
	//}

	vec4 res;
	res.rgb = gl_Color.rgb;
	float baseAlpha = smoothstep(500.0, 2000.0, planeDist) * 0.08;

	float inner_distance = inner_radius / radius;
	if(distance > inner_distance)
		baseAlpha *= 1.0 - ((distance - inner_distance) / (1.0 - inner_distance));

	vec2 absCoords = rcoords * radius;
	vec2 gridPos = abs(mod(absCoords, gridSize));
	gridPos = min(gridPos, gridSize - gridPos);

	// Main grid alpha
	if(planeDist < gridFadeDist) {
		if(gridPos.x <= gridWidth * bordMult || gridPos.y <= gridWidth * bordMult) {
			res.a = baseAlpha * 2.0;
			return res;
		}

		if(planeDist < subGridFadeDist) {
			vec2 subGridPos = abs(mod(absCoords, subGridSize));
			subGridPos = min(subGridPos, subGridSize - subGridPos);
			if(subGridPos.x <= subGridWidth * bordMult || subGridPos.y <= subGridWidth * bordMult) {
				res.a = baseAlpha * 1.8;
				return res;
			}
			
			if(planeDist < subsubGridFadeDist) {
				vec2 subsubGridPos = abs(mod(absCoords, subsubGridSize));
				subsubGridPos = min(subsubGridPos, subsubGridSize - subsubGridPos);
				if(subsubGridPos.x <= subsubGridWidth * bordMult || subsubGridPos.y <= subsubGridWidth * bordMult) {
					res.a = baseAlpha * 1.5;
					return res;
				}
			}
		}
	}
	
	res.a = baseAlpha;
	return res;
}

vec4 attackGlow(vec4 color, float distance, float bordMult) {
	float inner_distance = 1.0 - ((1.0 - (inner_radius / radius)) * 0.2 * bordMult);
	if(distance < inner_distance || distance > 1.0)
		return color;

	float pct = (distance - inner_distance) / (1.0 - inner_distance);
	pct *= abs(cycle - 0.5) / 0.5;

	return vec4(mix(glowColor.rgb, color.rgb, color.a / pct),
			mix(color.a, glowColor.a, pct));
}

void main() {
	float distance = length(rcoords);
	float glowMult = min(planeDist / 10000.0, 6.0) + 1.0;
	float bordMult = min(planeDist / 2000.0, 2.0);

	vec4 color = grid(distance, bordMult);

	if (glowColor.a != 0.0)
		color = attackGlow(color, distance, glowMult);

	if (color.a == 0.0)
		discard;

	gl_FragColor = color;
}