soonspacejs 2.11.71 → 2.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soonspacejs",
-  "version": "2.11.71",
+  "version": "2.12.0",
   "homepage": "https://www.xwbuilders.com/soonspacejs/",
   "description": "soonspacejs 2.x",
   "module": "./dist/index.esm.js",
@@ -27,8 +27,8 @@
   "license": "UNLICENSED",
   "peerDependencies": {
     "camera-controls": ">=2.9.0",
-    "three": ">=0.169.0",
-    "three-mesh-bvh": ">=0.7.6"
+    "three": ">=0.172.0",
+    "three-mesh-bvh": ">=0.8.3"
   },
-  "gitHead": "5baf7b852185a264678d38a3b40739c5308beded"
+  "gitHead": "24bd48245224b4fabb712d9ef722fa61700dfca8"
 }

package/types/Cache/ObjectsCache.d.ts

@@ -0,0 +1,19 @@
+import { Group, Light, Object3D } from 'three';
+import { BaseObject3D, Canvas3D, Decal, Model, PluginObject, Poi, PoiNode, Topology } from '../Library';
+declare class ObjectsCache {
+    objects: Map<BaseObject3D['sid'], Object3D>;
+    classified: {
+        Group: Set<Group<import("three").Object3DEventMap>>;
+        Light: Set<Light<import("three").LightShadow<import("three").Camera> | undefined>>;
+        Model: Set<Model>;
+        Poi: Set<Poi>;
+        PoiNode: Set<PoiNode>;
+        Canvas3D: Set<Canvas3D>;
+        Topology: Set<Topology>;
+        Helper: Set<Object3D<import("three").Object3DEventMap>>;
+        Decal: Set<Decal>;
+        PluginObject: Set<PluginObject>;
+    };
+    dispose(): void;
+}
+export { ObjectsCache, };

package/types/Cache/index.d.ts

@@ -0,0 +1 @@
+export { ObjectsCache, } from './ObjectsCache';

package/types/Controls/index.d.ts

@@ -11,4 +11,4 @@ declare class Controls extends CameraControls {
     constructor(viewport: Viewport);
     setOptions(options: ControlsOptions): void;
 }
-export { Controls, };
+export default Controls;

package/types/Interface/manager.d.ts

@@ -1,22 +1,7 @@
-import { Box3, DirectionalLight, HemisphereLight, SpotLight, PointLight, RectAreaLight, Object3D, Light } from 'three';
+import { Box3, DirectionalLight, HemisphereLight, SpotLight, PointLight, RectAreaLight } from 'three';
 import { BaseObjectInfo, IColor, IVector2, Position, Rotation, Scale } from './base';
-import { BaseObject3D, Canvas3D, Group, Model, ModelInfo, PluginObject, Poi, PoiInfo, PoiNode, Topology, Decal } from '../Library';
+import { BaseObject3D, ModelInfo, PoiInfo } from '../Library';
 import { AnimationOptions } from './animation';
-export type ManageCache = {
-    objects: Map<BaseObject3D['sid'], Object3D>;
-    classified: {
-        Group: Set<Group>;
-        Light: Set<Light>;
-        Model: Set<Model>;
-        Poi: Set<Poi>;
-        PoiNode: Set<PoiNode>;
-        Canvas3D: Set<Canvas3D>;
-        Topology: Set<Topology>;
-        Helper: Set<Object3D>;
-        Decal: Set<Decal>;
-        PluginObject: Set<PluginObject>;
-    };
-};
 interface UserDataPropertyFindFunc<T = BaseObject3D['userData']> {
     (userData: T): T;
 }

package/types/Library/PoiNode.d.ts

@@ -10,6 +10,9 @@ interface PoiNodeInfo extends BaseObject3DInfo {
     onChange?: (visible: boolean) => void;
     scaleFixed?: ScaleFixed | null;
 }
+export declare function isPoiNode2D(type: PoiNodeInfo['type']): boolean;
+export declare function isPoiNode25D(type: PoiNodeInfo['type']): boolean;
+export declare function isPoiNode3D(type: PoiNodeInfo['type']): boolean;
 declare class PoiNode extends BaseObject3D {
     readonly elementType: PoiNodeInfo['type'];
     readonly element: PoiNodeInfo['element'];

package/types/Manager/Canvas3DManage.d.ts

@@ -2,11 +2,11 @@ import { Object3D } from 'three';
 import Viewport from '../Viewport';
 import { Group, GroupInfo, Canvas3D, Canvas3DInfo } from '../Library';
 import DefaultManage from './DefaultManage';
-import { ManageCache } from '../Interface';
+import { ObjectsCache } from '../Cache';
 declare class Canvas3DManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
-    constructor(viewport: Viewport, cache: ManageCache);
+    readonly cache: ObjectsCache;
+    constructor(viewport: Viewport, cache: ObjectsCache);
     create(info: Canvas3DInfo, parent?: Object3D | null): Canvas3D;
     createToGroup(groupInfo: GroupInfo, canvas3DInfo: Canvas3DInfo[]): Group;
     addForGroup(group: Group | null, canvas3DInfo: Canvas3DInfo[]): Group | null;

package/types/Manager/DecalManage.d.ts

@@ -1,12 +1,12 @@
 import { Object3D } from 'three';
 import Viewport from '../Viewport';
 import DefaultManage from './DefaultManage';
-import { ManageCache } from '../Interface';
+import { ObjectsCache } from '../Cache';
 import { Decal, DecalGeometryInfo, DecalInfo } from '../Library';
 declare class DecalManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
-    constructor(viewport: Viewport, cache: ManageCache);
+    readonly cache: ObjectsCache;
+    constructor(viewport: Viewport, cache: ObjectsCache);
     /**
      * 创建贴花
      */

package/types/Manager/GroupManage.d.ts

@@ -1,9 +1,9 @@
-import { ManageCache } from '../Interface';
+import { ObjectsCache } from '../Cache';
 import Viewport from '../Viewport';
 import DefaultManage from './DefaultManage';
 declare class GroupManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
-    constructor(viewport: Viewport, cache: ManageCache);
+    readonly cache: ObjectsCache;
+    constructor(viewport: Viewport, cache: ObjectsCache);
 }
 export default GroupManage;

package/types/Manager/HelperManage.d.ts

@@ -2,12 +2,13 @@ import Viewport from '../Viewport';
 import DefaultManage from './DefaultManage';
 import { GridHelper, AxesHelper, Box3Helper, DirectionalLightHelper, HemisphereLightHelper, SpotLightHelper, PointLightHelper } from 'three';
 import { RectAreaLightHelper } from 'three/examples/jsm/helpers/RectAreaLightHelper.js';
-import { GridHelperOptions, AxesHelperOptions, BoxHelperOptions, PlaneHelperOptions, GroundHelperOptions, DirectionalLightHelperOptions, HemisphereLightHelperOptions, SpotLightHelperOptions, PointLightHelperOptions, RectAreaLightHelperOptions, ManageCache } from '../Interface';
+import { GridHelperOptions, AxesHelperOptions, BoxHelperOptions, PlaneHelperOptions, GroundHelperOptions, DirectionalLightHelperOptions, HemisphereLightHelperOptions, SpotLightHelperOptions, PointLightHelperOptions, RectAreaLightHelperOptions } from '../Interface';
 import { BaseMesh, Ground } from '../Library';
+import { ObjectsCache } from '../Cache';
 declare class HelperManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
-    constructor(viewport: Viewport, cache: ManageCache);
+    readonly cache: ObjectsCache;
+    constructor(viewport: Viewport, cache: ObjectsCache);
     addGridHelper(options: GridHelperOptions): GridHelper;
     addAxesHelper(options: AxesHelperOptions): AxesHelper;
     addBoxHelper(options: BoxHelperOptions): Box3Helper;

package/types/Manager/LightManage.d.ts

@@ -1,11 +1,12 @@
 import { AmbientLight, DirectionalLight, HemisphereLight, SpotLight, PointLight, RectAreaLight } from 'three';
 import DefaultManage from './DefaultManage';
 import Viewport from '../Viewport';
-import { AmbientLightOptions, DirectionalLightOptions, HemisphereLightOptions, SpotLightOptions, PointLightOptions, RectAreaLightOptions, ManageCache } from '../Interface';
+import { AmbientLightOptions, DirectionalLightOptions, HemisphereLightOptions, SpotLightOptions, PointLightOptions, RectAreaLightOptions } from '../Interface';
+import { ObjectsCache } from '../Cache';
 declare class LightManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
-    constructor(viewport: Viewport, cache: ManageCache);
+    readonly cache: ObjectsCache;
+    constructor(viewport: Viewport, cache: ObjectsCache);
     createAmbientLight(options: AmbientLightOptions): AmbientLight;
     setAmbientLight(light: AmbientLight | null, options: AmbientLightOptions): boolean;
     createDirectionalLight(options: DirectionalLightOptions): DirectionalLight;

package/types/Manager/ModelManage.d.ts

@@ -6,11 +6,12 @@ import { FBXLoader } from '../Loader/FBXLoader.js';
 import { OBJLoader } from '../Loader/OBJLoader.js';
 import Viewport from '../Viewport';
 import { Group, GroupInfo, Model, ModelInfo } from '../Library';
-import { CloneModelInfo, ManageCache } from '../Interface';
+import { CloneModelInfo } from '../Interface';
+import { ObjectsCache } from '../Cache';
 import DefaultManage from './DefaultManage';
 declare class ModelManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
+    readonly cache: ObjectsCache;
     /**
      * 场景是否卸载
      */
@@ -28,7 +29,7 @@ declare class ModelManage extends DefaultManage {
     fbxLoader: FBXLoader;
     objLoader: OBJLoader;
     stlLoader: STLLoader;
-    constructor(viewport: Viewport, cache: ManageCache);
+    constructor(viewport: Viewport, cache: ObjectsCache);
     /**
      * 设置 draco path
      * @param path

package/types/Manager/PluginObjectManage.d.ts

@@ -2,11 +2,11 @@ import { Object3D } from 'three';
 import DefaultManage from './DefaultManage';
 import { PluginObject, PluginObjectInfo } from '../Library';
 import Viewport from '../Viewport';
-import { ManageCache } from '../Interface';
+import { ObjectsCache } from '../Cache';
 declare class PluginManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
-    constructor(viewport: Viewport, cache: ManageCache);
+    readonly cache: ObjectsCache;
+    constructor(viewport: Viewport, cache: ObjectsCache);
     createObject(info: PluginObjectInfo, object?: Object3D): PluginObject;
     addToObject(pluginObject: PluginObject | null, object: Object3D): PluginObject | null;
 }

package/types/Manager/PoiManage.d.ts

@@ -1,13 +1,14 @@
 import { SpriteMaterial, Texture, CanvasTexture, Object3D, MeshBasicMaterial, Mesh } from 'three';
 import DefaultManage from './DefaultManage';
 import { Poi, PoiInfo, Group, GroupInfo, Icon, NameCanvasInfo } from '../Library';
-import { ClonePoiInfo, ManageCache, PoiType } from '../Interface';
+import { ClonePoiInfo, PoiType } from '../Interface';
 import Viewport from '../Viewport';
+import { ObjectsCache } from '../Cache';
 declare class PoiManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
+    readonly cache: ObjectsCache;
     textures: Map<string, Texture>;
-    constructor(viewport: Viewport, cache: ManageCache);
+    constructor(viewport: Viewport, cache: ObjectsCache);
     _createIcon(info: PoiInfo): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | Icon;
     _createIconMaterial({ url, type, }: PoiInfo): MeshBasicMaterial | SpriteMaterial | undefined;
     _createText(info: PoiInfo): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | Icon;

package/types/Manager/PoiNodeManage.d.ts

@@ -1,11 +1,11 @@
 import DefaultManage from './DefaultManage';
 import Viewport from '../Viewport';
 import { PoiNode, PoiNodeInfo, Group, GroupInfo } from '../Library';
-import { ManageCache } from '../Interface';
+import { ObjectsCache } from '../Cache';
 declare class PoiNodeManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
-    constructor(viewport: Viewport, cache: ManageCache);
+    readonly cache: ObjectsCache;
+    constructor(viewport: Viewport, cache: ObjectsCache);
     create(info: PoiNodeInfo): PoiNode;
     createToGroup(groupInfo: GroupInfo, poiNodeInfo: PoiNodeInfo[]): Group;
     addForGroup(group: Group | null, poiNodeInfo: PoiNodeInfo[]): Group | null;

package/types/Manager/TopologyManage.d.ts

@@ -1,15 +1,16 @@
 import DefaultManage from './DefaultManage';
 import { Group, GroupInfo, Topology, Node, TopologyInfo } from '../Library';
-import { TopologyInfoForGml, ShortestPathInfo, ShortestPathByMultipleStartPoints, ShortestPathByMultipleEndPoints, TopologyNodeInfo, TopologyInnerNodeInfo, Position, TopologyPassableInfo, ManageCache } from '../Interface';
+import { TopologyInfoForGml, ShortestPathInfo, ShortestPathByMultipleStartPoints, ShortestPathByMultipleEndPoints, TopologyNodeInfo, TopologyInnerNodeInfo, Position, TopologyPassableInfo } from '../Interface';
 import Viewport from '../Viewport';
 import { Dijkstras } from '../Math/dijkstra';
 import { DijkstraWorker } from '../Math/dijkstra/DijkstraWorker';
+import { ObjectsCache } from '../Cache';
 declare class TopologyManage extends DefaultManage {
     readonly viewport: Viewport;
-    readonly cache: ManageCache;
+    readonly cache: ObjectsCache;
     dijkstra: Dijkstras;
     dijkstraWorker: DijkstraWorker;
-    constructor(viewport: Viewport, cache: ManageCache);
+    constructor(viewport: Viewport, cache: ObjectsCache);
     createFromGml(topologyInfoForGml: TopologyInfoForGml): Promise<Topology>;
     create(topologyInfo: TopologyInfo): Topology;
     /**

package/types/Manager/index.d.ts

@@ -11,7 +11,8 @@ import HelperManage from './HelperManage';
 import PluginObjectManage from './PluginObjectManage';
 import GroupManage from './GroupManage';
 import DecalManage from './DecalManage';
-import { ManageCache, UserDataPropertyFindFunc } from '../Interface';
+import { UserDataPropertyFindFunc } from '../Interface';
+import { ObjectsCache } from '../Cache';
 interface ManagerStore {
     groupManager: GroupManage;
     lightManager: LightManage;
@@ -26,10 +27,10 @@ interface ManagerStore {
 }
 declare class Manager {
     readonly viewport: Viewport;
+    readonly cache: ObjectsCache;
     readonly scene: import("three").Scene;
-    readonly cache: ManageCache;
     readonly store: ManagerStore;
-    constructor(viewport: Viewport);
+    constructor(viewport: Viewport, cache: ObjectsCache);
     /**
      * level update
      * @returns

package/types/Renderer/CSS2DRenderer.d.ts

@@ -1,5 +1,7 @@
-import { Camera, Object3D, Scene } from 'three';
+import { Camera, Object3D } from 'three';
+import { ObjectsCache } from '../Cache';
 import Viewport from '../Viewport';
+type PoiNodeSet = ObjectsCache['classified']['PoiNode'];
 declare class CSS2DObject extends Object3D {
     isCSS2DObject: boolean;
     element: HTMLElement;
@@ -16,7 +18,7 @@ declare class CSS2DRenderer {
         width: number;
         height: number;
     };
-    render: (scene: Scene, camera: Camera) => void;
+    render: (poiNodeSet: PoiNodeSet, camera: Camera) => void;
     setSize: (width: number, height: number) => void;
     constructor(viewport: Viewport);
 }

package/types/Renderer/CSS3DRenderer.d.ts

@@ -1,5 +1,7 @@
-import { Object3D, OrthographicCamera, PerspectiveCamera, Scene } from 'three';
+import { Object3D, OrthographicCamera, PerspectiveCamera } from 'three';
+import { ObjectsCache } from '../Cache';
 import Viewport from '../Viewport';
+type PoiNodeSet = ObjectsCache['classified']['PoiNode'];
 declare class CSS3DObject extends Object3D {
     isCSS3DObject: boolean;
     element: HTMLElement;
@@ -19,7 +21,7 @@ declare class CSS3DRenderer {
         width: number;
         height: number;
     };
-    render: (scene: Scene, camera: PerspectiveCamera | OrthographicCamera) => void;
+    render: (poiNodeSet: PoiNodeSet, camera: PerspectiveCamera | OrthographicCamera) => void;
     setSize: (width: number, height: number) => void;
     constructor(viewport: Viewport);
 }

package/types/Viewport/CameraManager.d.ts

@@ -1,5 +1,5 @@
 import { Box3, PerspectiveCamera, OrthographicCamera, Vector3, Euler, Object3D } from 'three';
-import { Rotation, Position, AnimationOptions, FlyToViewpoint, FlyToObjOptions, SurroundOptions, LabelOptions, CameraViewpointData, CameraViewpointDataLegacy, FlyToOptions, CameraType } from '../Interface';
+import { Rotation, Position, FlyToViewpoint, FlyToObjOptions, SurroundOptions, LabelOptions, CameraViewpointData, CameraViewpointDataLegacy, FlyToOptions, CameraType } from '../Interface';
 import Viewport from '.';
 declare class CameraManager {
     viewport: Viewport;
@@ -25,14 +25,6 @@ declare class CameraManager {
     setCamera(cameraType: CameraType, viewpoint?: CameraViewpointData, enableTransition?: boolean): Promise<void>;
     getCameraViewpoint(): CameraViewpointData;
     setCameraViewpoint(data: CameraViewpointData | CameraViewpointDataLegacy, enableTransition?: boolean): Promise<void>;
-    /**
-     * @deprecated
-     */
-    moveTo(position: Position, options?: AnimationOptions): Promise<void>;
-    /**
-     * @deprecated
-     */
-    rotateTo(rotation: Euler, options?: AnimationOptions): Promise<void>;
     flyTo(position: Position, rotation?: FlyToViewpoint | Rotation | Euler, options?: FlyToOptions): Promise<void>;
     flyToObj(object: Object3D | Box3, viewpoint?: FlyToViewpoint, options?: FlyToObjOptions): Promise<void>;
     surroundOnTarget(target: Position, options?: SurroundOptions): Promise<void>;

package/types/Viewport/RendererManager.d.ts

@@ -2,6 +2,11 @@ import { WebGLRenderer } from 'three';
 import { CSS2DRenderer, CSS3DRenderer } from '../Renderer';
 import { InternalOptions } from '../Interface';
 import Viewport from '.';
+declare module 'three/src/renderers/WebGLRenderer' {
+    interface WebGLRenderer {
+        autoInstancing: boolean;
+    }
+}
 declare class RendererManager {
     readonly viewport: Viewport;
     internalOptions: InternalOptions;

package/types/Viewport/ViewHelper.d.ts

@@ -1,5 +1,5 @@
 import { Camera, Object3D, WebGLRenderer } from 'three';
-import { Controls } from '../Controls';
+import Controls from '../Controls';
 declare class ViewHelper extends Object3D {
     camera: Camera;
     controls: Controls;

package/types/Viewport/index.d.ts

@@ -10,18 +10,20 @@ import RendererManager from './RendererManager';
 import CameraManager from './CameraManager';
 import EffectManager from './EffectManager';
 import Bvh from './Bvh';
-import { Controls } from '../Controls';
+import Controls from '../Controls';
 import { Model } from '../Library';
 import { IColorSpace, SkyOptions, IColor, OffsetPoint, Position, ViewportOptions, ViewportState, ModelAnimationFindFunc, SignalsState, ToneMappingOptions, SSAOOptions, BloomOptions, IntersectsOptions, EnvironmentOptions } from '../Interface';
 import EventHandler from './EventHandler';
 import Info from './Info';
 import { ViewHelper } from './ViewHelper';
+import { ObjectsCache } from '../Cache';
 export declare const innerRenderState: {
     needsUpdate: boolean;
 };
 declare class Viewport {
-    options: ViewportOptions;
-    signals: SignalsState;
+    readonly options: ViewportOptions;
+    readonly signals: SignalsState;
+    readonly cache: ObjectsCache;
     clock: Clock;
     raycaster: Raycaster;
     scene: Scene;
@@ -57,9 +59,10 @@ declare class Viewport {
     postRender: Map<string | number, () => void>;
     private _loop;
     resizeObserver: ResizeObserver;
-    constructor(options: ViewportOptions, signals: SignalsState);
+    constructor(options: ViewportOptions, signals: SignalsState, cache: ObjectsCache);
     _initInfo(): void;
     _initStats(): void;
+    setAutoInstancing(enabled: boolean): void;
     /**
      ***************************** post-processing ***************************
      */

package/types/index.d.ts

@@ -16,8 +16,9 @@ import { PathAnimation, PathAnimationOptions } from './Animation/path-animation'
 import { CreatePathAnimationOptions, CreatePathAnimationActionForCameraOptions, CreateBonePathAnimationOptions, AnimationPath } from './Animation/createPathAnimation';
 import * as library from './Library';
 import { BaseObject3D, Model, ModelInfo, Poi, PoiInfo, PoiNode, PoiNodeInfo, Topology, TopologyInfo, Group, GroupInfo, Canvas3D, Canvas3DInfo, PluginObject, PluginObjectInfo, DecalInfo, Decal, DecalGeometryInfo, PoiMeshInfo, PolygonPoiMeshInfo } from './Library';
-import { Controls } from './Controls';
+import { ObjectsCache } from './Cache';
 import Viewport from './Viewport';
+import Controls from './Controls';
 import Manager from './Manager';
 import { BaseObjectInfo, ViewportOptions, SceneGlobalEvents, PluginsConstructor, IColor, Position, Rotation, OffsetPoint, ModelAnimationFindFunc, TopologyNodeInfo, FlyToViewpoint, FlyToOptions, FlyToObjOptions, SurroundOptions, LabelOptions, EdgeSelectOptions, StrokeSelectOptions, OpacitySelectOptions, HighlightSelectOptions, EmissiveSelectOptions, FogOptions, UserDataPropertyFindFunc, AmbientLightOptions, DirectionalLightOptions, HemisphereLightOptions, SpotLightOptions, PointLightOptions, CloneModelInfo, ClonePoiInfo, ShortestPathInfo, ShortestPathByMultipleStartPoints, ShortestPathByMultipleEndPoints, TopologyInfoForGml, GridHelperOptions, AxesHelperOptions, BoxHelperOptions, PlaneHelperOptions, GroundHelperOptions, DirectionalLightHelperOptions, HemisphereLightHelperOptions, SpotLightHelperOptions, PointLightHelperOptions, SignalsState, ControlsOptions, RectAreaLightOptions, RectAreaLightHelperOptions, SkyOptions, IColorSpace, ToneMappingOptions, SSAOOptions, BloomOptions, IVector3, EnvironmentOptions, PluginsConstructorWithOptions, TopologyPassableInfo, CameraViewpointData, CameraViewpointDataLegacy, CameraType } from './Interface';
 import { BoxSpace, FindObjectsNearPosition, FindNearbyObjects, SetTextureOptions } from './tools';
@@ -74,8 +75,9 @@ declare class SoonSpace {
     readonly options: InitOptions;
     readonly domElement: HTMLElement | null;
     readonly signals: SignalsState;
-    readonly controls: Controls;
+    readonly objectsCache: ObjectsCache;
     readonly viewport: Viewport;
+    readonly controls: Controls;
     readonly manager: Manager;
     readonly plugins: Record<string, any>;
     constructor(params: SoonSpaceConstructor);
@@ -141,10 +143,7 @@ declare class SoonSpace {
     /******* Viewport methods */
     /******/
     /******/
-    /**
-     * 设置空间反射
-     * @param options
-     */
+    setAutoInstancing(enabled: boolean): void;
     /**
      * 设置泛光
      * @param bloom