478 lines
20 KiB
JavaScript
478 lines
20 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 ],
|
|
uniformLocations: [ null ],
|
|
};
|
|
|
|
// +--------------------------------------------------------------+
|
|
// | Helpers |
|
|
// +--------------------------------------------------------------+
|
|
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;
|
|
}
|
|
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;
|
|
}
|
|
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;
|
|
}
|
|
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;
|
|
}
|
|
function verifyGlUniformLocationId(locationId, allowZero)
|
|
{
|
|
if (typeof(locationId) != "number") { return "LocationId is not a number!"; }
|
|
if (locationId == 0) { return allowZero ? null : "LocationId is 0!"; }
|
|
if (glObjects == null || glObjects.uniformLocations == null) { return "Locations array has not been initialized yet!"; }
|
|
if (locationId >= glObjects.uniformLocations.length) { return "LocationId is too high!"; }
|
|
if (glObjects.uniformLocations[locationId] == null) { return "LocationId is for a destroyed program!"; }
|
|
return null;
|
|
}
|
|
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 jsGlEnable(capability)
|
|
{
|
|
appGlobals.glContext.enable(capability);
|
|
}
|
|
export function jsGlDisable(capability)
|
|
{
|
|
appGlobals.glContext.disable(capability);
|
|
}
|
|
|
|
export function jsGlBlendFunc(srcFactor, dstFactor)
|
|
{
|
|
appGlobals.glContext.blendFunc(srcFactor, dstFactor);
|
|
}
|
|
export function jsGlBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha)
|
|
{
|
|
appGlobals.glContext.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
|
|
}
|
|
|
|
export function jsGlDepthFunc(depthFunc)
|
|
{
|
|
appGlobals.glContext.depthFunc(depthFunc);
|
|
}
|
|
|
|
export function jsGlFrontFace(cullMode)
|
|
{
|
|
appGlobals.glContext.frontFace(cullMode);
|
|
}
|
|
|
|
export function jsGlDeleteBuffer(bufferId)
|
|
{
|
|
if (!verifyParameter(verifyGlBufferId(bufferId, false), "gl.deleteBuffer", "bufferId", bufferId)) { return; }
|
|
appGlobals.glContext.deleteBuffer(glObjects.buffers[bufferId]);
|
|
glObjects.buffers[bufferId] = null;
|
|
}
|
|
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;
|
|
}
|
|
|
|
//TODO: jsGlDeleteVertexArray?
|
|
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 jsGlDeleteShader(shaderId)
|
|
{
|
|
if (!verifyParameter(verifyGlShaderId(shaderId, false), "gl.deleteShader", "shaderId", shaderId)) { return; }
|
|
appGlobals.glContext.deleteShader(glObjects.shaders[shaderId]);
|
|
glObjects.shaders[shaderId] = null;
|
|
}
|
|
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 jsGlDeleteProgram(programId)
|
|
{
|
|
if (!verifyParameter(verifyGlProgramId(programId, false), "gl.deleteProgram", "programId", programId)) { return; }
|
|
appGlobals.glContext.deleteShader(glObjects.programs[programId]);
|
|
glObjects.programs[programId] = null;
|
|
}
|
|
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 jsGlClearDepth(depth)
|
|
{
|
|
appGlobals.glContext.clearDepth(depth);
|
|
}
|
|
export function jsGlClearStencil(stencilValue)
|
|
{
|
|
appGlobals.glContext.clearStencil(stencilValue);
|
|
}
|
|
|
|
export function jsGlClear(bufferBits)
|
|
{
|
|
appGlobals.glContext.clear(bufferBits);
|
|
}
|
|
|
|
export function jsGlDrawArrays(geometryType, startIndex, count)
|
|
{
|
|
appGlobals.glContext.drawArrays(geometryType, startIndex, count);
|
|
}
|
|
|
|
export function jsGlGetUniformLocation(programId, nameLength, namePntr)
|
|
{
|
|
if (!verifyParameter(verifyGlProgramId(programId, false), "gl.getUniformLocation", "programId", programId)) { return false; }
|
|
let program = glObjects.programs[programId];
|
|
let nameStr = wasmPntrAndLengthToJsString(namePntr, nameLength);
|
|
let newLocation = appGlobals.glContext.getUniformLocation(program, nameStr);
|
|
let newLocationId = glObjects.uniformLocations.length;
|
|
glObjects.uniformLocations.push(newLocation);
|
|
return newLocationId;
|
|
}
|
|
|
|
export function jsGlUniform1f(locationId, value)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform1f", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform1f(location, value);
|
|
}
|
|
export function jsGlUniform2f(locationId, value0, value1)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform2f", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform2f(location, value0, value1);
|
|
}
|
|
export function jsGlUniform3f(locationId, value0, value1, value2)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform3f", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform3f(location, value0, value1, value2);
|
|
}
|
|
export function jsGlUniform4f(locationId, value0, value1, value2, value3)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform4f", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform4f(location, value0, value1, value2, value3);
|
|
}
|
|
|
|
export function jsGlUniform1fv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform1fv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Float32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount);
|
|
appGlobals.glContext.uniform1fv(location, valuesArray);
|
|
}
|
|
export function jsGlUniform2fv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform2fv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Float32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount*2);
|
|
appGlobals.glContext.uniform2fv(location, valuesArray);
|
|
}
|
|
export function jsGlUniform3fv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform3fv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Float32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount*3);
|
|
appGlobals.glContext.uniform3fv(location, valuesArray);
|
|
}
|
|
export function jsGlUniform4fv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform4fv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Float32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount*4);
|
|
appGlobals.glContext.uniform4fv(location, valuesArray);
|
|
}
|
|
|
|
export function jsGlUniform1i(locationId, value)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform1i", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform1i(location, value);
|
|
}
|
|
export function jsGlUniform2i(locationId, value0, value1)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform2i", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform2i(location, value0, value1);
|
|
}
|
|
export function jsGlUniform3i(locationId, value0, value1, value2)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform3i", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform3i(location, value0, value1, value2);
|
|
}
|
|
export function jsGlUniform4i(locationId, value0, value1, value2, value3)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform4i", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
appGlobals.glContext.uniform4i(location, value0, value1, value2, value3);
|
|
}
|
|
|
|
export function jsGlUniform1iv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform1iv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Int32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount);
|
|
appGlobals.glContext.uniform1iv(location, valuesArray);
|
|
}
|
|
export function jsGlUniform2iv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform2iv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Int32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount*2);
|
|
appGlobals.glContext.uniform2iv(location, valuesArray);
|
|
}
|
|
export function jsGlUniform3iv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform3iv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Int32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount*3);
|
|
appGlobals.glContext.uniform3iv(location, valuesArray);
|
|
}
|
|
export function jsGlUniform4iv(locationId, valuesCount, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniform4iv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Int32Array(appGlobals.memDataView.buffer, valuesPntr, valuesCount*4);
|
|
appGlobals.glContext.uniform4iv(location, valuesArray);
|
|
}
|
|
|
|
export function jsGlUniformMatrix2fv(locationId, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniformMatrix2fv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Float32Array(appGlobals.memDataView.buffer, valuesPntr, 2*2);
|
|
appGlobals.glContext.uniformMatrix2fv(location, false, valuesArray);
|
|
}
|
|
export function jsGlUniformMatrix3fv(locationId, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniformMatrix3fv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Float32Array(appGlobals.memDataView.buffer, valuesPntr, 3*3);
|
|
appGlobals.glContext.uniformMatrix3fv(location, false, valuesArray);
|
|
}
|
|
export function jsGlUniformMatrix4fv(locationId, valuesPntr)
|
|
{
|
|
if (!verifyParameter(verifyGlUniformLocationId(locationId, false), "gl.uniformMatrix4fv", "locationId", locationId)) { return false; }
|
|
let location = glObjects.uniformLocations[locationId];
|
|
let valuesArray = new Float32Array(appGlobals.memDataView.buffer, valuesPntr, 4*4);
|
|
appGlobals.glContext.uniformMatrix4fv(location, false, valuesArray);
|
|
}
|
|
|
|
export let jsGlFunctions = {
|
|
jsGlEnable: jsGlEnable,
|
|
jsGlDisable: jsGlDisable,
|
|
jsGlBlendFunc: jsGlBlendFunc,
|
|
jsGlBlendFuncSeparate: jsGlBlendFuncSeparate,
|
|
jsGlDepthFunc: jsGlDepthFunc,
|
|
jsGlFrontFace: jsGlFrontFace,
|
|
jsGlDeleteBuffer: jsGlDeleteBuffer,
|
|
jsGlCreateBuffer: jsGlCreateBuffer,
|
|
jsGlBindBuffer: jsGlBindBuffer,
|
|
jsGlBufferData: jsGlBufferData,
|
|
jsGlCreateVertexArray: jsGlCreateVertexArray,
|
|
jsGlBindVertexArray: jsGlBindVertexArray,
|
|
jsGlEnableVertexAttribArray: jsGlEnableVertexAttribArray,
|
|
jsGlVertexAttribPointer: jsGlVertexAttribPointer,
|
|
jsGlDeleteShader: jsGlDeleteShader,
|
|
jsGlCreateShader: jsGlCreateShader,
|
|
jsGlShaderSource: jsGlShaderSource,
|
|
jsGlCompileShader: jsGlCompileShader,
|
|
jsGlGetShaderParameterBool: jsGlGetShaderParameterBool,
|
|
jsGlGetShaderParameterInt: jsGlGetShaderParameterInt,
|
|
jsGlDeleteProgram: jsGlDeleteProgram,
|
|
jsGlCreateProgram: jsGlCreateProgram,
|
|
jsGlAttachShader: jsGlAttachShader,
|
|
jsGlLinkProgram: jsGlLinkProgram,
|
|
jsGlUseProgram: jsGlUseProgram,
|
|
jsGlGetProgramParameterBool: jsGlGetProgramParameterBool,
|
|
jsGlGetProgramParameterInt: jsGlGetProgramParameterInt,
|
|
jsGlClearColor: jsGlClearColor,
|
|
jsGlClearDepth: jsGlClearDepth,
|
|
jsGlClearStencil: jsGlClearStencil,
|
|
jsGlClear: jsGlClear,
|
|
jsGlDrawArrays: jsGlDrawArrays,
|
|
jsGlGetUniformLocation: jsGlGetUniformLocation,
|
|
jsGlUniform1f: jsGlUniform1f,
|
|
jsGlUniform2f: jsGlUniform2f,
|
|
jsGlUniform3f: jsGlUniform3f,
|
|
jsGlUniform4f: jsGlUniform4f,
|
|
jsGlUniform1fv: jsGlUniform1fv,
|
|
jsGlUniform2fv: jsGlUniform2fv,
|
|
jsGlUniform3fv: jsGlUniform3fv,
|
|
jsGlUniform4fv: jsGlUniform4fv,
|
|
jsGlUniform1i: jsGlUniform1i,
|
|
jsGlUniform2i: jsGlUniform2i,
|
|
jsGlUniform3i: jsGlUniform3i,
|
|
jsGlUniform4i: jsGlUniform4i,
|
|
jsGlUniform1iv: jsGlUniform1iv,
|
|
jsGlUniform2iv: jsGlUniform2iv,
|
|
jsGlUniform3iv: jsGlUniform3iv,
|
|
jsGlUniform4iv: jsGlUniform4iv,
|
|
jsGlUniformMatrix2fv: jsGlUniformMatrix2fv,
|
|
jsGlUniformMatrix3fv: jsGlUniformMatrix3fv,
|
|
jsGlUniformMatrix4fv: jsGlUniformMatrix4fv,
|
|
};
|
|
|
|
//TODO: deleteTexture(webglObjects.textures[textureId])
|
|
//TODO: texImage2D(target, level, internalformat, width, height, border, format, type, dataBuffer)
|
|
//TODO: generateMipmap(target)
|
|
|
|
//TODO: string getShaderInfoLog(shaderId)
|
|
//TODO: string getProgramInfoLog(programId)
|