StackGenVis: Alignment of Data, Algorithms, and Models for Stacking Ensemble Learning Using Performance Metrics https://doi.org/10.1109/TVCG.2020.3030352
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
StackGenVis/frontend/node_modules/stardust-webgl/dist/webgl/webgl.js

631 lines
28 KiB

"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var stardust_core_1 = require("stardust-core");
var stardust_core_2 = require("stardust-core");
var generator_1 = require("./generator");
var stardust_core_3 = require("stardust-core");
var stardust_core_4 = require("stardust-core");
var WebGLUtils = require("./webglutils");
var WebGLPlatformMarkProgram = /** @class */ (function () {
function WebGLPlatformMarkProgram(GL, spec, shader, asUniform, viewType, mode) {
this._GL = GL;
var generator = new generator_1.Generator(spec, shader, asUniform, viewType, mode);
this._program = WebGLUtils.compileProgram(this._GL, generator.getVertexCode(), generator.getFragmentCode());
this._uniformLocations = new stardust_core_2.Dictionary();
this._attribLocations = new stardust_core_2.Dictionary();
this._textures = new stardust_core_2.Dictionary();
this._currentTextureUnit = 0;
}
WebGLPlatformMarkProgram.prototype.use = function () {
this._GL.useProgram(this._program);
};
WebGLPlatformMarkProgram.prototype.setUniform = function (name, type, value) {
var location = this.getUniformLocation(name);
if (location == null) {
return;
}
var GL = this._GL;
if (type.primitive == "float") {
var va = value;
switch (type.primitiveCount) {
case 1:
GL.uniform1f(location, value);
break;
case 2:
GL.uniform2f(location, va[0], va[1]);
break;
case 3:
GL.uniform3f(location, va[0], va[1], va[2]);
break;
case 4:
GL.uniform4f(location, va[0], va[1], va[2], va[3]);
break;
}
}
if (type.primitive == "int") {
var va = value;
switch (type.primitiveCount) {
case 1:
GL.uniform1i(location, value);
break;
case 2:
GL.uniform2i(location, va[0], va[1]);
break;
case 3:
GL.uniform3i(location, va[0], va[1], va[2]);
break;
case 4:
GL.uniform4i(location, va[0], va[1], va[2], va[3]);
break;
}
}
};
WebGLPlatformMarkProgram.prototype.setTexture = function (name, texture) {
var GL = this._GL;
if (!this._textures.has(name)) {
var newTexture = GL.createTexture();
var unit = this._currentTextureUnit++;
this._textures.set(name, {
data: null,
texture: newTexture,
unit: unit
});
GL.bindTexture(GL.TEXTURE_2D, newTexture);
GL.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MAG_FILTER, GL.LINEAR);
GL.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR);
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.bindTexture(GL.TEXTURE_2D, null);
this.use();
this.setUniform(name, stardust_core_1.types.int, unit);
}
var cache = this._textures.get(name);
var newData = texture.getTextureData();
if (cache.data == newData) {
return;
}
else {
cache.data = newData;
// We need non-power-of-2 textures and floating point texture support.
GL.bindTexture(GL.TEXTURE_2D, cache.texture);
switch (newData.type) {
case "f32": {
GL.texImage2D(GL.TEXTURE_2D, 0, GL.RGBA, newData.width, newData.height, 0, GL.RGBA, GL.FLOAT, newData.data);
break;
}
case "u8": {
GL.texImage2D(GL.TEXTURE_2D, 0, GL.RGBA, newData.width, newData.height, 0, GL.RGBA, GL.FLOAT, newData.data);
break;
}
case "HTMLImageElement":
case "HTMLCanvasElement": {
GL.texImage2D(GL.TEXTURE_2D, 0, GL.RGBA, GL.RGBA, GL.FLOAT, newData.data);
break;
}
}
GL.bindTexture(GL.TEXTURE_2D, null);
this.use();
if (newData.dimensions == 1) {
this.setUniform(name + "_length", stardust_core_1.types.float, newData.width);
}
if (newData.dimensions == 2) {
this.setUniform(name + "_width", stardust_core_1.types.float, newData.width);
this.setUniform(name + "_height", stardust_core_1.types.float, newData.height);
}
}
};
WebGLPlatformMarkProgram.prototype.bindTextures = function () {
var GL = this._GL;
this._textures.forEach(function (cache) {
GL.activeTexture(GL.TEXTURE0 + cache.unit);
GL.bindTexture(GL.TEXTURE_2D, cache.texture);
});
};
WebGLPlatformMarkProgram.prototype.unbindTextures = function () {
var GL = this._GL;
this._textures.forEach(function (cache) {
GL.activeTexture(GL.TEXTURE0 + cache.unit);
GL.bindTexture(GL.TEXTURE_2D, null);
});
};
WebGLPlatformMarkProgram.prototype.getUniformLocation = function (name) {
if (this._uniformLocations.has(name)) {
return this._uniformLocations.get(name);
}
else {
var location_1 = this._GL.getUniformLocation(this._program, name);
this._uniformLocations.set(name, location_1);
return location_1;
}
};
WebGLPlatformMarkProgram.prototype.getAttribLocation = function (name) {
if (this._attribLocations.has(name)) {
return this._attribLocations.get(name);
}
else {
var location_2 = this._GL.getAttribLocation(this._program, name);
if (location_2 < 0) {
location_2 = null;
}
this._attribLocations.set(name, location_2);
return location_2;
}
};
return WebGLPlatformMarkProgram;
}());
var WebGLPlatformMarkData = /** @class */ (function (_super) {
__extends(WebGLPlatformMarkData, _super);
function WebGLPlatformMarkData() {
return _super !== null && _super.apply(this, arguments) || this;
}
return WebGLPlatformMarkData;
}(stardust_core_1.PlatformMarkData));
exports.WebGLPlatformMarkData = WebGLPlatformMarkData;
var WebGLPlatformMark = /** @class */ (function (_super) {
__extends(WebGLPlatformMark, _super);
function WebGLPlatformMark(platform, GL, mark, spec, shader, bindings, shiftBindings) {
var _this = _super.call(this) || this;
_this._platform = platform;
_this._GL = GL;
_this._mark = mark;
_this._bindings = bindings;
_this._shiftBindings = shiftBindings;
_this._spec = spec;
_this._shader = shader;
var flattenedInfo = stardust_core_2.Compiler.Transforms.flattenEmits(spec);
_this._specFlattened = flattenedInfo.specification;
_this._flattenedVertexIndexVariable = flattenedInfo.indexVariable;
_this._flattenedVertexCount = flattenedInfo.count;
_this._program = new WebGLPlatformMarkProgram(GL, _this._specFlattened, _this._shader, function (name) { return _this.isUniform(name); }, _this._platform.viewInfo.type, generator_1.GenerateMode.NORMAL);
_this._programPick = new WebGLPlatformMarkProgram(GL, _this._specFlattened, _this._shader, function (name) { return _this.isUniform(name); }, _this._platform.viewInfo.type, generator_1.GenerateMode.PICK);
_this.initializeUniforms();
return _this;
}
WebGLPlatformMark.prototype.initializeUniforms = function () {
for (var name_1 in this._specFlattened.input) {
if (this.isUniform(name_1)) {
var binding = this._bindings.get(name_1);
if (binding.bindingType == stardust_core_1.BindingType.VALUE) {
this.updateUniform(name_1, binding.specValue);
}
if (binding.bindingType == stardust_core_1.BindingType.TEXTURE) {
this.updateTexture(name_1, binding.textureValue);
}
}
}
};
WebGLPlatformMark.prototype.initializeBuffers = function () {
var _this = this;
var GL = this._GL;
var data = new WebGLPlatformMarkData();
data.buffers = new stardust_core_2.Dictionary();
this._bindings.forEach(function (binding, name) {
if (!_this.isUniform(name)) {
var location_3 = _this._program.getAttribLocation(name);
if (location_3 != null) {
data.buffers.set(name, GL.createBuffer());
}
}
});
data.buffers.set(this._flattenedVertexIndexVariable, GL.createBuffer());
if (this._programPick) {
data.buffers.set("s3_pick_index", GL.createBuffer());
}
data.ranges = [];
return data;
};
// Is the input attribute compiled as uniform?
WebGLPlatformMark.prototype.isUniform = function (name) {
// Extra variables we add are always not uniforms.
if (name == this._flattenedVertexIndexVariable) {
return false;
}
if (this._bindings.get(name) == null) {
if (this._shiftBindings.get(name) == null) {
throw new stardust_core_3.RuntimeError("attribute " + name + " is not specified.");
}
else {
return (this._bindings.get(this._shiftBindings.get(name).name).bindingType !=
stardust_core_1.BindingType.FUNCTION);
}
}
else {
// Look at the binding to determine.
return this._bindings.get(name).bindingType != stardust_core_1.BindingType.FUNCTION;
}
};
WebGLPlatformMark.prototype.updateUniform = function (name, value) {
var binding = this._bindings.get(name);
var type = binding.valueType;
this._program.use();
this._program.setUniform(name, type, value);
if (this._programPick) {
this._programPick.use();
this._programPick.setUniform(name, type, value);
}
};
WebGLPlatformMark.prototype.updateTexture = function (name, value) {
this._program.setTexture(name, value);
if (this._programPick) {
this._programPick.setTexture(name, value);
}
};
WebGLPlatformMark.prototype.uploadData = function (datas) {
var buffers = this.initializeBuffers();
buffers.ranges = [];
var repeatBegin = this._spec.repeatBegin || 0;
var repeatEnd = this._spec.repeatEnd || 0;
var GL = this._GL;
var bindings = this._bindings;
var rep = this._flattenedVertexCount;
var totalCount = 0;
datas.forEach(function (data) {
var n = data.length;
if (n == 0) {
buffers.ranges.push(null);
return;
}
else {
var c1 = totalCount;
totalCount += n + repeatBegin + repeatEnd;
var c2 = totalCount;
buffers.ranges.push([c1 * rep, c2 * rep]);
}
});
this._bindings.forEach(function (binding, name) {
var buffer = buffers.buffers.get(name);
if (buffer == null) {
return;
}
var type = binding.valueType;
var array = new Float32Array(type.primitiveCount * totalCount * rep);
var currentIndex = 0;
var multiplier = type.primitiveCount * rep;
datas.forEach(function (data) {
if (data.length == 0) {
return;
}
for (var i = 0; i < repeatBegin; i++) {
binding.fillBinary([data[0]], rep, array.subarray(currentIndex, currentIndex + multiplier));
currentIndex += multiplier;
}
binding.fillBinary(data, rep, array.subarray(currentIndex, currentIndex + data.length * multiplier));
currentIndex += data.length * multiplier;
for (var i = 0; i < repeatEnd; i++) {
binding.fillBinary([data[data.length - 1]], rep, array.subarray(currentIndex, currentIndex + multiplier));
currentIndex += multiplier;
}
});
GL.bindBuffer(GL.ARRAY_BUFFER, buffer);
GL.bufferData(GL.ARRAY_BUFFER, array, GL.STATIC_DRAW);
});
// The vertex index attribute.
var array = new Float32Array(totalCount * rep);
for (var i = 0; i < totalCount * rep; i++) {
array[i] = i % rep;
}
GL.bindBuffer(GL.ARRAY_BUFFER, buffers.buffers.get(this._flattenedVertexIndexVariable));
GL.bufferData(GL.ARRAY_BUFFER, array, GL.STATIC_DRAW);
// The pick index attribute.
if (this._programPick) {
var array_1 = new Float32Array(totalCount * rep * 4);
for (var i = 0; i < totalCount * rep; i++) {
var index = Math.floor(i / rep);
array_1[i * 4 + 0] = (index & 0xff) / 255.0;
array_1[i * 4 + 1] = ((index & 0xff00) >> 8) / 255.0;
array_1[i * 4 + 2] = ((index & 0xff0000) >> 16) / 255.0;
array_1[i * 4 + 3] = ((index & 0xff000000) >> 24) / 255.0;
}
GL.bindBuffer(GL.ARRAY_BUFFER, buffers.buffers.get("s3_pick_index"));
GL.bufferData(GL.ARRAY_BUFFER, array_1, GL.STATIC_DRAW);
}
return buffers;
};
// Render the graphics.
WebGLPlatformMark.prototype.renderBase = function (buffers, mode, onRender) {
var _this = this;
if (buffers.ranges.length > 0) {
var GL_1 = this._GL;
var spec = this._specFlattened;
var bindings = this._bindings;
// Decide which program to use
var program_1 = this._program;
if (mode == generator_1.GenerateMode.PICK) {
program_1 = this._programPick;
}
program_1.use();
var minOffset_1 = 0;
var maxOffset_1 = 0;
this._shiftBindings.forEach(function (shift, name) {
if (shift.offset > maxOffset_1) {
maxOffset_1 = shift.offset;
}
if (shift.offset < minOffset_1) {
minOffset_1 = shift.offset;
}
});
// Assign attributes to buffers
for (var name_2 in spec.input) {
var attributeLocation = program_1.getAttribLocation(name_2);
if (attributeLocation == null) {
continue;
}
if (this._shiftBindings.has(name_2)) {
var shift = this._shiftBindings.get(name_2);
GL_1.bindBuffer(GL_1.ARRAY_BUFFER, buffers.buffers.get(shift.name));
GL_1.enableVertexAttribArray(attributeLocation);
var type = bindings.get(shift.name).valueType;
GL_1.vertexAttribPointer(attributeLocation, type.primitiveCount, type.primitive == "float" ? GL_1.FLOAT : GL_1.INT, false, 0, type.size * (shift.offset - minOffset_1) * this._flattenedVertexCount);
}
else {
GL_1.bindBuffer(GL_1.ARRAY_BUFFER, buffers.buffers.get(name_2));
GL_1.enableVertexAttribArray(attributeLocation);
if (name_2 == this._flattenedVertexIndexVariable) {
GL_1.vertexAttribPointer(attributeLocation, 1, GL_1.FLOAT, false, 0, 4 * -minOffset_1 * this._flattenedVertexCount);
}
else {
var type = bindings.get(name_2).valueType;
GL_1.vertexAttribPointer(attributeLocation, type.primitiveCount, type.primitive == "float" ? GL_1.FLOAT : GL_1.INT, false, 0, type.size * -minOffset_1 * this._flattenedVertexCount);
}
}
}
// For pick mode, assign the pick index buffer
if (mode == generator_1.GenerateMode.PICK) {
var attributeLocation = program_1.getAttribLocation("s3_pick_index");
GL_1.bindBuffer(GL_1.ARRAY_BUFFER, buffers.buffers.get("s3_pick_index"));
GL_1.enableVertexAttribArray(attributeLocation);
GL_1.vertexAttribPointer(attributeLocation, 4, GL_1.FLOAT, false, 0, 0);
}
// Set view uniforms
var viewInfo = this._platform.viewInfo;
var pose = this._platform.pose;
var cameraPosition = this._platform.cameraPosition;
switch (viewInfo.type) {
case generator_1.ViewType.VIEW_2D:
{
GL_1.uniform4f(program_1.getUniformLocation("s3_view_params"), 2.0 / viewInfo.width, -2.0 / viewInfo.height, -1, +1);
}
break;
case generator_1.ViewType.VIEW_3D:
{
GL_1.uniform4f(program_1.getUniformLocation("s3_view_params"), 1.0 / Math.tan(viewInfo.fovY / 2.0) / viewInfo.aspectRatio, 1.0 / Math.tan(viewInfo.fovY / 2.0), (viewInfo.near + viewInfo.far) / (viewInfo.near - viewInfo.far), (2.0 * viewInfo.near * viewInfo.far) /
(viewInfo.near - viewInfo.far));
if (pose) {
// Rotation and position.
GL_1.uniform4f(program_1.getUniformLocation("s3_view_rotation"), pose.rotation.x, pose.rotation.y, pose.rotation.z, pose.rotation.w);
GL_1.uniform3f(program_1.getUniformLocation("s3_view_position"), pose.position.x, pose.position.y, pose.position.z);
}
else {
GL_1.uniform4f(program_1.getUniformLocation("s3_view_rotation"), 0, 0, 0, 1);
GL_1.uniform3f(program_1.getUniformLocation("s3_view_position"), 0, 0, 0);
}
GL_1.uniform3f(program_1.getUniformLocation("s3_camera_position"), cameraPosition.x, cameraPosition.y, cameraPosition.z);
}
break;
case generator_1.ViewType.VIEW_MATRIX:
{
GL_1.uniformMatrix4fv(program_1.getUniformLocation("s3_view_matrix"), false, viewInfo.viewMatrix);
GL_1.uniformMatrix4fv(program_1.getUniformLocation("s3_projection_matrix"), false, viewInfo.projectionMatrix);
if (pose) {
// Rotation and position.
GL_1.uniform4f(program_1.getUniformLocation("s3_view_rotation"), pose.rotation.x, pose.rotation.y, pose.rotation.z, pose.rotation.w);
GL_1.uniform3f(program_1.getUniformLocation("s3_view_position"), pose.position.x, pose.position.y, pose.position.z);
}
else {
GL_1.uniform4f(program_1.getUniformLocation("s3_view_rotation"), 0, 0, 0, 1);
GL_1.uniform3f(program_1.getUniformLocation("s3_view_position"), 0, 0, 0);
}
GL_1.uniform3f(program_1.getUniformLocation("s3_camera_position"), cameraPosition.x, cameraPosition.y, cameraPosition.z);
}
break;
}
// For pick, set the mark index
if (mode == generator_1.GenerateMode.PICK) {
GL_1.uniform1f(program_1.getUniformLocation("s3_pick_index_alpha"), this._pickIndex / 255.0);
}
program_1.bindTextures();
// Draw arrays
buffers.ranges.forEach(function (range, index) {
if (onRender) {
onRender(index);
}
if (range != null) {
program_1.use();
program_1.bindTextures();
GL_1.drawArrays(GL_1.TRIANGLES, range[0], range[1] -
range[0] -
(maxOffset_1 - minOffset_1) * _this._flattenedVertexCount);
}
});
program_1.unbindTextures();
// Unbind attributes
for (var name_3 in spec.input) {
var attributeLocation = program_1.getAttribLocation(name_3);
if (attributeLocation != null) {
GL_1.disableVertexAttribArray(attributeLocation);
}
}
// Unbind the pick index buffer
if (mode == generator_1.GenerateMode.PICK) {
var attributeLocation = program_1.getAttribLocation("s3_pick_index");
GL_1.disableVertexAttribArray(attributeLocation);
}
}
};
WebGLPlatformMark.prototype.setPickIndex = function (index) {
this._pickIndex = index;
};
WebGLPlatformMark.prototype.render = function (buffers, onRender) {
if (this._platform.renderMode == generator_1.GenerateMode.PICK) {
this.setPickIndex(this._platform.assignPickIndex(this._mark));
}
this.renderBase(buffers, this._platform.renderMode, onRender);
};
return WebGLPlatformMark;
}(stardust_core_1.PlatformMark));
exports.WebGLPlatformMark = WebGLPlatformMark;
var WebGLPlatform = /** @class */ (function (_super) {
__extends(WebGLPlatform, _super);
function WebGLPlatform(GL) {
var _this = _super.call(this) || this;
_this._GL = GL;
_this.set2DView(500, 500);
_this.setCameraPosition(new stardust_core_1.Vector3());
_this.setPose(new stardust_core_4.Pose());
_this._renderMode = generator_1.GenerateMode.NORMAL;
_this._pickFramebuffer = null;
return _this;
}
Object.defineProperty(WebGLPlatform.prototype, "viewInfo", {
get: function () {
return this._viewInfo;
},
enumerable: true,
configurable: true
});
Object.defineProperty(WebGLPlatform.prototype, "pose", {
get: function () {
return this._pose;
},
enumerable: true,
configurable: true
});
Object.defineProperty(WebGLPlatform.prototype, "cameraPosition", {
get: function () {
return this._cameraPosition;
},
enumerable: true,
configurable: true
});
Object.defineProperty(WebGLPlatform.prototype, "renderMode", {
get: function () {
return this._renderMode;
},
enumerable: true,
configurable: true
});
WebGLPlatform.prototype.getPickFramebuffer = function (width, height) {
if (this._pickFramebuffer == null ||
width != this._pickFramebufferWidth ||
height != this._pickFramebufferHeight) {
var GL = this._GL;
this._pickFramebuffer = GL.createFramebuffer();
this._pickFramebufferWidth = width;
this._pickFramebufferHeight = height;
GL.bindFramebuffer(GL.FRAMEBUFFER, this._pickFramebuffer);
this._pickFramebufferTexture = GL.createTexture();
GL.bindTexture(GL.TEXTURE_2D, this._pickFramebufferTexture);
GL.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MAG_FILTER, GL.LINEAR);
GL.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.LINEAR);
GL.texImage2D(GL.TEXTURE_2D, 0, GL.RGBA, width, height, 0, GL.RGBA, GL.UNSIGNED_BYTE, null);
GL.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, this._pickFramebufferTexture, 0);
GL.bindTexture(GL.TEXTURE_2D, null);
GL.bindFramebuffer(GL.FRAMEBUFFER, null);
}
return this._pickFramebuffer;
};
WebGLPlatform.prototype.beginPicking = function (width, height) {
this._renderMode = generator_1.GenerateMode.PICK;
var GL = this._GL;
var fb = this.getPickFramebuffer(width, height);
GL.bindFramebuffer(GL.FRAMEBUFFER, fb);
GL.clearColor(1, 1, 1, 1);
GL.clear(GL.COLOR_BUFFER_BIT);
GL.disable(GL.BLEND);
this._pickMarks = [];
};
WebGLPlatform.prototype.assignPickIndex = function (mark) {
var idx = this._pickMarks.indexOf(mark);
if (idx >= 0) {
return idx;
}
else {
var num = this._pickMarks.length;
this._pickMarks.push(mark);
return num;
}
};
WebGLPlatform.prototype.endPicking = function () {
var GL = this._GL;
GL.bindFramebuffer(GL.FRAMEBUFFER, null);
GL.enable(GL.BLEND);
this._renderMode = generator_1.GenerateMode.NORMAL;
};
WebGLPlatform.prototype.getPickingPixel = function (x, y) {
if (this._pickMarks == null ||
x < 0 ||
y < 0 ||
x >= this._pickFramebufferWidth ||
y >= this._pickFramebufferHeight) {
return null;
}
var GL = this._GL;
var fb = this._pickFramebuffer;
GL.bindFramebuffer(GL.FRAMEBUFFER, fb);
var data = new Uint8Array(4);
GL.readPixels(x, this._pickFramebufferHeight - 1 - y, 1, 1, GL.RGBA, GL.UNSIGNED_BYTE, data);
GL.bindFramebuffer(GL.FRAMEBUFFER, null);
var offset = data[0] + (data[1] << 8) + (data[2] << 16);
if (offset >= 16777215) {
return null;
}
return [this._pickMarks[data[3]], offset];
};
WebGLPlatform.prototype.set2DView = function (width, height) {
this._viewInfo = {
type: generator_1.ViewType.VIEW_2D,
width: width,
height: height
};
};
WebGLPlatform.prototype.set3DView = function (fovY, aspectRatio, near, far) {
if (near === void 0) { near = 0.1; }
if (far === void 0) { far = 1000; }
this._viewInfo = {
type: generator_1.ViewType.VIEW_3D,
fovY: fovY,
aspectRatio: aspectRatio,
near: near,
far: far
};
};
WebGLPlatform.prototype.setWebVRView = function (viewMatrix, projectionMatrix) {
this._viewInfo = {
type: generator_1.ViewType.VIEW_MATRIX,
viewMatrix: viewMatrix,
projectionMatrix: projectionMatrix
};
};
WebGLPlatform.prototype.setMatrixView = function (viewMatrix, projectionMatrix) {
this._viewInfo = {
type: generator_1.ViewType.VIEW_MATRIX,
viewMatrix: viewMatrix,
projectionMatrix: projectionMatrix
};
};
WebGLPlatform.prototype.setCameraPosition = function (cameraPosition) {
this._cameraPosition = cameraPosition;
};
WebGLPlatform.prototype.setPose = function (pose) {
this._pose = pose;
};
WebGLPlatform.prototype.compile = function (mark, spec, shader, bindings, shiftBindings) {
return new WebGLPlatformMark(this, this._GL, mark, spec, shader, bindings, shiftBindings);
};
return WebGLPlatform;
}(stardust_core_1.Platform));
exports.WebGLPlatform = WebGLPlatform;
//# sourceMappingURL=webgl.js.map