¡Hola! Como proveedor de Canvas, estoy muy emocionado de compartir con ustedes cómo crear una escena WebGL simple en Canvas. WebGL es una tecnología asombrosa que le permite representar gráficos 3D interactivos directamente en su navegador utilizando el elemento HTML5 Canvas. Es una herramienta poderosa para crear experiencias inmersivas y comenzar con ella es más fácil de lo que piensas.
¿Qué es WebGL y Canvas?
Primero lo primero, repasemos rápidamente qué son WebGL y Canvas. Canvas es un elemento HTML5 que proporciona una superficie de dibujo para gráficos. Puedes usar JavaScript para dibujar en el lienzo, creando de todo, desde formas simples hasta animaciones complejas. WebGL, por otro lado, es una API de JavaScript que le permite utilizar OpenGL ES 2.0 para representar gráficos 3D en Canvas. Aprovecha la GPU (Unidad de procesamiento de gráficos) de su computadora para hacer que los gráficos sean rápidos y fluidos.
Configurando el HTML
Para comenzar, deberá crear un archivo HTML. Aquí hay una plantilla básica:
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="ancho=ancho del dispositivo, escala inicial=1.0"> <título>Escena WebGL simple</título> <estilo> lienzo { display: block; margen: 0 automático; } </style> </head> <body> <canvas id="webglCanvas" width="800" height="600"></canvas> <script src="script.js"></script> </body> </html>En este código, creamos un elemento Canvas con un ID dewebglCanvasy establezca su ancho y alto. También enlazamos a un archivo JavaScript externo llamadoscript.jsdonde escribiremos nuestro código WebGL.
Obteniendo el contexto WebGL
Ahora, pasemos al código JavaScript. Abre elscript.jsy comience obteniendo el contexto WebGL del Canvas.
// Obtener el elemento lienzo const canvas = document.getElementById('webglCanvas'); // Obtener el contexto WebGL const gl = canvas.getContext('webgl'); if (!gl) { alert('No se puede inicializar WebGL. Es posible que su navegador o máquina no lo admita.'); devolver; }En este código, primero obtenemos el elemento Canvas usando su ID. Luego, intentamos obtener el contexto WebGL del Canvas. Si el navegador no es compatible con WebGL, mostramos una alerta y detenemos la ejecución.
Creando un programa de sombreado
WebGL utiliza sombreadores para representar gráficos. Los sombreadores son pequeños programas que se ejecutan en la GPU y se encargan de calcular las posiciones y colores de los píxeles de la pantalla. Hay dos tipos de sombreadores: sombreadores de vértices y sombreadores de fragmentos.
A continuación se muestra un ejemplo de un sombreador de vértices y un sombreador de fragmentos simples:
// Código fuente del sombreador de vértices const vertexShaderSource = ` atributo vec4 a_position; void main() { gl_Position = a_position; } `; // Código fuente del sombreador de fragmentos const fragmentShaderSource = ` precisión mediump float; vacío principal() { gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); } `; // Función para crear un sombreador function createShader(gl, type, source) { const shader = gl.createShader(type); gl.shaderSource(sombreador, fuente); gl.compileShader(sombreador); éxito constante = gl.getShaderParameter(shader, gl.COMPILE_STATUS); if (éxito) { return shader; } console.log(gl.getShaderInfoLog(shader)); gl.deleteShader(sombreador); } // Función para crear un programa de sombreado function createProgram(gl, vertexShader, fragmentShader) { const program = gl.createProgram(); gl.attachShader(programa, vertexShader); gl.attachShader(programa, fragmentShader); gl.linkProgram(programa); éxito constante = gl.getProgramParameter(programa, gl.LINK_STATUS); if (éxito) { programa de retorno; } console.log(gl.getProgramInfoLog(programa)); gl.deleteProgram(programa); } // Crea los sombreadores const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexShaderSource); const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource); // Crea el programa de sombreado const program = createProgram(gl, vertexShader, fragmentShader);En este código, primero definimos el código fuente para el sombreador de vértices y el sombreador de fragmentos. El sombreador de vértices toma un atributo de posición y establece la posición del vértice en la pantalla. El sombreador de fragmentos establece el color de los píxeles en rojo.
Luego creamos funciones para crear sombreadores y programas de sombreado. Estas funciones manejan la compilación y vinculación de los sombreadores. Finalmente, creamos los sombreadores y el programa de sombreado.
Crear un búfer y dibujar un triángulo
Ahora que tenemos un programa de sombreado, podemos crear un búfer para almacenar los datos del vértice y dibujar un triángulo.
// Crea un búfer const positionBuffer = gl.createBuffer(); // Vincula el búfer al objetivo ARRAY_BUFFER gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer); // Definir las posiciones de los vértices del triángulo const posiciones = [ 0.0, 0.5, -0.5, -0.5, 0.5, -0.5 ]; // Coloca los datos de posiciones en el búfer gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW); // Busque la ubicación del atributo a_position const positionAttributeLocation = gl.getAttribLocation(program, 'a_position'); // Habilita el atributo gl.enableVertexAttribArray(positionAttributeLocation); // Indica a WebGL cómo extraer los datos del búfer const size = 2; tipo constante = gl.FLOAT; constante normalizar = falso; zancada constante = 0; desplazamiento constante = 0; gl.vertexAttribPointer(positionAttributeLocation, tamaño, tipo, normalizar, zancada, desplazamiento); // Usa el programa de sombreado gl.useProgram(programa); // Limpiar el lienzo gl.clearColor(0.0, 0.0, 0.0, 1.0); gl.clear(gl.COLOR_BUFFER_BIT); // Dibuja el triángulo constprimitiveType = gl.TRIANGLES; const offsetDraw = 0; recuento constante = 3; gl.drawArrays(primitiveType, offsetDraw, count);En este código, primero creamos un búfer y lo vinculamos alARRAY_BUFFERobjetivo. Luego definimos las posiciones de los vértices del triángulo y colocamos los datos en el búfer.
A continuación buscamos la ubicación deluna_posiciónatributo en el sombreador de vértices y habilítelo. También le decimos a WebGL cómo extraer los datos del búfer.
Finalmente, usamos el programa de sombreado, limpiamos el lienzo y dibujamos el triángulo usando eldibujarArraysfunción.
Usando nuestro Canvas para proyectos WebGL
En nuestra empresa, ofrecemos una amplia gama de productos Canvas de alta calidad que son perfectos para proyectos WebGL. NuestroTextil de lona de algodón y poliéster para inyección de tinta para ecosolventes /uv/látexes una excelente opción para imprimir gráficos de alta resolución. Tiene una excelente reproducción del color y durabilidad, lo que lo hace ideal para crear impresionantes escenas WebGL.
También tenemosLona de algodón poliésterque es perfecto para una variedad de aplicaciones. Es sólido, flexible y fácil de usar, lo que lo convierte en una opción popular entre los desarrolladores.
Si está buscando un lienzo que pueda manejar diferentes tipos de tintas, nuestroTextil de lona de algodón y poliéster para inyección de tinta para tinte/pigmento /uv/látexes el camino a seguir. Está diseñado para funcionar con una amplia gama de tintas, lo que le brinda más opciones para sus proyectos WebGL.
Conclusión
Crear una escena WebGL sencilla en un Canvas es una experiencia divertida y gratificante. Con un poco de conocimiento de WebGL y JavaScript, puedes crear increíbles gráficos 3D directamente en tu navegador. Y si buscas un Canvas de alta calidad para tus proyectos, lo tenemos cubierto.
Si está interesado en nuestros productos Canvas, no dude en comunicarse con nosotros para obtener más información. Siempre estaremos encantados de ayudarle a encontrar el Canvas adecuado para sus necesidades. Si es un desarrollador profesional o recién está comenzando, podemos brindarle el soporte y los productos que necesita para crear impresionantes escenas WebGL. ¡No dudes en contactarnos y comenzar tu próximo proyecto hoy!
Referencias
- "Guía de programación WebGL: programación interactiva de gráficos 3D con WebGL" por Kouichi Matsuda y Rodger Lea
- Documentación de Mozilla Developer Network WebGL
