Make a python script where it renders a voxel cube with depth shading and use moderngl…
- User
Make a python script where it renders a voxel cube with depth shading and use moderngl python.
- Assistant
Here is a Python script that renders a voxel cube with depth shading using
moderngl. This script utilizes instanced rendering to efficiently draw multiple voxels (small cubes) in a grid formation to create the appearance of a larger cube composed of voxels. Depth shading is applied in the fragment shader based on the depth value of each fragment.import moderngl import moderngl_window as mglw import numpy as np from pyrr import Matrix44 class VoxelCube(mglw.WindowConfig): gl_version = (3, 3) title = "Voxel Cube with Depth Shading using Instanced Rendering" window_size = (800, 600) aspect_ratio = 16 / 9 resizable = True def __init__(self, **kwargs): super().__init__(**kwargs) self.camera = self.create_camera() self.program = self.create_shader_program() self.create_voxel_cube() def create_camera(self): # Set up a static camera looking at the origin return Matrix44.look_at( eye=(3.0, 3.0, 3.0), # Camera position target=(0.0, 0.0, 0.0), # Look at the origin up=(0.0, 1.0, 0.0) # Up direction ).astype('f4') def create_shader_program(self): vertex_shader = ''' #version 330 in vec3 in_position; in vec3 instance_position; uniform mat4 model; uniform mat4 view; uniform mat4 projection; out float depth; void main() { vec4 pos = vec4(in_position + instance_position, 1.0); gl_Position = projection * view * model * pos; depth = gl_Position.z / gl_Position.w; } ''' fragment_shader = ''' #version 330 in float depth; out vec4 f_color; void main() { float shade = (depth + 1.0) / 2.0; f_color = vec4(vec3(shade), 1.0); } ''' return self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader) def create_voxel_cube(self): # Define the vertices of a single cube s = 0.05 # Half the size of the cube vertices = np.array([ # Front face -s, -s, s, s, -s, s, s, s, s, -s, s, s, # Back face -s, -s, -s, s, -s, -s, s, s, -s, -s, s, -s, ], dtype='f4') indices = np.array([ 0, 1, 2, 2, 3, 0, # Front face 4, 5, 6, 6, 7, 4, # Back face 0, 1, 5, 5, 4, 0, # Bottom face 2, 3, 7, 7, 6, 2, # Top face 1, 2, 6, 6, 5, 1, # Right face 0, 3, 7, 7, 4, 0, # Left face ], dtype='i4') # Create grid positions for voxels grid_size = 10 # Number of voxels along one axis voxel_spacing = 0.1 # Spacing between voxels # Generate instance positions for each voxel positions = np.array([ [ x * voxel_spacing - (grid_size * voxel_spacing) / 2 + voxel_spacing / 2, y * voxel_spacing - (grid_size * voxel_spacing) / 2 + voxel_spacing / 2, z * voxel_spacing - (grid_size * voxel_spacing) / 2 + voxel_spacing / 2 ] for x in range(grid_size) for y in range(grid_size) for z in range(grid_size) ], dtype='f4') self.num_instances = positions.shape[0] # Create buffers for the cube vertices and instance positions vbo = self.ctx.buffer(vertices.tobytes()) ibo = self.ctx.buffer(indices.tobytes()) instance_vbo = self.ctx.buffer(positions.tobytes()) vao_content = [ (vbo, '3f', 'in_position'), (instance_vbo, '3f/i', 'instance_position'), ] self.vao = self.ctx.vertex_array(self.program, vao_content, ibo) # Set up the transformation matrices self.model = Matrix44.identity(dtype='f4') self.projection = Matrix44.perspective_projection( fovy=60.0, aspect_ratio=self.window_size[0]/self.window_size[1], near=0.1, far=100.0, dtype='f4' ) # Upload matrices to the shader program self.program['model'].write(self.model) self.program['view'].write(self.camera) self.program['projection'].write(self.projection) def render(self, time, frame_time): self.ctx.clear(0.1, 0.1, 0.1) # Clear the screen with a dark gray color self.ctx.enable(moderngl.DEPTH_TEST) # Enable depth testing self.ctx.front_face = 'ccw' # Set the front face to counter-clockwise self.vao.render(instances=self.num_instances) # Render all instances if __name__ == '__main__': mglw.run_window_config(VoxelCube)Explanation:
-
Shader Program:
- The vertex shader receives the cube's vertex positions and the instance positions (positions of each voxel in the grid). It calculates the
gl_Positionfor each vertex of each voxel cube and outputs the depth value for shading. - The fragment shader uses the interpolated depth value to calculate a shading factor, creating a depth shading effect based on how far each fragment is from the camera.
- The vertex shader receives the cube's vertex positions and the instance positions (positions of each voxel in the grid). It calculates the
-
Instanced Rendering:
- Instanced rendering is used to efficiently draw multiple instances of the cube geometry at different positions without sending the same geometry data multiple times to the GPU.
- An array of instance positions is generated to position each voxel within the larger cube.
- The
instancesparameter inself.vao.render(instances=self.num_instances)tells OpenGL to render that many instances of the cube.
-
Buffers and Vertex Array Object (VAO):
- A Vertex Buffer Object (VBO) is created for the cube's vertices.
- An Index Buffer Object (IBO) is created for the cube's indices, defining the cube's faces.
- Another VBO is created for the instance positions.
- The VAO ties together the VBOs and the IBO, specifying how the vertex attributes are laid out in the GPU memory.
-
Matrices:
- Model Matrix: Identity matrix (no transformation at the model level).
- View Matrix: Created using a static camera positioned away from the origin, looking at the origin.
- Projection Matrix: Perspective projection matrix to give a 3D effect.
-
Rendering Loop:
- Clears the screen each frame.
- Enables depth testing to ensure correct rendering of overlapping voxels.
- Renders all instances of the cube mesh to draw the voxel cube.
Dependencies:
Make sure to install the required packages before running the script:
pip install moderngl moderngl-window numpy pyrrRunning the Script:
Save the script in a
.pyfile and run it using Python 3:python voxel_cube.pyNote: This script requires a GPU that supports OpenGL 3.3 or higher. The script opens a window where you can see the rendered voxel cube with depth shading applied.
-