<!DOCTYPE html>
        <html>
        <head>
            <title>WebGL Triangle Example</title>
            <style>
                canvas { border: 1px solid black; }
            </style>
        </head>
        <body>
            <canvas id="webgl-canvas" width="400" height="400"></canvas>
            <script>
                // Get the canvas and WebGL context
                var canvas = document.getElementById('webgl-canvas');
                var gl = canvas.getContext('webgl');
                // Set clear color to transparent black
                gl.clearColor(0.0, 0.0, 0.0, 0.0);
                gl.clear(gl.COLOR_BUFFER_BIT);
                // Define the geometry
                var vertices = new Float32Array([
                    0.0,  0.5,  // Vertex 1 (X, Y)
                   -0.5, -0.5,  // Vertex 2 (X, Y)
                    0.5, -0.5   // Vertex 3 (X, Y)
                ]);
                // Create a buffer and put the vertices in it
                var vertexBuffer = gl.createBuffer();
                gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
                gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
                // Define the vertex shader
                var vertexShaderSource = `
                    attribute vec2 coordinates;
                    void main(void) {
                        gl_Position = vec4(coordinates, 0.0, 1.0);
                    }
                `;
                // Create and compile the vertex shader
                var vertexShader = gl.createShader(gl.VERTEX_SHADER);
                gl.shaderSource(vertexShader, vertexShaderSource);
                gl.compileShader(vertexShader);
                // Define the fragment shader
                var fragmentShaderSource = `
                    void main(void) {
                        gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); // Red color
                    }
                `;
                // Create and compile the fragment shader
                var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
                gl.shaderSource(fragmentShader, fragmentShaderSource);
                gl.compileShader(fragmentShader);
                // Create a shader program and link shaders
                var shaderProgram = gl.createProgram();
                gl.attachShader(shaderProgram, vertexShader);
                gl.attachShader(shaderProgram, fragmentShader);
                gl.linkProgram(shaderProgram);
                gl.useProgram(shaderProgram);
                // Bind the vertex buffer
                gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
                var coordinates = gl.getAttribLocation(shaderProgram, "coordinates");
                gl.vertexAttribPointer(coordinates, 2, gl.FLOAT, false, 0, 0);
                gl.enableVertexAttribArray(coordinates);
                // Draw the triangle
                gl.clear(gl.COLOR_BUFFER_BIT);
                gl.viewport(0, 0, canvas.width, canvas.height);
                gl.drawArrays(gl.TRIANGLES, 0, 3);
            </script>
        </body>
        </html>
    
				
	
													How do I avoid rehashing overhead with std::set in multithreaded code?
														
													How do I find elements with custom comparators with std::set for embedded targets?
														
													How do I erase elements while iterating with std::set for embedded targets?
														
													How do I provide stable iteration order with std::unordered_map for large datasets?
														
													How do I reserve capacity ahead of time with std::unordered_map for large datasets?
														
													How do I erase elements while iterating with std::unordered_map in multithreaded code?
														
													How do I provide stable iteration order with std::map for embedded targets?
														
													How do I provide stable iteration order with std::map in multithreaded code?
														
													How do I avoid rehashing overhead with std::map in performance-sensitive code?
														
													How do I merge two containers efficiently with std::map for embedded targets?