hyperstellar 1.5.6__py3-none-win_amd64.whl

hyperstellar/_native/linux-x64/shaders/axis.frag

@@ -0,0 +1,8 @@
+#version 430 core
+in vec3 color;
+
+out vec4 FragColor;
+
+void main() {
+    FragColor = vec4(color, 1.0); // Using the vertex color directly, smart
+}

hyperstellar/_native/linux-x64/shaders/axis.vert

@@ -0,0 +1,13 @@
+#version 430 core
+layout (location = 0) in vec2 aPos;
+layout (location = 1) in vec3 aColor;
+layout (location = 2) in float aWidth;
+
+uniform mat4 uProjView;
+
+out vec3 color;
+
+void main() {
+    gl_Position = uProjView * vec4(aPos, 0.0, 1.0);
+    color = aColor; // Pass color to fragment shader
+}

hyperstellar/_native/linux-x64/shaders/fragShader.frag

@@ -0,0 +1,27 @@
+#version 430 core
+
+in float magnitude;
+in float chargeInfluence; 
+
+out vec4 FragColor;
+
+void main() {
+    vec3 lowMagnitudeColor = vec3(0.0, 0.5, 1.0);  // A vibrant blue
+    vec3 midMagnitudeColor = vec3(1.0, 1.0, 0.0);  // A pure green
+    vec3 highMagnitudeColor = vec3(1.0, 0.5, 0.0); // An intense orange
+
+    float normalizedMagnitude = clamp(pow(magnitude, .9) * .1, 0.0, 1.0);
+
+    vec3 finalColor;
+
+    if (normalizedMagnitude <= 0.5) {
+        float t = normalizedMagnitude * 2.0;
+        finalColor = mix(lowMagnitudeColor, midMagnitudeColor, t);
+    } 
+    else {
+        float t = (normalizedMagnitude - 0.5) * 2.0;
+        finalColor = mix(midMagnitudeColor, highMagnitudeColor, t);
+    }
+
+    FragColor = vec4(finalColor, 1.0);
+}

hyperstellar/_native/linux-x64/shaders/geoShader.geom

@@ -0,0 +1,69 @@
+#version 430 core
+
+layout (points) in;
+layout (line_strip, max_vertices = 5) out;
+
+in vec2 v_basePos[]; // from vertex shader
+uniform mat4 projection;
+
+// Object data from C++
+uniform int numCharges;
+uniform vec2 objectPositions[200];
+uniform float objectCharges[200];
+
+out float magnitude;
+out float chargeInfluence;
+
+void main() {
+    vec2 basePos = v_basePos[0];
+
+    // Compute superposed electric field vector and charge influence
+    vec2 totalField = vec2(0.0);
+    chargeInfluence = 0.0;
+
+    for (int i = 0; i < numCharges; i++) {
+        vec2 r = basePos - objectPositions[i];
+        float d = length(r) + 1e-4; // Avoid division by zero
+        float inverseSquare = 1.0 / (d * d);
+
+        // Apply negative charge to flip the direction
+        totalField += -objectCharges[i] * normalize(r) * inverseSquare;
+        chargeInfluence += objectCharges[i] * inverseSquare;
+    }
+
+    magnitude = length(totalField);
+    vec2 dir = (magnitude > 0.0) ? normalize(totalField) : vec2(0.0, 0.0);
+    
+    // Scale arrow based on magnitude
+    float arrowLength = clamp(magnitude * 0.2, 0.001, 0.09);
+    vec2 tip = basePos + dir * arrowLength;
+
+    // Perpendicular for arrowhead
+    vec2 perp = vec2(-dir.y, dir.x);
+    float headLength = arrowLength / 3.0;
+    float headWidth = arrowLength / 6.0;
+
+    vec2 left = tip - dir * headLength + perp * headWidth;
+    vec2 right = tip - dir * headLength - perp * headWidth;
+
+    // Emit geometry (shaft + arrowhead)
+    magnitude = length(totalField);
+    chargeInfluence = chargeInfluence;
+
+    gl_Position = projection * vec4(basePos, 0.0, 1.0);
+    EmitVertex();
+
+    gl_Position = projection * vec4(tip, 0.0, 1.0);
+    EmitVertex();
+
+    gl_Position = projection * vec4(left, 0.0, 1.0);
+    EmitVertex();
+
+    gl_Position = projection * vec4(tip, 0.0, 1.0);
+    EmitVertex();
+
+    gl_Position = projection * vec4(right, 0.0, 1.0);
+    EmitVertex();
+
+    EndPrimitive();
+}