@deck.gl/extensions 9.0.0-beta.10 → 9.0.0-beta.11

package/src/terrain/terrain-pass.ts

@@ -1,10 +1,19 @@
-import {GL} from '@luma.gl/constants';
+import {RenderPipelineParameters} from '@luma.gl/core';
 import {Layer, Viewport, _LayersPass as LayersPass, LayersPassRenderOptions} from '@deck.gl/core';
 import type {HeightMapBuilder} from './height-map-builder';
 import type {TerrainCover} from './terrain-cover';
 
 export type TerrainPassRenderOptions = LayersPassRenderOptions;
 
+const TERRAIN_BLENDING: RenderPipelineParameters = {
+  blendColorOperation: 'max',
+  blendColorSrcFactor: 'one',
+  blendColorDstFactor: 'one',
+  blendAlphaOperation: 'max',
+  blendAlphaSrcFactor: 'one',
+  blendAlphaDstFactor: 'one'
+};
+
 /** Renders textures used by the TerrainEffect render pass */
 export class TerrainPass extends LayersPass {
   getRenderableLayers(viewport: Viewport, opts: TerrainPassRenderOptions): Layer[] {
@@ -32,24 +41,15 @@ export class TerrainPass extends LayersPass {
 
     target.resize(viewport);
 
-    this.device.withParametersWebGL(
-      {
-        clearColor: [0, 0, 0, 0],
-        blend: true,
-        blendFunc: [GL.ONE, GL.ONE],
-        blendEquation: GL.MAX,
-        depthTest: false
-      },
-      () =>
-        this.render({
-          ...opts,
-          target,
-          pass: 'terrain-height-map',
-          layers: opts.layers!,
-          viewports: [viewport],
-          effects: []
-        })
-    );
+    this.render({
+      ...opts,
+      target,
+      pass: 'terrain-height-map',
+      layers: opts.layers!,
+      viewports: [viewport],
+      effects: [],
+      clearColor: [0, 0, 0, 0]
+    });
   }
 
   renderTerrainCover(terrainCover: TerrainCover, opts: Partial<TerrainPassRenderOptions>) {
@@ -64,20 +64,23 @@ export class TerrainPass extends LayersPass {
     const layers = terrainCover.filterLayers(opts.layers!);
     target.resize(viewport);
 
-    this.device.withParametersWebGL(
-      {
-        clearColor: [0, 0, 0, 0],
-        depthTest: false
-      },
-      () =>
-        this.render({
-          ...opts,
-          target,
-          pass: `terrain-cover-${terrainCover.id}`,
-          layers,
-          effects: [],
-          viewports: [viewport]
-        })
-    );
+    this.render({
+      ...opts,
+      target,
+      pass: `terrain-cover-${terrainCover.id}`,
+      layers,
+      effects: [],
+      viewports: [viewport],
+      clearColor: [0, 0, 0, 0]
+    });
+  }
+
+  protected getLayerParameters(layer: Layer<{}>, layerIndex: number, viewport: Viewport) {
+    return {
+      ...layer.props.parameters,
+      blend: true,
+      depthTest: false,
+      ...(layer.props.operation.includes('terrain') && TERRAIN_BLENDING)
+    };
   }
 }

package/src/terrain/terrain-picking-pass.ts

@@ -53,33 +53,29 @@ export class TerrainPickingPass extends PickLayersPass {
     }
     target.resize(viewport);
 
-    this.device.withParametersWebGL(
-      {
-        depthTest: false
-      },
-      () =>
-        this.render({
-          ...opts,
-          pickingFBO: target,
-          pass: `terrain-cover-picking-${terrainCover.id}`,
-          layers,
-          effects: [],
-          viewports: [viewport],
-          // Disable the default culling because TileLayer would cull sublayers based on the screen viewport,
-          // not the viewport of the terrain cover. Culling is already done by `terrainCover.filterLayers`
-          cullRect: undefined,
-          deviceRect: viewport,
-          pickZ: false
-        })
-    );
+    this.render({
+      ...opts,
+      pickingFBO: target,
+      pass: `terrain-cover-picking-${terrainCover.id}`,
+      layers,
+      effects: [],
+      viewports: [viewport],
+      // Disable the default culling because TileLayer would cull sublayers based on the screen viewport,
+      // not the viewport of the terrain cover. Culling is already done by `terrainCover.filterLayers`
+      cullRect: undefined,
+      deviceRect: viewport,
+      pickZ: false
+    });
   }
 
   protected getLayerParameters(layer: Layer, layerIndex: number, viewport: Viewport): any {
+    let parameters: any;
     if (this.drawParameters[layer.id]) {
-      return this.drawParameters[layer.id];
+      parameters = this.drawParameters[layer.id];
+    } else {
+      parameters = super.getLayerParameters(layer, layerIndex, viewport);
+      parameters.blend = true;
     }
-    const parameters = super.getLayerParameters(layer, layerIndex, viewport);
-    parameters.blend = true;
-    return parameters;
+    return {...parameters, depthTest: false};
   }
 }

package/src/terrain/utils.ts

@@ -6,23 +6,29 @@ export function createRenderTarget(
   opts: {
     id: string;
     float?: boolean;
+    interpolate?: boolean;
   }
 ) {
   return device.createFramebuffer({
     id: opts.id,
     colorAttachments: [
       device.createTexture({
+        id: opts.id,
         ...(opts.float && {
           format: 'rgba32float',
           type: GL.FLOAT
         }),
         mipmaps: false,
-        sampler: {
-          minFilter: 'linear',
-          magFilter: 'linear',
-          addressModeU: 'clamp-to-edge',
-          addressModeV: 'clamp-to-edge'
-        }
+        sampler:
+          opts.interpolate === false
+            ? {
+                minFilter: 'nearest',
+                magFilter: 'nearest'
+              }
+            : {
+                minFilter: 'linear',
+                magFilter: 'linear'
+              }
       })
     ]
   });