""" #File Name: rendering.py Rendering class for the particle simulation. This class is responsible for rendering the particles, UI elements, and debug information on the screen. It handles the setup of the display, pre-rendering of static UI elements, and the drawing of particles, buttons, and debug overlays. The `draw_particles` function is the main method for rendering the particles on the screen. It takes the particle data, active particles, particle size, and particle colors as input, and renders the particles on the `particle_surface`. The `particle_surface` is then blitted onto the main screen. The `draw_zoom_window` function is used to render a zoomed-in view of the particles around the mouse cursor. It creates a separate surface for the zoomed-in view and returns it. The `draw_debug_overlay` function is responsible for rendering the debug information, such as FPS, mouse position, and particle information, on the screen. The `draw_buttons` function handles the rendering of the category buttons, particle buttons, and other UI elements like the clear screen and settings buttons. The `render_brush_cursor` function is used to draw a visual indicator for the current brush size. The `draw_brush_size_slider` function renders a slider for adjusting the brush size. The `draw_settings_menu` function creates a settings menu surface that can be displayed on the screen. The `clear_screen` function is used to reset the simulation grid and clear the display surfaces. """ from settings import pygame, random, particle_properties, engine_settings class Rendering: def __init__(self, width, height): self.screen = pygame.display.set_mode((width, height)) self.background = pygame.Surface((width, height)) self.background.fill((0, 0, 0)) self.width = width self.height = height self.particle_colors = {} self.particle_properties = particle_properties self.particle_surface = pygame.Surface((width, height), pygame.SRCALPHA) self.debug_surface = pygame.Surface((300, 150), pygame.SRCALPHA) self.cached_fonts = { 'debug': pygame.font.SysFont(None, 24), 'button': pygame.font.SysFont(None, 20) } # Pre-render static UI elements self.button_surfaces = {} # Initialize categories for name, properties in particle_properties.items(): if 'color' in properties: self.particle_colors[name.lower()] = properties['color'] self.categories = {'Solids': [], 'Liquids': [], 'Gases': [], 'Special': []} for particle_name, properties in self.particle_properties.items(): if properties.get('is_gas'): self.categories['Gases'].append(particle_name) elif properties.get('liquid'): self.categories['Liquids'].append(particle_name) elif properties.get('solid'): self.categories['Solids'].append(particle_name) else: self.categories['Special'].append(particle_name) self.current_category = 'Solids' self.category_buttons = {} self.setup_category_menu() self.setup_static_ui() def setup_gpu_rendering(self): # Initialize OpenGL context pygame.display.gl_set_attribute(pygame.GL_ACCELERATED_VISUAL, 1) self.screen = pygame.display.set_mode((self.width, self.height), pygame.OPENGL | pygame.DOUBLEBUF) def setup_static_ui(self): for category in self.categories: surf = pygame.Surface((80, 25)) surf.fill((150, 150, 150)) text = self.cached_fonts['button'].render(category, True, (0, 0, 0)) surf.blit(text, (5, 5)) self.button_surfaces[category] = surf def setup_category_menu(self): # Category buttons at the top x_offset = self.width - 350 y_offset = 10 for category in self.categories: button_rect = pygame.Rect(x_offset, y_offset, 80, 25) self.category_buttons[category] = button_rect x_offset += 90 def load_buttons(self): x_offset = 10 y_offset = 10 for particle_type, properties in self.particle_properties.items(): if 'color' in properties: button_rect = pygame.Rect(x_offset, y_offset, self.button_width, self.button_height) self.buttons[particle_type.lower()] = button_rect x_offset += self.button_width + 10 # Add spacing between buttons def draw_particles(self, particles, active_particles, particle_size, particle_colors): # this is the function that draws the particles #self.particle_surface = pygame.Surface((self.width, self.height), pygame.SRCALPHA) self.particle_surface.fill((0, 0, 0, 0)) particle_batches = {} for x, y in active_particles: particle = particles[x][y] if not particle: continue p_type = particle.particle_type if p_type not in particle_batches: particle_batches[p_type] = [] rect = pygame.Rect(x * particle_size, y * particle_size, particle_size, particle_size) particle_batches[p_type].append(rect) if particle.particle_type in particle_colors: color = particle_colors[particle.particle_type] else: color = (255, 255, 255) if engine_settings['enable_gas_effect']: if particle.is_gas: # Enhanced gas visibility alpha = random.randint(128, 200) color = list(color) if len(color) < 4: color.append(alpha) else: color[3] = alpha # Add subtle movement effect offset_x = random.randint(-1, 1) offset_y = random.randint(-1, 1) rect = (x * particle_size + offset_x, y * particle_size + offset_y, particle_size, particle_size) else: rect = (x * particle_size, y * particle_size, particle_size, particle_size) pygame.draw.rect(self.particle_surface, color, rect) if engine_settings['enable_glow']: glow_color = (255, 255, 255) glow_radius = 0.5 * particle_size glow_surface = pygame.Surface((glow_radius * 2, glow_radius * 2), pygame.SRCALPHA) pygame.draw.circle(glow_surface, glow_color, (glow_radius, glow_radius), glow_radius) glow_surface.set_alpha(85) self.particle_surface.blit(glow_surface, (x * particle_size - glow_radius, y * particle_size - glow_radius)) self.screen.blit(self.background, (0, 0)) self.screen.blit(self.particle_surface, (0, 0)) """#Potentially for future for p_type, rects in particle_batches.items(): color = particle_colors.get(p_type, (255, 255, 255)) rect = (x * particle_size, y * particle_size, particle_size, particle_size) if len(rects) > 1: pygame.draw.rect(self.particle_surface, color, rect) else: pygame.draw.rect(self.particle_surface, color, rect) self.screen.blit(self.background, (0, 0)) self.screen.blit(self.particle_surface, (0, 0))""" def draw_zoom_window(self, particles, particle_size, particle_colors, mouse_pos, zoom_factor=4): # this is the function that draws the zoom window print(f"Drawing zoom window.") zoom_size = 100 # Size of zoom window zoom_surface = pygame.Surface((zoom_size, zoom_size)) zoom_surface.fill((0, 0, 0)) # Get area around mouse to zoom mouse_x, mouse_y = mouse_pos view_x = mouse_x - zoom_size/(2*zoom_factor) view_y = mouse_y - zoom_size/(2*zoom_factor) print(f"Viewing area: {view_x}, {view_y}") # Draw zoomed particles for x in range(int(view_x), int(view_x + zoom_size/zoom_factor)): for y in range(int(view_y), int(view_y + zoom_size/zoom_factor)): if 0 <= x < len(particles) and 0 <= y < len(particles[0]): particle = particles[x][y] if particle: color = particle_colors.get(particle.particle_type, (255, 255, 255)) rect = ((x - view_x) * zoom_factor, (y - view_y) * zoom_factor, particle_size * zoom_factor, particle_size * zoom_factor) pygame.draw.rect(zoom_surface, color, rect) print(f"Drawing zoom window at {mouse_pos}{zoom_surface}") return zoom_surface def _get_particle_info(self, particles, x, y): if 0 <= x < len(particles) and 0 <= y < len(particles[0]): particle = particles[x][y] if particle: attrs = ['temperature', 'liquid', 'is_gas', 'solid', 'mass', 'velocity', 'friction'] info = [f"Type: {particle.particle_type}"] info.extend(f"{attr}: {getattr(particle, attr)}" for attr in attrs if hasattr(particle, attr)) return " | ".join(info) return "None" def draw_debug_overlay(self, fps, particles): # this is the function that draws the debug overlay if engine_settings ['enable_fps']: # Draw FPS font = pygame.font.Font(None, 24) fps_text = font.render(f"FPS: {fps:.2f}", True, (255, 255, 255)) self.screen.blit(fps_text, (10, 10)) if engine_settings ['enable_debug']: # Get mouse position and convert to grid coordinates self.debug_surface.fill((0, 0, 0, 0)) mouse_x, mouse_y = pygame.mouse.get_pos() grid_x, grid_y = mouse_x // 3, mouse_y // 3 particle_info = self._get_particle_info(particles, grid_x, grid_y) # Draw debug information font = pygame.font.SysFont(None, 24) particle_count = sum(1 for row in particles for cell in row if cell is not None) debug_info = [ f"FPS: {int(fps)}", f"Mouse: ({mouse_x}, {mouse_y})", f"Grid: ({grid_x}, {grid_y})", f"Particle: {particle_info}", #f"Active Particle Count: {sim.Simulation.get_active_particle_count(sim.Simulation)}", f"Particle Count: {particle_count}" ] y_offset = 10 for info in debug_info: debug_text = font.render(info, True, (255, 255, 255)) self.screen.blit(debug_text, (10, y_offset)) y_offset += 25 self.screen.blit(self.debug_surface, (10, 10)) def draw_buttons(self): # this is the function that draws the buttons self.buttons = {} # Draw category buttons on right x_offset = self.width - 100 y_offset = 10 # Draw cached category buttons for category, button in self.category_buttons.items(): surf = self.button_surfaces[category] if category == self.current_category: surf.set_alpha(255) else: surf.set_alpha(200) self.screen.blit(surf, button) # Draw particle buttons for current category y_offset = 150 # Start particle buttons below categories for particle_type in self.categories[self.current_category]: if particle_type in self.particle_properties: button_rect = pygame.Rect(x_offset, y_offset, 80, 25) self.buttons[particle_type] = button_rect # Use cached button surface if particle_type in self.button_surfaces: self.screen.blit(self.button_surfaces[particle_type], button_rect) else: # Create and cache button surface if not exists button_surface = pygame.Surface((80, 25)) color = self.particle_properties[particle_type].get('color', (255, 255, 255)) button_surface.fill(color) font = pygame.font.SysFont(None, 20) label = font.render(particle_type, True, (0, 0, 0)) button_surface.blit(label, (5, 5)) self.button_surfaces[particle_type] = button_surface self.screen.blit(button_surface, button_rect) y_offset += 30 # Stack buttons vertically final_y_offset = y_offset + 10 # Draw clear screen button if 'clear' not in self.button_surfaces: clear_surface = pygame.Surface((80, 25)) clear_surface.fill((255, 0, 0)) font = pygame.font.SysFont(None, 24) label = font.render("Clear", True, (255, 255, 255)) clear_surface.blit(label, (5, 5)) self.button_surfaces['clear'] = clear_surface self.clear_screen_button = pygame.Rect(x_offset, y_offset + 10, 80, 25) self.screen.blit(self.button_surfaces['clear'], self.clear_screen_button) # Draw Settings menu button if 'settings' not in self.button_surfaces: settings_surface = pygame.Surface((80, 25)) settings_surface.fill((255, 255, 255)) font = pygame.font.SysFont(None, 24) label = font.render("Settings", True, (0, 0, 0)) settings_surface.blit(label, (5, 5)) self.button_surfaces['settings'] = settings_surface self.settings_button = pygame.Rect(x_offset, y_offset + 50, 80, 25) self.screen.blit(self.button_surfaces['settings'], self.settings_button) def render_brush_cursor(self, x, y, radius): if engine_settings ['enable_cursor']: # Draw outline circle pygame.draw.circle(self.screen, (255, 255, 255), (x, y), radius, 1) # Draw slightly transparent fill cursor_surface = pygame.Surface((radius*2, radius*2), pygame.SRCALPHA) pygame.draw.circle(cursor_surface, (255, 255, 255, 55), (radius, radius), radius) self.screen.blit(cursor_surface, (x-radius, y-radius)) def draw_brush_size_slider(self, brush_size): # this is the function that draws the brush size slider # Draw the slider for brush size pygame.draw.rect(self.screen, (255, 255, 255), (500, 10, 100, 20)) pygame.draw.rect(self.screen, (0, 0, 0), (500, 10, 100, 20), 2) pygame.draw.rect(self.screen, (255, 0, 0), (500 + brush_size, 10, 100 - brush_size * 2, 20)) label = pygame.font.SysFont(None, 24).render(f"Brush Size: {brush_size}", True, (255, 255, 255)) self.screen.blit(label, (500, 10)) def draw_settings_menu(self): settings_surface = pygame.Surface((300, 400)) settings_surface.fill((50, 50, 50)) y_offset = 10 font = pygame.font.SysFont(None, 24) for setting, value in engine_settings.items(): # Create toggle button button_rect = pygame.Rect(10, y_offset, 20, 20) pygame.draw.rect(settings_surface, (0, 255, 0) if value else (255, 0, 0), button_rect) # Draw setting name label = font.render(setting.replace('_', ' ').title(), True, (255, 255, 255)) settings_surface.blit(label, (40, y_offset)) y_offset += 30 return settings_surface def clear_screen(self, sim): # this is the function that clears the screen # Store current particle type current_type = sim.current_particle_type # Reset simulation grid while preserving particle type sim.particles = [[None for _ in range(sim.height)] for _ in range(sim.width)] sim.active_particles.clear() sim.current_particle_type = current_type # Clear display surfaces self.background.fill((0, 0, 0)) self.particle_surface.fill((0, 0, 0, 0))