hyperstellar 1.5.6__py3-none-win_amd64.whl

hyperstellar/_native/windows-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/windows-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/windows-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/windows-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/debug.py

@@ -0,0 +1,169 @@
+"""
+Debugging utilities for the JIT system.
+
+Provides logging, shader source dumping, and rich error reporting with line context.
+"""
+
+import sys
+import difflib
+from typing import Optional, List, Set, Tuple
+
+# Global debug flag
+_DEBUG_ENABLED: bool = False
+_LOG_LEVEL: int = 0  # 0=error, 1=warn, 2=info, 3=debug
+
+
+def enable_debug(flag: bool = True) -> None:
+    """Enable or disable debug output."""
+    global _DEBUG_ENABLED
+    _DEBUG_ENABLED = flag
+
+
+def set_log_level(level: int) -> None:
+    """Set verbosity level (0=error, 1=warn, 2=info, 3=debug)."""
+    global _LOG_LEVEL
+    _LOG_LEVEL = level
+
+
+def _log(level: int, msg: str) -> None:
+    if not _DEBUG_ENABLED or level > _LOG_LEVEL:
+        return
+    prefix = ["[ERROR]", "[WARN]", "[INFO]", "[DEBUG]"][level]
+    print(f"{prefix} {msg}", file=sys.stderr)
+
+
+def error(msg: str) -> None:
+    """Log an error message."""
+    _log(0, msg)
+
+
+def warn(msg: str) -> None:
+    """Log a warning message."""
+    _log(1, msg)
+
+
+def info(msg: str) -> None:
+    """Log an info message."""
+    _log(2, msg)
+
+
+def debug(msg: str) -> None:
+    """Log a debug message."""
+    _log(3, msg)
+
+
+def log_shader(source: str, title: Optional[str] = None) -> None:
+    """Print the generated shader source to stderr."""
+    if not _DEBUG_ENABLED:
+        return
+    if title:
+        print(f"\n--- {title} ---", file=sys.stderr)
+    print(source, file=sys.stderr)
+    print("--- end shader ---\n", file=sys.stderr)
+
+
+def trace_call(func_name: str, *args, **kwargs) -> None:
+    """Log a function call with its arguments (for debugging JIT internals)."""
+    if not _DEBUG_ENABLED:
+        return
+    args_str = ", ".join(repr(a) for a in args)
+    if kwargs:
+        kwargs_str = ", ".join(f"{k}={v!r}" for k, v in kwargs.items())
+        if args_str:
+            args_str += ", " + kwargs_str
+        else:
+            args_str = kwargs_str
+    debug(f"CALL {func_name}({args_str})")
+
+
+# ----------------------------------------------------------------------------
+# Rich error reporting with line context and suggestions
+# ----------------------------------------------------------------------------
+
+def _get_line_context(source: str, lineno: int, context_lines: int = 2) -> str:
+    """Return a few lines of source around the given line number."""
+    if lineno is None or not source:
+        return ""
+    lines = source.splitlines()
+    if lineno < 1 or lineno > len(lines):
+        return ""
+    start = max(0, lineno - context_lines - 1)
+    end = min(len(lines), lineno + context_lines)
+    context_lines_output = []
+    for i in range(start, end):
+        line_num = i + 1
+        marker = ">" if line_num == lineno else " "
+        context_lines_output.append(f"{line_num:4} {marker} {lines[i]}")
+    return "\n".join(context_lines_output)
+
+
+def report_error(
+    msg: str,
+    source: str,
+    lineno: Optional[int] = None,
+    col_offset: Optional[int] = None,
+    suggestion: Optional[str] = None,
+    context_lines: int = 2,
+) -> None:
+    """
+    Print a formatted error message with source context and an optional suggestion.
+    Raises SyntaxError after printing.
+    """
+    full_msg = f"JIT Error: {msg}"
+    if suggestion:
+        full_msg += f"\nDid you mean: {suggestion}?"
+    if lineno is not None:
+        context = _get_line_context(source, lineno, context_lines)
+        if context:
+            full_msg += f"\n\nIn source:\n{context}"
+    error(full_msg)
+    raise SyntaxError(full_msg)
+
+
+def report_warning(
+    msg: str,
+    source: str,
+    lineno: Optional[int] = None,
+    col_offset: Optional[int] = None,
+    suggestion: Optional[str] = None,
+    context_lines: int = 2,
+) -> None:
+    """Print a formatted warning message with source context."""
+    full_msg = f"JIT Warning: {msg}"
+    if suggestion:
+        full_msg += f"\nDid you mean: {suggestion}?"
+    if lineno is not None:
+        context = _get_line_context(source, lineno, context_lines)
+        if context:
+            full_msg += f"\n\nIn source:\n{context}"
+    warn(full_msg)
+
+
+def get_close_matches(word: str, possibilities: Set[str], n: int = 3, cutoff: float = 0.6) -> List[str]:
+    """
+    Return a list of close matches from a set of possibilities.
+    Uses difflib.get_close_matches internally.
+    """
+    return difflib.get_close_matches(word, list(possibilities), n, cutoff)
+
+
+def format_error_summary(errors: List[Tuple[str, Optional[int], Optional[int], Optional[str]]],
+                         source: str) -> str:
+    """
+    Format a list of errors (msg, lineno, col_offset, suggestion) into a single
+    human-readable string with source context.
+    """
+    if not errors:
+        return ""
+    lines = []
+    for msg, lineno, col, suggestion in errors:
+        line_info = f" at line {lineno}" if lineno is not None else ""
+        full_msg = f"{msg}{line_info}"
+        if suggestion:
+            full_msg += f"\nDid you mean: {suggestion}?"
+        if lineno is not None:
+            context = _get_line_context(source, lineno, 1)
+            if context:
+                full_msg += f"\n{context}"
+        lines.append(full_msg)
+    return "\n\n".join(lines)