refactor: 地图文字渲染

This commit is contained in:
AncTe committed 2026-11-19 16:36:43 +08:00
1 parent 86054951ed
commit b0fd0ca091
10 files changed
+616 -570

No files matched your search

+108 -71
View File
@@ -1,74 +1,57 @@
import { MotaOffscreenCanvas2D, RenderItem } from '@motajs/render';
import { IGameMap } from '@user/data-base';
import { IMapRenderer } from './types';
import { ElementNamespace, ComponentInternalInstance } from 'vue';
import { CELL_HEIGHT, CELL_WIDTH, MAP_HEIGHT, MAP_WIDTH } from '../shared';
import { IMapExtensionManager } from './extension';
import {
ActionEventMap,
ActionType,
EventProgress,
IRenderTreeRoot,
MotaOffscreenCanvas2D,
RenderItem,
Transform
} from '@motajs/render';
import { mat3 } from 'gl-matrix';
import { IMapRenderer, IMapRenderItem } from './types';
import { GameMap, IGameMap } from '@user/data-base';
import { MapRenderer } from './renderer';
export class MapRenderItem extends RenderItem {
/**
* @param layerState 地图状态对象
* @param renderer 地图渲染器对象
*/
constructor(
readonly layerState: IGameMap,
readonly renderer: IMapRenderer,
readonly exManager: IMapExtensionManager
) {
super(false);
export class MapRenderItem extends RenderItem implements IMapRenderItem {
/** 当前的委托 id */
private delegation: number = -1;
renderer.setLayerState(layerState);
renderer.setCellSize(CELL_WIDTH, CELL_HEIGHT);
renderer.setRenderSize(MAP_WIDTH, MAP_HEIGHT);
/** 当前使用的地图渲染器 */
renderer: IMapRenderer | null = null;
/** 当前正在渲染的地图 */
map: IGameMap | null = null;
// 元素被销毁时会自动删除所有的激励对象,所以不需要担心会内存泄漏
this.delegateExcitable(time => {
this.renderer.tick(time);
protected onConnected(root: IRenderTreeRoot): void {
this.delegation = root.delegateExcitable(time => {
if (!this.renderer) return;
if (this.renderer.needUpdate()) {
this.update();
}
const text = exManager.textRenderer;
if (text) {
if (text.needResize) {
this.resizeTextRenderer(this.width, this.height);
}
if (text.needUpdate()) {
this.update();
}
}
this.renderer.excited(time);
});
}
private resizeTextRenderer(width: number, height: number) {
const ex = this.exManager.textRenderer;
if (!ex) return;
const ratio = this.highResolution ? devicePixelRatio : 1;
const scale = ratio * this.scale;
const w = width * scale;
const h = height * scale;
ex.resize(
w,
h,
w / this.renderer.renderWidth,
h / this.renderer.renderHeight
);
protected onDisconnected(prevRoot: IRenderTreeRoot): void {
prevRoot.removeExcitable(this.delegation);
}
protected getDefaultCache(): boolean {
return true;
}
/**
* 重设 WebGL2 画布的宽高
* @param width 宽度
* @param height 高度
*/
private sizeGL(width: number, height: number) {
if (!this.renderer) return;
const ratio = this.highResolution ? devicePixelRatio : 1;
const scale = ratio * this.scale;
const w = width * scale;
const h = height * scale;
this.renderer.setCanvasSize(w, h);
this.renderer.setViewport(0, 0, w, h);
if (this.exManager.textRenderer) {
this.exManager.textRenderer.resize(
w,
h,
w / this.renderer.renderWidth,
h / this.renderer.renderHeight
);
}
}
onResize(scale: number): void {
@@ -81,29 +64,83 @@ export class MapRenderItem extends RenderItem {
this.sizeGL(width, height);
}
protected render(canvas: MotaOffscreenCanvas2D): void {
this.renderer.clear(true, true);
const map = this.renderer.render();
canvas.ctx.drawImage(map.canvas, 0, 0, canvas.width, canvas.height);
if (this.exManager.textRenderer) {
const text = this.exManager.textRenderer.render(map);
canvas.ctx.drawImage(text, 0, 0, canvas.width, canvas.height);
protected propagateEvent<T extends ActionType>(
type: T,
progress: EventProgress,
event: ActionEventMap[T]
): void {
//
if (progress === EventProgress.Capture) {
this.bubbleEvent(type, event);
} else {
this.parent?.bubbleEvent(type, event);
}
}
patchProp(
key: string,
prevValue: any,
nextValue: any,
namespace?: ElementNamespace,
parentComponent?: ComponentInternalInstance | null
): void {
protected render(canvas: MotaOffscreenCanvas2D): void {
if (!this.renderer) return;
this.renderer.clear(true, true);
const map = this.renderer.render();
canvas.ctx.drawImage(map.canvas, 0, 0, canvas.width, canvas.height);
// 在外部计算好要乘的视角变换矩阵
const { renderWidth, renderHeight } = this.renderer;
const [a, b, , c, d, , e, f] = this.renderer.transform.mat;
const ee = (e * renderWidth) / 2;
const ff = (f * renderHeight) / 2;
const mat = mat3.fromValues(a, b, 0, c, d, 0, ee, ff, 1);
mat3.mul(mat, mat, mat3.fromValues(1, 0, 0, 0, -1, 0, 0, 0, 1));
const vTransform = new Transform();
vTransform.setTransform(mat[0], mat[1], mat[3], mat[4], mat[6], mat[7]);
const sorted = this.getSortedChildren() as RenderItem[];
sorted.forEach(item => {
if (item.hidden) return;
// sortedChildren 内部存储 RenderItem,transform 可写,倒序相乘后直接写入,渲染完毕后回退,外部无感
// 元素本身可以通过调整自己的 `selfTransform` 来调整渲染模式
// TODO: 可能需要调整设计以避免使用 as RenderItem 这种 Hack 设计
const before = item.transform;
const targetTransform = item.transform.multiply(vTransform);
item.transform = targetTransform;
item.renderContent(canvas);
item.transform = before;
});
}
setRenderer(renderer: IMapRenderer | null): void {
this.renderer = renderer;
this.renderer?.setGameMap(this.map);
this.update();
}
setRenderMap(map: IGameMap | null): void {
this.map = map;
this.renderer?.setGameMap(map);
this.update();
}
handleProps(key: string, prevValue: any, nextValue: any): boolean {
if (super.handleProps(key, prevValue, nextValue)) return true;
switch (key) {
case 'layerState': {
this.renderer.setLayerState(nextValue);
break;
case 'map': {
if (!nextValue) {
this.setRenderMap(null);
return true;
}
if (!this.assertType(nextValue, GameMap, key)) return false;
this.setRenderMap(nextValue);
return true;
}
case 'renderer': {
if (!nextValue) {
this.setRenderer(null);
return true;
}
if (!this.assertType(nextValue, MapRenderer, key)) return false;
this.setRenderer(nextValue);
return true;
}
}
super.patchProp(key, prevValue, nextValue, namespace, parentComponent);
return false;
}
}
@@ -1,280 +0,0 @@
import { logger } from '@motajs/common';
import {
IChunkData,
IBlockSplitter,
IMapRenderer,
IMapRenderResult,
IMapVertexBlock
} from '../types';
import { IMapTextArea, IMapTextRenderable, IOnMapTextRenderer } from './types';
import { ITransformUpdatable, Transform } from '@motajs/render';
export class OnMapTextRenderer
implements IOnMapTextRenderer, ITransformUpdatable<Transform>
{
/** 画布元素 */
readonly canvas: HTMLCanvasElement;
/** 画布 Canvas2D 上下文 */
readonly ctx: CanvasRenderingContext2D;
needResize: boolean = true;
/** 分块上附着文本区域的标识符 */
private readonly attachSymbol: symbol = Symbol('onMapTextAreas');
/** 是否有内容发生变化,需要更新 */
private dirty: boolean = false;
/** 分块对象 */
private readonly block: IBlockSplitter<IMapVertexBlock>;
/** 变换矩阵 */
private readonly transform: Transform;
constructor(readonly renderer: IMapRenderer) {
this.canvas = document.createElement('canvas');
this.ctx = this.canvas.getContext('2d')!;
this.block = renderer.vertex.block;
this.transform = renderer.transform;
this.ctx.lineWidth = 2;
this.transform.bind(this);
}
updateTransform() {
this.dirty = true;
}
/**
* 标记为需要更新
*/
markDirty(): void {
this.dirty = true;
}
resize(
width: number,
height: number,
scaleX: number,
scaleY: number
): void {
this.canvas.width = width;
this.canvas.height = height;
this.ctx.setTransform(1, 0, 0, 1, 0, 0);
this.ctx.translate(width / 2, height / 2);
this.ctx.scale(1, -1);
this.ctx.scale(scaleX, scaleY);
this.dirty = true;
this.needResize = false;
}
getBlockByLoc(x: number, y: number): Readonly<IMapTextArea> | null {
const index = y * this.renderer.mapWidth + x;
// 首先尝试使用分块系统获取对应分块并从分块附着数据读取
const blockData = this.block.getChunkByElementIndex(index);
if (blockData) {
const map = blockData.data.getAttachedData<
Map<number, MapTextArea>
>(this.attachSymbol);
if (map) return map.get(index) ?? null;
}
return null;
}
getBlockByIndex(index: number): Readonly<IMapTextArea> | null {
const blockData = this.block.getChunkByElementIndex(index);
if (blockData) {
const map = blockData.data.getAttachedData<
Map<number, MapTextArea>
>(this.attachSymbol);
if (map) return map.get(index) || null;
}
return null;
}
render(data: IMapRenderResult): HTMLCanvasElement {
if (!this.dirty) return this.canvas;
const ctx = this.ctx;
const { renderWidth, renderHeight } = this.renderer;
// clear
ctx.clearRect(
-renderWidth / 2,
-renderHeight / 2,
renderWidth,
renderHeight
);
ctx.save();
// apply transform matrix
const [a, b, , c, d, , e, f] = this.transform.mat;
ctx.transform(
a,
b,
c,
d,
(e * renderWidth) / 2,
(f * renderHeight) / 2
);
// 由于 WebGL 坐标系与 Canvas2D 坐标系不一样,所以还需要变换一下
ctx.scale(1, -1);
// draw text in each block
for (const blk of data.area.blockList) {
const map = blk.data.getAttachedData<Map<number, MapTextArea>>(
this.attachSymbol
);
if (!map) continue;
for (const area of map.values()) {
const baseX = area.mapX * this.renderer.cellWidth;
const baseY = area.mapY * this.renderer.cellHeight;
for (const renderable of area.getRenderables()) {
const x = baseX + (renderable.px ?? 0) - renderWidth / 2;
const y = renderHeight / 2 - (baseY + (renderable.py ?? 0));
ctx.font = renderable.font.string();
ctx.textAlign = renderable.textAlign ?? 'left';
ctx.textBaseline = renderable.textBaseline ?? 'top';
if (renderable.stroke) {
ctx.strokeStyle = renderable.strokeStyle ?? 'black';
ctx.strokeText(renderable.text, x, -y);
}
if (renderable.fill) {
ctx.fillStyle = renderable.fillStyle ?? 'white';
ctx.fillText(renderable.text, x, -y);
}
}
}
}
this.dirty = false;
ctx.restore();
return this.canvas;
}
/**
* 获取分块所附着的文字数据
* @param blockData 分块数据
*/
private getAttachedMap(
blockData: IChunkData<IMapVertexBlock>
): Map<number, MapTextArea> {
const map = blockData.data.getAttachedData<Map<number, MapTextArea>>(
this.attachSymbol
);
if (map) return map;
else {
const map = new Map();
blockData.data.attach(this.attachSymbol, map);
return map;
}
}
requireBlockArea(x: number, y: number): Readonly<IMapTextArea> | null {
const index = y * this.renderer.mapWidth + x;
// try to find corresponding block by data index
const blockData = this.block.getChunkByElementIndex(index);
if (blockData) {
const map = this.getAttachedMap(blockData);
const exist = map.get(index);
if (exist) return exist;
const area = new MapTextArea(this, x, y);
map.set(index, area);
this.markDirty();
return area;
} else {
logger.error(47);
return null;
}
}
needUpdate(): boolean {
return this.dirty;
}
clear(): void {
// 清理所有附着在分块上的文本区域
for (const b of this.block.iterateChunks()) {
const blk = b.data;
const map = blk.getAttachedData<Map<number, MapTextArea>>(
this.attachSymbol
);
if (map) {
for (const area of map.values()) area.clear();
blk.deleteAttachedData(this.attachSymbol);
}
}
this.dirty = true;
}
destroy(): void {
this.transform.unbind(this);
this.clear();
// the canvas and context references are left intact; consumers may
// discard the renderer instance to allow GC. We don't detach the
// canvas from any DOM since ownership is external.
}
}
class MapTextArea implements IMapTextArea {
readonly index: number;
// maintain both a set for quick membership checks and a map for index lookup
private renderableSet: Set<IMapTextRenderable> = new Set();
private renderableMap: Map<number, IMapTextRenderable> = new Map();
private reverseMap: Map<IMapTextRenderable, number> = new Map();
private nextRenderableIndex: number = 1;
/**
* 获取本区域的所有可渲染对象,用于绘制阶段
*/
getRenderables(): Iterable<IMapTextRenderable> {
return this.renderableSet;
}
constructor(
readonly renderer: OnMapTextRenderer,
public readonly mapX: number,
public readonly mapY: number
) {
this.index = mapY * renderer.renderer.mapWidth + mapX;
}
addTextRenderable(renderable: IMapTextRenderable): number {
const idx = this.nextRenderableIndex++;
this.renderableSet.add(renderable);
this.renderableMap.set(idx, renderable);
this.reverseMap.set(renderable, idx);
this.renderer.markDirty();
return idx;
}
removeTextRenderable(renderable: IMapTextRenderable): void {
const idx = this.reverseMap.get(renderable);
if (idx !== void 0) {
this.renderableSet.delete(renderable);
this.renderableMap.delete(idx);
this.reverseMap.delete(renderable);
this.renderer.markDirty();
}
}
removeTextRenderableByIndex(index: number): void {
const obj = this.renderableMap.get(index);
if (obj !== void 0) {
this.renderableMap.delete(index);
this.renderableSet.delete(obj);
this.reverseMap.delete(obj);
this.renderer.markDirty();
}
}
clear(): void {
if (this.renderableSet.size > 0) {
this.renderableSet.clear();
this.renderableMap.clear();
this.reverseMap.clear();
this.renderer.markDirty();
}
}
}
@@ -1,15 +1,12 @@
import { ITexture, Font } from '@motajs/render';
import { ITexture } from '@motajs/render';
import { IFaceManager } from '@user/data-common';
import { IHeroLocation, IMapLayer } from '@user/data-base';
import { IMapRenderResult } from '../types';
export interface IMapExtensionManager {
/** 勇士状态至勇士渲染器的映射 */
readonly heroMap: Map<IHeroLocation, IMapHeroRenderer>;
/** 地图图层到门渲染器的映射 */
readonly doorMap: Map<IMapLayer, IMapDoorRenderer>;
/** 单例的文字渲染拓展(独立图层) */
readonly textRenderer: IOnMapTextRenderer | null;
/**
* 添加勇士渲染拓展
@@ -38,16 +35,6 @@ export interface IMapExtensionManager {
*/
removeDoor(layer: IMapLayer): void;
/**
* 添加文字渲染拓展
*/
addText(): IOnMapTextRenderer | null;
/**
* 移除文字渲染拓展
*/
removeText(): void;
/**
* 摧毁这个拓展管理对象,释放相关资源
*/
@@ -126,122 +113,3 @@ export interface IMapDoorRenderer {
*/
destroy(): void;
}
export interface IMapTextRenderable {
/** 文本内容 */
readonly text: string;
/** 文本字体 */
readonly font: Font;
/** 是否填充 */
readonly fill?: boolean;
/** 是否描边 */
readonly stroke?: boolean;
/** 文本填充样式 */
readonly fillStyle?: CanvasStyle;
/** 文本描边样式 */
readonly strokeStyle?: CanvasStyle;
/** 文本横坐标,注意 {@link IMapTextArea.addTextRenderable} 的相对关系 */
readonly px?: number;
/** 文本纵坐标,注意 {@link IMapTextArea.addTextRenderable} 的相对关系 */
readonly py?: number;
/** 文本横向对齐方式 */
readonly textAlign?: CanvasTextAlign;
/** 文本纵向对齐方式 */
readonly textBaseline?: CanvasTextBaseline;
}
export interface IMapTextRequested {
/**
* 申请更新指定的图块
* @param blocks 需要更新数据的图块列表
*/
requestBlocks(blocks: IMapTextArea[]): void;
}
export interface IMapTextArea {
/** 图块在地图上的索引 */
readonly index: number;
/** 图块横坐标 */
readonly mapX: number;
/** 图块纵坐标 */
readonly mapY: number;
/**
* 添加文字可渲染对象。可渲染对象的坐标相对于图块,而非地图。
* @param renderable 可渲染对象
* @returns 添加的可渲染对象的唯一索引标识符
*/
addTextRenderable(renderable: IMapTextRenderable): number;
/**
* 移除指定的文字可渲染对象
* @param renderable 可渲染对象
*/
removeTextRenderable(renderable: IMapTextRenderable): void;
/**
* 根据可渲染对象的索引标识符移除文字的可渲染对象
* @param index 可渲染对象对应的索引标识符
*/
removeTextRenderableByIndex(index: number): void;
/**
* 清除本图块的所有文字可渲染对象
*/
clear(): void;
}
export interface IOnMapTextRenderer {
/** 是否需要修改画布大小 */
readonly needResize: boolean;
/**
* 修改画布的缩放比例,传入的参数包含 `devicePixelRatio` 以及渲染器自身缩放比例
* @param width 画布宽度
* @param height 画布高度
* @param scaleX 画布横向比例
* @param scaleY 画布纵向比例
*/
resize(width: number, height: number, scaleX: number, scaleY: number): void;
/**
* 渲染地图文字,返回的画布就是文字画到的画布
*/
render(data: IMapRenderResult): HTMLCanvasElement;
/**
* 申请指定图块坐标的文字管理对象,如果该点已被申请,则会使用已申请的对象
* @param x 图块横坐标
* @param y 图块纵坐标
* @returns 申请的文字管理对象,如果申请的坐标不在地图上,则会返回 `null`
*/
requireBlockArea(x: number, y: number): Readonly<IMapTextArea> | null;
/**
* 根据图块坐标获取已申请的文字管理对象,如果未申请则返回 `null`
* @param x 图块横坐标
* @param y 图块纵坐标
*/
getBlockByLoc(x: number, y: number): Readonly<IMapTextArea> | null;
/**
* 根据索引获取已申请的文字管理对象,如果未申请则返回 `null`
* @param index 管理对象索引
*/
getBlockByIndex(index: number): Readonly<IMapTextArea> | null;
/**
* 判断是否需要更新
*/
needUpdate(): boolean;
/**
* 清空所有文字内容
*/
clear(): void;
/**
* 摧毁这个文字渲染对象,释放相关资源
*/
destroy(): void;
}
@@ -3,6 +3,7 @@ export * from './extension';
export * from './chunk';
export * from './constant';
export * from './element';
export * from './mapText';
export * from './moving';
export * from './renderer';
export * from './status';
@@ -0,0 +1,271 @@
import {
Hookable,
HookController,
IHookController,
logger
} from '@motajs/common';
import { MotaOffscreenCanvas2D } from '@motajs/render';
import { DefaultProps } from '@motajs/render-vue';
import { defineComponent, onMounted, ref, watch } from 'vue';
import { SetupComponentOptions } from '@motajs/system';
import { isNil } from 'lodash-es';
import {
IBlockSplitter,
IChunkData,
IMapRenderer,
IMapTextArea,
IMapTextManager,
IMapTextManagerHooks,
IMapTextRenderable,
IMapVertexBlock
} from './types';
export class MapTextManager
extends Hookable<IMapTextManagerHooks>
implements IMapTextManager
{
/** 分块上附着文本区域的标识符 */
private readonly attachSymbol: symbol = Symbol('onMapTextAreas');
/** 分块对象 */
private readonly block: IBlockSplitter<IMapVertexBlock>;
constructor(private readonly renderer: IMapRenderer) {
super();
this.block = renderer.vertex.block;
}
protected createController(
hook: Partial<IMapTextManagerHooks>
): IHookController<IMapTextManagerHooks> {
return new HookController(this, hook);
}
/**
* 触发更新通知
*/
private update() {
this.forEachHook(hook => hook.onUpdate?.());
}
/**
* 获取分块所附着的文字数据
* @param blockData 分块数据
*/
private getAttachedMap(
blockData: IChunkData<IMapVertexBlock>
): Map<number, MapTextArea> {
return blockData.data.getOrInsertAttachedData(
this.attachSymbol,
() => new Map<number, MapTextArea>()
);
}
requireBlockArea(x: number, y: number): Readonly<IMapTextArea> | null {
const index = y * this.renderer.mapWidth + x;
const blockData = this.block.getChunkByElementIndex(index);
if (!blockData) {
logger.error(47);
return null;
}
const map = this.getAttachedMap(blockData);
return map.getOrInsertComputed(index, () => {
// 新增的时候,TextArea 本身是没有任何内容的,所以不需要触发更新
return new MapTextArea(index, x, y, () => this.update());
});
}
getBlockByLoc(x: number, y: number): Readonly<IMapTextArea> | null {
return this.getBlockByIndex(y * this.renderer.mapWidth + x);
}
getBlockByIndex(index: number): Readonly<IMapTextArea> | null {
const blockData = this.block.getChunkByElementIndex(index);
if (!blockData) return null;
const map = blockData.data.getAttachedData<Map<number, MapTextArea>>(
this.attachSymbol
);
return map?.get(index) ?? null;
}
iterateBlockData(
block: IChunkData<IMapVertexBlock>
): Iterable<IMapTextArea> {
const attached = this.getAttachedMap(block);
return attached.values();
}
deleteBlockArea(x: number, y: number): void {
const index = y * this.renderer.mapWidth + x;
const blockData = this.block.getChunkByElementIndex(index);
if (!blockData) return;
const map = this.getAttachedMap(blockData);
map.delete(index);
if (map.size === 0) {
blockData.data.deleteAttachedData(this.attachSymbol);
}
}
clear(): void {
for (const b of this.block.iterateChunks()) {
const blk = b.data;
const map = blk.getAttachedData<Map<number, MapTextArea>>(
this.attachSymbol
);
if (map) {
for (const area of map.values()) area.clear();
blk.deleteAttachedData(this.attachSymbol);
}
}
this.update();
}
destroy(): void {
this.clear();
}
}
class MapTextArea implements IMapTextArea {
/** 标记管理器需要更新的回调 */
private readonly markDirty: () => void;
/** 本区域所有可渲染对象的集合,用于绘制阶段 */
private readonly renderableSet: Set<IMapTextRenderable> = new Set();
/** 可渲染对象索引到可渲染对象的映射 */
private readonly renderableMap: Map<number, IMapTextRenderable> = new Map();
/** 可渲染对象到其索引的映射 */
private readonly reverseMap: Map<IMapTextRenderable, number> = new Map();
/** 下一个可用的可渲染对象索引 */
private nextRenderableIndex: number = 1;
constructor(
readonly index: number,
readonly mapX: number,
readonly mapY: number,
markDirty: () => void
) {
this.markDirty = markDirty;
}
/**
* 获取本区域的所有可渲染对象,用于绘制阶段
*/
getRenderables(): Iterable<IMapTextRenderable> {
return this.renderableSet;
}
addTextRenderable(renderable: IMapTextRenderable): number {
const idx = this.nextRenderableIndex++;
this.renderableSet.add(renderable);
this.renderableMap.set(idx, renderable);
this.reverseMap.set(renderable, idx);
this.markDirty();
return idx;
}
removeTextRenderable(renderable: IMapTextRenderable): void {
const idx = this.reverseMap.get(renderable);
if (!isNil(idx)) {
this.renderableSet.delete(renderable);
this.renderableMap.delete(idx);
this.reverseMap.delete(renderable);
this.markDirty();
}
}
removeTextRenderableByIndex(index: number): void {
const obj = this.renderableMap.get(index);
if (obj) {
this.renderableMap.delete(index);
this.renderableSet.delete(obj);
this.reverseMap.delete(obj);
this.markDirty();
}
}
clear(): void {
if (this.renderableSet.size > 0) {
this.renderableSet.clear();
this.renderableMap.clear();
this.reverseMap.clear();
this.markDirty();
}
}
}
export interface IMapTextProps extends DefaultProps {
/** 文字管理器,提供文字数据 */
manager?: IMapTextManager;
/** 地图渲染器,提供尺寸与可见区域 */
renderer?: IMapRenderer;
}
const mapTextProps = {
props: ['loc', 'manager', 'renderer']
} satisfies SetupComponentOptions<IMapTextProps>;
/**
* 地图文字组件,按照地图坐标系绘制文字管理器中的所有文字。
* 参数为文字管理器与地图渲染器,前者提供文字数据,后者提供尺寸与可见区域。
*/
export const MapText = defineComponent<IMapTextProps>(props => {
const counter = ref(0);
const hook: IMapTextManagerHooks = {
onUpdate() {
counter.value++;
}
};
const render = (canvas: MotaOffscreenCanvas2D) => {
const { manager, renderer } = props;
if (!manager || !renderer) return;
const ctx = canvas.ctx;
const blockList = renderer.viewport.getRenderArea().blockList;
ctx.lineWidth = 2;
for (const chunk of blockList) {
const areas = manager.iterateBlockData(chunk);
for (const area of areas) {
const baseX = area.mapX * renderer.cellWidth;
const baseY = area.mapY * renderer.cellHeight;
const renderables = area.getRenderables();
for (const renderable of renderables) {
const x = baseX + (renderable.px ?? 0);
const y = baseY + (renderable.py ?? 0);
ctx.font = renderable.font.string();
ctx.textAlign = renderable.textAlign ?? 'left';
ctx.textBaseline = renderable.textBaseline ?? 'top';
if (renderable.stroke) {
ctx.strokeStyle = renderable.strokeStyle ?? 'black';
ctx.strokeText(renderable.text, x, y);
}
if (renderable.fill) {
ctx.fillStyle = renderable.fillStyle ?? 'white';
ctx.fillText(renderable.text, x, y);
}
}
}
}
};
onMounted(() => {
props.manager?.addHook(hook);
});
watch(
() => props.manager,
(value, old) => {
old?.removeHook(hook);
value?.addHook(hook);
}
);
return () => {
return (
<custom
selfTransform
loc={props.loc}
render={render}
bindings={[counter.value]}
/>
);
};
}, mapTextProps);
+39 -57
View File
@@ -18,7 +18,6 @@ import {
IMapRenderConfig,
IMapRenderer,
IMapRendererPostEffect,
IMapRendererTicker,
IMapRenderResult,
IMapVertexGenerator,
IMapViewportController,
@@ -53,6 +52,7 @@ import {
import { MapViewport } from './viewport';
import { INSTANCED_COUNT } from './constant';
import { OverlayBlock, StaticBlockStatus } from './status';
import { IExcitableController, IExcitation } from '@motajs/animate';
const enum BackgroundType {
Static,
@@ -158,8 +158,6 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
/** 移动容忍度,如果正在移动的图块数量长期小于预留数量的一半,那么将减少移动数组长度 */
private lastExpandTime = 0;
/** 时间戳 */
private timestamp: number = 0;
/** 上一帧动画的时刻 */
private lastFrameTime: number = 0;
/** 当前帧数 */
@@ -168,8 +166,6 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
private needUpdateFrameCounter: boolean = true;
/** 帧动画速率 */
private frameSpeed: number = 300;
/** 帧动画列表 */
private tickers: Set<MapRendererTicker> = new Set();
/** 画布元素 */
readonly canvas: HTMLCanvasElement;
@@ -202,6 +198,11 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
/** `gl.viewport` 高度 */
private viewportHeight: number = 0;
/** 激励控制器 */
private exciteController: IExcitableController<number> | null = null;
/** 激励源 */
private excitation: IExcitation<number> | null = null;
//#endregion
//#region 初始化
@@ -228,7 +229,6 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
this.contextData = data;
this.vertex = new MapVertexGenerator(this, data);
this.autotile = manager.autotile;
this.tick = this.tick.bind(this);
this.viewport = new MapViewport(this);
this.tileAnimater = new TextureColumnAnimater();
this.initVertexPointer(this.gl, data);
@@ -463,24 +463,24 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
this.vertex.updateLayerArray();
}
setLayerState(map: IGameMap): void {
setGameMap(map: IGameMap | null): void {
if (map === this.map) return;
this.mapHook?.unload();
this.map = map;
this.syncLayerHooks();
this.mapHook = map.addHook(new RendererLayerStateHook(this));
if (map) {
this.mapHook = map.addHook(new RendererLayerStateHook(this));
this.layerCount = map.layerList.size;
} else {
this.mapHook = null;
this.layerCount = 0;
}
this.sortLayer();
this.resizeLayer();
this.layerCount = map.layerList.size;
this.vertex.updateLayerArray();
this.vertex.resizeMap();
}
getLayer(identifier: string): IMapLayer | null {
if (!this.map) return null;
return this.map.getLayerByAlias(identifier) ?? null;
}
hasLayer(layer: IMapLayer): boolean {
if (!this.map) return false;
return this.map.hasLayer(layer);
@@ -523,7 +523,7 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
this.staticBack = renderable;
this.dynamicBack = null;
this.tileBack = 0;
this.backLastFrame = this.timestamp;
this.backLastFrame = this.getTimestamp();
this.backgroundFrameCount = 1;
this.backgroundDirty = true;
this.checkBackground(this.gl, this.contextData);
@@ -535,7 +535,7 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
this.dynamicBack = array;
this.staticBack = null;
this.tileBack = 0;
this.backLastFrame = this.timestamp;
this.backLastFrame = this.getTimestamp();
this.backgroundFrameCount = array.length;
this.backgroundDirty = true;
this.checkBackground(this.gl, this.contextData);
@@ -546,7 +546,7 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
this.tileBack = tile;
this.staticBack = null;
this.dynamicBack = null;
this.backLastFrame = this.timestamp;
this.backLastFrame = this.getTimestamp();
this.backgroundDirty = true;
this.checkBackground(this.gl, this.contextData);
}
@@ -1738,7 +1738,7 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
DYNAMIC_RESERVE
);
if (this.overlayIndexPool.length < half) {
this.lastExpandTime = this.timestamp;
this.lastExpandTime = this.getTimestamp();
}
return this.overlayIndexPool.pop()!;
}
@@ -1826,48 +1826,47 @@ export class MapRenderer implements IMapRenderer, IMapDataGetter {
//#region 其他方法
getTimestamp(): number {
return this.timestamp;
useExcitation(excitation: IExcitation<number> | null): void {
if (this.exciteController) {
this.exciteController.revoke();
}
if (this.excitation) {
this.excitation.remove(this);
}
this.excitation = excitation;
if (excitation) {
this.exciteController = excitation.add(this);
}
}
tick(timestamp: number) {
this.timestamp = timestamp;
getTimestamp(): number {
return this.excitation?.payload() ?? 0;
}
excited(payload: number) {
// 移动数组
const expandDT = timestamp - this.lastExpandTime;
const expandDT = payload - this.lastExpandTime;
if (expandDT > MOVING_TOLERANCE * 1000) {
this.reduceOverlay();
this.lastExpandTime = timestamp;
this.lastExpandTime = payload;
}
// 背景
const backgroundDT = timestamp - this.backLastFrame;
const backgroundDT = payload - this.backLastFrame;
if (backgroundDT > this.backFrameSpeed) {
this.backgroundFrame++;
this.backgroundFrame %= this.backgroundFrameCount;
this.backLastFrame = timestamp;
this.backLastFrame = payload;
this.needUpdateBackgroundFrame = true;
}
// 地图帧动画
const frameDT = timestamp - this.lastFrameTime;
const frameDT = payload - this.lastFrameTime;
if (frameDT > this.frameSpeed) {
this.lastFrameTime = timestamp;
this.lastFrameTime = payload;
this.frameCounter++;
this.needUpdateFrameCounter = true;
}
this.tickers.forEach(v => void v.fn(timestamp));
}
requestTicker(fn: (timestamp: number) => void): IMapRendererTicker {
const ticker = new MapRendererTicker(this, fn, this.timestamp);
this.tickers.add(ticker);
return ticker;
}
removeTicker(ticker: MapRendererTicker): void {
this.tickers.delete(ticker);
}
updateTransform(): void {
@@ -1923,20 +1922,3 @@ class RendererLayerHook implements Partial<IMapLayerHooks> {
this.renderer.updateLayerBlock(this.layer, block, x, y);
}
}
class MapRendererTicker implements IMapRendererTicker {
constructor(
readonly renderer: MapRenderer,
readonly fn: (timestamp: number) => void,
public timestamp: number
) {}
tick(timestamp: number) {
this.timestamp = timestamp;
this.fn(timestamp);
}
remove(): void {
this.renderer.removeTicker(this);
}
}
+171 -13
View File
@@ -1,5 +1,13 @@
import { IDirtyMark, IDirtyTracker, ITileLocator } from '@motajs/common';
import {
IDirtyMark,
IDirtyTracker,
IHookable,
IHookBase,
ITileLocator
} from '@motajs/common';
import {
Font,
IRenderItem,
ITextureRenderable,
SizedCanvasImageSource,
Transform
@@ -14,7 +22,8 @@ import { IGameMap, IMapLayer } from '@user/data-base';
import {
ExcitationCurve,
ExcitationCurve2D,
IExcitable
IExcitable,
IExcitation
} from '@motajs/animate';
//#region 枚举值
@@ -359,7 +368,7 @@ export interface IMapRenderResult {
readonly area: IMapRenderData;
}
export interface IMapRenderer {
export interface IMapRenderer extends IExcitable<number> {
/** 地图渲染器使用的资源管理器 */
readonly manager: ITextureManager;
/** 画布渲染上下文 */
@@ -395,6 +404,12 @@ export interface IMapRenderer {
/** 图集高度 */
readonly assetHeight: number;
/**
* 设置地图渲染器使用的激励源对象
* @param excitation 激励源对象
*/
useExcitation(excitation: IExcitation<number> | null): void;
/**
* 使用指定图集对象
* @param asset 要使用的缓存对象
@@ -465,15 +480,9 @@ export interface IMapRenderer {
/**
* 设置渲染器使用的地图状态
* @param layerState 地图状态
* @param map 地图状态
*/
setLayerState(layerState: IGameMap): void;
/**
* 根据标识符获取图层
* @param identifier 图层标识符
*/
getLayer(identifier: string): IMapLayer | null;
setGameMap(map: IGameMap | null): void;
/**
* 判断当前渲染器是否包含指定图层对象
@@ -963,6 +972,13 @@ export interface IMapVertexBlock extends IMapVertexData {
*/
getAttachedData<T>(symbol: symbol): T | undefined;
/**
* 获取这个分块上的附着数据,当不存在指定附着数据时,插入指定附着数据
* @param symbol 附着数据的标识符
* @param func 当附着数据不存在时,调用此函数,返回值将作为附着数据
*/
getOrInsertAttachedData<T>(symbol: symbol, func: (sym: symbol) => T): T;
/**
* 删除这个分块上指定的附着数据
* @param symbol 附着数据的标识符
@@ -1203,9 +1219,9 @@ export interface IMapRenderArea {
export interface IMapRenderData {
/** 需要渲染的区域 */
readonly render: IMapRenderArea[];
readonly render: Readonly<IMapRenderArea>[];
/** 需要更新顶点数组的区域 */
readonly dirty: IMapRenderArea[];
readonly dirty: Readonly<IMapRenderArea>[];
/** 需要更新的分块列表 */
readonly blockList: IChunkData<IMapVertexBlock>[];
}
@@ -1225,3 +1241,145 @@ export interface IMapViewportController {
*/
bindTransform(transform: Transform): void;
}
//#region 渲染元素
export interface IMapRenderItem extends IRenderItem {
/** 当前使用的地图渲染器 */
readonly renderer: IMapRenderer | null;
/** 当前正在渲染的地图 */
readonly map: IGameMap | null;
/**
* 设置当前使用的地图渲染器
* @param renderer 地图渲染器
*/
setRenderer(renderer: IMapRenderer | null): void;
/**
* 设置当前要渲染的地图
* @param map 要渲染的地图
*/
setRenderMap(map: IGameMap | null): void;
}
//#endregion
//#region 拓展内容
export interface IMapTextRenderable {
/** 文本内容 */
readonly text: string;
/** 文本字体 */
readonly font: Font;
/** 是否填充 */
readonly fill?: boolean;
/** 是否描边 */
readonly stroke?: boolean;
/** 文本填充样式 */
readonly fillStyle?: CanvasStyle;
/** 文本描边样式 */
readonly strokeStyle?: CanvasStyle;
/** 文本横坐标,注意 {@link IMapTextArea.addTextRenderable} 的相对关系 */
readonly px?: number;
/** 文本纵坐标,注意 {@link IMapTextArea.addTextRenderable} 的相对关系 */
readonly py?: number;
/** 文本横向对齐方式 */
readonly textAlign?: CanvasTextAlign;
/** 文本纵向对齐方式 */
readonly textBaseline?: CanvasTextBaseline;
}
export interface IMapTextArea {
/** 图块在地图上的索引 */
readonly index: number;
/** 图块横坐标 */
readonly mapX: number;
/** 图块纵坐标 */
readonly mapY: number;
/**
* 添加文字可渲染对象。可渲染对象的坐标相对于图块,而非地图。
* @param renderable 可渲染对象
* @returns 添加的可渲染对象的唯一索引标识符
*/
addTextRenderable(renderable: IMapTextRenderable): number;
/**
* 移除指定的文字可渲染对象
* @param renderable 可渲染对象
*/
removeTextRenderable(renderable: IMapTextRenderable): void;
/**
* 根据可渲染对象的索引标识符移除文字的可渲染对象
* @param index 可渲染对象对应的索引标识符
*/
removeTextRenderableByIndex(index: number): void;
/**
* 获取当前的所有文字可渲染对象
*/
getRenderables(): Iterable<IMapTextRenderable>;
/**
* 清除本图块的所有文字可渲染对象
*/
clear(): void;
}
export interface IMapTextManagerHooks extends IHookBase {
/**
* 当内容变化需要更新时触发
*/
onUpdate?(): void;
}
export interface IMapTextManager extends IHookable<IMapTextManagerHooks> {
/**
* 申请指定图块坐标的文字管理对象,如果该点已被申请,则会使用已申请的对象
* @param x 图块横坐标
* @param y 图块纵坐标
*/
requireBlockArea(x: number, y: number): IMapTextArea | null;
/**
* 删除指定图块坐标的文字管理对象
* @param x 图块横坐标
* @param y 图块纵坐标
*/
deleteBlockArea(x: number, y: number): void;
/**
* 根据图块坐标获取已申请的文字管理对象,如果未申请则返回 `null`
* @param x 图块横坐标
* @param y 图块纵坐标
*/
getBlockByLoc(x: number, y: number): IMapTextArea | null;
/**
* 根据索引获取已申请的文字管理对象,如果未申请则返回 `null`
* @param index 管理对象索引
*/
getBlockByIndex(index: number): IMapTextArea | null;
/**
* 获取某一个分块的所有文字管理对象
* @param block 分块对象
*/
iterateBlockData(
block: IChunkData<IMapVertexBlock>
): Iterable<IMapTextArea>;
/**
* 清空所有文字内容
*/
clear(): void;
/**
* 摧毁这个文字管理对象,释放相关资源
*/
destroy(): void;
}
//#endregion
@@ -1549,6 +1549,10 @@ class MapVertexBlock implements IMapVertexBlock {
return this.attachedData.get(symbol) as T;
}
getOrInsertAttachedData<T>(symbol: symbol, func: (sym: symbol) => T): T {
return this.attachedData.getOrInsertComputed(symbol, func) as T;
}
deleteAttachedData(symbol: symbol): void {
this.attachedData.delete(symbol);
}
+20 -3
View File
@@ -1,4 +1,4 @@
import { Transform } from '@motajs/render';
import { ITransformUpdatable, Transform } from '@motajs/render';
import {
IChunkData,
IMapRenderArea,
@@ -10,13 +10,23 @@ import {
} from './types';
import { clamp } from 'lodash-es';
export class MapViewport implements IMapViewportController {
export class MapViewport
implements IMapViewportController, ITransformUpdatable<Transform>
{
transform: Transform = new Transform();
/** 顶点生成器 */
readonly vertex: IMapVertexGenerator;
/** 当前的渲染区域缓存 */
private cache: IMapRenderData | null = null;
constructor(readonly renderer: IMapRenderer) {
this.vertex = renderer.vertex;
this.transform.bind(this);
}
updateTransform(): void {
this.cache = null;
}
private pushBlock(
@@ -52,6 +62,7 @@ export class MapViewport implements IMapViewportController {
}
getRenderArea(): IMapRenderData {
if (this.cache) return this.cache;
const { cellWidth, cellHeight, renderWidth, renderHeight } =
this.renderer;
const {
@@ -130,14 +141,20 @@ export class MapViewport implements IMapViewportController {
this.checkDynamic(updateArea, dynamicStart, dynamicCount);
}
return {
const res: IMapRenderData = {
render: renderArea,
dirty: updateArea,
blockList: blockList
};
this.cache = res;
return res;
}
bindTransform(transform: Transform): void {
this.transform.unbind(this);
this.transform = transform;
this.transform.bind(this);
this.cache = null;
}
}
+1 -13
View File
@@ -99,19 +99,7 @@ export class ClientCore extends CoreState implements IClientCore {
this.renderer.registerElement('icon', () => new Icon());
this.renderer.registerElement('winskin', () => new Winskin());
// TODO: 这个回头要改
this.renderer.registerElement(
'map-render',
() =>
new MapRenderItem(
this.maps.getMap('test')!,
this.mainMapRenderer
)
);
// const { createApp, render, tagManager } = createRendererFor(
// this.renderer
// );
this.renderer.registerElement('map-render', () => new MapRenderItem());
this.loader.addCoreConfig('client', config.clientURL);