当前位置：首页 > news >正文

Vue3 + OpenLayers 开发教程（六）WebGL渲染优化

news 2025/4/28 12:39:25

1. WebGL 渲染优化

1.1 WebGL 渲染器配置

创建 src/utils/webgl.ts：

import { Map } from 'ol';
import { WebGLPointsLayer } from 'ol/layer';
import { Vector as VectorSource } from 'ol/source';
import { Style, Circle, Fill, Stroke } from 'ol/style';// 创建 WebGL 点图层
export const createWebGLPointsLayer = (map: Map, features: Feature[]) => {const source = new VectorSource({features: features});const layer = new WebGLPointsLayer({source: source,style: {symbol: {symbolType: 'circle',size: 10,color: '#ff0000',opacity: 0.8}}});map.addLayer(layer);return layer;
};// 优化 WebGL 渲染性能
export const optimizeWebGLRender = (map: Map) => {// 启用 WebGL 渲染map.getLayers().forEach(layer => {if (layer instanceof WebGLPointsLayer) {layer.setRenderMode('image');}});// 优化渲染参数map.getView().setConstrainResolution(true);map.getView().setSmoothResolutionConstraint(true);
};

1.2 自定义 WebGL 渲染器

创建 src/utils/custom-renderer.ts：

import { WebGLPointsLayer } from 'ol/layer';
import { WebGLPointsLayerRenderer } from 'ol/renderer/webgl/PointsLayer';// 自定义 WebGL 渲染器
export class CustomWebGLRenderer extends WebGLPointsLayerRenderer {constructor(layer: WebGLPointsLayer) {super(layer);}// 重写渲染方法renderFrame(frameState: any) {// 自定义渲染逻辑this.prepareFrame(frameState);this.renderPoints(frameState);}// 自定义点渲染private renderPoints(frameState: any) {const gl = this.getGL();const program = this.getProgram();// 设置着色器参数gl.useProgram(program);this.setUniforms(frameState);// 渲染点gl.drawArrays(gl.POINTS, 0, this.getPointCount());}
}

2. 自定义图层开发

2.1 创建自定义图层基类

创建 src/utils/custom-layer.ts：

import { Layer } from 'ol/layer';
import { Source } from 'ol/source';
import { FrameState } from 'ol/PluggableMap';// 自定义图层基类
export abstract class CustomLayer extends Layer {constructor(options: any) {super({...options,render: this.render.bind(this)});}// 抽象渲染方法abstract render(frameState: FrameState): void;// 图层更新update(frameState: FrameState) {this.changed();}// 图层销毁dispose() {super.dispose();}
}

2.2 实现自定义图层

创建 src/utils/heatmap-layer.ts：

import { CustomLayer } from './custom-layer';
import { FrameState } from 'ol/PluggableMap';
import { Feature } from 'ol';
import { Geometry } from 'ol/geom';// 热力图图层
export class HeatmapLayer extends CustomLayer {private features: Feature<Geometry>[];private radius: number;private gradient: string[];constructor(options: {features: Feature<Geometry>[];radius?: number;gradient?: string[];}) {super({source: null});this.features = options.features;this.radius = options.radius || 15;this.gradient = options.gradient || ['rgba(0, 0, 255, 0)','rgba(0, 0, 255, 1)','rgba(0, 255, 255, 1)','rgba(0, 255, 0, 1)','rgba(255, 255, 0, 1)','rgba(255, 0, 0, 1)'];}render(frameState: FrameState) {const canvas = document.createElement('canvas');const ctx = canvas.getContext('2d');const size = frameState.size;canvas.width = size[0];canvas.height = size[1];// 渲染热力图this.features.forEach(feature => {const coord = feature.getGeometry()?.getCoordinates();const pixel = frameState.pixelToCoordinateTransform(coord);if (ctx) {const gradient = ctx.createRadialGradient(pixel[0], pixel[1], 0,pixel[0], pixel[1], this.radius);this.gradient.forEach((color, index) => {gradient.addColorStop(index / (this.gradient.length - 1), color);});ctx.fillStyle = gradient;ctx.fillRect(0, 0, size[0], size[1]);}});return canvas;}
}

3. 复杂动画实现

3.1 动画系统设计

创建 src/utils/animation.ts：

import { Map } from 'ol';
import { Feature } from 'ol';
import { Geometry } from 'ol/geom';
import { Easing } from 'ol/easing';// 动画基类
export abstract class Animation {protected map: Map;protected duration: number;protected startTime: number;constructor(map: Map, duration: number) {this.map = map;this.duration = duration;this.startTime = Date.now();}// 抽象更新方法abstract update(): boolean;// 获取动画进度protected getProgress(): number {const elapsed = Date.now() - this.startTime;return Math.min(elapsed / this.duration, 1);}// 获取缓动值protected getEasing(progress: number): number {return Easing.easeInOut(progress);}
}// 轨迹动画
export class TrackAnimation extends Animation {private feature: Feature<Geometry>;private coordinates: number[][];private currentIndex: number;constructor(map: Map,feature: Feature<Geometry>,coordinates: number[][],duration: number) {super(map, duration);this.feature = feature;this.coordinates = coordinates;this.currentIndex = 0;}update(): boolean {const progress = this.getProgress();if (progress >= 1) return false;const easing = this.getEasing(progress);const nextIndex = Math.floor(easing * (this.coordinates.length - 1));if (nextIndex !== this.currentIndex) {this.currentIndex = nextIndex;this.feature.getGeometry()?.setCoordinates(this.coordinates[this.currentIndex]);}return true;}
}// 动画管理器
export class AnimationManager {private map: Map;private animations: Animation[];private animationFrame: number;constructor(map: Map) {this.map = map;this.animations = [];this.animationFrame = 0;}// 添加动画addAnimation(animation: Animation) {this.animations.push(animation);if (this.animations.length === 1) {this.start();}}// 开始动画private start() {const animate = () => {this.animations = this.animations.filter(animation => animation.update());if (this.animations.length > 0) {this.animationFrame = requestAnimationFrame(animate);} else {this.stop();}};this.animationFrame = requestAnimationFrame(animate);}// 停止动画stop() {if (this.animationFrame) {cancelAnimationFrame(this.animationFrame);this.animationFrame = 0;}this.animations = [];}
}

4. 大数据可视化

4.1 数据分片处理

创建 src/utils/data-chunk.ts：

import { Feature } from 'ol';
import { Geometry } from 'ol/geom';
import { Extent } from 'ol/extent';// 数据分片管理器
export class DataChunkManager {private features: Feature<Geometry>[];private chunkSize: number;private chunks: Map<string, Feature<Geometry>[]>;private extent: Extent;constructor(features: Feature<Geometry>[], chunkSize: number = 1000) {this.features = features;this.chunkSize = chunkSize;this.chunks = new Map();this.extent = this.calculateExtent();}// 计算数据范围private calculateExtent(): Extent {return this.features.reduce((extent, feature) => {const geometry = feature.getGeometry();if (geometry) {return geometry.getExtent(extent);}return extent;}, [Infinity, Infinity, -Infinity, -Infinity]);}// 分片处理processChunks() {const width = this.extent[2] - this.extent[0];const height = this.extent[3] - this.extent[1];const chunkWidth = width / Math.ceil(Math.sqrt(this.features.length / this.chunkSize));const chunkHeight = height / Math.ceil(Math.sqrt(this.features.length / this.chunkSize));this.features.forEach(feature => {const coord = feature.getGeometry()?.getCoordinates();if (coord) {const chunkX = Math.floor((coord[0] - this.extent[0]) / chunkWidth);const chunkY = Math.floor((coord[1] - this.extent[1]) / chunkHeight);const chunkKey = `${chunkX},${chunkY}`;if (!this.chunks.has(chunkKey)) {this.chunks.set(chunkKey, []);}this.chunks.get(chunkKey)?.push(feature);}});}// 获取范围内的分片getChunksInExtent(extent: Extent): Feature<Geometry>[] {const result: Feature<Geometry>[] = [];this.chunks.forEach((features, key) => {const [x, y] = key.split(',').map(Number);const chunkExtent = [this.extent[0] + x * (this.extent[2] - this.extent[0]) / this.chunkSize,this.extent[1] + y * (this.extent[3] - this.extent[1]) / this.chunkSize,this.extent[0] + (x + 1) * (this.extent[2] - this.extent[0]) / this.chunkSize,this.extent[1] + (y + 1) * (this.extent[3] - this.extent[1]) / this.chunkSize];if (this.intersects(extent, chunkExtent)) {result.push(...features);}});return result;}// 判断范围是否相交private intersects(extent1: Extent, extent2: Extent): boolean {return !(extent1[2] < extent2[0] ||extent1[0] > extent2[2] ||extent1[3] < extent2[1] ||extent1[1] > extent2[3]);}
}

5. 离线地图支持

5.1 离线存储管理

创建 src/utils/offline-storage.ts：

import { Tile } from 'ol';
import { TileCoord } from 'ol/tilecoord';// 离线存储管理器
export class OfflineStorageManager {private db: IDBDatabase;private storeName: string;constructor(storeName: string = 'tiles') {this.storeName = storeName;this.initDB();}// 初始化数据库private async initDB() {const request = indexedDB.open('map-tiles', 1);request.onupgradeneeded = (event) => {const db = (event.target as IDBOpenDBRequest).result;if (!db.objectStoreNames.contains(this.storeName)) {db.createObjectStore(this.storeName);}};this.db = await new Promise((resolve, reject) => {request.onsuccess = () => resolve(request.result);request.onerror = () => reject(request.error);});}// 保存瓦片async saveTile(coord: TileCoord, tile: Tile) {const tx = this.db.transaction(this.storeName, 'readwrite');const store = tx.objectStore(this.storeName);const key = this.getTileKey(coord);await new Promise((resolve, reject) => {const request = store.put(tile.getImage(), key);request.onsuccess = () => resolve(null);request.onerror = () => reject(request.error);});}// 获取瓦片async getTile(coord: TileCoord): Promise<HTMLImageElement | null> {const tx = this.db.transaction(this.storeName, 'readonly');const store = tx.objectStore(this.storeName);const key = this.getTileKey(coord);return new Promise((resolve, reject) => {const request = store.get(key);request.onsuccess = () => resolve(request.result);request.onerror = () => reject(request.error);});}// 生成瓦片键private getTileKey(coord: TileCoord): string {return `${coord[0]}/${coord[1]}/${coord[2]}`;}// 清理过期瓦片async cleanup(expireDays: number = 30) {const tx = this.db.transaction(this.storeName, 'readwrite');const store = tx.objectStore(this.storeName);const expireTime = Date.now() - expireDays * 24 * 60 * 60 * 1000;await new Promise((resolve, reject) => {const request = store.openCursor();request.onsuccess = (event) => {const cursor = (event.target as IDBRequest).result;if (cursor) {if (cursor.value.timestamp < expireTime) {cursor.delete();}cursor.continue();} else {resolve(null);}};request.onerror = () => reject(request.error);});}
}

6. 3D 地图集成

6.1 3D 渲染配置

创建 src/utils/3d-renderer.ts：

import { Map } from 'ol';
import { WebGLTileLayer } from 'ol/layer';
import { XYZ } from 'ol/source';
import { transform } from 'ol/proj';// 3D 渲染配置
export class ThreeDRenderer {private map: Map;private terrainLayer: WebGLTileLayer;private elevationData: Float32Array;constructor(map: Map) {this.map = map;this.initTerrainLayer();this.loadElevationData();}// 初始化地形图层private initTerrainLayer() {this.terrainLayer = new WebGLTileLayer({source: new XYZ({url: 'https://api.example.com/terrain/{z}/{x}/{y}.png'}),style: {color: {condition: [['>', ['get', 'elevation'], 1000],'rgba(255, 255, 255, 1)','rgba(200, 200, 200, 1)']}}});this.map.addLayer(this.terrainLayer);}// 加载高程数据private async loadElevationData() {const response = await fetch('https://api.example.com/elevation');const data = await response.json();this.elevationData = new Float32Array(data);}// 获取高程值getElevation(lon: number, lat: number): number {const coord = transform([lon, lat], 'EPSG:4326', 'EPSG:3857');const x = Math.floor((coord[0] - this.map.getView().getCenter()[0]) / 100);const y = Math.floor((coord[1] - this.map.getView().getCenter()[1]) / 100);const index = y * 100 + x;return this.elevationData[index] || 0;}// 更新地形updateTerrain() {this.terrainLayer.changed();}
}