hyperstellar 1.5.6__py3-none-win_amd64.whl

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

@@ -0,0 +1,26 @@
+#version 430 core
+
+in vec2 fragTexCoord;
+in vec4 fragColor;
+in float fragSpeed;
+
+out vec4 FragColor;
+
+void main() {
+    // Circle if texcoord is non-zero (from circle emission)
+    bool isCircle = fragTexCoord != vec2(0.0);
+
+    if (isCircle) {
+        float dist = length(fragTexCoord);
+
+        // HARD EDGE: Discard everything outside the exact circle boundary
+        if (dist > 1.0) discard;
+
+        // No smoothstep - just use the original color with full opacity
+        FragColor = fragColor;
+
+    } else {
+        // Rectangle & polygon (texcoord = 0) - use color as-is
+        FragColor = fragColor;
+    }
+}

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

@@ -0,0 +1,149 @@
+#version 430 core
+
+layout(points) in;
+layout(triangle_strip, max_vertices = 64) out;
+
+in vec2 vPosition[];
+in vec2 vVelocity[];
+in float vMass[];
+in float vCharge[];
+in int vVisualSkinType[];
+in vec4 vVisualData[];  // x=rotation, y=angular_vel, z=width/radius, w=height/sides
+in vec4 vColor[];
+
+out vec2 fragTexCoord;
+out vec4 fragColor;
+out float fragSpeed;
+
+uniform mat4 uProjection;
+uniform mat4 uView;
+
+const int SKIN_CIRCLE = 0;
+const int SKIN_RECTANGLE = 1;
+const int SKIN_POLYGON = 2;
+const float PI = 3.14159265359;
+
+void emitCircle(vec2 center, float radius, vec4 color, float speed) {
+    mat4 MVP = uProjection * uView;
+    
+    // Bottom-left
+    gl_Position = MVP * vec4(center + vec2(-radius, -radius), 0.0, 1.0);
+    fragTexCoord = vec2(-1.0, -1.0);
+    fragColor = color;
+    fragSpeed = speed;
+    EmitVertex();
+    
+    // Top-left
+    gl_Position = MVP * vec4(center + vec2(-radius, radius), 0.0, 1.0);
+    fragTexCoord = vec2(-1.0, 1.0);
+    fragColor = color;
+    fragSpeed = speed;
+    EmitVertex();
+    
+    // Bottom-right
+    gl_Position = MVP * vec4(center + vec2(radius, -radius), 0.0, 1.0);
+    fragTexCoord = vec2(1.0, -1.0);
+    fragColor = color;
+    fragSpeed = speed;
+    EmitVertex();
+    
+    // Top-right
+    gl_Position = MVP * vec4(center + vec2(radius, radius), 0.0, 1.0);
+    fragTexCoord = vec2(1.0, 1.0);
+    fragColor = color;
+    fragSpeed = speed;
+    EmitVertex();
+    
+    EndPrimitive();
+}
+
+void emitRectangle(vec2 center, float width, float height, float rotation, vec4 color, float speed) {
+    mat4 MVP = uProjection * uView;
+    
+    float cosR = cos(rotation);
+    float sinR = sin(rotation);
+    float hw = width * 0.5;
+    float hh = height * 0.5;
+    
+    vec2 corners[4];
+    corners[0] = vec2(-hw, -hh);
+    corners[1] = vec2( hw, -hh);
+    corners[2] = vec2(-hw,  hh);
+    corners[3] = vec2( hw,  hh);
+    
+    for (int i = 0; i < 4; i++) {
+        vec2 rotated = vec2(
+            corners[i].x * cosR - corners[i].y * sinR,
+            corners[i].x * sinR + corners[i].y * cosR
+        );
+        gl_Position = MVP * vec4(center + rotated, 0.0, 1.0);
+        fragTexCoord = vec2(0.0);
+        fragColor = color;
+        fragSpeed = speed;
+        EmitVertex();
+    }
+    EndPrimitive();
+}
+
+void emitPolygon(vec2 center, float radius, int numSides, float rotation, vec4 color, float speed) {
+    mat4 MVP = uProjection * uView;
+    numSides = clamp(numSides, 3, 20);
+    
+    vec2 pts[21];
+    for (int i = 0; i < numSides; i++) {
+        float angle = rotation + (2.0 * PI * float(i) / float(numSides));
+        pts[i] = center + vec2(cos(angle), sin(angle)) * radius;
+    }
+    
+    for (int i = 0; i < numSides; i++) {
+        gl_Position = MVP * vec4(pts[i], 0.0, 1.0);
+        fragColor = color;
+        fragSpeed = speed;
+        fragTexCoord = vec2(0.0);
+        EmitVertex();
+        
+        gl_Position = MVP * vec4(center, 0.0, 1.0);
+        fragColor = color;
+        fragSpeed = speed;
+        fragTexCoord = vec2(0.0);
+        EmitVertex();
+    }
+    
+    gl_Position = MVP * vec4(pts[0], 0.0, 1.0);
+    fragColor = color;
+    fragSpeed = speed;
+    fragTexCoord = vec2(0.0);
+    EmitVertex();
+    
+    EndPrimitive();
+}
+
+void main() {
+    vec2 pos = vPosition[0];
+    vec2 vel = vVelocity[0];
+    float speed = length(vel);
+    int skinType = vVisualSkinType[0];
+    
+    //LAYOUT: width/height in x/y, rotation/angular_vel in z/w
+    float param_x = vVisualData[0].x;       // width or radius
+    float param_y = vVisualData[0].y;       // height or numSides
+    float rotation = vVisualData[0].z;      // ROTATION NOW IN Z
+    float angular_vel = vVisualData[0].w;   // ANGULAR_VEL NOW IN W
+    
+    vec4 color = vColor[0];
+
+    if (skinType == SKIN_CIRCLE) {
+        float radius = param_x; 
+        emitCircle(pos, radius, color, speed);
+    }
+    else if (skinType == SKIN_RECTANGLE) {
+        float width = param_x;
+        float height = param_y;
+        emitRectangle(pos, width, height, rotation, color, speed);
+    }
+    else if (skinType == SKIN_POLYGON) {
+        float radius = param_x;
+        int numSides = int(param_y);
+        emitPolygon(pos, radius, numSides, rotation, color, speed);
+    }
+}

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

@@ -0,0 +1,39 @@
+#version 430 core
+
+// These should match  VAO setup from objects.cpp
+layout(location = 0) in vec2 aPosition;
+layout(location = 1) in vec2 aVelocity;
+layout(location = 2) in float aMass;
+layout(location = 3) in float aCharge;
+layout(location = 4) in int aVisualSkinType;    
+layout(location = 5) in vec4 aVisualData;       
+layout(location = 6) in vec4 aColor;            
+layout(location = 7) in int aEquationID;
+
+out vec2 vPosition;
+out vec2 vVelocity;
+out float vMass;
+out float vCharge;
+out int vVisualSkinType;    
+out vec4 vVisualData;       
+out vec4 vColor;            
+//Add rotation and angular velocity as separate outputs if needed
+out float vRotation;
+out float vAngularVelocity;
+
+void main() {
+    vPosition = aPosition;
+    vVelocity = aVelocity;
+    vMass = aMass;
+    vCharge = aCharge;
+    vVisualSkinType = aVisualSkinType;
+    vVisualData = aVisualData;
+    vColor = aColor;
+    
+    // Extract rotation and angular velocity from visualData
+    vRotation = aVisualData.x;
+    vAngularVelocity = aVisualData.y;
+    
+    gl_Position = vec4(aPosition, 0.0, 1.0);
+    gl_PointSize = 10.0; // For point rendering fallback
+}

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

@@ -0,0 +1,13 @@
+#version 430 core
+layout(location = 0) in vec2 basePos;
+uniform vec2 chargePos = vec2(0.0, 0.0);
+uniform mat4 projection;
+out vec2 v_basePos;
+out vec2 v_chargePos;
+void main()
+{
+    vec4 hi = projection * vec4(basePos, 0.0, 1.0);
+    gl_Position = vec4(basePos, 0.0, 1.0); 
+    v_basePos = basePos;
+    v_chargePos = chargePos;
+}

hyperstellar/_native/windows-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/windows-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/windows-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/windows-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();
+}