237 lines
9.5 KiB
JavaScript
237 lines
9.5 KiB
JavaScript
|
|
import { appGlobals } from './globals.js'
|
|
import { wasmPntrToJsString, wasmPntrAndLengthToJsString } from './wasm_functions.js'
|
|
|
|
export var glObjects = {
|
|
buffers: [ null ],
|
|
vaos: [ null ],
|
|
shaders: [ null ],
|
|
programs: [ null ],
|
|
};
|
|
|
|
// +--------------------------------------------------------------+
|
|
// | Helpers |
|
|
// +--------------------------------------------------------------+
|
|
export function verifyGlBufferId(bufferId, allowZero)
|
|
{
|
|
if (typeof(bufferId) != "number") { return "BufferId is not a number!"; }
|
|
if (bufferId == 0) { return allowZero ? null : "BufferId is 0!"; }
|
|
if (glObjects == null || glObjects.buffers == null) { return "Buffers array has not been initialized yet!"; }
|
|
if (bufferId >= glObjects.buffers.length) { return "BufferId is too high!"; }
|
|
if (glObjects.buffers[bufferId] == null) { return "BufferId is for a destroyed vertBuffer!"; }
|
|
return null;
|
|
}
|
|
export function verifyGlVaoId(vaoId, allowZero)
|
|
{
|
|
if (typeof(vaoId) != "number") { return "VaoId is not a number!"; }
|
|
if (vaoId == 0) { return allowZero ? null : "VaoId is 0!"; }
|
|
if (glObjects == null || glObjects.vaos == null) { return "Vaos array has not been initialized yet!"; }
|
|
if (vaoId >= glObjects.vaos.length) { return "VaoId is too high!"; }
|
|
if (glObjects.vaos[vaoId] == null) { return "VaoId is for a destroyed array!"; }
|
|
return null;
|
|
}
|
|
export function verifyGlShaderId(shaderId, allowZero)
|
|
{
|
|
if (typeof(shaderId) != "number") { return "ShaderId is not a number!"; }
|
|
if (shaderId == 0) { return allowZero ? null : "ShaderId is 0!"; }
|
|
if (glObjects == null || glObjects.shaders == null) { return "Shaders array has not been initialized yet!"; }
|
|
if (shaderId >= glObjects.shaders.length) { return "ShaderId is too high!"; }
|
|
if (glObjects.shaders[shaderId] == null) { return "ShaderId is for a destroyed shader!"; }
|
|
return null;
|
|
}
|
|
export function verifyGlProgramId(programId, allowZero)
|
|
{
|
|
if (typeof(programId) != "number") { return "ProgramId is not a number!"; }
|
|
if (programId == 0) { return allowZero ? null : "ProgramId is 0!"; }
|
|
if (glObjects == null || glObjects.programs == null) { return "Programs array has not been initialized yet!"; }
|
|
if (programId >= glObjects.programs.length) { return "ProgramId is too high!"; }
|
|
if (glObjects.programs[programId] == null) { return "ProgramId is for a destroyed program!"; }
|
|
return null;
|
|
}
|
|
export function verifyParameter(verifyResult, functionName, parameterName, parameterValue)
|
|
{
|
|
if (verifyResult == null) { return true; }
|
|
console.error("Invalid argument \"" + parameterName + "\" passed to " + functionName + ": " + verifyResult);
|
|
console.error("Argument value: " + parameterValue);
|
|
return false;
|
|
}
|
|
|
|
// +--------------------------------------------------------------+
|
|
// | WebGL API |
|
|
// +--------------------------------------------------------------+
|
|
export function jsGlCreateBuffer()
|
|
{
|
|
let newBuffer = appGlobals.glContext.createBuffer();
|
|
let newBufferId = glObjects.buffers.length;
|
|
glObjects.buffers.push(newBuffer);
|
|
return newBufferId;
|
|
}
|
|
|
|
export function jsGlBindBuffer(bufferType, bufferId)
|
|
{
|
|
if (!verifyParameter(verifyGlBufferId(bufferId, true), "gl.bindBuffer", "bufferId", bufferId)) { return; }
|
|
let buffer = glObjects.buffers[bufferId];
|
|
appGlobals.glContext.bindBuffer(bufferType, buffer);
|
|
}
|
|
|
|
export function jsGlBufferData(bufferType, dataLength, dataPntr, usageHint)
|
|
{
|
|
let dataArray = appGlobals.memDataView.buffer.slice(dataPntr, dataPntr + dataLength)
|
|
appGlobals.glContext.bufferData(bufferType, dataArray, usageHint);
|
|
}
|
|
|
|
export function jsGlCreateVertexArray()
|
|
{
|
|
let newVao = appGlobals.glContext.createVertexArray();
|
|
let newVaoId = glObjects.vaos.length;
|
|
glObjects.vaos.push(newVao);
|
|
return newVaoId;
|
|
}
|
|
|
|
export function jsGlBindVertexArray(vaoId)
|
|
{
|
|
if (!verifyParameter(verifyGlVaoId(vaoId, true), "gl.bindVertexArray", "vaoId", vaoId)) { return; }
|
|
let vao = glObjects.vaos[vaoId];
|
|
appGlobals.glContext.bindVertexArray(vao);
|
|
}
|
|
|
|
export function jsGlEnableVertexAttribArray(location)
|
|
{
|
|
appGlobals.glContext.enableVertexAttribArray(location);
|
|
}
|
|
|
|
export function jsGlVertexAttribPointer(attribLocation, componentCount, componentType, normalized, stride, offset)
|
|
{
|
|
appGlobals.glContext.vertexAttribPointer(attribLocation, componentCount, componentType, normalized, stride, offset);
|
|
}
|
|
|
|
export function jsGlCreateShader(shaderType)
|
|
{
|
|
let newShader = appGlobals.glContext.createShader(shaderType);
|
|
let newShaderId = glObjects.shaders.length;
|
|
glObjects.shaders.push(newShader);
|
|
return newShaderId;
|
|
}
|
|
|
|
export function jsGlShaderSource(shaderId, sourceLength, sourcePntr)
|
|
{
|
|
if (!verifyParameter(verifyGlShaderId(shaderId, false), "gl.shaderSource", "shaderId", shaderId)) { return; }
|
|
let shader = glObjects.shaders[shaderId];
|
|
let sourceStr = wasmPntrAndLengthToJsString(sourcePntr, sourceLength);
|
|
appGlobals.glContext.shaderSource(shader, sourceStr);
|
|
}
|
|
|
|
export function jsGlCompileShader(shaderId)
|
|
{
|
|
if (!verifyParameter(verifyGlShaderId(shaderId, false), "gl.compileShader", "shaderId", shaderId)) { return; }
|
|
let shader = glObjects.shaders[shaderId];
|
|
appGlobals.glContext.compileShader(shader);
|
|
}
|
|
|
|
export function jsGlGetShaderParameterBool(shaderId, parameter)
|
|
{
|
|
if (!verifyParameter(verifyGlShaderId(shaderId, false), "gl.getShaderParameter", "shaderId", shaderId)) { return false; }
|
|
let shader = glObjects.shaders[shaderId];
|
|
let paramValue = appGlobals.glContext.getShaderParameter(shader, parameter);
|
|
if (typeof(paramValue) != "boolean") { console.error("Tried to get GL parameter " + parameter + " as bool when it's actually: " + typeof(paramValue)); return false; }
|
|
return paramValue;
|
|
}
|
|
export function jsGlGetShaderParameterInt(shaderId, parameter)
|
|
{
|
|
if (!verifyParameter(verifyGlShaderId(shaderId, false), "gl.getShaderParameter", "shaderId", shaderId)) { return false; }
|
|
let shader = glObjects.shaders[shaderId];
|
|
let paramValue = appGlobals.glContext.getShaderParameter(shader, parameter);
|
|
if (typeof(paramValue) != "number") { console.error("Tried to get GL parameter " + parameter + " as number when it's actually: " + typeof(paramValue)); return false; }
|
|
return paramValue;
|
|
}
|
|
|
|
export function jsGlCreateProgram()
|
|
{
|
|
let newProgram = appGlobals.glContext.createProgram();
|
|
let newProgramId = glObjects.programs.length;
|
|
glObjects.programs.push(newProgram);
|
|
return newProgramId;
|
|
}
|
|
|
|
export function jsGlAttachShader(programId, shaderId)
|
|
{
|
|
if (!verifyParameter(verifyGlProgramId(programId, false), "gl.attachShader", "programId", programId)) { return; }
|
|
if (!verifyParameter(verifyGlShaderId(shaderId, false), "gl.attachShader", "shaderId", shaderId)) { return; }
|
|
let program = glObjects.programs[programId];
|
|
let shader = glObjects.shaders[shaderId];
|
|
appGlobals.glContext.attachShader(program, shader);
|
|
}
|
|
|
|
export function jsGlLinkProgram(programId)
|
|
{
|
|
if (!verifyParameter(verifyGlProgramId(programId, false), "gl.linkProgram", "programId", programId)) { return; }
|
|
let program = glObjects.programs[programId];
|
|
appGlobals.glContext.linkProgram(program);
|
|
}
|
|
|
|
export function jsGlUseProgram(programId)
|
|
{
|
|
if (!verifyParameter(verifyGlProgramId(programId, true), "gl.useProgram", "programId", programId)) { return; }
|
|
let program = glObjects.programs[programId];
|
|
appGlobals.glContext.useProgram(program);
|
|
}
|
|
|
|
export function jsGlGetProgramParameterBool(programId, parameter)
|
|
{
|
|
if (!verifyParameter(verifyGlProgramId(programId, false), "gl.getProgramParameter", "programId", programId)) { return false; }
|
|
let program = glObjects.programs[programId];
|
|
let paramValue = appGlobals.glContext.getProgramParameter(program, parameter);
|
|
if (typeof(paramValue) != "boolean") { console.error("Tried to get GL parameter " + parameter + " as bool when it's actually: " + typeof(paramValue)); return false; }
|
|
return paramValue;
|
|
}
|
|
export function jsGlGetProgramParameterInt(programId, parameter)
|
|
{
|
|
if (!verifyParameter(verifyGlProgramId(programId, false), "gl.getProgramParameter", "programId", programId)) { return false; }
|
|
let program = glObjects.programs[programId];
|
|
let paramValue = appGlobals.glContext.getProgramParameter(program, parameter);
|
|
if (typeof(paramValue) != "number") { console.error("Tried to get GL parameter " + parameter + " as number when it's actually: " + typeof(paramValue)); return false; }
|
|
return paramValue;
|
|
}
|
|
|
|
export function jsGlClearColor(rValue, gValue, bValue, aValue)
|
|
{
|
|
appGlobals.glContext.clearColor(rValue, gValue, bValue, aValue);
|
|
}
|
|
|
|
export function jsGlClear(bufferBits)
|
|
{
|
|
appGlobals.glContext.clear(bufferBits);
|
|
}
|
|
|
|
export function jsGlDrawArrays(geometryType, startIndex, count)
|
|
{
|
|
appGlobals.glContext.drawArrays(geometryType, startIndex, count);
|
|
}
|
|
|
|
export let jsGlFunctions = {
|
|
jsGlCreateBuffer: jsGlCreateBuffer,
|
|
jsGlBindBuffer: jsGlBindBuffer,
|
|
jsGlBufferData: jsGlBufferData,
|
|
jsGlCreateVertexArray: jsGlCreateVertexArray,
|
|
jsGlBindVertexArray: jsGlBindVertexArray,
|
|
jsGlEnableVertexAttribArray: jsGlEnableVertexAttribArray,
|
|
jsGlVertexAttribPointer: jsGlVertexAttribPointer,
|
|
jsGlCreateShader: jsGlCreateShader,
|
|
jsGlShaderSource: jsGlShaderSource,
|
|
jsGlCompileShader: jsGlCompileShader,
|
|
jsGlGetShaderParameterBool: jsGlGetShaderParameterBool,
|
|
jsGlGetShaderParameterInt: jsGlGetShaderParameterInt,
|
|
jsGlCreateProgram: jsGlCreateProgram,
|
|
jsGlAttachShader: jsGlAttachShader,
|
|
jsGlLinkProgram: jsGlLinkProgram,
|
|
jsGlUseProgram: jsGlUseProgram,
|
|
jsGlGetProgramParameterBool: jsGlGetProgramParameterBool,
|
|
jsGlGetProgramParameterInt: jsGlGetProgramParameterInt,
|
|
jsGlClearColor: jsGlClearColor,
|
|
jsGlClear: jsGlClear,
|
|
jsGlDrawArrays: jsGlDrawArrays,
|
|
};
|
|
|
|
//TODO: string getShaderInfoLog(shaderId)
|
|
//TODO: string getProgramInfoLog(programId)
|