A WebGL permite exibir gráficos 3D incríveis em tempo real no navegador, mas o que muitas pessoas não sabem é que ela é uma API 2D, não 3D. Vou explicar.
O WebGL só se preocupa com duas coisas. Coordenadas de espaço de recorte em 2D e cores. Seu trabalho como programador que usa o WebGL é fornecer esses dois elementos. Para isso, você fornece dois "shaders". Um sombreador de vértice que fornece as coordenadas do espaço de recorte e um sombreador de fragmento que fornece a cor. As coordenadas do espaço de recorte sempre vão de -1 a +1, não importa o tamanho da tela. Veja um exemplo simples que mostra o WebGL na forma mais básica.
// Get A WebGL context
var canvas = document.getElementById("canvas");
var gl = canvas.getContext("experimental-webgl");
// setup a GLSL program
var vertexShader = createShaderFromScriptElement(gl, "2d-vertex-shader");
var fragmentShader = createShaderFromScriptElement(gl, "2d-fragment-shader");
var program = createProgram(gl, [vertexShader, fragmentShader]);
gl.useProgram(program);
// look up where the vertex data needs to go.
var positionLocation = gl.getAttribLocation(program, "a_position");
// Create a buffer and put a single clipspace rectangle in
// it (2 triangles)
var buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.bufferData(
gl.ARRAY_BUFFER,
new Float32Array([
-1.0, -1.0,
1.0, -1.0,
-1.0, 1.0,
-1.0, 1.0,
1.0, -1.0,
1.0, 1.0]),
gl.STATIC_DRAW);
gl.enableVertexAttribArray(positionLocation);
gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);
// draw
gl.drawArrays(gl.TRIANGLES, 0, 6);
Aqui estão os dois sombreadores
<script id="2d-vertex-shader" type="x-shader/x-vertex">
attribute vec2 a_position;
void main() {
gl_Position = vec4(a_position, 0, 1);
}
</script>
<script id="2d-fragment-shader" type="x-shader/x-fragment">
void main() {
gl_FragColor = vec4(0,1,0,1); // green
}
</script>
Novamente, as coordenadas do clipspace sempre vão de -1 a +1, independentemente do tamanho da tela. No caso acima, você pode ver que estamos apenas transmitindo nossos dados de posição diretamente. Como os dados de posição já estão no espaço de recorte, não há nada a fazer. Se você quiser 3D, precisará fornecer sombreadores que convertam de 3D para 2D, porque a WebGL É UMA API 2D! Para coisas em 2D, você provavelmente prefere trabalhar em pixels do que em clipspace. Então, vamos mudar o sombreador para que possamos fornecer retângulos em pixels e convertê-los em clipspace para nós. Este é o novo sombreador de vértice:
<script id="2d-vertex-shader" type="x-shader/x-vertex">
attribute vec2 a_position;
uniform vec2 u_resolution;
void main() {
// convert the rectangle from pixels to 0.0 to 1.0
vec2 zeroToOne = a_position / u_resolution;
// convert from 0->1 to 0->2
vec2 zeroToTwo = zeroToOne * 2.0;
// convert from 0->2 to -1->+1 (clipspace)
vec2 clipSpace = zeroToTwo - 1.0;
gl_Position = vec4(clipSpace, 0, 1);
}
</script>
Agora podemos mudar nossos dados de clipspace para pixels
// set the resolution
var resolutionLocation = gl.getUniformLocation(program, "u_resolution");
gl.uniform2f(resolutionLocation, canvas.width, canvas.height);
// setup a rectangle from 10,20 to 80,30 in pixels
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
10, 20,
80, 20,
10, 30,
10, 30,
80, 20,
80, 30]), gl.STATIC_DRAW);
O retângulo está perto da parte de baixo dessa área. O WebGL considera o canto inferior esquerdo como 0,0. Para que ele fique no canto superior esquerdo, mais tradicional, usado para APIs de gráficos 2D, basta inverter a coordenada y.
gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);
Vamos transformar o código que define um retângulo em uma função para que possamos chamá-lo para retângulos de tamanhos diferentes. Enquanto isso, vamos tornar a cor configurável. Primeiro, fazemos com que o sombreador de fragmento use uma entrada uniforme de cor.
<script id="2d-fragment-shader" type="x-shader/x-fragment">
precision mediump float;
uniform vec4 u_color;
void main() {
gl_FragColor = u_color;
}
</script>
E aqui está o novo código que desenha 50 retângulos em lugares e cores aleatórios.
...
var colorLocation = gl.getUniformLocation(program, "u_color");
...
// Create a buffer
var buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.enableVertexAttribArray(positionLocation);
gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);
// draw 50 random rectangles in random colors
for (var ii = 0; ii < 50; ++ii) {
// Setup a random rectangle
setRectangle(
gl, randomInt(300), randomInt(300), randomInt(300), randomInt(300));
// Set a random color.
gl.uniform4f(colorLocation, Math.random(), Math.random(), Math.random(), 1);
// Draw the rectangle.
gl.drawArrays(gl.TRIANGLES, 0, 6);
}
}
// Returns a random integer from 0 to range - 1.
function randomInt(range) {
return Math.floor(Math.random() * range);
}
// Fills the buffer with the values that define a rectangle.
function setRectangle(gl, x, y, width, height) {
var x1 = x;
var x2 = x + width;
var y1 = y;
var y2 = y + height;
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
x1, y1,
x2, y1,
x1, y2,
x1, y2,
x2, y1,
x2, y2]), gl.STATIC_DRAW);
}
Espero que você perceba que a WebGL é uma API bem simples. Embora possa ser mais complicado fazer 3D, essa complicação é adicionada por você, o programador, na forma de sombreadores mais complexos. A API WebGL em si é 2D e bastante simples.
O que significam type="x-shader/x-vertex" e type="x-shader/x-fragment"?
As tags <script> têm JavaScript por padrão. Você pode não colocar nenhum tipo ou colocar type="javascript" ou type="text/javascript", e o navegador vai interpretar o conteúdo como JavaScript. Se você colocar qualquer outra coisa, o navegador vai ignorar o conteúdo da tag script.
Podemos usar esse recurso para armazenar shaders em tags script. Melhor ainda, podemos criar nosso próprio tipo e, no JavaScript, procurar por ele para decidir se o sombreador será compilado como um sombreador de vértice ou de fragmento.
Nesse caso, a função createShaderFromScriptElement procura um script com o id especificado e, em seguida, analisa o type para decidir que tipo de sombreador criar.
Processamento de imagens WebGL
O processamento de imagens é fácil no WebGL. É fácil? Leia abaixo.
Para desenhar imagens no WebGL, precisamos usar texturas. Da mesma forma que o WebGL espera coordenadas de clipspace ao renderizar em vez de pixels, ele espera coordenadas de textura ao ler uma textura. As coordenadas de textura vão de 0,0 a 1,0, independentemente das dimensões da textura. Como estamos desenhando apenas um retângulo (na verdade, dois triângulos), precisamos informar ao WebGL qual lugar na textura corresponde a cada ponto no retângulo. Vamos transmitir essas informações do sombreador de vértice para o sombreador de fragmento usando um tipo especial de variável chamada "varying". É chamada de variável porque varia. O WebGL vai interpolar os valores que fornecemos no sombreador de vértice ao desenhar cada pixel usando o sombreador de fragmento. Usando o sombreador de vértice do final da seção anterior, precisamos adicionar um atributo para transmitir as coordenadas de textura e, em seguida, transmiti-las ao sombreador de fragmento.
attribute vec2 a_texCoord;
...
varying vec2 v_texCoord;
void main() {
...
// pass the texCoord to the fragment shader
// The GPU will interpolate this value between points
v_texCoord = a_texCoord;
}
Em seguida, fornecemos um sombreador de fragmento para procurar cores na textura.
<script id="2d-fragment-shader" type="x-shader/x-fragment">
precision mediump float;
// our texture
uniform sampler2D u_image;
// the texCoords passed in from the vertex shader.
varying vec2 v_texCoord;
void main() {
// Look up a color from the texture.
gl_FragColor = texture2D(u_image, v_texCoord);
}
</script>
Por fim, precisamos carregar uma imagem, criar uma textura e copiar a imagem para a textura. Como estamos em um navegador, as imagens são carregadas de forma assíncrona. Por isso, precisamos reorganizar um pouco o código para esperar que a textura seja carregada. Quando ela carregar, vamos desenhá-la.
function main() {
var image = new Image();
image.src = "http://someimage/on/our/server"; // MUST BE SAME DOMAIN!!!
image.onload = function() {
render(image);
}
}
function render(image) {
...
// all the code we had before.
...
// look up where the texture coordinates need to go.
var texCoordLocation = gl.getAttribLocation(program, "a_texCoord");
// provide texture coordinates for the rectangle.
var texCoordBuffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
0.0, 0.0,
1.0, 0.0,
0.0, 1.0,
0.0, 1.0,
1.0, 0.0,
1.0, 1.0]), gl.STATIC_DRAW);
gl.enableVertexAttribArray(texCoordLocation);
gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);
// Create a texture.
var texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
// Set the parameters so we can render any size image.
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
// Upload the image into the texture.
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
...
}
Não é muito interessante, então vamos manipular essa imagem. Que tal trocar o vermelho e o azul?
...
gl_FragColor = texture2D(u_image, v_texCoord).bgra;
...
E se quisermos fazer um processamento de imagem que realmente analise outros pixels? Como o WebGL faz referência a texturas em coordenadas de textura que vão de 0,0 a 1,0, podemos calcular quanto mover para 1 pixel com a matemática simples onePixel = 1.0 / textureSize.
Este é um sombreador de fragmento que calcula a média dos pixels à esquerda e à direita de cada pixel na textura.
<script id="2d-fragment-shader" type="x-shader/x-fragment">
precision mediump float;
// our texture
uniform sampler2D u_image;
uniform vec2 u_textureSize;
// the texCoords passed in from the vertex shader.
varying vec2 v_texCoord;
void main() {
// compute 1 pixel in texture coordinates.
vec2 onePixel = vec2(1.0, 1.0) / u_textureSize;
// average the left, middle, and right pixels.
gl_FragColor = (
texture2D(u_image, v_texCoord) +
texture2D(u_image, v_texCoord + vec2(onePixel.x, 0.0)) +
texture2D(u_image, v_texCoord + vec2(-onePixel.x, 0.0))) / 3.0;
}
</script>
Em seguida, precisamos transmitir o tamanho da textura do JavaScript.
...
var textureSizeLocation = gl.getUniformLocation(program, "u_textureSize");
...
// set the size of the image
gl.uniform2f(textureSizeLocation, image.width, image.height);
...
Agora que sabemos como referenciar outros pixels, vamos usar um kernel de convolução para fazer um processamento de imagem comum. Neste caso, vamos usar um kernel 3x3. Um kernel de convolução é apenas uma matriz 3x3 em que cada entrada representa o quanto multiplicar os 8 pixels ao redor do pixel que estamos renderizando. Em seguida, dividimos o resultado pelo peso do kernel (a soma de todos os valores no kernel) ou por 1,0, o que for maior. Confira este artigo sobre o assunto. E aqui está outro artigo que mostra um código real se você fosse escrever isso manualmente em C++. No nosso caso, vamos fazer esse trabalho no sombreador. Então, aqui está o novo sombreador de fragmentos.
<script id="2d-fragment-shader" type="x-shader/x-fragment">
precision mediump float;
// our texture
uniform sampler2D u_image;
uniform vec2 u_textureSize;
uniform float u_kernel[9];
// the texCoords passed in from the vertex shader.
varying vec2 v_texCoord;
void main() {
vec2 onePixel = vec2(1.0, 1.0) / u_textureSize;
vec4 colorSum =
texture2D(u_image, v_texCoord + onePixel * vec2(-1, -1)) * u_kernel[0] +
texture2D(u_image, v_texCoord + onePixel * vec2( 0, -1)) * u_kernel[1] +
texture2D(u_image, v_texCoord + onePixel * vec2( 1, -1)) * u_kernel[2] +
texture2D(u_image, v_texCoord + onePixel * vec2(-1, 0)) * u_kernel[3] +
texture2D(u_image, v_texCoord + onePixel * vec2( 0, 0)) * u_kernel[4] +
texture2D(u_image, v_texCoord + onePixel * vec2( 1, 0)) * u_kernel[5] +
texture2D(u_image, v_texCoord + onePixel * vec2(-1, 1)) * u_kernel[6] +
texture2D(u_image, v_texCoord + onePixel * vec2( 0, 1)) * u_kernel[7] +
texture2D(u_image, v_texCoord + onePixel * vec2( 1, 1)) * u_kernel[8] ;
float kernelWeight =
u_kernel[0] +
u_kernel[1] +
u_kernel[2] +
u_kernel[3] +
u_kernel[4] +
u_kernel[5] +
u_kernel[6] +
u_kernel[7] +
u_kernel[8] ;
if (kernelWeight <= 0.0) {
kernelWeight = 1.0;
}
// Divide the sum by the weight but just use rgb
// we'll set alpha to 1.0
gl_FragColor = vec4((colorSum / kernelWeight).rgb, 1.0);
}
</script>
No JavaScript, precisamos fornecer um kernel de convolução.
...
var kernelLocation = gl.getUniformLocation(program, "u_kernel[0]");
...
var edgeDetectKernel = [
-1, -1, -1,
-1, 8, -1,
-1, -1, -1
];
gl.uniform1fv(kernelLocation, edgeDetectKernel);
...
Espero que isso tenha convencido você de que o processamento de imagens no WebGL é bem simples. Em seguida, vou mostrar como aplicar mais de um efeito à imagem.
O que são os prefixos a, u e v_ nas variáveis em GLSL?
Essa é apenas uma convenção de nomenclatura. a_ para atributos, que são os dados fornecidos pelos buffers. u_ para uniformes, que são entradas para os shaders, v_ para variações, que são valores transmitidos de um shader de vértice para um shader de fragmento e interpolados (ou variados) entre os vértices de cada pixel desenhado.
Como aplicar vários efeitos
A próxima pergunta mais óbvia para o processamento de imagens é: como aplicar vários efeitos?
Você pode tentar gerar sombreadores em tempo real. Forneça uma interface que permita ao usuário selecionar os efeitos que ele quer usar e, em seguida, gere um sombreador que faça todos os efeitos. Nem sempre isso é possível, mas essa técnica é frequentemente usada para criar efeitos para gráficos em tempo real. Uma maneira mais flexível é usar mais duas texturas e renderizar cada uma delas, alternando entre elas e aplicando o próximo efeito a cada vez.
Original Image -> [Blur] -> Texture 1
Texture 1 -> [Sharpen] -> Texture 2
Texture 2 -> [Edge Detect] -> Texture 1
Texture 1 -> [Blur] -> Texture 2
Texture 2 -> [Normal] -> Canvas
Para isso, precisamos criar framebuffers. No WebGL e no OpenGL, o nome Framebuffer não é muito adequado. Um Framebuffer WebGL/OpenGL é apenas uma coleção de estados, não um buffer de qualquer tipo. No entanto, ao anexar uma textura a um framebuffer, podemos renderizar nela. Primeiro, vamos transformar o código antigo de criação de textura em uma função.
function createAndSetupTexture(gl) {
var texture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, texture);
// Set up texture so we can render any size image and so we are
// working with pixels.
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
return texture;
}
// Create a texture and put the image in it.
var originalImageTexture = createAndSetupTexture(gl);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
Agora vamos usar essa função para criar mais 2 texturas e anexá-las a 2 framebuffers.
// create 2 textures and attach them to framebuffers.
var textures = [];
var framebuffers = [];
for (var ii = 0; ii < 2; ++ii) {
var texture = createAndSetupTexture(gl);
textures.push(texture);
// make the texture the same size as the image
gl.texImage2D(
gl.TEXTURE_2D, 0, gl.RGBA, image.width, image.height, 0,
gl.RGBA, gl.UNSIGNED_BYTE, null);
// Create a framebuffer
var fbo = gl.createFramebuffer();
framebuffers.push(fbo);
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
// Attach a texture to it.
gl.framebufferTexture2D(
gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
}
Agora vamos criar um conjunto de kernels e uma lista deles para aplicar.
// Define several convolution kernels
var kernels = {
normal: [
0, 0, 0,
0, 1, 0,
0, 0, 0
],
gaussianBlur: [
0.045, 0.122, 0.045,
0.122, 0.332, 0.122,
0.045, 0.122, 0.045
],
unsharpen: [
-1, -1, -1,
-1, 9, -1,
-1, -1, -1
],
emboss: [
-2, -1, 0,
-1, 1, 1,
0, 1, 2
]
};
// List of effects to apply.
var effectsToApply = [
"gaussianBlur",
"emboss",
"gaussianBlur",
"unsharpen"
];
Por fim, vamos aplicar cada um, alternando a textura que estamos renderizando
// start with the original image
gl.bindTexture(gl.TEXTURE_2D, originalImageTexture);
// don't y flip images while drawing to the textures
gl.uniform1f(flipYLocation, 1);
// loop through each effect we want to apply.
for (var ii = 0; ii < effectsToApply.length; ++ii) {
// Setup to draw into one of the framebuffers.
setFramebuffer(framebuffers[ii % 2], image.width, image.height);
drawWithKernel(effectsToApply[ii]);
// for the next draw, use the texture we just rendered to.
gl.bindTexture(gl.TEXTURE_2D, textures[ii % 2]);
}
// finally draw the result to the canvas.
gl.uniform1f(flipYLocation, -1); // need to y flip for canvas
setFramebuffer(null, canvas.width, canvas.height);
drawWithKernel("normal");
function setFramebuffer(fbo, width, height) {
// make this the framebuffer we are rendering to.
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
// Tell the shader the resolution of the framebuffer.
gl.uniform2f(resolutionLocation, width, height);
// Tell webgl the viewport setting needed for framebuffer.
gl.viewport(0, 0, width, height);
}
function drawWithKernel(name) {
// set the kernel
gl.uniform1fv(kernelLocation, kernels[name]);
// Draw the rectangle.
gl.drawArrays(gl.TRIANGLES, 0, 6);
}
Algumas coisas que preciso revisar.
Chamar gl.bindFramebuffer com null informa ao WebGL que você quer renderizar na tela em vez de em um dos framebuffers.
O WebGL precisa converter o espaço de recorte de volta em pixels. Isso é feito com base nas configurações de gl.viewport. As configurações de gl.viewport usam como padrão o tamanho da tela quando inicializamos o WebGL. Como os framebuffers que estamos renderizando têm um tamanho diferente da tela, precisamos definir a janela de visualização de forma adequada.
Por fim, nos exemplos de conceitos básicos do WebGL, invertemos a coordenada Y ao renderizar porque o WebGL exibe a tela com 0,0 sendo o canto inferior esquerdo, em vez do canto superior esquerdo, mais tradicional para 2D. Isso não é necessário ao renderizar em um framebuffer. Como o framebuffer nunca é exibido, não importa qual parte é a de cima e qual é a de baixo. O que importa é que o pixel 0,0 no framebuffer corresponda a 0,0 nos nossos cálculos. Para lidar com isso, adicionei uma entrada ao sombreador para definir se a imagem deve ser invertida ou não.
<script id="2d-vertex-shader" type="x-shader/x-vertex">
...
uniform float u_flipY;
...
void main() {
...
gl_Position = vec4(clipSpace * vec2(1, u_flipY), 0, 1);
...
}
</script>
E podemos defini-lo quando renderizamos com
...
var flipYLocation = gl.getUniformLocation(program, "u_flipY");
...
// don't flip
gl.uniform1f(flipYLocation, 1);
...
// flip
gl.uniform1f(flipYLocation, -1);
Mantive este exemplo simples usando um único programa GLSL que pode alcançar vários efeitos. Se você quiser fazer um processamento de imagem completo, provavelmente vai precisar de muitos programas GLSL. Um programa para ajuste de matiz, saturação e luminância. Outro para brilho e contraste. Um para inverter, outro para ajustar níveis etc. Você precisaria mudar o código para alternar os programas GLSL e atualizar os parâmetros desse programa específico. Eu considerei escrever esse exemplo, mas é um exercício que é melhor deixar para o leitor, porque vários programas GLSL, cada um com suas próprias necessidades de parâmetros, provavelmente significam uma grande refatoração para evitar que tudo se torne uma grande bagunça. Espero que este e os exemplos anteriores tenham tornado o WebGL um pouco mais acessível e que começar com 2D ajude a entender melhor o WebGL. Se eu encontrar tempo, tentarei escrever mais alguns artigos sobre como fazer 3D, bem como mais detalhes sobre o que o WebGL realmente está fazendo nos bastidores.
WebGL e Alfa
Percebi que alguns desenvolvedores do OpenGL têm problemas com a forma como o WebGL trata o alfa no backbuffer (ou seja, o canvas). Por isso, achei que seria bom analisar algumas das diferenças entre o WebGL e o OpenGL relacionadas ao alfa.
A maior diferença entre o OpenGL e o WebGL é que o OpenGL renderiza em um backbuffer que não é composto com nada, ou seja, não é composto com nada pelo gerenciador de janelas do SO. Portanto, não importa qual seja o alfa.
O WebGL é composto pelo navegador com a página da Web, e o padrão é usar o alfa pré-multiplicado, assim como as tags <img> .png com transparência e as tags de tela 2D.
O WebGL tem várias maneiras de tornar isso mais parecido com o OpenGL.
N° 1. Informe ao WebGL que você quer que ele seja composto com alfa não pré-multiplicado
gl = canvas.getContext("experimental-webgl", {premultipliedAlpha: false});
O padrão é verdadeiro. É claro que o resultado ainda será composto na página com qualquer cor de fundo que acabe ficando sob a tela (a cor de fundo da tela, a cor de fundo do contêiner da tela, a cor de fundo da página, o que está atrás da tela se ela tiver um z-index > 0 etc.), ou seja, a cor que o CSS define para essa área da página da Web. Uma boa maneira de descobrir se você tem problemas com o canal alfa é definir o plano de fundo da tela como uma cor brilhante, como vermelho. Você vai ver imediatamente o que está acontecendo.
<canvas style="background: red;"></canvas>
Você também pode definir como preto, o que vai ocultar qualquer problema de alfa que você tenha.
N° 2. Informar ao WebGL que você não quer alfa no backbuffer
gl = canvas.getContext("experimental-webgl", {alpha: false});
Isso vai fazer com que ele funcione mais como o OpenGL, já que o backbuffer terá apenas RGB. Essa é provavelmente a melhor opção, porque um bom navegador pode ver que você não tem alfa e otimizar a forma como a WebGL é composta. Isso também significa que ele não terá alfa no backbuffer. Portanto, se você estiver usando alfa no backbuffer para alguma finalidade, talvez isso não funcione. Poucos apps que conheço usam alfa no buffer de retorno. Acho que esse deveria ter sido o padrão.
N° 3. Limpar o alfa no final da renderização
..
renderScene();
..
// Set the backbuffer's alpha to 1.0
gl.clearColor(1, 1, 1, 1);
gl.colorMask(false, false, false, true);
gl.clear(gl.COLOR_BUFFER_BIT);
A limpeza geralmente é muito rápida, porque há um caso especial para ela na maioria dos hardwares. Fiz isso na maioria das minhas demonstrações. Se eu fosse esperto, mudaria para o método 2 acima. Talvez eu faça isso logo depois de postar este vídeo. Parece que a maioria das bibliotecas WebGL deve usar esse método como padrão. Os poucos desenvolvedores que usam o canal alfa para efeitos de composição podem pedir isso. O restante vai ter o melhor desempenho e o menor número de surpresas.
N° 4. Limpar o alfa uma vez e não renderizar mais nele
// At init time. Clear the back buffer.
gl.clearColor(1,1,1,1);
gl.clear(gl.COLOR_BUFFER_BIT);
// Turn off rendering to alpha
gl.colorMask(true, true, true, false);
Se você estiver renderizando nos seus próprios framebuffers, talvez seja necessário ativar a renderização para alfa novamente e desativá-la de novo ao alternar para a renderização na tela.
N° 5. Como processar imagens
Além disso, se você estiver carregando arquivos PNG com alfa em texturas, o padrão é que o alfa seja pré-multiplicado, o que geralmente NÃO é como a maioria dos jogos faz. Se você quiser evitar esse comportamento, informe ao WebGL com
gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
N° 6. Usar uma equação de combinação que funcione com alfa pré-multiplicado
Quase todos os apps OpenGL que escrevi ou em que trabalhei usam
gl.blendFunc(gl.SRC_ALPHA, gl_ONE_MINUS_SRC_ALPHA);
Isso funciona para texturas alfa não pré-multiplicadas. Se você quiser trabalhar com texturas alfa pré-multiplicadas, provavelmente vai querer
gl.blendFunc(gl.ONE, gl_ONE_MINUS_SRC_ALPHA);
Esses são os métodos que conheço. Se você souber de mais, poste abaixo.