I'll create a comprehensive benchmark environment using Pygame and PyOpenGL for 3D rendering. Here's the complete implementation: import pygame from pygame.locals import * from OpenGL.GL import * from OpenGL.GLU import * import random import time import math import sys import platform import psutil import numpy as np from collections import deque # System information def get_system_info(): return { "processor": platform.processor(), "system": platform.system(), "memory": f"{psutil.virtual_memory().total / (1024**3):.2f} GB", "graphics": "N/A" # This would need platform-specific implementation } class BenchmarkStats: def __init__(self): self.frame_times = deque(maxlen=300) self.current_frame = 0 self.min_frame = float('inf') self.max_frame = 0 self.scene_start_time = 0 self.scene_duration = 5 # seconds per scene self.current_scene = 0 self.total_scenes = 4 self.running = True self.benchmark_complete = False self.final_score = 0 self.system_info = get_system_info() def update_frame_time(self, frame_time): self.frame_times.append(frame_time) self.current_frame = frame_time self.min_frame = min(self.min_frame, frame_time) self.max_frame = max(self.max_frame, frame_time) def get_avg_frame_time(self): if len(self.frame_times) == 0: return 0 return sum(self.frame_times) / len(self.frame_times) def get_fps(self, frame_time): return 1.0 / frame_time if frame_time > 0 else 0 def next_scene(self): self.current_scene += 1 self.scene_start_time = time.time() if self.current_scene >= self.total_scenes: self.complete_benchmark() def complete_benchmark(self): self.running = False self.benchmark_complete = True avg_frame = self.get_avg_frame_time() self.final_score = (1 / avg_frame) * 1000 if avg_frame > 0 else 0 # Higher is better class Ball: def __init__(self): self.radius = 0.2 self.position = [random.uniform(-5, 5), 10, random.uniform(-5, 5)] self.velocity = [0, 0, 0] self.color = [random.random(), random.random(), random.random()] self.mass = 1.0 def update(self, dt): # Simple gravity self.velocity[1] -= 9.8 * dt self.position[0] += self.velocity[0] * dt self.position[1] += self.velocity[1] * dt self.position[2] += self.velocity[2] * dt # Simple ground collision if self.position[1] < self.radius: self.position[1] = self.radius self.velocity[1] = -self.velocity[1] * 0.8 # Bounce with some energy loss def draw(self): glPushMatrix() glTranslatef(*self.position) glColor3f(*self.color) quad = gluNewQuadric() gluSphere(quad, self.radius, 16, 16) glPopMatrix() class LightSource: def __init__(self): self.angle = random.uniform(0, 2 * math.pi) self.distance = 5 self.height = 3 self.speed = random.uniform(0.5, 1.5) self.color = [random.uniform(0.5, 1), random.uniform(0.5, 1), random.uniform(0.5, 1)] self.update_position() def update(self, dt): self.angle += self.speed * dt self.update_position() def update_position(self): self.position = [ math.cos(self.angle) * self.distance, self.height, math.sin(self.angle) * self.distance ] class WaterSimulator: def __init__(self): self.size = 10 self.grid_size = 50 self.height_map = np.zeros((self.grid_size, self.grid_size)) self.velocity_map = np.zeros((self.grid_size, self.grid_size)) self.damping = 0.99 self.spread = 0.25 self.objects = [] for _ in range(5): self.objects.append({ 'position': [random.uniform(-self.size/2, self.size/2), 0.5, random.uniform(-self.size/2, self.size/2)], 'radius': random.uniform(0.3, 0.7) }) def update(self, dt): # Update height map with velocity self.height_map += self.velocity_map * dt # Apply damping self.velocity_map *= self.damping # Spread waves new_height = np.zeros_like(self.height_map) for i in range(1, self.grid_size-1): for j in range(1, self.grid_size-1): new_height[i,j] = ( self.height_map[i,j] + self.spread * ( self.height_map[i+1,j] + self.height_map[i-1,j] + self.height_map[i,j+1] + self.height_map[i,j-1] - 4 * self.height_map[i,j] ) ) self.height_map = new_height # Add random ripples if random.random() < 0.05: x = random.randint(5, self.grid_size-5) y = random.randint(5, self.grid_size-5) self.velocity_map[x,y] = random.uniform(-0.5, -0.1) def draw(self): glBegin(GL_QUADS) for i in range(self.grid_size-1): for j in range(self.grid_size-1): x1 = (i / (self.grid_size-1) - 0.5) * self.size z1 = (j / (self.grid_size-1) - 0.5) * self.size x2 = ((i+1) / (self.grid_size-1) - 0.5) * self.size z2 = ((j+1) / (self.grid_size-1) - 0.5) * self.size y1 = self.height_map[i,j] y2 = self.height_map[i+1,j] y3 = self.height_map[i+1,j+1] y4 = self.height_map[i,j+1] # Water color with some transparency glColor4f(0.2, 0.4, 0.8, 0.7) glVertex3f(x1, y1, z1) glVertex3f(x2, y2, z1) glVertex3f(x2, y3, z2) glVertex3f(x1, y4, z2) glEnd() # Draw floating objects for obj in self.objects: glPushMatrix() glTranslatef(*obj['position']) glColor3f(0.9, 0.9, 0.1) quad = gluNewQuadric() gluSphere(quad, obj['radius'], 16, 16) glPopMatrix() class HairSimulator: def __init__(self): self.strands = [] self.num_strands = 100 self.strand_length = 10 self.points_per_strand = 20 self.positions = np.zeros((self.num_strands, self.points_per_strand, 3)) self.prev_positions = np.zeros((self.num_strands, self.points_per_strand, 3)) # Initialize positions for i in range(self.num_strands): base_x = random.uniform(-3, 3) base_z = random.uniform(-3, 3) for j in range(self.points_per_strand): self.positions[i,j,0] = base_x self.positions[i,j,1] = 5 - j * 0.5 self.positions[i,j,2] = base_z self.prev_positions = np.copy(self.positions) self.objects = [] for _ in range(3): self.objects.append({ 'position': [random.uniform(-3, 3), random.uniform(2, 4), random.uniform(-3, 3)], 'velocity': [random.uniform(-1, 1), random.uniform(-1, 1), random.uniform(-1, 1)], 'radius': random.uniform(0.3, 0.6) }) def update(self, dt): # Update objects for obj in self.objects: obj['position'][0] += obj['velocity'][0] * dt obj['position'][1] += obj['velocity'][1] * dt obj['position'][2] += obj['velocity'][2] * dt # Bounce off walls for i in range(3): if abs(obj['position'][i]) > 4: obj['velocity'][i] *= -1 obj['position'][i] = 4 * (1 if obj['position'][i] > 0 else -1) # Verlet integration for hair strands temp = np.copy(self.positions) # Apply gravity and constraints for i in range(self.num_strands): for j in range(self.points_per_strand): if j == 0: continue # Fixed root # Gravity vel = self.positions[i,j] - self.prev_positions[i,j] self.prev_positions[i,j] = self.positions[i,j] self.positions[i,j] += vel * 0.99 # Damping self.positions[i,j,1] -= 0.01 # Gravity # Collision with objects for obj in self.objects: dist = np.linalg.norm(self.positions[i,j] - obj['position']) if dist < obj['radius']: direction = (self.positions[i,j] - obj['position']) / dist self.positions[i,j] = obj['position'] + direction * obj['radius'] # Length constraint if j > 0: prev_pos = self.positions[i,j-1] desired_dist = 0.5 current_dist = np.linalg.norm(self.positions[i,j] - prev_pos) if current_dist > 0: correction = (current_dist - desired_dist) / current_dist self.positions[i,j] -= (self.positions[i,j] - prev_pos) * correction * 0.5 self.positions[i,j-1] += (self.positions[i,j] - prev_pos) * correction * 0.5 def draw(self): # Draw objects for obj in self.objects: glPushMatrix() glTranslatef(*obj['position']) glColor3f(0.8, 0.2, 0.2) quad = gluNewQuadric() gluSphere(quad, obj['radius'], 16, 16) glPopMatrix() # Draw hair strands glBegin(GL_LINES) for i in range(self.num_strands): glColor3f(0.5, 0.35, 0.05) # Brown color for hair for j in range(self.points_per_strand - 1): glVertex3f(*self.positions[i,j]) glVertex3f(*self.positions[i,j+1]) glEnd() class BenchmarkApp: def __init__(self): pygame.init() self.width, self.height = 1280, 720 self.screen = pygame.display.set_mode((self.width, self.height), DOUBLEBUF|OPENGL) pygame.display.set_caption("3D Benchmark Tool") gluPerspective(45, (self.width/self.height), 0.1, 50.0) glTranslatef(0.0, 0.0, -10) glEnable(GL_DEPTH_TEST) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) self.stats = BenchmarkStats() self.balls = [Ball() for _ in range(50)] self.lights = [LightSource() for _ in range(4)] self.water = WaterSimulator() self.hair = HairSimulator() self.camera_angle = 0 self.camera_distance = 8 self.font = pygame.font.SysFont('Arial', 20) self.big_font = pygame.font.SysFont('Arial', 32) self.in_menu = True self.menu_option = 0 def handle_events(self): for event in pygame.event.get(): if event.type == pygame.QUIT: self.stats.running = False elif event.type == pygame.KEYDOWN: if self.in_menu: if event.key == pygame.K_UP: self.menu_option = (self.menu_option - 1) % 2 elif event.key == pygame.K_DOWN: self.menu_option = (self.menu_option + 1) % 2 elif event.key == pygame.K_RETURN: if self.menu_option == 0: # Start benchmark self.in_menu = False self.stats.scene_start_time = time.time() else: # Exit self.stats.running = False elif event.key == pygame.K_ESCAPE: if not self.in_menu and not self.stats.benchmark_complete: self.in_menu = True def update(self, dt): if not self.in_menu and not self.stats.benchmark_complete: # Check if scene should change if time.time() - self.stats.scene_start_time > self.stats.scene_duration: self.stats.next_scene() # Update current scene if self.stats.current_scene == 0: # Ball physics for ball in self.balls: ball.update(dt) elif self.stats.current_scene == 1: # Lighting for light in self.lights: light.update(dt) self.camera_angle += 0.5 * dt elif self.stats.current_scene == 2: # Water self.water.update(dt) elif self.stats.current_scene == 3: # Hair self.hair.update(dt) def draw_scene(self): glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) # Set up lighting for scenes that need it if self.stats.current_scene == 1 or self.stats.current_scene == 3: glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) glLightfv(GL_LIGHT0, GL_POSITION, [0, 5, 0, 1]) glLightfv(GL_LIGHT0, GL_DIFFUSE, [1, 1, 1, 1]) glLightfv(GL_LIGHT0, GL_SPECULAR, [1, 1, 1, 1]) # Additional lights for scene 1 if self.stats.current_scene == 1: for i, light in enumerate(self.lights): glEnable(GL_LIGHT1 + i) glLightfv(GL_LIGHT1 + i, GL_POSITION, light.position + [1]) glLightfv(GL_LIGHT1 + i, GL_DIFFUSE, light.color + [1]) glLightfv(GL_LIGHT1 + i, GL_SPECULAR, light.color + [1]) else: glDisable(GL_LIGHTING) # Set camera position glLoadIdentity() if self.stats.current_scene == 1: # Rotating camera for lighting scene cam_x = math.sin(self.camera_angle) * self.camera_distance cam_z = math.cos(self.camera_angle) * self.camera_distance gluLookAt(cam_x, 3, cam_z, 0, 0, 0, 0, 1, 0) else: gluLookAt(0, 5, -10, 0, 0, 0, 0, 1, 0) # Draw ground plane glBegin(GL_QUADS) glColor3f(0.3, 0.3, 0.3) glVertex3f(-10, 0, -10) glVertex3f(-10, 0, 10) glVertex3f(10, 0, 10) glVertex3f(10, 0, -10) glEnd() # Draw current scene if self.stats.current_scene == 0: # Ball physics for ball in self.balls: ball.draw() elif self.stats.current_scene == 1: # Lighting # Draw central object glPushMatrix() glColor3f(0.8, 0.8, 0.8) glMaterialfv(GL_FRONT, GL_SPECULAR, [1, 1, 1, 1]) glMaterialf(GL_FRONT, GL_SHININESS, 50) quad = gluNewQuadric() gluSphere(quad, 2, 32, 32) glPopMatrix() elif self.stats.current_scene == 2: # Water self.water.draw() elif self.stats.current_scene == 3: # Hair self.hair.draw() def draw_stats(self): # Switch to 2D orthographic projection for HUD glMatrixMode(GL_PROJECTION) glPushMatrix() glLoadIdentity() gluOrtho2D(0, self.width, self.height, 0) glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() # Disable lighting for text glDisable(GL_LIGHTING) glColor3f(1, 1, 1) # Draw stats if not self.in_menu and not self.stats.benchmark_complete: scene_names = [ "Scene 1: Physics (50 balls)", "Scene 2: Lighting (4 lights)", "Scene 3: Water simulation", "Scene 4: Hair simulation" ] # Scene info text = f"{scene_names[self.stats.current_scene]} - Time remaining: {max(0, self.stats.scene_duration - (time.time() - self.stats.scene_start_time)):.1f}s" self.render_text(text, 10, 10) # Performance stats avg_frame = self.stats.get_avg_frame_time() fps = self.stats.get_fps(self.stats.current_frame) self.render_text(f"Current FPS: {fps:.1f}", 10, 40) self.render_text(f"Avg FPS: {1/avg_frame:.1f}" if avg_frame > 0 else "Avg FPS: N/A", 10, 70) self.render_text(f"Min FPS: {1/self.stats.max_frame:.1f}" if self.stats.max_frame > 0 else "Min FPS: N/A", 10, 100) self.render_text(f"Max FPS: {1/self.stats.min_frame:.1f}" if self.stats.min_frame < float('inf') else "Max FPS: N/A", 10, 130) # Restore 3D projection glMatrixMode(GL_PROJECTION) glPopMatrix() glMatrixMode(GL_MODELVIEW) glPopMatrix() def draw_menu(self): # Switch to 2D orthographic projection for menu glMatrixMode(GL_PROJECTION) glPushMatrix() glLoadIdentity() gluOrtho2D(0, self.width, self.height, 0) glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() # Disable lighting for menu glDisable(GL_LIGHTING) # Draw menu background glColor4f(0, 0, 0, 0.7) glBegin(GL_QUADS) glVertex2f(self.width/2 - 200, self.height/2 - 150) glVertex2f(self.width/2 + 200, self.height/2 - 150) glVertex2f(self.width/2 + 200, self.height/2 + 150) glVertex2f(self.width/2 - 200, self.height/2 + 150) glEnd() # Draw title title = self.big_font.render("3D Benchmark Tool", True, (255, 255, 255)) title_rect = title.get_rect(center=(self.width/2, self.height/2 - 100)) # Draw menu options options = ["Start Benchmark", "Exit"] option_surfaces = [] for i, option in enumerate(options): color = (255, 215, 0) if i == self.menu_option else (255, 255, 255) option_surfaces.append(self.big_font.render(option, True, color)) # Blit all text surfaces screen_surface = pygame.Surface((self.width, self.height), pygame.SRCALPHA) screen_surface.blit(title, title_rect) for i, surface in enumerate(option_surfaces): rect = surface.get_rect(center=(self.width/2, self.height/2 + i * 60)) screen_surface.blit(surface, rect) # Instructions instructions = self.font.render("Use UP/DOWN arrows to select, ENTER to confirm", True, (200, 200, 200)) instructions_rect = instructions.get_rect(center=(self.width/2, self.height/2 + 150)) screen_surface.blit(instructions, instructions_rect) # Convert to OpenGL texture and draw texture_data = pygame.image.tostring(screen_surface, "RGBA", True) glEnable(GL_TEXTURE_2D) texture = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, texture) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture_data) glBegin(GL_QUADS) glTexCoord2f(0, 0); glVertex2f(0, 0) glTexCoord2f(1, 0); glVertex2f(self.width, 0) glTexCoord2f(1, 1); glVertex2f(self.width, self.height) glTexCoord2f(0, 1); glVertex2f(0, self.height) glEnd() glDisable(GL_TEXTURE_2D) glDeleteTextures([texture]) # Restore 3D projection glMatrixMode(GL_PROJECTION) glPopMatrix() glMatrixMode(GL_MODELVIEW) glPopMatrix() def draw_results(self): # Switch to 2D orthographic projection for results glMatrixMode(GL_PROJECTION) glPushMatrix() glLoadIdentity() gluOrtho2D(0, self.width, self.height, 0) glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() # Disable lighting for results glDisable(GL_LIGHTING) # Draw results background glColor4f(0, 0, 0, 0.7) glBegin(GL_QUADS) glVertex2f(100, 50) glVertex2f(self.width - 100, 50) glVertex2f(self.width - 100, self.height - 50) glVertex2f(100, self.height - 50) glEnd() # Prepare results text screen_surface = pygame.Surface((self.width, self.height), pygame.SRCALPHA) # Title title = self.big_font.render("Benchmark Results", True, (255, 255, 255)) title_rect = title.get_rect(center=(self.width/2, 80)) screen_surface.blit(title, title_rect) # Score score_text = self.big_font.render(f"Final Score: {self.stats.final_score:.1f}", True, (255, 215, 0)) score_rect = score_text.get_rect(center=(self.width/2, 150)) screen_surface.blit(score_text, score_rect) # Performance stats stats_y = 220 stats = [ f"Average FPS: {1/self.stats.get_avg_frame_time():.1f}", f"Minimum FPS: {1/self.stats.max_frame:.1f}", f"Maximum FPS: {1/self.stats.min_frame:.1f}" ] for stat in stats: stat_surface = self.font.render(stat, True, (255, 255, 255)) stat_rect = stat_surface.get_rect(center=(self.width/2, stats_y)) screen_surface.blit(stat_surface, stat_rect) stats_y += 40 # System info sys_y = stats_y + 40 sys_title = self.font.render("System Information:", True, (200, 200, 255)) sys_title_rect = sys_title.get_rect(center=(self.width/2, sys_y)) screen_surface.blit(sys_title, sys_title_rect) sys_y += 30 for key, value in self.stats.system_info.items(): info_surface = self.font.render(f"{key.capitalize()}: {value}", True, (200, 200, 200)) info_rect = info_surface.get_rect(center=(self.width/2, sys_y)) screen_surface.blit(info_surface, info_rect) sys_y += 30 # Instructions instructions = self.font.render("Press ESC to return to menu", True, (200, 200, 200)) instructions_rect = instructions.get_rect(center=(self.width/2, self.height - 80)) screen_surface.blit(instructions, instructions_rect) # Convert to OpenGL texture and draw texture_data = pygame.image.tostring(screen_surface, "RGBA", True) glEnable(GL_TEXTURE_2D) texture = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, texture) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture_data) glBegin(GL_QUADS) glTexCoord2f(0, 0); glVertex2f(0, 0) glTexCoord2f(1, 0); glVertex2f(self.width, 0) glTexCoord2f(1, 1); glVertex2f(self.width, self.height) glTexCoord2f(0, 1); glVertex2f(0, self.height) glEnd() glDisable(GL_TEXTURE_2D) glDeleteTextures([texture]) # Restore 3D projection glMatrixMode(GL_PROJECTION) glPopMatrix() glMatrixMode(GL_MODELVIEW) glPopMatrix() def render_text(self, text, x, y): text_surface = self.font.render(text, True, (255, 255, 255)) text_data = pygame.image.tostring(text_surface, "RGBA", True) glEnable(GL_TEXTURE_2D) texture = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, texture) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, text_surface.get_width(), text_surface.get_height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, text_data) glBegin(GL_QUADS) glTexCoord2f(0, 0); glVertex2f(x, y) glTexCoord2f(1, 0); glVertex2f(x + text_surface.get_width(), y) glTexCoord2f(1, 1); glVertex2f(x + text_surface.get_width(), y + text_surface.get_height()) glTexCoord2f(0, 1); glVertex2f(x, y + text_surface.get_height()) glEnd() glDisable(GL_TEXTURE_2D) glDeleteTextures([texture]) def run(self): clock = pygame.time.Clock() last_time = time.time() while self.stats.running: current_time = time.time() dt = current_time - last_time last_time = current_time self.handle_events() self.update(dt) if self.in_menu: glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) self.draw_menu() elif self.stats.benchmark_complete: glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) self.draw_results() else: self.draw_scene() self.draw_stats() self.stats.update_frame_time(dt) pygame.display.flip() clock.tick(60) pygame.quit() if __name__ == "__main__": app = BenchmarkApp() app.run() pygame==2.5.2 PyOpenGL==3.1.7 numpy==1.26.4 psutil==5.9.6