149 lines
4.3 KiB
TypeScript
149 lines
4.3 KiB
TypeScript
import { Vec2 } from "./common.js"
|
|
|
|
function fullscreenCanvas(gfx: Graphics, id: string) {
|
|
const canvas = document.getElementById(id) as HTMLCanvasElement;
|
|
canvas.width = window.innerWidth;
|
|
canvas.height = window.innerHeight;
|
|
gfx.ctx.viewport(0, 0, canvas.width, canvas.height);
|
|
}
|
|
|
|
function createShader(ctx: WebGL2RenderingContext, type: GLenum, source: string): WebGLShader {
|
|
var shader = ctx.createShader(type);
|
|
if (!shader) {
|
|
throw new Error("Couldn't create shader: " + type);
|
|
}
|
|
|
|
ctx.shaderSource(shader, source);
|
|
ctx.compileShader(shader);
|
|
|
|
var success = ctx.getShaderParameter(shader, ctx.COMPILE_STATUS);
|
|
if (!success) {
|
|
console.log(ctx.getShaderInfoLog(shader));
|
|
ctx.deleteShader(shader);
|
|
throw new Error("Couldn't compile shader: " + type);
|
|
}
|
|
|
|
return shader;
|
|
}
|
|
|
|
function createProgram(ctx: WebGL2RenderingContext, vertexShaderSource: string | null, fragmentShaderSource: string | null): WebGLProgram {
|
|
var program = ctx.createProgram();
|
|
|
|
if (vertexShaderSource !== null) {
|
|
const vs = createShader(ctx, ctx.VERTEX_SHADER, vertexShaderSource);
|
|
ctx.attachShader(program, vs);
|
|
}
|
|
|
|
if (fragmentShaderSource !== null) {
|
|
const fs = createShader(ctx, ctx.FRAGMENT_SHADER, fragmentShaderSource);
|
|
ctx.attachShader(program, fs);
|
|
}
|
|
|
|
ctx.linkProgram(program);
|
|
|
|
var success = ctx.getProgramParameter(program, ctx.LINK_STATUS);
|
|
if (!success) {
|
|
console.log(ctx.getProgramInfoLog(program));
|
|
ctx.deleteProgram(program);
|
|
throw new Error("Failed to create program!");
|
|
}
|
|
|
|
return program;
|
|
}
|
|
|
|
class Graphics {
|
|
ctx: WebGL2RenderingContext;
|
|
program: WebGLProgram;
|
|
attribs: Map<string, Attribute> = new Map();
|
|
uniforms: Map<string, WebGLUniformLocation> = new Map();
|
|
vao: WebGLVertexArrayObject;
|
|
constructor(ctx: WebGL2RenderingContext, vs: string, fs: string) {
|
|
this.ctx = ctx;
|
|
this.program = createProgram(ctx, vs, fs);
|
|
this.vao = ctx.createVertexArray();
|
|
|
|
ctx.bindVertexArray(this.vao);
|
|
ctx.viewport(0, 0, ctx.canvas.width, ctx.canvas.height);
|
|
ctx.useProgram(this.program);
|
|
}
|
|
|
|
clear(r: number, g: number, b: number, a: number) {
|
|
this.ctx.clearColor(r, g, b, a);
|
|
this.ctx.clear(this.ctx.COLOR_BUFFER_BIT);
|
|
}
|
|
|
|
createAttribute(name: string): Attribute {
|
|
const attrib = new Attribute(this.ctx, this.program, name);
|
|
this.attribs.set(name, attrib);
|
|
return attrib;
|
|
}
|
|
|
|
getAttribute(name: string): Attribute {
|
|
const attrib = this.attribs.get(name);
|
|
|
|
if (attrib === undefined)
|
|
throw new Error("Tried to get uninitialized attribute: " + name);
|
|
|
|
return attrib;
|
|
}
|
|
|
|
createUniform(name: string) {
|
|
const loc = this.ctx.getUniformLocation(this.program, name);
|
|
|
|
if (loc === null)
|
|
throw new Error("Couldn't get location for uniform: " + name);
|
|
|
|
this.uniforms.set(name, loc);
|
|
}
|
|
|
|
getUniform(name: string): WebGLUniformLocation {
|
|
const loc = this.uniforms.get(name);
|
|
|
|
if (loc === undefined)
|
|
throw new Error("Tried to get uninitialized uniform: " + name);
|
|
|
|
return loc;
|
|
}
|
|
}
|
|
|
|
class Attribute {
|
|
loc: GLint;
|
|
buffer: WebGLBuffer;
|
|
|
|
// TODO: maybe use undefined as default value?
|
|
size: GLint = 0;
|
|
type: GLenum = 0;
|
|
normalized: GLboolean = false;
|
|
stride: GLsizei = 0;
|
|
offset: GLintptr = 0;
|
|
|
|
constructor(ctx: WebGL2RenderingContext, program: WebGLProgram, name: string) {
|
|
this.loc = ctx.getAttribLocation(program, name);
|
|
this.buffer = ctx.createBuffer();
|
|
|
|
ctx.enableVertexAttribArray(this.loc);
|
|
}
|
|
|
|
format(
|
|
size: GLint,
|
|
type: GLenum,
|
|
normalized: GLboolean,
|
|
stride: GLsizei,
|
|
offset: GLintptr)
|
|
{
|
|
this.size = size;
|
|
this.type = type;
|
|
this.normalized = normalized;
|
|
this.stride = stride;
|
|
this.offset = offset;
|
|
}
|
|
|
|
data(ctx: WebGL2RenderingContext, data: Array<number>, usage: GLenum) {
|
|
ctx.bindBuffer(ctx.ARRAY_BUFFER, this.buffer);
|
|
ctx.bufferData(ctx.ARRAY_BUFFER, new Float32Array(data), usage);
|
|
ctx.vertexAttribPointer(this.loc, this.size, this.type, this.normalized, this.stride, this.offset);
|
|
}
|
|
}
|
|
|
|
export { fullscreenCanvas, Graphics, Attribute }
|