phg-vis 1.2.1__tar.gz → 1.3.0__tar.gz

{phg_vis-1.2.1/phg_vis.egg-info → phg_vis-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phg_vis
-Version: 1.2.1
+Version: 1.3.0
 Summary: A package for the PHG modeling language and 3D visualization tool.
 Home-page: https://github.com/panguojun/Coordinate-System
 Author: romeosoft

phg_vis-1.3.0/phg/__init__.py

@@ -0,0 +1,82 @@
+"""
+__init__.py
+PHG主库 - 集成PHG到Shader转换功能
+"""
+
+from .visphg import vis, image
+from .shader_render import ShaderRenderer, render_shader
+from .phg_to_shader import PHGToShaderConverter, phg_to_shader
+
+# 扩展ShaderRenderer类以支持PHG直接渲染
+class PHGShaderRenderer(ShaderRenderer):
+    """支持PHG直接渲染的Shader渲染器"""
+    
+    def render_phg(self, phg_script: str, duration=0, interactive=True):
+        """
+        渲染PHG脚本
+        
+        参数:
+            phg_script: PHG脚本代码
+            duration: 渲染持续时间
+            interactive: 是否允许交互
+            
+        返回:
+            success: 是否成功渲染
+        """
+        converter = PHGToShaderConverter()
+        shader_code = converter.generate_shader_code(phg_script)
+        
+        if not shader_code:
+            print("错误: PHG转换失败")
+            return False
+            
+        return self.render_shader(shader_code, duration, interactive)
+
+# 便捷函数
+def render_phg(phg_script: str, width=800, height=600, duration=0, title="PHG Renderer"):
+    """
+    直接渲染PHG脚本
+    
+    参数:
+        phg_script: PHG脚本代码
+        width: 窗口宽度
+        height: 窗口高度  
+        duration: 渲染持续时间
+        title: 窗口标题
+    """
+    renderer = PHGShaderRenderer(width, height, title)
+    success = renderer.render_phg(phg_script, duration)
+    renderer.close()
+    return success
+
+def convert_phg_to_shader(phg_script: str) -> str:
+    """
+    将PHG脚本转换为GLSL着色器代码
+    
+    参数:
+        phg_script: PHG脚本
+        
+    返回:
+        shader_code: GLSL着色器代码
+    """
+    return phg_to_shader(phg_script)
+
+__all__ = [
+    'vis', 
+    'image', 
+    'ShaderRenderer', 
+    'render_shader',
+    'PHGToShaderConverter',
+    'PHGShaderRenderer', 
+    'render_phg',
+    'convert_phg_to_shader',
+    'phg_to_shader'
+]
+
+__version__ = "0.2.0"
+__author__ = "PHG Development Team"
+__description__ = "Python Graphics Library with PHG to Shader conversion"
+
+# 包初始化信息
+print(f"PHG {__version__} - {__description__}")
+print("PHG to Shader转换器已加载")

phg_vis-1.3.0/phg/phg_to_shader.py

@@ -0,0 +1,433 @@
+"""
+phg_to_shader.py
+PHG to Shader Converter Core Library
+"""
+
+import re
+import math
+from typing import Dict, List, Any, Tuple
+
+class PHGToShaderConverter:
+    """PHG to Shader converter"""
+    
+    def __init__(self):
+        self.nodes = {}
+        self.geometry_types = {
+            'cylinder': 'CYLINDER',
+            'sphere': 'SPHERE', 
+            'cube': 'BOX',
+            'box': 'BOX',
+            'cone': 'CONE',
+            'torus': 'TORUS',
+            'plane': 'PLANE'
+        }
+        self.primitive_count = 0
+        
+    def parse_phg(self, phg_script: str) -> Dict[str, Any]:
+        """Parse PHG script and extract node information"""
+        # Remove comments
+        phg_clean = re.sub(r'#.*$', '', phg_script, flags=re.MULTILINE)
+        
+        # Extract node definitions
+        node_pattern = r'(\w+)\s*\{([^}]*)\}'
+        nodes = {}
+        
+        for match in re.finditer(node_pattern, phg_clean):
+            node_name = match.group(1)
+            node_content = match.group(2)
+            
+            # Parse node properties
+            properties = self._parse_node_properties(node_content)
+            nodes[node_name] = properties
+            
+        return nodes
+    
+    def _parse_node_properties(self, content: str) -> Dict[str, Any]:
+        """Parse node properties"""
+        properties = {}
+        
+        # Property pattern: property:value1,value2;
+        prop_pattern = r'(\w+):([^;]+);'
+        
+        for match in re.finditer(prop_pattern, content):
+            prop_name = match.group(1)
+            prop_value = match.group(2).strip()
+            
+            # Handle different property types
+            if prop_name == 'md':
+                # Geometry definition
+                properties['geometry'] = self._parse_geometry(prop_value)
+            elif prop_name in ['xyz', 'sxyz', 'hpr', 'rot']:
+                # Vector values
+                properties[prop_name] = self._parse_vector(prop_value)
+            elif prop_name in ['x', 'y', 'z', 'rx', 'ry', 'rz', 's']:
+                # Scalar values
+                properties[prop_name] = float(prop_value)
+            elif prop_name == 'rgb':
+                # Color values
+                properties['color'] = self._parse_color(prop_value)
+                
+        return properties
+    
+    def _parse_geometry(self, geom_str: str) -> Dict[str, Any]:
+        """Parse geometry definition"""
+        parts = geom_str.strip().split()
+        if not parts:
+            return {}
+            
+        geom_type = parts[0]
+        
+        geometry = {'type': geom_type}
+        
+        try:
+            if geom_type == 'cylinder':
+                geometry['radius'] = float(parts[1])
+                geometry['height'] = float(parts[2])
+            elif geom_type == 'sphere':
+                geometry['radius'] = float(parts[1])
+            elif geom_type == 'cube':
+                geometry['size'] = [float(parts[1])] * 3
+            elif geom_type == 'box':
+                if len(parts) >= 4:
+                    geometry['size'] = [float(parts[1]), float(parts[2]), float(parts[3])]
+                else:
+                    geometry['size'] = [1.0, 1.0, 1.0]
+            elif geom_type == 'cone':
+                geometry['radius1'] = float(parts[1])
+                geometry['radius2'] = float(parts[2]) if len(parts) > 2 else 0.0
+                geometry['height'] = float(parts[3]) if len(parts) > 3 else 1.0
+            elif geom_type == 'torus':
+                geometry['radius1'] = float(parts[1])
+                geometry['radius2'] = float(parts[2]) if len(parts) > 2 else 0.3
+            elif geom_type == 'plane':
+                geometry['normal'] = [float(parts[1]), float(parts[2]), float(parts[3])] if len(parts) > 3 else [0, 1, 0]
+        except (IndexError, ValueError):
+            print(f"Warning: Geometry parameter parsing error: {geom_str}")
+            
+        return geometry
+    
+    def _parse_vector(self, vec_str: str) -> List[float]:
+        """Parse vector values"""
+        try:
+            return [float(x.strip()) for x in vec_str.split(',')]
+        except ValueError:
+            return [0.0, 0.0, 0.0]
+    
+    def _parse_color(self, color_str: str) -> List[float]:
+        """Parse color values and normalize to 0-1"""
+        try:
+            rgb = [float(x.strip()) for x in color_str.split(',')]
+            return [c / 255.0 for c in rgb]
+        except ValueError:
+            return [0.7, 0.7, 0.7]
+    
+    def geometry_to_sdf_params(self, geometry: Dict[str, Any], transform: Dict[str, Any]) -> List[str]:
+        """Convert geometry to SDF parameter array"""
+        geom_type = geometry.get('type', 'sphere')
+        color = transform.get('color', [0.7, 0.7, 0.7])
+        position = transform.get('xyz', [0, 0, 0])
+        
+        # Determine SDF type
+        sdf_type = self.geometry_types.get(geom_type, 'SPHERE')
+        
+        params = []
+        
+        # params[0]: position + type
+        params.append(f"vec4({position[0]:.3f}, {position[1]:.3f}, {position[2]:.3f}, float({sdf_type}))")
+        
+        # params[1]: size parameters
+        if geom_type == 'cylinder':
+            radius = geometry.get('radius', 1.0)
+            height = geometry.get('height', 2.0)
+            params.append(f"vec4({radius:.3f}, {height:.3f}, 0.0, 0.0)")
+        elif geom_type == 'sphere':
+            radius = geometry.get('radius', 1.0)
+            params.append(f"vec4({radius:.3f}, 0.0, 0.0, 0.0)")
+        elif geom_type in ['cube', 'box']:
+            size = geometry.get('size', [1.0, 1.0, 1.0])
+            params.append(f"vec4({size[0]:.3f}, {size[1]:.3f}, {size[2]:.3f}, 0.0)")
+        elif geom_type == 'cone':
+            r1 = geometry.get('radius1', 1.0)
+            r2 = geometry.get('radius2', 0.0)
+            h = geometry.get('height', 2.0)
+            params.append(f"vec4({r1:.3f}, {h:.3f}, {r2:.3f}, 0.0)")
+        elif geom_type == 'torus':
+            r1 = geometry.get('radius1', 1.0)
+            r2 = geometry.get('radius2', 0.3)
+            params.append(f"vec4({r1:.3f}, {r2:.3f}, 0.0, 0.0)")
+        elif geom_type == 'plane':
+            normal = geometry.get('normal', [0, 1, 0])
+            params.append(f"vec4({normal[0]:.1f}, {normal[1]:.1f}, {normal[2]:.1f}, 0.0)")
+        else:
+            params.append("vec4(1.0, 0.0, 0.0, 0.0)")
+        
+        # params[2]: rotation/direction
+        rotation = transform.get('hpr', transform.get('rot', [0, 0, 0]))
+        params.append(f"vec4({rotation[0]:.1f}, {rotation[1]:.1f}, {rotation[2]:.1f}, 0.0)")
+        
+        # params[3]: color
+        params.append(f"vec4({color[0]:.3f}, {color[1]:.3f}, {color[2]:.3f}, 0.0)")
+        
+        return params
+    
+    def generate_shader_code(self, phg_script: str) -> str:
+        """Generate complete GLSL shader code"""
+        self.nodes = self.parse_phg(phg_script)
+        
+        # Collect all geometries
+        primitives = []
+        for node_name, properties in self.nodes.items():
+            if 'geometry' in properties:
+                primitives.append((node_name, properties))
+        
+        self.primitive_count = len(primitives)
+        
+        if self.primitive_count == 0:
+            return self._create_empty_shader()
+        
+        # Generate shader code
+        shader_code = self._create_shader_template()
+        shader_code = self._insert_primitives(shader_code, primitives)
+        
+        return shader_code
+    
+    def _create_empty_shader(self) -> str:
+        """Create shader for empty scene"""
+        return """
+#version 330 core
+out vec4 fragColor;
+uniform float time;
+uniform vec2 resolution;
+uniform vec2 mouse;
+uniform vec3 cameraPosition;
+uniform vec3 cameraTarget;
+uniform vec3 cameraUp;
+uniform float cameraFov;
+
+void main() {
+    vec2 uv = gl_FragCoord.xy / resolution.xy;
+    vec3 color = vec3(0.1, 0.2, 0.4);
+    fragColor = vec4(color, 1.0);
+}
+"""
+    
+    def _create_shader_template(self) -> str:
+        """Create shader template with camera support"""
+        return """
+#version 330 core
+out vec4 fragColor;
+
+uniform float time;
+uniform vec2 resolution;
+uniform vec2 mouse;
+uniform vec3 cameraPosition;
+uniform vec3 cameraTarget;
+uniform vec3 cameraUp;
+uniform float cameraFov;
+
+#define MAX_STEPS 100
+#define MAX_DIST 200.0
+#define SURF_DIST 0.001
+
+// Primitive type enum
+#define SPHERE 0
+#define BOX 1
+#define CYLINDER 2
+#define TORUS 3
+#define PLANE 4
+#define CONE 5
+
+// Primitive parameter definitions
+{primitive_definitions}
+
+// SDF function definitions
+float sdfSphere(vec3 p, vec4 params) {
+    return length(p) - params.x;
+}
+
+float sdfBox(vec3 p, vec4 params) {
+    vec3 b = params.xyz;
+    vec3 q = abs(p) - b;
+    return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0);
+}
+
+float sdfCylinder(vec3 p, vec4 params) {
+    vec2 d = abs(vec2(length(p.xz), p.y)) - vec2(params.x, params.y);
+    return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
+}
+
+float sdfTorus(vec3 p, vec4 params) {
+    vec2 q = vec2(length(p.xz) - params.x, p.y);
+    return length(q) - params.y;
+}
+
+float sdfPlane(vec3 p, vec4 params) {
+    return dot(p, normalize(params.xyz));
+}
+
+float sdfCone(vec3 p, vec4 params) {
+    // params.x = base radius, params.y = height, params.z = top radius
+    vec2 q = vec2(length(p.xz), -p.y);
+    float d = length(q);
+    float angle = atan(params.z - params.x, params.y);
+    float c = cos(angle);
+    float s = sin(angle);
+    return max(dot(q, vec2(c, s)), -p.y - params.y);
+}
+
+// Unified SDF dispatcher function
+float mapPrimitive(vec3 p, vec4 params[4]) {
+    int type = int(params[0].w);
+    
+    if (type == SPHERE) return sdfSphere(p - params[0].xyz, params[1]);
+    if (type == BOX) return sdfBox(p - params[0].xyz, params[1]);
+    if (type == CYLINDER) return sdfCylinder(p - params[0].xyz, params[1]);
+    if (type == TORUS) return sdfTorus(p - params[0].xyz, params[1]);
+    if (type == PLANE) return sdfPlane(p - params[0].xyz, params[1]);
+    if (type == CONE) return sdfCone(p - params[0].xyz, params[1]);
+    
+    return 1000.0;
+}
+
+// Scene SDF
+float mapScene(vec3 p) {
+    float minDist = 1000.0;
+    
+{primitive_calls}
+    
+    return minDist;
+}
+
+// Normal calculation
+vec3 calculateNormal(vec3 p) {
+    vec2 e = vec2(0.001, 0.0);
+    return normalize(vec3(
+        mapScene(p + e.xyy) - mapScene(p - e.xyy),
+        mapScene(p + e.yxy) - mapScene(p - e.yxy),
+        mapScene(p + e.yyx) - mapScene(p - e.yyx)
+    ));
+}
+
+// Ray marching
+float rayMarch(vec3 ro, vec3 rd) {
+    float depth = 0.0;
+    
+    for (int i = 0; i < MAX_STEPS; i++) {
+        vec3 p = ro + depth * rd;
+        float dist = mapScene(p);
+        depth += dist;
+        
+        if (dist < SURF_DIST || depth > MAX_DIST) break;
+    }
+    
+    return depth;
+}
+
+// Get hit object color
+vec3 getObjectColor(vec3 p) {
+    float minDist = 1000.0;
+    vec3 color = vec3(0.5);
+    
+{color_calls}
+    
+    return color;
+}
+
+// Calculate camera ray direction using camera uniforms
+vec3 getCameraRay(vec2 uv, vec3 camPos, vec3 camTarget, vec3 camUp, float fov) {
+    vec3 forward = normalize(camTarget - camPos);
+    vec3 right = normalize(cross(forward, camUp));
+    vec3 up = normalize(cross(right, forward));
+    
+    float tanFov = tan(radians(fov) * 0.5);
+    vec3 rayDir = normalize(forward + right * uv.x * tanFov * (resolution.x / resolution.y) + up * uv.y * tanFov);
+    
+    return rayDir;
+}
+
+void main() {
+    vec2 uv = (gl_FragCoord.xy - 0.5 * resolution.xy) / resolution.y;
+    
+    // Use camera uniforms from Python for ray direction
+    vec3 ro = cameraPosition;
+    vec3 rd = getCameraRay(uv, cameraPosition, cameraTarget, cameraUp, cameraFov);
+    
+    // Ray marching
+    float dist = rayMarch(ro, rd);
+    
+    // Shading
+    vec3 color = vec3(0.1, 0.2, 0.4);
+    
+    if (dist < MAX_DIST) {
+        vec3 p = ro + rd * dist;
+        vec3 normal = calculateNormal(p);
+        vec3 objColor = getObjectColor(p);
+        
+        // Simple lighting
+        vec3 lightDir = normalize(vec3(1.0, 3.0, 2.0));
+        float diff = max(dot(normal, lightDir), 0.2);
+        
+        color = objColor * diff;
+        
+        // Add some ambient occlusion
+        float ao = 1.0 - (1.0 / (1.0 + dist * 0.1));
+        color *= ao;
+    }
+    
+    fragColor = vec4(color, 1.0);
+}
+"""
+    
+    def _insert_primitives(self, template: str, primitives: List[Tuple[str, Dict]]) -> str:
+        """Insert primitive definitions and call code"""
+        primitive_definitions = []
+        primitive_calls = []
+        color_calls = []
+        
+        for i, (node_name, properties) in enumerate(primitives):
+            geometry = properties['geometry']
+            params = self.geometry_to_sdf_params(geometry, properties)
+            
+            # Generate primitive parameter definitions
+            primitive_definitions.append(f"// {node_name}")
+            for j, param in enumerate(params):
+                primitive_definitions.append(f"vec4 prim_{i}_{j} = {param};")
+            primitive_definitions.append("")
+            
+            # Generate SDF calls
+            primitive_calls.append(f"    // {node_name}")
+            primitive_calls.append(f"    vec4 prim_{i}[4] = vec4[4](prim_{i}_0, prim_{i}_1, prim_{i}_2, prim_{i}_3);")
+            primitive_calls.append(f"    float dist_{i} = mapPrimitive(p, prim_{i});")
+            primitive_calls.append(f"    minDist = min(minDist, dist_{i});")
+            primitive_calls.append("")
+            
+            # Generate color calls
+            color_calls.append(f"    // {node_name}")
+            color_calls.append(f"    vec4 color_prim_{i}[4] = vec4[4](prim_{i}_0, prim_{i}_1, prim_{i}_2, prim_{i}_3);")
+            color_calls.append(f"    float color_dist_{i} = mapPrimitive(p, color_prim_{i});")
+            color_calls.append(f"    if (color_dist_{i} < SURF_DIST && color_dist_{i} < minDist) {{")
+            color_calls.append(f"        minDist = color_dist_{i};")
+            color_calls.append(f"        color = prim_{i}_3.xyz;")
+            color_calls.append(f"    }}")
+            color_calls.append("")
+        
+        # Replace placeholders in template
+        shader_code = template.replace("{primitive_definitions}", "\n".join(primitive_definitions))
+        shader_code = shader_code.replace("{primitive_calls}", "\n".join(primitive_calls))
+        shader_code = shader_code.replace("{color_calls}", "\n".join(color_calls))
+        
+        return shader_code
+
+# Convenient conversion function
+def phg_to_shader(phg_script: str) -> str:
+    """
+    Convert PHG script to GLSL shader code
+    
+    Args:
+        phg_script: PHG script string
+        
+    Returns:
+        shader_code: GLSL shader code
+    """
+    converter = PHGToShaderConverter()
+    return converter.generate_shader_code(phg_script)

phg_vis-1.3.0/phg/shader_render.py

@@ -0,0 +1,425 @@
+import pygame
+import numpy as np
+from OpenGL.GL import *
+from OpenGL.GL.shaders import compileProgram, compileShader
+import sys
+import time
+
+class Camera:
+    """Camera class with mouse interaction controls"""
+    
+    def __init__(self):
+        # Start further back to see the whole scene
+        self.position = np.array([0.0, 3.0, 12.0], dtype=np.float32)  # Camera position - further back
+        self.target = np.array([0.0, 0.0, 0.0], dtype=np.float32)     # Look at target
+        self.up = np.array([0.0, 1.0, 0.0], dtype=np.float32)         # Up direction
+        
+        # Camera parameters
+        self.fov = 45.0  # Field of view
+        self.zoom_speed = 0.5  # Increased zoom speed
+        self.rotate_speed = 0.01  # Increased rotate speed
+        self.pan_speed = 0.02  # Increased pan speed
+        
+        # Mouse state
+        self.last_mouse_pos = None
+        self.is_rotating = False
+        self.is_panning = False
+        
+    def zoom(self, delta):
+        """Zoom control"""
+        direction = self.target - self.position
+        distance = np.linalg.norm(direction)
+        
+        # Limit min and max distance
+        min_distance = 1.0
+        max_distance = 100.0
+        
+        new_distance = distance * (1.0 - delta * self.zoom_speed)
+        new_distance = np.clip(new_distance, min_distance, max_distance)
+        
+        self.position = self.target - direction * (new_distance / distance)
+        print(f"Zoom: position={self.position}, distance={new_distance}")
+    
+    def rotate(self, delta_x, delta_y):
+        """Rotation control"""
+        # Calculate vector from target to camera (inverse of camera to target)
+        direction = self.position - self.target
+        distance = np.linalg.norm(direction)
+        
+        if distance < 0.001:
+            return
+            
+        # Spherical coordinates rotation
+        # Convert to spherical coordinates
+        theta = np.arctan2(direction[0], direction[2])  # Horizontal angle (around Y axis)
+        phi = np.arctan2(direction[1], np.sqrt(direction[0]**2 + direction[2]**2))  # Vertical angle
+        
+        # Apply rotation (inverted for more intuitive control)
+        theta -= delta_x * self.rotate_speed
+        phi += delta_y * self.rotate_speed  # Inverted Y for more natural control
+        
+        # Limit vertical angle (avoid flipping)
+        phi = np.clip(phi, -np.pi/2 + 0.1, np.pi/2 - 0.1)
+        
+        # Convert back to Cartesian coordinates
+        new_x = distance * np.sin(theta) * np.cos(phi)
+        new_y = distance * np.sin(phi)
+        new_z = distance * np.cos(theta) * np.cos(phi)
+        
+        self.position = self.target + np.array([new_x, new_y, new_z])
+        
+        print(f"Rotate: position={self.position}")
+    
+    def pan(self, delta_x, delta_y):
+        """Pan control"""
+        # Calculate camera coordinate system
+        forward = normalize(self.target - self.position)
+        right = normalize(np.cross(forward, self.up))
+        up = normalize(np.cross(right, forward))
+        
+        # Apply pan (inverted for more intuitive control)
+        pan_distance = 0.1
+        pan_vector = -delta_x * right * self.pan_speed + delta_y * up * self.pan_speed
+        
+        self.position += pan_vector
+        self.target += pan_vector
+        
+        print(f"Pan: position={self.position}, target={self.target}")
+
+def normalize(v):
+    """Normalize a vector"""
+    norm = np.linalg.norm(v)
+    if norm == 0:
+        return v
+    return v / norm
+
+class ShaderRenderer:
+    """
+    Shader renderer class for visualizing GLSL shaders
+    
+    Usage:
+    renderer = ShaderRenderer()
+    renderer.render_shader(fragment_shader_code)
+    """
+    
+    def __init__(self, width=800, height=600, title="Shader Renderer"):
+        """
+        Initialize Shader renderer
+        
+        Args:
+            width: Window width
+            height: Window height  
+            title: Window title
+        """
+        self.width = width
+        self.height = height
+        self.title = title
+        self.is_running = False
+        self.shader_program = None
+        self.start_time = 0
+        self.camera = Camera()
+        self.show_help = True
+        
+        self.vertex_shader_src = """
+        #version 330 core
+        layout (location = 0) in vec3 aPos;
+        layout (location = 1) in vec2 aTexCoord;
+
+        out vec2 TexCoord;
+
+        void main()
+        {
+            gl_Position = vec4(aPos, 1.0);
+            TexCoord = aTexCoord;
+        }
+        """
+        
+        self._init_pygame()
+        self._init_opengl()
+        self._create_geometry()
+        self._init_font()
+    
+    def _init_pygame(self):
+        """Initialize Pygame and OpenGL context"""
+        pygame.init()
+        self.screen = pygame.display.set_mode((self.width, self.height), pygame.OPENGL | pygame.DOUBLEBUF)
+        pygame.display.set_caption(self.title)
+    
+    def _init_opengl(self):
+        """Initialize OpenGL settings"""
+        glClearColor(0.0, 0.0, 0.0, 1.0)
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+    
+    def _init_font(self):
+        """Initialize font for text rendering"""
+        self.font = pygame.font.Font(None, 24)
+        self.small_font = pygame.font.Font(None, 18)
+    
+    def _create_geometry(self):
+        """Create geometry required for rendering"""
+        # Vertex data: position + texture coordinates
+        self.vertices = np.array([
+            # Position          # Texture coordinates
+            -1.0, -1.0, 0.0, 0.0, 0.0,
+             1.0, -1.0, 0.0, 1.0, 0.0,
+             1.0,  1.0, 0.0, 1.0, 1.0,
+            -1.0,  1.0, 0.0, 0.0, 1.0
+        ], dtype=np.float32)
+        
+        self.indices = np.array([
+            0, 1, 2,
+            2, 3, 0
+        ], dtype=np.uint32)
+        
+        # Create VAO, VBO, EBO
+        self.VAO = glGenVertexArrays(1)
+        self.VBO = glGenBuffers(1)
+        self.EBO = glGenBuffers(1)
+        
+        glBindVertexArray(self.VAO)
+        
+        glBindBuffer(GL_ARRAY_BUFFER, self.VBO)
+        glBufferData(GL_ARRAY_BUFFER, self.vertices.nbytes, self.vertices, GL_STATIC_DRAW)
+        
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.EBO)
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, self.indices.nbytes, self.indices, GL_STATIC_DRAW)
+        
+        # Position attribute
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * self.vertices.itemsize, ctypes.c_void_p(0))
+        glEnableVertexAttribArray(0)
+        
+        # Texture coordinate attribute
+        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * self.vertices.itemsize, ctypes.c_void_p(3 * self.vertices.itemsize))
+        glEnableVertexAttribArray(1)
+        
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        glBindVertexArray(0)
+    
+    def _compile_shader(self, fragment_src):
+        """
+        Compile shader program
+        
+        Args:
+            fragment_src: Fragment shader code
+            
+        Returns:
+            shader_program: Compiled shader program, None if failed
+        """
+        try:
+            vertex_shader = compileShader(self.vertex_shader_src, GL_VERTEX_SHADER)
+            fragment_shader = compileShader(fragment_src, GL_FRAGMENT_SHADER)
+            shader_program = compileProgram(vertex_shader, fragment_shader)
+            return shader_program
+        except Exception as e:
+            print(f"Shader compilation error: {e}")
+            return None
+    
+    def _render_help_text(self):
+        """Render help text on screen"""
+        # Switch to 2D rendering for text
+        glDisable(GL_DEPTH_TEST)
+        
+        # Create a semi-transparent background for better readability
+        help_lines = [
+            "=== CAMERA CONTROLS ===",
+            "LEFT CLICK + DRAG: Rotate Camera",
+            "MIDDLE CLICK + DRAG: Pan Camera", 
+            "MOUSE WHEEL: Zoom In/Out",
+            "R: Reset Camera Position",
+            "H: Toggle This Help",
+            "ESC: Exit Renderer",
+            "",
+            "Camera debugging enabled - check console"
+        ]
+        
+        y_offset = 20
+        for i, line in enumerate(help_lines):
+            if i == 0:  # Header
+                text_surface = self.font.render(line, True, (255, 255, 0))
+            else:
+                text_surface = self.small_font.render(line, True, (255, 255, 255))
+            self.screen.blit(text_surface, (20, y_offset))
+            y_offset += 22 if i == 0 else 18
+        
+        # Camera position info
+        cam_info = [
+            f"Camera Pos: ({self.camera.position[0]:.1f}, {self.camera.position[1]:.1f}, {self.camera.position[2]:.1f})",
+            f"Camera Target: ({self.camera.target[0]:.1f}, {self.camera.target[1]:.1f}, {self.camera.target[2]:.1f})"
+        ]
+        
+        y_offset += 10
+        for info in cam_info:
+            text_surface = self.small_font.render(info, True, (0, 255, 255))
+            self.screen.blit(text_surface, (20, y_offset))
+            y_offset += 18
+        
+        glEnable(GL_DEPTH_TEST)
+    
+    def render_shader(self, fragment_shader, duration=0, interactive=True):
+        """
+        Render specified shader
+        
+        Args:
+            fragment_shader: Fragment shader code string
+            duration: Render duration in seconds, 0 for infinite
+            interactive: Allow interaction (ESC to exit)
+            
+        Returns:
+            success: Whether rendering was successful
+        """
+        # Compile shader
+        self.shader_program = self._compile_shader(fragment_shader)
+        if not self.shader_program:
+            return False
+        
+        # Get uniform locations
+        time_loc = glGetUniformLocation(self.shader_program, "time")
+        resolution_loc = glGetUniformLocation(self.shader_program, "resolution")
+        mouse_loc = glGetUniformLocation(self.shader_program, "mouse")
+        camera_pos_loc = glGetUniformLocation(self.shader_program, "cameraPosition")
+        camera_target_loc = glGetUniformLocation(self.shader_program, "cameraTarget")
+        camera_up_loc = glGetUniformLocation(self.shader_program, "cameraUp")
+        camera_fov_loc = glGetUniformLocation(self.shader_program, "cameraFov")
+        
+        self.is_running = True
+        self.start_time = time.time()
+        clock = pygame.time.Clock()
+        
+        mouse_pos = [0.0, 0.0]
+        
+        print("Renderer started! Camera controls:")
+        print("- Left mouse button + drag: Rotate")
+        print("- Middle mouse button + drag: Pan") 
+        print("- Mouse wheel: Zoom")
+        print("- R: Reset camera")
+        print("- H: Toggle help")
+        
+        while self.is_running:
+            current_time = time.time() - self.start_time
+            
+            # Handle events
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    self.is_running = False
+                elif event.type == pygame.KEYDOWN:
+                    if event.key == pygame.K_ESCAPE and interactive:
+                        self.is_running = False
+                    elif event.key == pygame.K_r:  # R key to reset camera
+                        self.camera = Camera()
+                        print("Camera reset to default position")
+                    elif event.key == pygame.K_h:  # H key to toggle help
+                        self.show_help = not self.show_help
+                        print(f"Help display: {'ON' if self.show_help else 'OFF'}")
+                
+                # Handle mouse events for camera control
+                if interactive:
+                    if event.type == pygame.MOUSEBUTTONDOWN:
+                        if event.button == 1:  # Left button - rotate
+                            self.camera.is_rotating = True
+                            self.camera.last_mouse_pos = event.pos
+                            print("Rotation started")
+                        elif event.button == 2:  # Middle button - pan
+                            self.camera.is_panning = True
+                            self.camera.last_mouse_pos = event.pos
+                            print("Panning started")
+                        elif event.button == 4:  # Wheel up - zoom in
+                            self.camera.zoom(1.0)
+                        elif event.button == 5:  # Wheel down - zoom out
+                            self.camera.zoom(-1.0)
+                            
+                    elif event.type == pygame.MOUSEBUTTONUP:
+                        if event.button == 1:  # Left button release
+                            self.camera.is_rotating = False
+                            print("Rotation ended")
+                        elif event.button == 2:  # Middle button release
+                            self.camera.is_panning = False
+                            print("Panning ended")
+                        self.camera.last_mouse_pos = None
+                        
+                    elif event.type == pygame.MOUSEMOTION:
+                        # Update mouse position for shader
+                        mouse_pos[0] = event.pos[0] / self.width
+                        mouse_pos[1] = 1.0 - event.pos[1] / self.height
+                        
+                        # Handle camera movement
+                        if self.camera.last_mouse_pos is not None:
+                            delta_x = event.pos[0] - self.camera.last_mouse_pos[0]
+                            delta_y = event.pos[1] - self.camera.last_mouse_pos[1]
+                            
+                            if self.camera.is_rotating:
+                                self.camera.rotate(delta_x, delta_y)
+                            elif self.camera.is_panning:
+                                self.camera.pan(delta_x, delta_y)
+                            
+                            self.camera.last_mouse_pos = event.pos
+            
+            # Check duration
+            if duration > 0 and current_time >= duration:
+                break
+            
+            # Render
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+            
+            glUseProgram(self.shader_program)
+            
+            # Set uniforms
+            if time_loc != -1:
+                glUniform1f(time_loc, current_time)
+            if resolution_loc != -1:
+                glUniform2f(resolution_loc, self.width, self.height)
+            if mouse_loc != -1:
+                glUniform2f(mouse_loc, mouse_pos[0], mouse_pos[1])
+            if camera_pos_loc != -1:
+                glUniform3f(camera_pos_loc, 
+                           self.camera.position[0], 
+                           self.camera.position[1], 
+                           self.camera.position[2])
+            if camera_target_loc != -1:
+                glUniform3f(camera_target_loc, 
+                           self.camera.target[0], 
+                           self.camera.target[1], 
+                           self.camera.target[2])
+            if camera_up_loc != -1:
+                glUniform3f(camera_up_loc, 
+                           self.camera.up[0], 
+                           self.camera.up[1], 
+                           self.camera.up[2])
+            if camera_fov_loc != -1:
+                glUniform1f(camera_fov_loc, self.camera.fov)
+            
+            glBindVertexArray(self.VAO)
+            glDrawElements(GL_TRIANGLES, len(self.indices), GL_UNSIGNED_INT, None)
+            glBindVertexArray(0)
+            
+            # Render help text if enabled
+            if self.show_help:
+                self._render_help_text()
+            
+            pygame.display.flip()
+            clock.tick(60)
+        
+        return True
+    
+    def close(self):
+        """Clean up resources"""
+        if self.shader_program:
+            glDeleteProgram(self.shader_program)
+        pygame.quit()
+
+# Convenience function
+def render_shader(fragment_shader, width=800, height=600, duration=0, title="Shader Renderer"):
+    """
+    Convenience function: Directly render shader
+    
+    Args:
+        fragment_shader: Fragment shader code
+        width: Window width
+        height: Window height
+        duration: Render duration in seconds
+        title: Window title
+    """
+    renderer = ShaderRenderer(width, height, title)
+    success = renderer.render_shader(fragment_shader, duration)
+    renderer.close()
+    return success

{phg_vis-1.2.1 → phg_vis-1.3.0/phg_vis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phg_vis
-Version: 1.2.1
+Version: 1.3.0
 Summary: A package for the PHG modeling language and 3D visualization tool.
 Home-page: https://github.com/panguojun/Coordinate-System
 Author: romeosoft

{phg_vis-1.2.1 → phg_vis-1.3.0}/phg_vis.egg-info/SOURCES.txt

@@ -4,6 +4,8 @@ README.md
 setup.py
 phg/VisPHG.py
 phg/__init__.py
+phg/phg_to_shader.py
+phg/shader_render.py
 phg/visphg.py
 phg/vis/GCU.dll
 phg/vis/dragpad.exe

{phg_vis-1.2.1 → phg_vis-1.3.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='phg_vis', 
-    version='1.2.1', 
+    version='1.3.0', 
     packages=find_packages(),
     include_package_data=True,
     description='A package for the PHG modeling language and 3D visualization tool.',

phg_vis-1.2.1/phg/__init__.py

@@ -1,4 +0,0 @@
-# phg/__init__.py
-from .visphg import vis, image
-
-__all__ = ['vis', 'image']