11171365851

Committed 03 Oct 2024 11:38PM UTC coverage: 91.643% (-0.001%) from 91.644%

Build # 11171365851

Build Type

Pull #9192

github

Committed by

web-flow

Commit Message

Merge 67efc5aa0 into da0c1f9e3

Pull Request Pull Request #9192: Generic module props handling in Layer class

Run Details

6744 of 7378 branches covered (91.41%)

Branch coverage included in aggregate %.

272 of 283 new or added lines in 34 files covered. (96.11%)

5 existing lines in 1 file now uncovered.

54689 of 59657 relevant lines covered (91.67%)

14710.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

51.06

/modules/carto/src/layers/post-process-utils.ts

// deck.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import {Framebuffer, TextureProps} from '@luma.gl/core';
import {
  CompositeLayer,
  Layer,
  LayerContext,
  LayerProps,
  LayersList,
  PostProcessEffect,
  PostRenderOptions
} from '@deck.gl/core';

const TEXTURE_PROPS: TextureProps = {
  format: 'rgba8unorm',
  mipmaps: false,
  sampler: {
    minFilter: 'linear',
    magFilter: 'linear',
    addressModeU: 'clamp-to-edge',
    addressModeV: 'clamp-to-edge'
  }
};

interface IPostProcessLayer {
  applyPostProcess: () => void;
  enableRTT: Layer['draw'];
  disableRTT: () => void;
  props: LayerProps;
}

type Constructor<T> = (new (...args: any[]) => T) & {layerName: string};
type DrawableCompositeLayer = CompositeLayer & {
  renderLayers(): Layer<{}> | null | LayersList;
};

function getPostProcessLayer(layer: any): IPostProcessLayer {
  while (layer.parent && !layer.applyPostProcess) {
    layer = layer.parent;
  }
  return layer as unknown as IPostProcessLayer;
}

/**
 * Dummy Layer that draws nothing, just calls back to root Layer
 */
class DrawCallbackLayer extends Layer {
  static layerName = 'DrawCallbackLayer';

  initializeState(this: DrawCallbackLayer): void {
    this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;
  }

  _drawLayer(this: DrawCallbackLayer) {
    getPostProcessLayer(this).applyPostProcess();
  }
}

/**
 * Modifier that marks a layer for Render-to-Target rendering.
 * Resulting layer must be used as a sublayer of a layer created
 * with `PostProcessModifier`
 */
export function RTTModifier(BaseLayer) {
  return class RTTLayer extends BaseLayer {
    static layerName = `RTT-${BaseLayer.layerName}`;

    draw(this: RTTLayer, opts: any) {
      const {shaderModuleProps} = opts;
      const {picking} = shaderModuleProps;
      const postProcessLayer = getPostProcessLayer(this);

      if (!picking.isActive) {
        postProcessLayer.enableRTT(opts);
      }

      // Draw actual layer
      super.draw(opts);

      if (!picking.isActive) {
        postProcessLayer.disableRTT();
      }
    }
  };
}

/**
 * Modifier that returns the a modified Layer, which applies a
 * postprocess effect to all subLayers created using `RTTModifier`
 */
export function PostProcessModifier<T extends Constructor<DrawableCompositeLayer>>(
  BaseLayer: T,
  effect: any
): T {
  return class PostProcessLayer extends BaseLayer {
    static layerName = `PostProcess${BaseLayer.layerName}`;

    internalState: any;

    initializeState(this: PostProcessLayer, context: LayerContext): void {
      super.initializeState(context);

      this._createTextures();
      this.internalState.postProcess = new PostProcessEffect(effect, this.props);
      this.internalState.postProcess.setup(context);
    }

    updateState(this: PostProcessLayer, params: any): void {
      super.updateState(params);
      this.internalState.postProcess.setProps(this.props);
    }

    renderLayers(): PostProcessLayer | null | LayersList {
      let subLayers = super.renderLayers();
      if (!subLayers) {
        return null;
      }
      subLayers = Array.isArray(subLayers) ? subLayers : [subLayers];
      return [...subLayers, new DrawCallbackLayer()];
    }

    _createTextures(this: PostProcessLayer) {
      const {device} = this.context;
      this.internalState.renderBuffers = [0, 1].map(i => {
        return device.createFramebuffer({
          id: `layer-fbo-${i}`,
          colorAttachments: [device.createTexture(TEXTURE_PROPS)],
          depthStencilAttachment: 'depth16unorm'
        });
      });
    }

    _resizeBuffers(this: PostProcessLayer, opts: any) {
      // TODO we could likely render to a smaller buffer for better perf
      const {shaderModuleProps} = opts;
      const {viewport} = this.context;
      const {devicePixelRatio} = shaderModuleProps.project;
      const width = devicePixelRatio * viewport.width;
      const height = devicePixelRatio * viewport.height;
      this.internalState.renderBuffers.forEach((fbo: Framebuffer) => fbo.resize({width, height}));
    }

    enableRTT(this: PostProcessLayer, opts: any) {
      this._resizeBuffers(opts);
      this.internalState.originalRenderPass = this.context.renderPass;

      const [framebuffer] = this.internalState.renderBuffers;

      // Create new render pass for RTT
      this.internalState.internalRenderPass = this.context.device.beginRenderPass({
        framebuffer,
        parameters: {viewport: [0, 0, framebuffer.width, framebuffer.height]},
        // Only clear on first render
        clearColor: this.internalState.renderInProgress ? false : [0, 0, 0, 0]
      });
      this.internalState.renderInProgress = true;
      this.context.renderPass = this.internalState.internalRenderPass;
    }

    disableRTT(this: PostProcessLayer) {
      // End render pass, and reinstate original
      this.internalState.internalRenderPass.end();
      this.context.renderPass = this.internalState.originalRenderPass;
    }

    applyPostProcess(this: PostProcessLayer) {
      if (!this.internalState.renderInProgress) {
        return;
      }

      // Apply post process effect
      const [inputBuffer, swapBuffer] = this.internalState.renderBuffers;
      const {framebuffer: target} = this.context.renderPass.props;
      this.internalState.postProcess.postRender({
        inputBuffer,
        swapBuffer,
        target
      } as PostRenderOptions);

      this.internalState.renderInProgress = false;
    }
  };
}

1	// deck.gl	1✔
2	// SPDX-License-Identifier: MIT	1✔
3	// Copyright (c) vis.gl contributors	1✔
4		1✔
5	import {Framebuffer, TextureProps} from '@luma.gl/core';	1✔
6	import {	1✔
7	CompositeLayer,	1✔
8	Layer,	1✔
9	LayerContext,	1✔
10	LayerProps,	1✔
11	LayersList,	1✔
12	PostProcessEffect,	1✔
13	PostRenderOptions	1✔
14	} from '@deck.gl/core';	1✔
15		1✔
16	const TEXTURE_PROPS: TextureProps = {	1✔
17	format: 'rgba8unorm',	1✔
18	mipmaps: false,	1✔
19	sampler: {	1✔
20	minFilter: 'linear',	1✔
21	magFilter: 'linear',	1✔
22	addressModeU: 'clamp-to-edge',	1✔
23	addressModeV: 'clamp-to-edge'	1✔
24	}	1✔
25	};	1✔
26		1✔
27	interface IPostProcessLayer {	1✔
28	applyPostProcess: () => void;	1✔
29	enableRTT: Layer['draw'];	1✔
30	disableRTT: () => void;	1✔
31	props: LayerProps;	1✔
32	}	1✔
33		1✔
34	type Constructor<T> = (new (...args: any[]) => T) & {layerName: string};	1✔
35	type DrawableCompositeLayer = CompositeLayer & {	1✔
36	renderLayers(): Layer<{}> \| null \| LayersList;	1✔
37	};	1✔
38		1✔
39	function getPostProcessLayer(layer: any): IPostProcessLayer {	×
40	while (layer.parent && !layer.applyPostProcess) {	×
41	layer = layer.parent;	×
42	}	×
43	return layer as unknown as IPostProcessLayer;	×
44	}	×
45		1✔
46	/**	1✔
47	* Dummy Layer that draws nothing, just calls back to root Layer	1✔
48	*/	1✔
49	class DrawCallbackLayer extends Layer {	1✔
50	static layerName = 'DrawCallbackLayer';	1✔
51		1✔
52	initializeState(this: DrawCallbackLayer): void {	1✔
53	this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;	×
54	}	×
55		1✔
56	_drawLayer(this: DrawCallbackLayer) {	1✔
57	getPostProcessLayer(this).applyPostProcess();	×
58	}	×
59	}	1✔
60		1✔
61	/**	1✔
62	* Modifier that marks a layer for Render-to-Target rendering.	1✔
63	* Resulting layer must be used as a sublayer of a layer created	1✔
64	* with `PostProcessModifier`	1✔
65	*/	1✔
66	export function RTTModifier(BaseLayer) {	1✔
67	return class RTTLayer extends BaseLayer {	1✔
68	static layerName = `RTT-${BaseLayer.layerName}`;	1✔
69		1✔
70	draw(this: RTTLayer, opts: any) {	1✔
NEW 71	const {shaderModuleProps} = opts;	×
NEW 72	const {picking} = shaderModuleProps;	×
73	const postProcessLayer = getPostProcessLayer(this);	×
74		×
75	if (!picking.isActive) {	×
76	postProcessLayer.enableRTT(opts);	×
77	}	×
78		×
79	// Draw actual layer	×
80	super.draw(opts);	×
81		×
82	if (!picking.isActive) {	×
83	postProcessLayer.disableRTT();	×
84	}	×
85	}	×
86	};	1✔
87	}	1✔
88		1✔
89	/**	1✔
90	* Modifier that returns the a modified Layer, which applies a	1✔
91	* postprocess effect to all subLayers created using `RTTModifier`	1✔
92	*/	1✔
93	export function PostProcessModifier<T extends Constructor<DrawableCompositeLayer>>(	1✔
94	BaseLayer: T,	1✔
95	effect: any	1✔
96	): T {	1✔
97	return class PostProcessLayer extends BaseLayer {	1✔
98	static layerName = `PostProcess${BaseLayer.layerName}`;	1✔
99		1✔
100	internalState: any;	1✔
101		1✔
102	initializeState(this: PostProcessLayer, context: LayerContext): void {	1✔
103	super.initializeState(context);	×
104		×
105	this._createTextures();	×
106	this.internalState.postProcess = new PostProcessEffect(effect, this.props);	×
107	this.internalState.postProcess.setup(context);	×
108	}	×
109		1✔
110	updateState(this: PostProcessLayer, params: any): void {	1✔
111	super.updateState(params);	×
112	this.internalState.postProcess.setProps(this.props);	×
113	}	×
114		1✔
115	renderLayers(): PostProcessLayer \| null \| LayersList {	1✔
116	let subLayers = super.renderLayers();	×
117	if (!subLayers) {	×
118	return null;	×
119	}	×
120	subLayers = Array.isArray(subLayers) ? subLayers : [subLayers];	×
121	return [...subLayers, new DrawCallbackLayer()];	×
122	}	×
123		1✔
124	_createTextures(this: PostProcessLayer) {	1✔
125	const {device} = this.context;	×
126	this.internalState.renderBuffers = [0, 1].map(i => {	×
127	return device.createFramebuffer({	×
128	id: `layer-fbo-${i}`,	×
129	colorAttachments: [device.createTexture(TEXTURE_PROPS)],	×
130	depthStencilAttachment: 'depth16unorm'	×
131	});	×
132	});	×
133	}	×
134		1✔
135	_resizeBuffers(this: PostProcessLayer, opts: any) {	1✔
136	// TODO we could likely render to a smaller buffer for better perf	×
NEW 137	const {shaderModuleProps} = opts;	×
138	const {viewport} = this.context;	×
NEW 139	const {devicePixelRatio} = shaderModuleProps.project;	×
NEW 140	const width = devicePixelRatio * viewport.width;	×
NEW 141	const height = devicePixelRatio * viewport.height;	×
142	this.internalState.renderBuffers.forEach((fbo: Framebuffer) => fbo.resize({width, height}));	×
143	}	×
144		1✔
145	enableRTT(this: PostProcessLayer, opts: any) {	1✔
146	this._resizeBuffers(opts);	×
147	this.internalState.originalRenderPass = this.context.renderPass;	×
148		×
149	const [framebuffer] = this.internalState.renderBuffers;	×
150		×
151	// Create new render pass for RTT	×
152	this.internalState.internalRenderPass = this.context.device.beginRenderPass({	×
153	framebuffer,	×
154	parameters: {viewport: [0, 0, framebuffer.width, framebuffer.height]},	×
155	// Only clear on first render	×
156	clearColor: this.internalState.renderInProgress ? false : [0, 0, 0, 0]	×
157	});	×
158	this.internalState.renderInProgress = true;	×
159	this.context.renderPass = this.internalState.internalRenderPass;	×
160	}	×
161		1✔
162	disableRTT(this: PostProcessLayer) {	1✔
163	// End render pass, and reinstate original	×
164	this.internalState.internalRenderPass.end();	×
165	this.context.renderPass = this.internalState.originalRenderPass;	×
166	}	×
167		1✔
168	applyPostProcess(this: PostProcessLayer) {	1✔
169	if (!this.internalState.renderInProgress) {	×
170	return;	×
171	}	×
172		×
173	// Apply post process effect	×
174	const [inputBuffer, swapBuffer] = this.internalState.renderBuffers;	×
175	const {framebuffer: target} = this.context.renderPass.props;	×
176	this.internalState.postProcess.postRender({	×
177	inputBuffer,	×
178	swapBuffer,	×
179	target	×
180	} as PostRenderOptions);	×
181		×
182	this.internalState.renderInProgress = false;	×
183	}	×
184	};	1✔
185	}	1✔

visgl / deck.gl / 11171365851

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous