Archive commit

src/ts/client/webgl.ts

@@ -0,0 +1,136 @@
+import { spriteShader, paletteLayersShader, lightShader } from '../generated/shaders';
+import { FrameBuffer, createFrameBuffer, disposeFrameBuffer } from '../graphics/webgl/frameBuffer';
+import { SpriteSheet, CommonPalettes, PaletteManager, Camera } from '../common/interfaces';
+import { Shader, createShader, disposeShader } from '../graphics/webgl/shader';
+import { PaletteSpriteBatch, PALETTE_BATCH_BYTES_PER_VERTEX } from '../graphics/paletteSpriteBatch';
+import { getWebGLContext, getRenderTargetSize, unbindAllTexturesAndBuffers } from '../graphics/webgl/webglUtils';
+import { createCommonPalettes } from '../graphics/graphicsUtils';
+import { createTexturesForSpriteSheets, disposeTexturesForSpriteSheets } from '../graphics/spriteSheetUtils';
+import * as sprites from '../generated/sprites';
+import { SpriteBatch } from '../graphics/spriteBatch';
+import { BATCH_SIZE_MAX } from '../common/constants';
+
+export interface WebGL {
+	gl: WebGLRenderingContext;
+	frameBuffer: FrameBuffer | undefined;
+	frameBufferSheet: SpriteSheet;
+	spriteShader: Shader;
+	lightShader: Shader;
+	paletteShader: Shader;
+	spriteBatch: SpriteBatch;
+	paletteBatch: PaletteSpriteBatch;
+	palettes: CommonPalettes;
+	failedFBO: boolean;
+	renderer: string;
+}
+
+const spriteShaderSource = spriteShader;
+const paletteShaderSource = paletteLayersShader;
+const lightShaderSource = lightShader;
+
+function createIndices(capacity: number) {
+	const numIndices = (capacity * 6) | 0;
+	const indices = new Uint16Array(numIndices);
+
+	for (let i = 0, j = 0; i < numIndices; j = (j + 4) | 0) {
+		indices[i++] = (j + 0) | 0;
+		indices[i++] = (j + 1) | 0;
+		indices[i++] = (j + 2) | 0;
+		indices[i++] = (j + 0) | 0;
+		indices[i++] = (j + 2) | 0;
+		indices[i++] = (j + 3) | 0;
+	}
+
+	return indices;
+}
+
+export function initWebGL(canvas: HTMLCanvasElement, paletteManager: PaletteManager, camera: Camera): WebGL {
+	const gl = getWebGLContext(canvas);
+	return initWebGLResources(gl, paletteManager, camera);
+}
+
+export function initWebGLResources(gl: WebGLRenderingContext, paletteManager: PaletteManager, camera: Camera): WebGL {
+	let renderer = '';
+	let failedFBO = false;
+	let frameBuffer: FrameBuffer | undefined;
+	let frameBufferSheet: SpriteSheet = { texture: undefined, sprites: [], palette: false };
+
+	try {
+		const size = getRenderTargetSize(camera.w, camera.h);
+		frameBuffer = createFrameBuffer(gl, size, size);
+		frameBufferSheet.texture = frameBuffer.texture;
+	} catch (e) {
+		DEVELOPMENT && console.warn(e);
+		failedFBO = true;
+	}
+
+	createTexturesForSpriteSheets(gl, sprites.spriteSheets);
+	const palettes = createCommonPalettes(paletteManager);
+
+	const paletteShader = createShader(gl, paletteShaderSource);
+	const spriteShader = createShader(gl, spriteShaderSource);
+	const lightShader = createShader(gl, lightShaderSource);
+
+	const VERTICES_PER_SPRITE = 4;
+	const buffer = new ArrayBuffer(BATCH_SIZE_MAX * VERTICES_PER_SPRITE * PALETTE_BATCH_BYTES_PER_VERTEX);
+	const vertexBuffer = gl.createBuffer();
+
+	if (!vertexBuffer) {
+		throw new Error(`Failed to allocate vertex buffer`);
+	}
+
+	const indexBuffer = gl.createBuffer();
+
+	if (!indexBuffer) {
+		throw new Error(`Failed to allocate index buffer`);
+	}
+
+	gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
+	gl.bufferData(gl.ARRAY_BUFFER, buffer, gl.STATIC_DRAW);
+	gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+	gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, createIndices(BATCH_SIZE_MAX), gl.STATIC_DRAW);
+
+	const vertexBuffer2 = gl.createBuffer();
+
+	if (!vertexBuffer2) {
+		throw new Error(`Failed to allocate vertex buffer (2)`);
+	}
+
+	gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer2);
+	gl.bufferData(gl.ARRAY_BUFFER, buffer, gl.STATIC_DRAW);
+
+	const spriteBatch = new SpriteBatch(gl, BATCH_SIZE_MAX, buffer, vertexBuffer2, indexBuffer);
+	const paletteBatch = new PaletteSpriteBatch(gl, BATCH_SIZE_MAX, buffer, vertexBuffer, indexBuffer);
+	spriteBatch.rectSprite = sprites.pixel;
+	paletteBatch.rectSprite = sprites.pixel2;
+	paletteBatch.defaultPalette = palettes.defaultPalette;
+
+	gl.bindBuffer(gl.ARRAY_BUFFER, null);
+	gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+
+	paletteManager.init(gl);
+
+	const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+
+	if (debugInfo) {
+		renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+	}
+
+	return {
+		gl, paletteShader, spriteShader, lightShader, spriteBatch, paletteBatch,
+		frameBuffer, frameBufferSheet, palettes, failedFBO, renderer,
+	};
+}
+
+export function disposeWebGL(webgl: WebGL) {
+	const { gl } = webgl;
+
+	unbindAllTexturesAndBuffers(gl);
+	disposeTexturesForSpriteSheets(gl, sprites.spriteSheets);
+	disposeFrameBuffer(gl, webgl.frameBuffer);
+	disposeShader(gl, webgl.lightShader);
+	disposeShader(gl, webgl.spriteShader);
+	disposeShader(gl, webgl.paletteShader);
+	webgl.spriteBatch.dispose();
+	webgl.paletteBatch.dispose();
+}