molstar 4.0.1 → 4.2.0

package/lib/mol-canvas3d/passes/draw.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
@@ -14,14 +14,21 @@ import { DpoitPass } from './dpoit';
 import { AntialiasingPass, PostprocessingPass } from './postprocessing';
 import { MarkingPass } from './marking';
 import { createCopyRenderable } from '../../mol-gl/compute/util';
-import { isTimingMode } from '../../mol-util/debug';
+import { isDebugMode, isTimingMode } from '../../mol-util/debug';
+import { BloomPass } from './bloom';
 export class DrawPass {
     setTransparency(transparency) {
         if (transparency === 'wboit') {
             this.transparencyMode = this.wboit.supported ? 'wboit' : 'blended';
+            if (isDebugMode && !this.wboit.supported) {
+                console.log('Missing "wboit" support, falling back to "blended".');
+            }
         }
         else if (transparency === 'dpoit') {
             this.transparencyMode = this.dpoit.supported ? 'dpoit' : 'blended';
+            if (isDebugMode && !this.dpoit.supported) {
+                console.log('Missing "dpoit" support, falling back to "blended".');
+            }
         }
         else {
             this.transparencyMode = 'blended';
@@ -49,7 +56,8 @@ export class DrawPass {
         this.dpoit = new DpoitPass(webgl, width, height);
         this.marking = new MarkingPass(webgl, width, height);
         this.postprocessing = new PostprocessingPass(webgl, assetManager, this);
-        this.antialiasing = new AntialiasingPass(webgl, this);
+        this.antialiasing = new AntialiasingPass(webgl, width, height);
+        this.bloom = new BloomPass(webgl, width, height);
         this.copyFboTarget = createCopyRenderable(webgl, this.colorTarget.texture);
         this.copyFboPostprocessing = createCopyRenderable(webgl, this.postprocessing.target.texture);
         this.setTransparency(transparency);
@@ -82,6 +90,7 @@ export class DrawPass {
         this.marking.setSize(width, height);
         this.postprocessing.setSize(width, height);
         this.antialiasing.setSize(width, height);
+        this.bloom.setSize(width, height);
     }
     _renderDpoit(renderer, camera, scene, iterations, transparentBackground, postprocessingProps) {
         if (!this.dpoit.supported)
@@ -239,6 +248,7 @@ export class DrawPass {
         }
     }
     _render(renderer, camera, scene, helper, toDrawingBuffer, transparentBackground, props) {
+        var _a;
         const volumeRendering = scene.volumes.renderables.length > 0;
         const postprocessingEnabled = PostprocessingPass.isEnabled(props.postprocessing);
         const antialiasingEnabled = AntialiasingPass.isEnabled(props.postprocessing);
@@ -296,7 +306,10 @@ export class DrawPass {
             renderer.renderBlended(helper.camera.scene, helper.camera.camera);
         }
         if (antialiasingEnabled) {
-            this.antialiasing.render(camera, toDrawingBuffer, props.postprocessing);
+            const input = PostprocessingPass.isEnabled(props.postprocessing)
+                ? this.postprocessing.target.texture
+                : this.colorTarget.texture;
+            this.antialiasing.render(camera, input, toDrawingBuffer, props.postprocessing);
         }
         else if (toDrawingBuffer) {
             this.drawTarget.bind();
@@ -308,6 +321,19 @@ export class DrawPass {
                 this.copyFboTarget.render();
             }
         }
+        if (props.postprocessing.bloom.name === 'on') {
+            const emissiveBloom = props.postprocessing.bloom.params.mode === 'emissive';
+            if (emissiveBloom && scene.emissiveAverage > 0) {
+                this.bloom.emissiveTarget.bind();
+                renderer.clear(false, true);
+                renderer.update(camera, scene);
+                renderer.renderEmissive(scene.primitives, camera, null);
+            }
+            if (!emissiveBloom || scene.emissiveAverage > 0) {
+                this.bloom.update(this.colorTarget.texture, this.bloom.emissiveTarget.texture, ((_a = this.depthTargetOpaque) === null || _a === void 0 ? void 0 : _a.texture) || this.depthTextureOpaque, props.postprocessing.bloom.params);
+                this.bloom.render(camera.viewport, toDrawingBuffer ? undefined : this.getColorTarget(props.postprocessing));
+            }
+        }
         this.webgl.gl.flush();
     }
     render(ctx, props, toDrawingBuffer) {

package/lib/mol-canvas3d/passes/image.d.ts

@@ -58,6 +58,12 @@ export declare const ImageParams: {
         background: PD.Normalize<{
             variant: any;
         }>;
+        bloom: PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+            strength: any;
+            radius: any;
+            threshold: any;
+            mode: any;
+        }>, "on">;
     }>>;
     marking: PD.Group<PD.Normalize<{
         enabled: boolean;

package/lib/mol-canvas3d/passes/postprocessing.d.ts

@@ -1,11 +1,14 @@
 /**
- * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
  * @author Ludovic Autin <ludovic.autin@gmail.com>
  */
+import { TextureSpec, Values, UniformSpec, DefineSpec } from '../../mol-gl/renderable/schema';
 import { WebGLContext } from '../../mol-gl/webgl/context';
+import { Texture } from '../../mol-gl/webgl/texture';
+import { ComputeRenderable } from '../../mol-gl/renderable';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { RenderTarget } from '../../mol-gl/webgl/render-target';
 import { DrawPass } from './draw';
@@ -14,6 +17,23 @@ import { Color } from '../../mol-util/color';
 import { BackgroundPass } from './background';
 import { AssetManager } from '../../mol-util/assets';
 import { Light } from '../../mol-gl/renderer';
+export declare const OutlinesSchema: {
+    tDepthOpaque: TextureSpec<"texture">;
+    tDepthTransparent: TextureSpec<"texture">;
+    uTexSize: UniformSpec<"v2">;
+    dOrthographic: DefineSpec<"number">;
+    uNear: UniformSpec<"f">;
+    uFar: UniformSpec<"f">;
+    uInvProjection: UniformSpec<"m4">;
+    uOutlineThreshold: UniformSpec<"f">;
+    dTransparentOutline: DefineSpec<"boolean">;
+    drawCount: import("../../mol-gl/renderable/schema").ValueSpec<"number">;
+    instanceCount: import("../../mol-gl/renderable/schema").ValueSpec<"number">;
+    aPosition: import("../../mol-gl/renderable/schema").AttributeSpec<"float32">;
+    uQuadScale: UniformSpec<"v2">;
+};
+export type OutlinesRenderable = ComputeRenderable<Values<typeof OutlinesSchema>>;
+export declare function getOutlinesRenderable(ctx: WebGLContext, depthTextureOpaque: Texture, depthTextureTransparent: Texture, transparentOutline: boolean): OutlinesRenderable;
 export declare const PostprocessingParams: {
     occlusion: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
         samples: number;
@@ -72,6 +92,7 @@ export declare const PostprocessingParams: {
             lightness: any;
             faces: any;
             blur: any;
+            rotation: any;
         }>, "skybox"> | PD.NamedParams<PD.Normalize<{
             topColor: any;
             bottomColor: any;
@@ -79,6 +100,12 @@ export declare const PostprocessingParams: {
             coverage: any;
         }>, "horizontalGradient">;
     }>>;
+    bloom: PD.Mapped<PD.NamedParams<PD.Normalize<unknown>, "off"> | PD.NamedParams<PD.Normalize<{
+        strength: number;
+        radius: number;
+        threshold: number;
+        mode: "luminosity" | "emissive";
+    }>, "on">>;
 };
 export type PostprocessingProps = PD.Values<typeof PostprocessingParams>;
 export declare class PostprocessingPass {
@@ -115,7 +142,7 @@ export declare class PostprocessingPass {
     readonly background: BackgroundPass;
     constructor(webgl: WebGLContext, assetManager: AssetManager, drawPass: DrawPass);
     setSize(width: number, height: number): void;
-    private updateState;
+    updateState(camera: ICamera, transparentBackground: boolean, backgroundColor: Color, props: PostprocessingProps, light: Light): void;
     private occlusionOffset;
     setOcclusionOffset(x: number, y: number): void;
     private transparentBackground;
@@ -123,18 +150,17 @@ export declare class PostprocessingPass {
     render(camera: ICamera, toDrawingBuffer: boolean, transparentBackground: boolean, backgroundColor: Color, props: PostprocessingProps, light: Light): void;
 }
 export declare class AntialiasingPass {
-    private drawPass;
     static isEnabled(props: PostprocessingProps): boolean;
     readonly target: RenderTarget;
     private readonly internalTarget;
     private readonly fxaa;
     private readonly smaa;
     private readonly cas;
-    constructor(webgl: WebGLContext, drawPass: DrawPass);
+    constructor(webgl: WebGLContext, width: number, height: number);
     setSize(width: number, height: number): void;
     private _renderFxaa;
     private _renderSmaa;
     private _renderAntialiasing;
     private _renderCas;
-    render(camera: ICamera, toDrawingBuffer: boolean, props: PostprocessingProps): void;
+    render(camera: ICamera, input: Texture, toDrawingBuffer: boolean | RenderTarget, props: PostprocessingProps): void;
 }

package/lib/mol-canvas3d/passes/postprocessing.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2019-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Áron Samuel Kovács <aron.kovacs@mail.muni.cz>
@@ -25,7 +25,8 @@ import { isTimingMode } from '../../mol-util/debug';
 import { BackgroundParams, BackgroundPass } from './background';
 import { shadows_frag } from '../../mol-gl/shader/shadows.frag';
 import { CasParams, CasPass } from './cas';
-const OutlinesSchema = {
+import { BloomParams } from './bloom';
+export const OutlinesSchema = {
     ...QuadSchema,
     tDepthOpaque: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'),
     tDepthTransparent: TextureSpec('texture', 'rgba', 'ubyte', 'nearest'),
@@ -37,7 +38,7 @@ const OutlinesSchema = {
     uOutlineThreshold: UniformSpec('f'),
     dTransparentOutline: DefineSpec('boolean'),
 };
-function getOutlinesRenderable(ctx, depthTextureOpaque, depthTextureTransparent, transparentOutline) {
+export function getOutlinesRenderable(ctx, depthTextureOpaque, depthTextureTransparent, transparentOutline) {
     const width = depthTextureOpaque.getWidth();
     const height = depthTextureOpaque.getHeight();
     const values = {
@@ -323,6 +324,10 @@ export const PostprocessingParams = {
         off: PD.Group({})
     }, { cycle: true, description: 'Contrast Adaptive Sharpening' }),
     background: PD.Group(BackgroundParams, { isFlat: true }),
+    bloom: PD.MappedStatic('on', {
+        on: PD.Group(BloomParams),
+        off: PD.Group({})
+    }, { cycle: true, description: 'Bloom' }),
 };
 function getLevels(props, levels) {
     const count = props.length;
@@ -378,22 +383,22 @@ export class PostprocessingPass {
         const qw = Math.max(1, Math.floor(sw * 0.25));
         const qh = Math.max(1, Math.floor(sh * 0.25));
         this.downsampledDepthTarget = drawPass.packedDepth
-            ? webgl.createRenderTarget(sw, sh, false, 'uint8', 'linear', 'rgba')
-            : webgl.createRenderTarget(sw, sh, false, 'float32', 'linear', webgl.isWebGL2 ? 'alpha' : 'rgba');
+            ? webgl.createRenderTarget(sw, sh, false, 'uint8', 'nearest', 'rgba')
+            : webgl.createRenderTarget(sw, sh, false, 'float32', 'nearest', webgl.isWebGL2 ? 'alpha' : 'rgba');
         this.downsampleDepthRenderable = createCopyRenderable(webgl, depthTextureOpaque);
         const depthTexture = this.ssaoScale === 1 ? depthTextureOpaque : this.downsampledDepthTarget.texture;
         this.depthHalfTarget = drawPass.packedDepth
-            ? webgl.createRenderTarget(hw, hh, false, 'uint8', 'linear', 'rgba')
-            : webgl.createRenderTarget(hw, hh, false, 'float32', 'linear', webgl.isWebGL2 ? 'alpha' : 'rgba');
+            ? webgl.createRenderTarget(hw, hh, false, 'uint8', 'nearest', 'rgba')
+            : webgl.createRenderTarget(hw, hh, false, 'float32', 'nearest', webgl.isWebGL2 ? 'alpha' : 'rgba');
         this.depthHalfRenderable = createCopyRenderable(webgl, depthTexture);
         this.depthQuarterTarget = drawPass.packedDepth
-            ? webgl.createRenderTarget(qw, qh, false, 'uint8', 'linear', 'rgba')
-            : webgl.createRenderTarget(qw, qh, false, 'float32', 'linear', webgl.isWebGL2 ? 'alpha' : 'rgba');
+            ? webgl.createRenderTarget(qw, qh, false, 'uint8', 'nearest', 'rgba')
+            : webgl.createRenderTarget(qw, qh, false, 'float32', 'nearest', webgl.isWebGL2 ? 'alpha' : 'rgba');
         this.depthQuarterRenderable = createCopyRenderable(webgl, this.depthHalfTarget.texture);
-        this.ssaoDepthTexture = webgl.resources.texture('image-uint8', 'rgba', 'ubyte', 'linear');
+        this.ssaoDepthTexture = webgl.resources.texture('image-uint8', 'rgba', 'ubyte', 'nearest');
         this.ssaoDepthTexture.define(sw, sh);
         this.ssaoDepthTexture.attachFramebuffer(this.ssaoFramebuffer, 'color0');
-        this.ssaoDepthBlurProxyTexture = webgl.resources.texture('image-uint8', 'rgba', 'ubyte', 'linear');
+        this.ssaoDepthBlurProxyTexture = webgl.resources.texture('image-uint8', 'rgba', 'ubyte', 'nearest');
         this.ssaoDepthBlurProxyTexture.define(sw, sh);
         this.ssaoDepthBlurProxyTexture.attachFramebuffer(this.ssaoBlurFirstPassFramebuffer, 'color0');
         this.ssaoDepthTexture.attachFramebuffer(this.ssaoBlurSecondPassFramebuffer, 'color0');
@@ -737,11 +742,7 @@ export class AntialiasingPass {
     static isEnabled(props) {
         return props.antialiasing.name !== 'off';
     }
-    constructor(webgl, drawPass) {
-        this.drawPass = drawPass;
-        const { colorTarget } = drawPass;
-        const width = colorTarget.getWidth();
-        const height = colorTarget.getHeight();
+    constructor(webgl, width, height) {
         this.target = webgl.createRenderTarget(width, height, false);
         this.internalTarget = webgl.createRenderTarget(width, height, false);
         this.fxaa = new FxaaPass(webgl, this.target.texture);
@@ -760,60 +761,53 @@ export class AntialiasingPass {
             this.cas.setSize(width, height);
         }
     }
-    _renderFxaa(camera, target, props) {
+    _renderFxaa(camera, input, target, props) {
         if (props.antialiasing.name !== 'fxaa')
             return;
-        const input = PostprocessingPass.isEnabled(props)
-            ? this.drawPass.postprocessing.target.texture
-            : this.drawPass.colorTarget.texture;
         this.fxaa.update(input, props.antialiasing.params);
         this.fxaa.render(camera.viewport, target);
     }
-    _renderSmaa(camera, target, props) {
+    _renderSmaa(camera, input, target, props) {
         if (props.antialiasing.name !== 'smaa')
             return;
-        const input = PostprocessingPass.isEnabled(props)
-            ? this.drawPass.postprocessing.target.texture
-            : this.drawPass.colorTarget.texture;
         this.smaa.update(input, props.antialiasing.params);
         this.smaa.render(camera.viewport, target);
     }
-    _renderAntialiasing(camera, target, props) {
+    _renderAntialiasing(camera, input, target, props) {
         if (props.antialiasing.name === 'fxaa') {
-            this._renderFxaa(camera, target, props);
+            this._renderFxaa(camera, input, target, props);
         }
         else if (props.antialiasing.name === 'smaa') {
-            this._renderSmaa(camera, target, props);
+            this._renderSmaa(camera, input, target, props);
         }
     }
-    _renderCas(camera, target, props) {
+    _renderCas(camera, input, target, props) {
         if (props.sharpening.name !== 'on')
             return;
-        const input = props.antialiasing.name !== 'off'
-            ? this.internalTarget.texture
-            : PostprocessingPass.isEnabled(props)
-                ? this.drawPass.postprocessing.target.texture
-                : this.drawPass.colorTarget.texture;
+        if (props.antialiasing.name !== 'off')
+            input = this.internalTarget.texture;
         this.cas.update(input, props.sharpening.params);
         this.cas.render(camera.viewport, target);
     }
-    render(camera, toDrawingBuffer, props) {
+    render(camera, input, toDrawingBuffer, props) {
         if (props.antialiasing.name === 'off' && props.sharpening.name === 'off')
             return;
         if (props.antialiasing.name === 'smaa' && !this.smaa.supported) {
             console.error('SMAA not supported, missing "HTMLImageElement"');
             return;
         }
-        const target = toDrawingBuffer ? undefined : this.target;
+        const target = toDrawingBuffer === true
+            ? undefined : toDrawingBuffer === false
+            ? this.target : toDrawingBuffer;
         if (props.sharpening.name === 'off') {
-            this._renderAntialiasing(camera, target, props);
+            this._renderAntialiasing(camera, input, target, props);
         }
         else if (props.antialiasing.name === 'off') {
-            this._renderCas(camera, target, props);
+            this._renderCas(camera, input, target, props);
         }
         else {
-            this._renderAntialiasing(camera, this.internalTarget, props);
-            this._renderCas(camera, target, props);
+            this._renderAntialiasing(camera, input, this.internalTarget, props);
+            this._renderCas(camera, input, target, props);
         }
     }
 }

package/lib/mol-geo/geometry/base.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -61,6 +61,7 @@ export declare namespace BaseGeometry {
                 scale: any;
             }>[];
         }>>;
+        emissive: PD.Numeric;
         instanceGranularity: PD.BooleanParam;
         lod: PD.Vec3;
         cellSize: PD.Numeric;
@@ -87,6 +88,7 @@ export declare namespace BaseGeometry {
         uMetalness: ValueCell<number, never>;
         uRoughness: ValueCell<number, never>;
         uBumpiness: ValueCell<number, never>;
+        uEmissive: ValueCell<number, never>;
         dLightCount: ValueCell<number, never>;
         dColorMarker: ValueCell<boolean, never>;
         dClipObjectCount: ValueCell<number, never>;

package/lib/mol-geo/geometry/base.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -76,6 +76,7 @@ export var BaseGeometry;
         quality: PD.Select('auto', VisualQualityOptions, { isEssential: true, description: 'Visual/rendering quality of the representation.' }),
         material: Material.getParam(),
         clip: PD.Group(Clip.Params),
+        emissive: PD.Numeric(0, { min: 0, max: 1, step: 0.01 }),
         instanceGranularity: PD.Boolean(false, { description: 'Use instance granularity for marker, transparency, clipping, overpaint, substance data to save memory.' }),
         lod: PD.Vec3(Vec3(), undefined, { ...BaseGeometry.CullingLodCategory, description: 'Level of detail.', fieldLabels: { x: 'Min Distance', y: 'Max Distance', z: 'Overlap (Shader)' } }),
         cellSize: PD.Numeric(200, { min: 0, max: 5000, step: 100 }, { ...BaseGeometry.CullingLodCategory, description: 'Instance grid cell size.' }),
@@ -103,6 +104,7 @@ export var BaseGeometry;
             uMetalness: ValueCell.create(props.material.metalness),
             uRoughness: ValueCell.create(props.material.roughness),
             uBumpiness: ValueCell.create(props.material.bumpiness),
+            uEmissive: ValueCell.create(props.emissive),
             dLightCount: ValueCell.create(1),
             dColorMarker: ValueCell.create(true),
             dClipObjectCount: ValueCell.create(clip.objects.count),
@@ -122,6 +124,7 @@ export var BaseGeometry;
         ValueCell.updateIfChanged(values.uMetalness, props.material.metalness);
         ValueCell.updateIfChanged(values.uRoughness, props.material.roughness);
         ValueCell.updateIfChanged(values.uBumpiness, props.material.bumpiness);
+        ValueCell.updateIfChanged(values.uEmissive, props.emissive);
         const clip = Clip.getClip(props.clip);
         ValueCell.updateIfChanged(values.dClipObjectCount, clip.objects.count);
         ValueCell.updateIfChanged(values.dClipVariant, clip.variant);

package/lib/mol-geo/geometry/cylinders/cylinders.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Gianluca Tomasello <giagitom@gmail.com>
@@ -73,6 +73,7 @@ export declare namespace Cylinders {
                 scale: any;
             }>[];
         }>>;
+        emissive: PD.Numeric;
         instanceGranularity: PD.BooleanParam;
         lod: PD.Vec3;
         cellSize: PD.Numeric;

package/lib/mol-geo/geometry/cylinders/cylinders.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  * @author Gianluca Tomasello <giagitom@gmail.com>
@@ -20,6 +20,7 @@ import { createEmptyTransparency } from '../transparency-data';
 import { hashFnv32a } from '../../../mol-data/util';
 import { createEmptyClipping } from '../clipping-data';
 import { createEmptySubstance } from '../substance-data';
+import { createEmptyEmissive } from '../emissive-data';
 export var Cylinders;
 (function (Cylinders) {
     function create(mappings, indices, groups, starts, ends, scales, caps, colorModes, cylinderCount, cylinders) {
@@ -164,6 +165,7 @@ export var Cylinders;
             : createMarkers(instanceCount * groupCount, 'groupInstance');
         const overpaint = createEmptyOverpaint();
         const transparency = createEmptyTransparency();
+        const emissive = createEmptyEmissive();
         const material = createEmptySubstance();
         const clipping = createEmptyClipping();
         const counts = { drawCount: cylinders.cylinderCount * 4 * 3, vertexCount: cylinders.cylinderCount * 6, groupCount, instanceCount };
@@ -188,6 +190,7 @@ export var Cylinders;
             ...marker,
             ...overpaint,
             ...transparency,
+            ...emissive,
             ...material,
             ...clipping,
             ...transform,

package/lib/mol-geo/geometry/direct-volume/direct-volume.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -55,6 +55,7 @@ export declare namespace DirectVolume {
                 scale: any;
             }>[];
         }>>;
+        emissive: PD.Numeric;
         instanceGranularity: PD.BooleanParam;
         lod: PD.Vec3;
         cellSize: PD.Numeric;

package/lib/mol-geo/geometry/direct-volume/direct-volume.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -21,6 +21,7 @@ import { createTransferFunctionTexture, getControlPointsFromVec2Array } from './
 import { createEmptyClipping } from '../clipping-data';
 import { Grid } from '../../../mol-model/volume';
 import { createEmptySubstance } from '../substance-data';
+import { createEmptyEmissive } from '../emissive-data';
 const VolumeBox = Box();
 export var DirectVolume;
 (function (DirectVolume) {
@@ -169,6 +170,7 @@ export var DirectVolume;
             : createMarkers(instanceCount * groupCount, 'groupInstance');
         const overpaint = createEmptyOverpaint();
         const transparency = createEmptyTransparency();
+        const emissive = createEmptyEmissive();
         const material = createEmptySubstance();
         const clipping = createEmptyClipping();
         const [x, y, z] = gridDimension.ref.value;
@@ -183,6 +185,7 @@ export var DirectVolume;
             ...marker,
             ...overpaint,
             ...transparency,
+            ...emissive,
             ...material,
             ...clipping,
             ...transform,

package/lib/mol-geo/geometry/emissive-data.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ValueCell } from '../../mol-util/value-cell';
+import { Vec2, Vec3, Vec4 } from '../../mol-math/linear-algebra';
+import { TextureImage } from '../../mol-gl/renderable/util';
+import { Texture } from '../../mol-gl/webgl/texture';
+export type EmissiveType = 'instance' | 'groupInstance' | 'volumeInstance';
+export type EmissiveData = {
+    tEmissive: ValueCell<TextureImage<Uint8Array>>;
+    uEmissiveTexDim: ValueCell<Vec2>;
+    dEmissive: ValueCell<boolean>;
+    emissiveAverage: ValueCell<number>;
+    tEmissiveGrid: ValueCell<Texture>;
+    uEmissiveGridDim: ValueCell<Vec3>;
+    uEmissiveGridTransform: ValueCell<Vec4>;
+    dEmissiveType: ValueCell<string>;
+    uEmissiveStrength: ValueCell<number>;
+};
+export declare function applyEmissiveValue(array: Uint8Array, start: number, end: number, value: number): boolean;
+export declare function getEmissiveAverage(array: Uint8Array, count: number): number;
+export declare function clearEmissive(array: Uint8Array, start: number, end: number): void;
+export declare function createEmissive(count: number, type: EmissiveType, emissiveData?: EmissiveData): EmissiveData;
+export declare function createEmptyEmissive(emissiveData?: EmissiveData): EmissiveData;

package/lib/mol-geo/geometry/emissive-data.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { ValueCell } from '../../mol-util/value-cell';
+import { Vec2, Vec3, Vec4 } from '../../mol-math/linear-algebra';
+import { createTextureImage } from '../../mol-gl/renderable/util';
+import { createNullTexture } from '../../mol-gl/webgl/texture';
+export function applyEmissiveValue(array, start, end, value) {
+    for (let i = start; i < end; ++i) {
+        array[i] = value * 255;
+    }
+    return true;
+}
+export function getEmissiveAverage(array, count) {
+    if (count === 0 || array.length < count)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < count; ++i) {
+        sum += array[i];
+    }
+    return sum / (255 * count);
+}
+export function clearEmissive(array, start, end) {
+    array.fill(0, start, end);
+}
+export function createEmissive(count, type, emissiveData) {
+    const emissive = createTextureImage(Math.max(1, count), 1, Uint8Array, emissiveData && emissiveData.tEmissive.ref.value.array);
+    if (emissiveData) {
+        ValueCell.update(emissiveData.tEmissive, emissive);
+        ValueCell.update(emissiveData.uEmissiveTexDim, Vec2.create(emissive.width, emissive.height));
+        ValueCell.updateIfChanged(emissiveData.dEmissive, count > 0);
+        ValueCell.updateIfChanged(emissiveData.emissiveAverage, getEmissiveAverage(emissive.array, count));
+        ValueCell.updateIfChanged(emissiveData.dEmissiveType, type);
+        return emissiveData;
+    }
+    else {
+        return {
+            tEmissive: ValueCell.create(emissive),
+            uEmissiveTexDim: ValueCell.create(Vec2.create(emissive.width, emissive.height)),
+            dEmissive: ValueCell.create(count > 0),
+            emissiveAverage: ValueCell.create(0),
+            tEmissiveGrid: ValueCell.create(createNullTexture()),
+            uEmissiveGridDim: ValueCell.create(Vec3.create(1, 1, 1)),
+            uEmissiveGridTransform: ValueCell.create(Vec4.create(0, 0, 0, 1)),
+            dEmissiveType: ValueCell.create(type),
+            uEmissiveStrength: ValueCell.create(1),
+        };
+    }
+}
+const emptyEmissiveTexture = { array: new Uint8Array(1), width: 1, height: 1 };
+export function createEmptyEmissive(emissiveData) {
+    if (emissiveData) {
+        ValueCell.update(emissiveData.tEmissive, emptyEmissiveTexture);
+        ValueCell.update(emissiveData.uEmissiveTexDim, Vec2.create(1, 1));
+        return emissiveData;
+    }
+    else {
+        return {
+            tEmissive: ValueCell.create(emptyEmissiveTexture),
+            uEmissiveTexDim: ValueCell.create(Vec2.create(1, 1)),
+            dEmissive: ValueCell.create(false),
+            emissiveAverage: ValueCell.create(0),
+            tEmissiveGrid: ValueCell.create(createNullTexture()),
+            uEmissiveGridDim: ValueCell.create(Vec3.create(1, 1, 1)),
+            uEmissiveGridTransform: ValueCell.create(Vec4.create(0, 0, 0, 1)),
+            dEmissiveType: ValueCell.create('groupInstance'),
+            uEmissiveStrength: ValueCell.create(1),
+        };
+    }
+}

package/lib/mol-geo/geometry/image/image.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -49,6 +49,7 @@ declare namespace Image {
                 scale: any;
             }>[];
         }>>;
+        emissive: PD.Numeric;
         instanceGranularity: PD.BooleanParam;
         lod: PD.Vec3;
         cellSize: PD.Numeric;

package/lib/mol-geo/geometry/image/image.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2020-2023 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2024 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -20,6 +20,7 @@ import { createEmptyClipping } from '../clipping-data';
 import { NullLocation } from '../../../mol-model/location';
 import { QuadPositions } from '../../../mol-gl/compute/util';
 import { createEmptySubstance } from '../substance-data';
+import { createEmptyEmissive } from '../emissive-data';
 const QuadIndices = new Uint32Array([
     0, 1, 2,
     1, 3, 2
@@ -114,6 +115,7 @@ var Image;
             : createMarkers(instanceCount * groupCount, 'groupInstance');
         const overpaint = createEmptyOverpaint();
         const transparency = createEmptyTransparency();
+        const emissive = createEmptyEmissive();
         const material = createEmptySubstance();
         const clipping = createEmptyClipping();
         const counts = { drawCount: QuadIndices.length, vertexCount: QuadPositions.length / 3, groupCount, instanceCount };
@@ -125,6 +127,7 @@ var Image;
             ...marker,
             ...overpaint,
             ...transparency,
+            ...emissive,
             ...material,
             ...clipping,
             ...transform,