meltygui 0.1.0__py3-none-any.whl

meltygui/graphics/generate_stubs.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""
+Standalone script to generate type stub files.
+
+Run from the shader_library directory:
+    python3 generate_stubs.py
+"""
+
+import sys
+import os
+
+# Import to register all shaders
+from meltygui.graphics.stub_generator import generate_filter_stub
+
+# Generate the stub file
+stub_path = os.path.join(os.path.dirname(__file__), '', 'filter.pyi')
+content = generate_filter_stub(stub_path)
+
+lines = len(content.splitlines())
+print(f"✓ Generated {stub_path}")
+print(f"✓ {lines} lines")
+print(f"✓ Shaders included: {content.count('def ') - 20}")  # Subtract non-shader methods

meltygui/graphics/registry.py

@@ -0,0 +1,203 @@
+"""
+Shader and shader type registry with decorator-based registration.
+"""
+
+from typing import Dict, Type, Any, Optional, Callable
+from dataclasses import dataclass, field
+
+from meltygui.graphics.base import ShaderType
+from meltygui.graphics.base import Shader
+from meltygui.graphics.base import camel_to_snake
+from meltygui.graphics.base import GLType
+
+
+class ShaderRegistry:
+    """
+    Central registry for shader types and shaders.
+    
+    This is a singleton that holds all registered shader types and shaders.
+    """
+    _instance: Optional['ShaderRegistry'] = None
+    
+    def __new__(cls) -> 'ShaderRegistry':
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._shader_types: Dict[str, ShaderType] = {}
+            cls._instance._shaders: Dict[str, Shader] = {}
+        return cls._instance
+    
+    @property
+    def shader_types(self) -> Dict[str, ShaderType]:
+        return self._shader_types
+    
+    @property
+    def shaders(self) -> Dict[str, Shader]:
+        return self._shaders
+    
+    def register_type(self, shader_type: ShaderType) -> None:
+        """Register a shader type."""
+        self._shader_types[shader_type.name] = shader_type
+    
+    def register_shader(self, shader: Shader) -> None:
+        """Register a shader."""
+        self._shaders[shader.name] = shader
+    
+    def get_type(self, name: str) -> Optional[ShaderType]:
+        """Get a shader type by name."""
+        return self._shader_types.get(name)
+    
+    def get_shader(self, name: str) -> Optional[Shader]:
+        """Get a shader by name."""
+        return self._shaders.get(name)
+    
+    def clear(self) -> None:
+        """Clear all registrations (mainly for testing)."""
+        self._shader_types.clear()
+        self._shaders.clear()
+
+
+# Global registry instance
+
+_registry = ShaderRegistry()
+
+
+def get_registry() -> ShaderRegistry:
+    """Get the global shader registry."""
+    return _registry
+
+
+def register_shader_type(cls: Type) -> Type:
+    """
+    Decorator to register a shader type.
+    
+    The type name is inferred from the class name (converted to snake_case).
+    
+    Example:
+        @register_shader_type
+        class Standard:
+            vertex_in = {'position': GLType.VEC3, 'texcoord': GLType.VEC2}
+            vertex_out = {'v_texcoord': GLType.VEC2}
+            vertex_code = '''
+                void main() {
+                    v_texcoord = texcoord;
+                    gl_Position = vec4(position, 1.0);
+                }
+            '''
+    """
+    name = camel_to_snake(cls.__name__)
+    
+    # Extract attributes from class
+    vertex_in = getattr(cls, 'vertex_in', {})
+    vertex_out = getattr(cls, 'vertex_out', {})
+    vertex_code = getattr(cls, 'vertex_code', '')
+    
+    # Convert string type names to GLType if needed
+    vertex_in = _normalize_type_dict(vertex_in)
+    vertex_out = _normalize_type_dict(vertex_out)
+    
+    shader_type = ShaderType(
+        name=name,
+        vertex_in=vertex_in,
+        vertex_out=vertex_out,
+        vertex_code=vertex_code
+    )
+    
+    _registry.register_type(shader_type)
+    
+    # Store the ShaderType on the class for reference
+    cls._shader_type = shader_type
+    
+    return cls
+
+
+def register_shader(cls: Type = None, *, shader_type: str = 'standard') -> Callable:
+    """
+    Decorator to register a shader.
+    
+    The shader name is inferred from the class name (converted to snake_case).
+    
+    Can be used with or without arguments:
+        @register_shader
+        class BrightnessContrast:
+            ...
+        
+        @register_shader(shader_type='fullscreen')
+        class GaussianBlur:
+            ...
+    
+    Example:
+        @register_shader
+        class BrightnessContrast:
+            uniforms = {
+                'brightness': (GLType.FLOAT, 0.0),
+                'contrast': (GLType.FLOAT, 1.0),
+            }
+            fragment_code = '''
+                void main() {
+                    vec4 color = texture(u_texture, v_texcoord);
+                    color.rgb = (color.rgb - 0.5) * contrast + 0.5 + brightness;
+                    fragColor = color;
+                }
+            '''
+    """
+    def decorator(cls: Type) -> Type:
+        name = camel_to_snake(cls.__name__)
+        
+        # Extract attributes from class
+        uniforms = getattr(cls, 'uniforms', {})
+        fragment_code = getattr(cls, 'fragment_code', '')
+        vertex_code = getattr(cls, 'vertex_code', None)
+        type_name = getattr(cls, 'shader_type', shader_type)
+        
+        # Normalize uniforms
+        uniforms = _normalize_uniforms(uniforms)
+        
+        shader = Shader(
+            name=name,
+            shader_type=type_name,
+            fragment_code=fragment_code,
+            vertex_code=vertex_code,
+            uniforms=uniforms
+        )
+        
+        _registry.register_shader(shader)
+        
+        # Store the Shader on the class for reference
+        cls._shader = shader
+        
+        return cls
+    
+    # Handle both @register_shader and @register_shader() syntax
+    if cls is not None:
+        return decorator(cls)
+    return decorator
+
+
+def _normalize_type_dict(d: Dict[str, Any]) -> Dict[str, GLType]:
+    """Convert string type names to GLType enum values."""
+    result = {}
+    for name, type_val in d.items():
+        if isinstance(type_val, str):
+            type_val = GLType(type_val)
+        elif isinstance(type_val, GLType):
+            pass
+        else:
+            print(f"Warning: Unexpected type for {name}: {type_val}")
+        result[name] = type_val
+    return result
+
+
+def _normalize_uniforms(uniforms: Dict[str, Any]) -> Dict[str, tuple]:
+    """Normalize uniform definitions to (GLType, default) tuples."""
+    result = {}
+    for name, value in uniforms.items():
+        if isinstance(value, tuple):
+            gl_type, default = value
+            if isinstance(gl_type, str):
+                gl_type = GLType(gl_type)
+            result[name] = (gl_type, default)
+        elif isinstance(value, GLType):
+            result[name] = (value, None)
+        else:
+            print(f"Warning: Unexpected uniform definition for {name}: {value}")
+    return result

meltygui/graphics/shader_compiler.py

@@ -0,0 +1,155 @@
+"""
+OpenGL shader program compilation and management.
+"""
+
+from typing import Dict, Optional, Any, Tuple
+from dataclasses import dataclass
+import ctypes
+
+from meltygui.graphics.base import ShaderType
+from meltygui.graphics.base import Shader
+
+# GLSL version header
+GLSL_VERSION = "#version 330 core\n"
+
+
+def _get_gl():
+    """Lazy import of OpenGL."""
+    from OpenGL import GL
+    from OpenGL.GL import shaders
+    return GL, shaders
+
+
+@dataclass
+class CompiledProgram:
+    """A compiled shader program with its metadata."""
+    program_id: int
+    shader: Shader
+    shader_type: ShaderType
+    uniform_locations: Dict[str, int]
+    attribute_locations: Dict[str, int]
+
+
+class ProgramCompiler:
+    """
+    Compiles and manages OpenGL shader programs.
+    """
+    
+    def __init__(self):
+        """Initialize the program compiler."""
+        self._programs: Dict[str, CompiledProgram] = {}
+    
+    def compile(self, shader: Shader, shader_type: ShaderType) -> CompiledProgram:
+        """
+        Compile a shader into an OpenGL program.
+        
+        Args:
+            shader: The shader definition
+            shader_type: The shader type definition
+            
+        Returns:
+            CompiledProgram with the program ID and metadata
+        """
+        GL, shaders = _get_gl()
+        
+        # Generate full shader source code
+        vertex_src = self._generate_vertex_source(shader, shader_type)
+        fragment_src = self._generate_fragment_source(shader, shader_type)
+        
+        try:
+            vertex_shader = shaders.compileShader(vertex_src, GL.GL_VERTEX_SHADER)
+            fragment_shader = shaders.compileShader(fragment_src, GL.GL_FRAGMENT_SHADER)
+            program_id = shaders.compileProgram(vertex_shader, fragment_shader)
+        except shaders.ShaderCompilationError as e:
+            raise ShaderCompilationError(f"Failed to compile shader '{shader.name}': {e}")
+        
+        # Get uniform locations
+        uniform_locations = {}
+        for name in shader.uniforms.keys():
+            uniform_locations[name] = GL.glGetUniformLocation(program_id, name)
+        uniform_locations['u_texture'] = GL.glGetUniformLocation(program_id, 'u_texture')
+        uniform_locations['u_projection'] = GL.glGetUniformLocation(program_id, 'u_projection')
+        uniform_locations['u_modelview'] = GL.glGetUniformLocation(program_id, 'u_modelview')
+        
+        # Get attribute locations
+        attribute_locations = {}
+        for name in shader_type.vertex_in.keys():
+            attribute_locations[name] = GL.glGetAttribLocation(program_id, name)
+        
+        compiled = CompiledProgram(
+            program_id=program_id,
+            shader=shader,
+            shader_type=shader_type,
+            uniform_locations=uniform_locations,
+            attribute_locations=attribute_locations
+        )
+        
+        self._programs[shader.name] = compiled
+        return compiled
+    
+    def _generate_vertex_source(self, shader: Shader, shader_type: ShaderType) -> str:
+        """Generate the complete vertex shader source."""
+        parts = [GLSL_VERSION]
+        
+        # Add input declarations
+        for name, gl_type in shader_type.vertex_in.items():
+            parts.append(f"in {gl_type.value} {name};")
+        
+        # Add output declarations (varyings)
+        for name, gl_type in shader_type.vertex_out.items():
+            parts.append(f"out {gl_type.value} {name};")
+        
+        # Add common uniforms
+        parts.append("uniform mat4 u_projection;")
+        parts.append("uniform mat4 u_modelview;")
+        
+        # Add the vertex code
+        vertex_code = shader.vertex_code if shader.vertex_code else shader_type.vertex_code
+        parts.append(vertex_code)
+        
+        return '\n'.join(parts)
+    
+    def _generate_fragment_source(self, shader: Shader, shader_type: ShaderType) -> str:
+        """Generate the complete fragment shader source."""
+        parts = [GLSL_VERSION]
+        
+        # Add input declarations (varyings from vertex shader)
+        for name, gl_type in shader_type.vertex_out.items():
+            parts.append(f"in {gl_type.value} {name};")
+        
+        # Add output declaration
+        parts.append("out vec4 fragColor;")
+        
+        # Add texture sampler
+        parts.append("uniform sampler2D u_texture;")
+        
+        # Add shader-specific uniforms
+        for name, (gl_type, _) in shader.uniforms.items():
+            parts.append(f"uniform {gl_type.value} {name};")
+        
+        # Add the fragment code
+        parts.append(shader.fragment_code)
+        
+        return '\n'.join(parts)
+    
+    def get_program(self, name: str) -> Optional[CompiledProgram]:
+        """Get a compiled program by shader name."""
+        return self._programs.get(name)
+    
+    def delete_program(self, name: str) -> None:
+        """Delete a compiled program."""
+        if name in self._programs:
+            GL, _ = _get_gl()
+            compiled = self._programs[name]
+            GL.glDeleteProgram(compiled.program_id)
+            del self._programs[name]
+    
+    def cleanup(self) -> None:
+        """Clean up all compiled programs."""
+        for name in list(self._programs.keys()):
+            self.delete_program(name)
+
+
+class ShaderCompilationError(Exception):
+    """Raised when shader compilation fails."""
+    pass