andras/sdf-2d
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Improve uniform loading

Browse source
This commit is contained in:
schmelczerandras 2020-09-28 17:39:07 +02:00
parent 31fcfd3d6b
commit 971ddbd08e
21 changed files with 271 additions and 251 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/graphics/graphics-library/helper/enable-context-lost-simulator.ts
View file

@ -10,15 +10,15 @@ export const enableContextLostSimulator = (canvas: HTMLCanvasElement) => {
isEnabled = true;
const gl = canvas.getContext('webgl2')!;
const ext = gl.getExtension('WEBGL_lose_context');
const ext = gl.getExtension('WEBGL_lose_context')!;
const simulateContextLost = () => {
ext!.loseContext();
ext.loseContext();
console.log('lost');
const restoreTimeout = Math.random() * 500;
setTimeout(() => {
ext!.restoreContext();
ext.restoreContext();
console.log('restored');
}, restoreTimeout);

206
src/graphics/graphics-library/helper/load-uniform.ts
View file

@ -1,9 +1,114 @@
import { mat3, ReadonlyVec3, ReadonlyVec4, vec2, vec3, vec4 } from 'gl-matrix';
import { mat3, vec2, vec3, vec4 } from 'gl-matrix';
import { UniversalRenderingContext } from '../universal-rendering-context';
/** @internal */
const loaderMat3 = mat3.create();
/** @internal */
const converters: Map<
GLenum,
(gl: UniversalRenderingContext, value: any, location: WebGLUniformLocation) => void
> = new Map();
converters.set(WebGLRenderingContext.SAMPLER_2D, (gl, v, l) => gl.uniform1i(l, v));
converters.set(
WebGLRenderingContext.FLOAT,
(gl, v: number | Array<number> | Float32Array, l) => {
if (v instanceof Array || v instanceof Float32Array) {
if (v.length == 0) {
return;
}
gl.uniform1fv(l, new Float32Array(v));
} else {
gl.uniform1f(l, v);
}
}
);
converters.set(
WebGLRenderingContext.FLOAT_VEC2,
(gl, v: vec2 | Array<vec2> | Float32Array, l) => {
if (v.length == 0) {
return;
}
if (v[0] instanceof Array || v[0] instanceof Float32Array) {
const result = new Float32Array(v.length * 2);
for (let i = 0; i < v.length; i++) {
result[2 * i] = (v[i] as Array<number>).x;
result[2 * i + 1] = (v[i] as Array<number>).y;
}
gl.uniform2fv(l, result);
} else {
gl.uniform2fv(l, v as vec2);
}
}
);
converters.set(
WebGLRenderingContext.FLOAT_VEC3,
(gl, v: vec3 | Array<vec3> | Float32Array, l) => {
if (v.length == 0) {
return;
}
if (v[0] instanceof Array || v[0] instanceof Float32Array) {
const result = new Float32Array(v.length * 3);
for (let i = 0; i < v.length; i++) {
result[3 * i] = (v[i] as Array<number>)[0];
result[3 * i + 1] = (v[i] as Array<number>)[1];
result[3 * i + 2] = (v[i] as Array<number>)[2];
}
gl.uniform3fv(l, result);
} else {
gl.uniform3fv(l, v as vec3);
}
}
);
converters.set(
WebGLRenderingContext.FLOAT_VEC4,
(gl, v: vec4 | Array<vec4> | Float32Array, l) => {
if (v.length == 0) {
return;
}
if (v[0] instanceof Array || v[0] instanceof Float32Array) {
const result = new Float32Array(v.length * 4);
for (let i = 0; i < v.length; i++) {
result[3 * i] = (v[i] as Array<number>)[0];
result[3 * i + 1] = (v[i] as Array<number>)[1];
result[3 * i + 2] = (v[i] as Array<number>)[2];
result[3 * i + 3] = (v[i] as Array<number>)[3];
}
gl.uniform4fv(l, result);
} else {
gl.uniform4fv(l, v as vec4);
}
}
);
converters.set(WebGLRenderingContext.FLOAT_MAT3, (gl, v, l) => {
if (gl.isWebGL2) {
gl.uniformMatrix3fv(l, true, mat3.fromMat2d(loaderMat3, v));
} else {
gl.uniformMatrix3fv(
l,
false,
mat3.transpose(mat3.create(), mat3.fromMat2d(loaderMat3, v))
);
}
});
converters.set(WebGLRenderingContext.BOOL, (gl, v: number, l) => gl.uniform1i(l, v));
converters.set(WebGLRenderingContext.INT, (gl, v: number, l) => gl.uniform1i(l, v));
/** @internal */
export const loadUniform = (
gl: UniversalRenderingContext,
@ -11,106 +116,7 @@ export const loadUniform = (
type: GLenum,
location: WebGLUniformLocation
): any => {
const converters: Map<
GLenum,
(gl: UniversalRenderingContext, value: any, location: WebGLUniformLocation) => void
> = new Map();
{
converters.set(WebGLRenderingContext.SAMPLER_2D, (gl, v, l) => {
gl.uniform1i(l, v);
});
converters.set(WebGLRenderingContext.FLOAT, (gl, v, l) => {
if (v instanceof Array || v[0] instanceof Float32Array) {
if (v.length == 0) {
return;
}
gl.uniform1fv(l, new Float32Array(v));
} else {
gl.uniform1f(l, v);
}
});
converters.set(WebGLRenderingContext.FLOAT_VEC2, (gl, v: vec2 | Array<vec2>, l) => {
if (v.length == 0) {
return;
}
if (v[0] instanceof Array || v[0] instanceof Float32Array) {
const result = new Float32Array(v.length * 2);
for (let i = 0; i < v.length; i++) {
result[2 * i] = (v[i] as Array<number>).x;
result[2 * i + 1] = (v[i] as Array<number>).y;
}
gl.uniform2fv(l, result);
} else {
gl.uniform2fv(l, v as vec2);
}
});
converters.set(
WebGLRenderingContext.FLOAT_VEC3,
(gl, v: ReadonlyVec3 | Array<vec3>, l) => {
if (v.length == 0) {
return;
}
if (v[0] instanceof Array || v[0] instanceof Float32Array) {
const result = new Float32Array(v.length * 3);
for (let i = 0; i < v.length; i++) {
result[3 * i] = (v[i] as Array<number>)[0];
result[3 * i + 1] = (v[i] as Array<number>)[1];
result[3 * i + 2] = (v[i] as Array<number>)[2];
}
gl.uniform3fv(l, result);
} else {
gl.uniform3fv(l, v as vec3);
}
}
);
converters.set(
WebGLRenderingContext.FLOAT_VEC4,
(gl, v: ReadonlyVec4 | Array<vec4>, l) => {
if (v.length == 0) {
return;
}
if (v[0] instanceof Array || v[0] instanceof Float32Array) {
const result = new Float32Array(v.length * 4);
for (let i = 0; i < v.length; i++) {
result[3 * i] = (v[i] as Array<number>)[0];
result[3 * i + 1] = (v[i] as Array<number>)[1];
result[3 * i + 2] = (v[i] as Array<number>)[2];
result[3 * i + 3] = (v[i] as Array<number>)[3];
}
gl.uniform4fv(l, result);
} else {
gl.uniform4fv(l, v as vec4);
}
}
);
converters.set(WebGLRenderingContext.FLOAT_MAT3, (gl, v, l) => {
if (gl.isWebGL2) {
gl.uniformMatrix3fv(l, true, mat3.fromMat2d(loaderMat3, v));
} else {
gl.uniformMatrix3fv(
l,
false,
mat3.transpose(mat3.create(), mat3.fromMat2d(loaderMat3, v))
);
}
});
converters.set(WebGLRenderingContext.BOOL, (gl, v, l) => gl.uniform1i(l, v));
if (!converters.has(type)) {
throw new Error(`Unimplemented webgl type: ${type}`);
}

4
src/graphics/graphics-library/program/uniform-array-autoscaling-program.ts
View file

@ -15,7 +15,7 @@ export class UniformArrayAutoScalingProgram implements IProgram {
}> = [];
private current?: FragmentShaderOnlyProgram;
private descriptors?: Array<DrawableDescriptor>;
private descriptors!: Array<DrawableDescriptor>;
private drawingRectangleBottomLeft = vec2.fromValues(0, 0);
private drawingRectangleSize = vec2.fromValues(1, 1);
@ -54,7 +54,7 @@ export class UniformArrayAutoScalingProgram implements IProgram {
}
public draw(uniforms: { [name: string]: any }): void {
const values = this.descriptors!.map((d) => {
const values = this.descriptors.map((d) => {
const uniformNames = last(Object.entries(d.propertyUniformMapping));
if (!uniformNames) {
return 0;

24
src/graphics/rendering/renderer/context-aware-renderer.ts
View file

@ -8,9 +8,9 @@ import { RendererImplementation } from './renderer-implementation';
/** @internal */
export class ContextAwareRenderer implements Renderer {
private renderer?: RendererImplementation;
private renderer!: RendererImplementation;
private isRendererReady = false;
private readyPromise?: Promise<void>;
private readyPromise!: Promise<void>;
private runtimeOverrides: Partial<RuntimeSettings> = {};
private ignoreWebGL2?: boolean;
private previousViewAreaTopLeft?: vec2;
@ -34,7 +34,7 @@ export class ContextAwareRenderer implements Renderer {
}
public get initializedPromise(): Promise<void> {
return this.readyPromise!;
return this.readyPromise;
}
private createRenderer() {
@ -102,21 +102,21 @@ export class ContextAwareRenderer implements Renderer {
}
public get canvasSize(): vec2 {
return this.handle(() => this.renderer!.canvasSize, vec2.create());
return this.handle(() => this.renderer.canvasSize, vec2.create());
}
public get viewAreaSize(): vec2 {
return this.handle(() => this.renderer!.viewAreaSize, vec2.create());
return this.handle(() => this.renderer.viewAreaSize, vec2.create());
}
public get insights(): any {
return this.handle(() => this.renderer!.insights, {});
return this.handle(() => this.renderer.insights, {});
}
public setViewArea(topLeft: vec2, size: vec2): void {
this.previousViewAreaTopLeft = topLeft;
this.previousViewAreaSize = size;
return this.handle(() => this.renderer!.setViewArea(topLeft, size), undefined);
return this.handle(() => this.renderer.setViewArea(topLeft, size), undefined);
}
public setRuntimeSettings(overrides: Partial<RuntimeSettings>): void {
@ -125,19 +125,19 @@ export class ContextAwareRenderer implements Renderer {
...overrides,
};
return this.handle(() => this.renderer!.setRuntimeSettings(overrides), undefined);
return this.handle(() => this.renderer.setRuntimeSettings(overrides), undefined);
}
public addDrawable(drawable: Drawable): void {
return this.handle(() => this.renderer!.addDrawable(drawable), undefined);
return this.handle(() => this.renderer.addDrawable(drawable), undefined);
}
public autoscaleQuality(deltaTime: number): void {
return this.handle(() => this.renderer!.autoscaleQuality(deltaTime), undefined);
return this.handle(() => this.renderer.autoscaleQuality(deltaTime), undefined);
}
public renderDrawables(): void {
return this.handle(() => this.renderer!.renderDrawables(), undefined);
return this.handle(() => this.renderer.renderDrawables(), undefined);
}
public destroy(): void {
@ -151,6 +151,6 @@ export class ContextAwareRenderer implements Renderer {
this.isRendererReady = false;
this.handle(() => this.renderer!.destroy(), undefined);
this.handle(() => this.renderer.destroy(), undefined);
}
}