Decouple mesh-specific data from GL-context-wide data in the demo

demo/client/src/aa-strategy.ts

@@ -71,9 +71,10 @@ export class NoAAStrategy extends AntialiasingStrategy {
     }
 
     prepare(renderer: Renderer) {
-        renderer.gl.bindFramebuffer(renderer.gl.FRAMEBUFFER, renderer.destFramebuffer);
-        renderer.gl.viewport(0, 0, this.framebufferSize[0], this.framebufferSize[1]);
-        renderer.gl.disable(renderer.gl.SCISSOR_TEST);
+        const renderContext = renderer.renderContext;
+        renderContext.gl.bindFramebuffer(renderContext.gl.FRAMEBUFFER, renderer.destFramebuffer);
+        renderContext.gl.viewport(0, 0, this.framebufferSize[0], this.framebufferSize[1]);
+        renderContext.gl.disable(renderContext.gl.SCISSOR_TEST);
     }
 
     antialias(renderer: Renderer) {}

demo/client/src/ssaa-strategy.ts

@@ -36,6 +36,8 @@ export default class SSAAStrategy extends AntialiasingStrategy {
     attachMeshes(renderer: Renderer) {}
 
     setFramebufferSize(renderer: Renderer) {
+        const renderContext = renderer.renderContext;
+
         this.destFramebufferSize = glmatrix.vec2.clone(renderer.destAllocatedSize);
 
         this.supersampledFramebufferSize = glmatrix.vec2.create();
@@ -43,29 +45,29 @@ export default class SSAAStrategy extends AntialiasingStrategy {
                           this.destFramebufferSize,
                           this.supersampleScale);
 
-        this.supersampledColorTexture = unwrapNull(renderer.gl.createTexture());
-        renderer.gl.activeTexture(renderer.gl.TEXTURE0);
-        renderer.gl.bindTexture(renderer.gl.TEXTURE_2D, this.supersampledColorTexture);
-        renderer.gl.texImage2D(renderer.gl.TEXTURE_2D,
-                               0,
-                               renderer.colorAlphaFormat,
-                               this.supersampledFramebufferSize[0],
-                               this.supersampledFramebufferSize[1],
-                               0,
-                               renderer.colorAlphaFormat,
-                               renderer.gl.UNSIGNED_BYTE,
-                               null);
-        setTextureParameters(renderer.gl, renderer.gl.LINEAR);
+        this.supersampledColorTexture = unwrapNull(renderContext.gl.createTexture());
+        renderContext.gl.activeTexture(renderContext.gl.TEXTURE0);
+        renderContext.gl.bindTexture(renderContext.gl.TEXTURE_2D, this.supersampledColorTexture);
+        renderContext.gl.texImage2D(renderContext.gl.TEXTURE_2D,
+                                    0,
+                                    renderer.colorAlphaFormat,
+                                    this.supersampledFramebufferSize[0],
+                                    this.supersampledFramebufferSize[1],
+                                    0,
+                                    renderer.colorAlphaFormat,
+                                    renderContext.gl.UNSIGNED_BYTE,
+                                    null);
+        setTextureParameters(renderContext.gl, renderContext.gl.LINEAR);
 
         this.supersampledDepthTexture =
-            createFramebufferDepthTexture(renderer.gl, this.supersampledFramebufferSize);
+            createFramebufferDepthTexture(renderContext.gl, this.supersampledFramebufferSize);
 
-        this.supersampledFramebuffer = createFramebuffer(renderer.gl,
-                                                         renderer.drawBuffersExt,
+        this.supersampledFramebuffer = createFramebuffer(renderContext.gl,
+                                                         renderContext.drawBuffersExt,
                                                          [this.supersampledColorTexture],
                                                          this.supersampledDepthTexture);
 
-        renderer.gl.bindFramebuffer(renderer.gl.FRAMEBUFFER, null);
+        renderContext.gl.bindFramebuffer(renderContext.gl.FRAMEBUFFER, null);
     }
 
     get transform(): glmatrix.mat4 {
@@ -78,41 +80,51 @@ export default class SSAAStrategy extends AntialiasingStrategy {
     }
 
     prepare(renderer: Renderer) {
+        const renderContext = renderer.renderContext;
         const framebufferSize = this.supersampledFramebufferSize;
         const usedSize = this.usedSupersampledFramebufferSize(renderer);
-        renderer.gl.bindFramebuffer(renderer.gl.FRAMEBUFFER, this.supersampledFramebuffer);
-        renderer.gl.viewport(0, 0, framebufferSize[0], framebufferSize[1]);
-        renderer.gl.scissor(0, 0, usedSize[0], usedSize[1]);
-        renderer.gl.enable(renderer.gl.SCISSOR_TEST);
+        renderContext.gl.bindFramebuffer(renderContext.gl.FRAMEBUFFER,
+                                         this.supersampledFramebuffer);
+        renderContext.gl.viewport(0, 0, framebufferSize[0], framebufferSize[1]);
+        renderContext.gl.scissor(0, 0, usedSize[0], usedSize[1]);
+        renderContext.gl.enable(renderContext.gl.SCISSOR_TEST);
     }
 
     antialias(renderer: Renderer) {}
 
     resolve(renderer: Renderer) {
-        renderer.gl.bindFramebuffer(renderer.gl.FRAMEBUFFER, renderer.destFramebuffer);
-        renderer.gl.viewport(0, 0, renderer.destAllocatedSize[0], renderer.destAllocatedSize[1]);
-        renderer.gl.disable(renderer.gl.DEPTH_TEST);
-        renderer.gl.disable(renderer.gl.BLEND);
+        const renderContext = renderer.renderContext;
+        renderContext.gl.bindFramebuffer(renderContext.gl.FRAMEBUFFER, renderer.destFramebuffer);
+        renderContext.gl.viewport(0,
+                                  0,
+                                  renderer.destAllocatedSize[0],
+                                  renderer.destAllocatedSize[1]);
+        renderContext.gl.disable(renderContext.gl.DEPTH_TEST);
+        renderContext.gl.disable(renderContext.gl.BLEND);
 
         // Set up the blit program VAO.
         let resolveProgram;
         if (this.subpixelAA !== 'none')
-            resolveProgram = renderer.shaderPrograms.ssaaSubpixelResolve;
+            resolveProgram = renderContext.shaderPrograms.ssaaSubpixelResolve;
         else
-            resolveProgram = renderer.shaderPrograms.blit;
-        renderer.gl.useProgram(resolveProgram.program);
-        renderer.initQuadVAO(resolveProgram.attributes);
+            resolveProgram = renderContext.shaderPrograms.blit;
+        renderContext.gl.useProgram(resolveProgram.program);
+        renderContext.initQuadVAO(resolveProgram.attributes);
 
         // Resolve framebuffer.
-        renderer.gl.activeTexture(renderer.gl.TEXTURE0);
-        renderer.gl.bindTexture(renderer.gl.TEXTURE_2D, this.supersampledColorTexture);
-        renderer.gl.uniform1i(resolveProgram.uniforms.uSource, 0);
-        renderer.gl.uniform2i(resolveProgram.uniforms.uSourceDimensions,
-                          this.supersampledFramebufferSize[0],
-                          this.supersampledFramebufferSize[1]);
+        renderContext.gl.activeTexture(renderContext.gl.TEXTURE0);
+        renderContext.gl.bindTexture(renderContext.gl.TEXTURE_2D, this.supersampledColorTexture);
+        renderContext.gl.uniform1i(resolveProgram.uniforms.uSource, 0);
+        renderContext.gl.uniform2i(resolveProgram.uniforms.uSourceDimensions,
+                                   this.supersampledFramebufferSize[0],
+                                   this.supersampledFramebufferSize[1]);
         renderer.setTransformAndTexScaleUniformsForDest(resolveProgram.uniforms);
-        renderer.gl.bindBuffer(renderer.gl.ELEMENT_ARRAY_BUFFER, renderer.quadElementsBuffer);
-        renderer.gl.drawElements(renderer.gl.TRIANGLES, 6, renderer.gl.UNSIGNED_BYTE, 0);
+        renderContext.gl.bindBuffer(renderContext.gl.ELEMENT_ARRAY_BUFFER,
+                                    renderContext.quadElementsBuffer);
+        renderContext.gl.drawElements(renderContext.gl.TRIANGLES,
+                                      6,
+                                      renderContext.gl.UNSIGNED_BYTE,
+                                      0);
     }
 
     get shouldRenderDirect() {

demo/client/src/view.ts

@@ -121,7 +121,7 @@ export abstract class PathfinderView {
     }
 }
 
-export abstract class DemoView extends PathfinderView implements Renderer {
+export abstract class DemoView extends PathfinderView implements Renderer, RenderContext {
     gl: WebGLRenderingContext;
 
     shaderPrograms: ShaderMap<PathfinderShaderProgram>;
@@ -156,6 +156,10 @@ export abstract class DemoView extends PathfinderView implements Renderer {
         return this.sRGBExt == null ? this.gl.RGBA : this.sRGBExt.SRGB_ALPHA_EXT;
     }
 
+    get renderContext(): RenderContext {
+        return this;
+    }
+
     protected sRGBExt: EXTsRGB;
     protected timerQueryExt: EXTDisjointTimerQuery;
 
@@ -731,7 +735,7 @@ export abstract class DemoView extends PathfinderView implements Renderer {
     protected abstract get directInteriorProgramName(): keyof ShaderMap<void>;
 }
 
-export interface Renderer {
+export interface RenderContext {
     /// The OpenGL context.
     readonly gl: WebGLRenderingContext;
 
@@ -746,6 +750,12 @@ export interface Renderer {
     readonly quadPositionsBuffer: WebGLBuffer;
     readonly quadElementsBuffer: WebGLBuffer;
 
+    initQuadVAO(attributes: any): void;
+}
+
+export interface Renderer {
+    readonly renderContext: RenderContext;
+
     readonly destFramebuffer: WebGLFramebuffer | null;
     readonly pathTransformBufferTextures: PathfinderBufferTexture[];
 
@@ -762,8 +772,6 @@ export interface Renderer {
     readonly bgColor: glmatrix.vec4 | null;
     readonly fgColor: glmatrix.vec4 | null;
 
-    initQuadVAO(attributes: any): void;
-
     pathBoundingRects(objectIndex: number): Float32Array;
 
     setFramebufferSizeUniform(uniforms: UniformMap): void;