refactor: 渲染系统结构,子元素具有一致性排序,所有元素不需要传入构造参数

This commit is contained in:
AncTe committed 2026-11-13 20:19:51 +08:00
1 parent 49ad2779ab
commit 2047bf7e34
23 files changed
+545 -1295

No files matched your search

@@ -1,46 +1,7 @@
import { logger } from '@motajs/common';
import { MapRenderItem } from '../map';
// @ts-expect-error render/renderer 按 D-54 留在实现层,本文件已移入系统层,按 D-67 暂以标注记录标签注册耦合,不反向引用、不解耦
import { mainRenderer, tagManager } from '../renderer';
import { createCache } from './cache';
import { Icon, Winskin } from './misc';
export function createElements() {
createCache();
// ----- 注册标签
mainRenderer.registerElement('icon', Icon);
mainRenderer.registerElement('winskin', Winskin);
mainRenderer.registerElement('map-render', MapRenderItem);
tagManager.registerTag(
'icon',
tagManager.createStandardElement(false, Icon)
);
tagManager.registerTag(
'winskin',
tagManager.createStandardElement(false, Winskin)
);
tagManager.registerTag('map-render', props => {
if (!props) {
logger.error(42, 'layerState');
throw new Error(`Lack of map-render property.`);
}
const { layerState, renderer, extension } = props;
if (!layerState) {
logger.error(42, 'layerState');
throw new Error(`Lack of map-render property.`);
}
if (!renderer) {
logger.error(42, 'renderer');
throw new Error(`Lack of map-render property.`);
}
if (!extension) {
logger.error(42, 'extension');
throw new Error(`Lack of map-render property.`);
}
return new MapRenderItem(layerState, renderer, extension);
});
}
export * from './cache';
+14 -6
View File
@@ -30,12 +30,16 @@ export class Icon extends RenderItem implements IMotaIcon, IExcitable<number> {
/** 委托激励对象 id,用于图标的动画展示 */
private delegation: number = -1;
constructor(cache: boolean = false) {
super(cache);
constructor() {
super();
this.setAntiAliasing(false);
this.setHD(false);
}
protected getDefaultCache(): boolean {
return false;
}
excited(payload: number): void {
if (!this.renderable) return;
const frame = Math.floor(payload / 300);
@@ -116,8 +120,8 @@ export class Icon extends RenderItem implements IMotaIcon, IExcitable<number> {
setAnimateStatus(animate: boolean): void {
this.animate = animate;
if (!animate) this.removeExcitable(this.delegation);
else this.delegation = this.delegateExcitable(this);
// if (!animate) this.removeExcitable(this.delegation);
// else this.delegation = this.delegateExcitable(this);
this.update();
}
@@ -174,11 +178,15 @@ export class Winskin extends RenderItem implements IMotaWinskin {
private pendingImage?: ImageIds;
constructor(enableCache: boolean = false) {
super(enableCache);
constructor() {
super();
this.setAntiAliasing(false);
}
protected getDefaultCache(): boolean {
return true;
}
protected render(canvas: MotaOffscreenCanvas2D): void {
const img = this.image;
if (!img) return;
@@ -1,7 +1,7 @@
import { BaseProps, TagDefine } from '@motajs/render-vue';
import { ERenderItemEvent, SizedCanvasImageSource } from '@motajs/render';
import { IRenderItemBaseHooks, SizedCanvasImageSource } from '@motajs/render';
import { IGameMap } from '@user/data-base';
import { IMapExtensionManager, IMapRenderer } from '../map';
import { IMapRenderer } from '../map';
export interface IconProps extends BaseProps {
/** 图标 id 或数字 */
@@ -24,17 +24,16 @@ export interface WinskinProps extends BaseProps {
}
export interface MapRenderProps extends BaseProps {
layerState: IGameMap;
map: IGameMap;
renderer: IMapRenderer;
extension: IMapExtensionManager;
}
declare module 'vue/jsx-runtime' {
namespace JSX {
export interface IntrinsicElements {
icon: TagDefine<IconProps, ERenderItemEvent>;
winskin: TagDefine<WinskinProps, ERenderItemEvent>;
'map-render': TagDefine<MapRenderProps, ERenderItemEvent>;
icon: TagDefine<IconProps, IRenderItemBaseHooks>;
winskin: TagDefine<WinskinProps, IRenderItemBaseHooks>;
'map-render': TagDefine<MapRenderProps, IRenderItemBaseHooks>;
}
}
}
+1 -6
View File
@@ -1,6 +1,5 @@
import { IExcitation, IExcitationDivider } from '@motajs/animate';
import { IRenderTreeRoot } from '@motajs/render';
import { IRendererUsing } from '@motajs/render-vue';
import {
IUIController,
IUIDefaultPropsBase,
@@ -10,7 +9,7 @@ import { IBGMPlayer, IMotaAudioContext, ISoundPlayer } from '@motajs/audio';
import { ICoreState } from '@user/data-state';
import { ISaveSystem } from './save';
import { ITextureManager } from './material';
import { IMapRenderer, IMapExtensionManager } from './map';
import { IMapRenderer } from './map';
import { IClientHotkey } from './hotkey';
export interface IGameUIPropsBase<
@@ -40,10 +39,6 @@ export interface IClientBase extends ICoreState {
readonly mainMapRenderer: IMapRenderer;
/** 副地图渲染器,主要用于渲染缩略图、浏览地图等内容 */
readonly expandMapRenderer: IMapRenderer;
/** 主地图渲染器的拓展管理对象 */
readonly mainMapExtension: IMapExtensionManager;
/** 渲染器使用对象,供组件内注册渲染激励与事件监听 */
readonly using: IRendererUsing;
/** 主场景的 UI 控制器,管理游戏主场景的 UI 显示 */
readonly sceneController: IUIController<IGameUIPropsBase>;
/** 主界面的 UI 控制器,管理游戏主界面的 UI 显示 */
+22 -13
View File
@@ -27,21 +27,18 @@ import {
SaveSystem,
IGameUIPropsBase,
ClientHotkey,
IClientHotkey
} from '@user/client-base';
import {
IMapRenderer,
IMapExtensionManager,
MapRenderer,
MapExtensionManager
IClientHotkey,
Icon,
Winskin,
MapRenderItem
} from '@user/client-base';
import { IMapRenderer, MapRenderer } from '@user/client-base';
import {
ExcitationDivider,
IExcitation,
IExcitationDivider,
RafExcitation
} from '@motajs/animate';
import { IRendererUsing, RendererUsing } from '@motajs/render-vue';
import { IUIController, UIController } from '@motajs/system';
import { createUIPropsBase } from './ui/func';
@@ -55,10 +52,8 @@ export class ClientCore extends CoreState implements IClientCore {
readonly excitationDivider: IExcitationDivider<number>;
readonly renderer: IRenderTreeRoot;
readonly materials: ITextureManager;
readonly using: IRendererUsing;
readonly mainMapRenderer: IMapRenderer;
readonly expandMapRenderer: IMapRenderer;
readonly mainMapExtension: IMapExtensionManager;
readonly sceneController: IUIController<IGameUIPropsBase>;
readonly mainUIController: IUIController<IGameUIPropsBase>;
readonly hotkey: IClientHotkey;
@@ -94,9 +89,7 @@ export class ClientCore extends CoreState implements IClientCore {
// 使用分频器,用户可以在设置中调整,如果设备性能较差调高分频有助于提高性能表现
excitaion: this.excitationDivider
});
this.using = new RendererUsing(this.renderer);
this.mainMapRenderer = new MapRenderer(this.materials);
this.mainMapExtension = new MapExtensionManager(this.mainMapRenderer);
this.expandMapRenderer = new MapRenderer(this.materials);
this.sceneController = new UIController<IGameUIPropsBase>();
this.mainUIController = new UIController<IGameUIPropsBase>();
@@ -104,6 +97,22 @@ export class ClientCore extends CoreState implements IClientCore {
this.sceneController.setPropsBaseCreator(pbCreator);
this.mainUIController.setPropsBaseCreator(pbCreator);
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.loader.addCoreConfig('client', config.clientURL);
// 渲染端插件注册表
@@ -236,6 +245,6 @@ export class ClientCore extends CoreState implements IClientCore {
// this.mainMapExtension.addHero(this.hero.mover, layer);
// this.mainMapExtension.addDoor(layer);
// }
this.mainMapExtension.addText();
// this.mainMapExtension.addText();
}
}
@@ -7,6 +7,3 @@ export function createRender() {
export * from './fx';
export * from './utils';
export * from './weather';
export * from './renderer';
export * from './scene';
export * from './use';
@@ -1,46 +0,0 @@
import { MotaRenderer } from '@motajs/render';
import {
MAIN_WIDTH,
MAIN_HEIGHT,
DEBUG_VARIATOR,
VARIATOR_DEBUG_SPEED,
DEBUG_DIVIDER,
DIVIDER_DEBUG_DIVIDER
} from '../shared';
import { createRendererFor, RendererUsing } from '@motajs/render-vue';
import {
ExcitationDivider,
ExcitationVariator,
RafExcitation
} from '@motajs/animate';
/** 渲染激励源 */
export const rafExcitation = new RafExcitation();
/** 渲染分频器 */
export const excitationDivider = new ExcitationDivider<number>();
if (DEBUG_VARIATOR) {
const variator = new ExcitationVariator();
variator.bindExcitation(rafExcitation);
variator.setSpeed(VARIATOR_DEBUG_SPEED);
excitationDivider.bindExcitation(variator);
} else {
excitationDivider.bindExcitation(rafExcitation);
}
if (DEBUG_DIVIDER) {
excitationDivider.setDivider(DIVIDER_DEBUG_DIVIDER);
}
export const mainRenderer = new MotaRenderer({
canvas: '#render-main',
width: MAIN_WIDTH,
height: MAIN_HEIGHT,
// 使用分频器,用户可以在设置中调整,如果设备性能较差调高分频有助于提高性能表现
excitaion: excitationDivider
});
export const using = new RendererUsing(mainRenderer);
export const { createApp, render, tagManager } =
createRendererFor(mainRenderer);
@@ -1,4 +0,0 @@
import { UIController } from '@motajs/system';
import { IGameUIPropsBase } from '@user/client-base';
export const sceneController = new UIController<IGameUIPropsBase>();
@@ -1,337 +0,0 @@
import {
ExcitationCurve,
excited,
IAnimatable,
IExcitableController,
ITransition,
Transition
} from '@motajs/animate';
import { logger } from '@motajs/common';
import { IRenderItem, IRenderTreeRoot } from '@motajs/render';
import {
ComponentInternalInstance,
getCurrentInstance,
onMounted,
onUnmounted,
ref,
Ref
} from 'vue';
export const enum Orientation {
/** 横屏 */
Landscape,
/** 竖屏 */
Portrait
}
export type OrientationHook = (
orientation: Orientation,
width: number,
height: number
) => void;
let nowOrientation = Orientation.Landscape;
const orientationHooks = new Set<OrientationHook>();
function checkOrientation() {
const before = nowOrientation;
// 只要宽度大于高度,那么就视为横屏
if (window.innerWidth >= window.innerHeight) {
nowOrientation = Orientation.Landscape;
} else {
nowOrientation = Orientation.Portrait;
}
if (nowOrientation === before) return;
orientationHooks.forEach(v => {
v(nowOrientation, window.innerWidth, window.innerHeight);
});
}
window.addEventListener('resize', checkOrientation);
/**
* 当屏幕方向改变时执行函数
* @param hook 当屏幕方向改变时执行的函数
*/
export function onOrientationChange(hook: OrientationHook) {
onMounted(() => {
orientationHooks.add(hook);
hook(nowOrientation, window.innerWidth, window.innerHeight);
});
onUnmounted(() => {
orientationHooks.delete(hook);
});
}
export interface ITransitionedController<T> {
readonly ref: Ref<T>;
readonly value: T;
/**
* 执行动画,使当前值缓慢变化至目标值
* @param value 目标值
* @param time 动画时长
*/
set(value: T, time?: number): void;
/**
* 设置动画的速率曲线
* @param timing 速率曲线
*/
mode(timing: ExcitationCurve): void;
/**
* 设置动画的动画时长
* @param time 动画时长
*/
setTime(time: number): void;
}
class RenderTransition implements ITransitionedController<number> {
public readonly ref: Ref<number>;
set value(v: number) {
this.set(v);
}
get value() {
return this.ref.value;
}
constructor(
value: number,
public readonly transition: ITransition,
public time: number,
public curve: ExcitationCurve
) {
this.ref = ref(value);
}
set(value: number, time: number = this.time): void {
this.transition.curve(this.curve).transition(this.ref).to(value, time);
}
mode(timing: ExcitationCurve): void {
this.curve = timing;
}
setTime(time: number): void {
this.time = time;
}
}
type ColorRGBA = [number, number, number, number];
class RenderColorTransition implements ITransitionedController<string> {
private static key: number = 0;
private readonly keyR: string = `$colorR${RenderColorTransition.key++}`;
private readonly keyG: string = `$colorG${RenderColorTransition.key++}`;
private readonly keyB: string = `$colorB${RenderColorTransition.key++}`;
private readonly keyA: string = `$colorA${RenderColorTransition.key++}`;
private readonly rValue: IAnimatable;
private readonly gValue: IAnimatable;
private readonly bValue: IAnimatable;
private readonly aValue: IAnimatable;
private readonly controller: IExcitableController<number> | null = null;
public readonly ref: Ref<string>;
set value(v: string) {
this.set(v);
}
get value() {
return this.encodeColor();
}
constructor(
value: string,
public readonly transition: ITransition,
public time: number,
public curve: ExcitationCurve
) {
this.ref = ref(value);
const [r, g, b, a] = this.decodeColor(value);
this.rValue = { value: r };
this.gValue = { value: g };
this.bValue = { value: b };
this.aValue = { value: a };
if (!transition.excitation) {
logger.warn(94, 'transitionedColor');
} else {
this.controller = transition.excitation.add(
excited(() => {
this.ref.value = this.encodeColor();
})
);
}
}
set(value: string, time: number = this.time): void {
this.transitionColor(this.decodeColor(value), time);
}
mode(timing: ExcitationCurve): void {
this.curve = timing;
}
setTime(time: number): void {
this.time = time;
}
private transitionColor([r, g, b, a]: ColorRGBA, time: number) {
this.transition
.curve(this.curve)
.transition(this.rValue)
.to(r, time)
.transition(this.gValue)
.to(g, time)
.transition(this.bValue)
.to(b, time)
.transition(this.aValue)
.to(a, time);
}
private decodeColor(color: string): ColorRGBA {
if (color.startsWith('#')) {
return this.decodeHash(color);
} else if (color.startsWith('rgba')) {
return this.decodeRGBA(color);
} else if (color.startsWith('rgb')) {
return this.decodeRGB(color);
}
return [0, 0, 0, 1];
}
private decodeHash(color: string): ColorRGBA {
switch (color.length) {
case 4:
return [
Number(`0x${color.slice(1, 2).repeat(2)}`),
Number(`0x${color.slice(2, 3).repeat(2)}`),
Number(`0x${color.slice(3, 4).repeat(2)}`),
1
];
case 5:
return [
Number(`0x${color.slice(1, 2).repeat(2)}`),
Number(`0x${color.slice(2, 3).repeat(2)}`),
Number(`0x${color.slice(3, 4).repeat(2)}`),
Number(`0x${color.slice(4, 5).repeat(2)}`)
];
case 7:
return [
Number(`0x${color.slice(1, 3)}`),
Number(`0x${color.slice(3, 5)}`),
Number(`0x${color.slice(5, 7)}`),
1
];
case 9:
return [
Number(`0x${color.slice(1, 3)}`),
Number(`0x${color.slice(3, 5)}`),
Number(`0x${color.slice(5, 7)}`),
Number(`0x${color.slice(7, 9)}`)
];
}
return [0, 0, 0, 0];
}
private decodeRGBA(color: string): ColorRGBA {
const data = color.slice(color.indexOf('(') + 1, color.indexOf(')'));
const [r, g, b, a] = data.split(',');
return [Number(r), Number(g), Number(b), Number(a)];
}
private decodeRGB(color: string): ColorRGBA {
const data = color.slice(color.indexOf('(') + 1, color.indexOf(')'));
const [r, g, b] = data.split(',');
return [Number(r), Number(g), Number(b), 1];
}
private encodeColor() {
const r = this.rValue.value;
const g = this.gValue.value;
const b = this.bValue.value;
const a = this.aValue.value;
return `rgba(${r},${g},${b},${a})`;
}
}
const transitionMap = new Map<ComponentInternalInstance, ITransition>();
function checkTransition() {
const instance = getCurrentInstance();
if (!instance) return null;
const root = instance.root;
if (!root) return null;
const el = root.vnode.el as IRenderItem;
const renderer = el.parent as IRenderTreeRoot;
if (!renderer) return null;
if (instance.isUnmounted) {
const tran = transitionMap.get(instance);
tran?.destroy();
transitionMap.delete(instance);
return null;
}
if (!transitionMap.has(instance)) {
const tran = new Transition();
tran.bindExcitation(renderer.excitation);
transitionMap.set(instance, tran);
onUnmounted(() => {
transitionMap.delete(instance);
tran.destroy();
});
}
const tran = transitionMap.get(instance);
if (!tran) return null;
return tran;
}
/**
* 创建一个渐变数值,当数值发生变化时会缓慢变化值目标值而非突变,只可以用于组件内,不可用于组件外
* ```tsx
* const value = transitioned(10, 300, linear()); // 创建渐变,初始值为 10,渐变时长 300ms,线性变化
* value.set(100); // 渐变至 100
*
* // 直接在元素上使用
* <text text={value.ref.value} />
* ```
* @param value 初始值
* @param time 渐变时长
* @param curve 渐变的速率曲线
*/
export function transitioned(
value: number,
time: number,
curve: ExcitationCurve
): ITransitionedController<number> | null {
const tran = checkTransition();
if (!tran) return null;
return new RenderTransition(value, tran, time, curve);
}
/**
* 创建一个渐变颜色,当颜色发生变化时会缓慢变化值目标值而非突变,自动判断颜色字符串类型,只可用于组件内,不可用于组件外
* ```tsx
* // 创建渐变,初始值为 '#fff'(白色),渐变时长 300ms,线性变化
* const color = transitionedColor('#fff', 300, linear());
* color.set('rgba(129, 30, 40, 0.7)'); // 渐变至这个颜色
*
* // 直接在元素上使用
* <text text='文本' fillStyle={color.ref.value} />
* ```
* @param color 颜色的初始值
* @param time 渐变时长
* @param curve 渐变的速率曲线
*/
export function transitionedColor(
color: string,
time: number,
curve: ExcitationCurve
): ITransitionedController<string> | null {
const tran = checkTransition();
if (!tran) return null;
return new RenderColorTransition(color, tran, time, curve);
}
-1
View File
@@ -1,6 +1,5 @@
export * from './elements';
export * from './props';
export * from './renderer';
export * from './tag';
export * from './types';
export * from './use';
+21 -48
View File
@@ -6,62 +6,39 @@ import {
IRenderItem,
IRenderTreeRoot
} from '@motajs/render';
import {
ComponentInternalInstance,
CreateAppFunction,
createRenderer,
ElementNamespace,
RootRenderFunction,
VNodeProps
} from 'vue';
import { IRenderTagManager } from './types';
import { RenderTagManager } from './tag';
export interface RendererData {
render: RootRenderFunction<IRenderItem>;
createApp: CreateAppFunction<IRenderItem>;
tagManager: IRenderTagManager;
}
import { createRenderer } from 'vue';
export function createRendererFor(renderer: IRenderTreeRoot) {
const tagManager = new RenderTagManager(renderer);
const { createApp, render } = createRenderer<IRenderItem, IRenderItem>({
return createRenderer<IRenderItem, IRenderItem>({
patchProp: function (
el: RenderItem,
key: string,
prevValue: any,
nextValue: any,
namespace?: ElementNamespace,
parentComponent?: ComponentInternalInstance | null
nextValue: any
): void {
el.patchProp(key, prevValue, nextValue, namespace, parentComponent);
el.patchProp(key, prevValue, nextValue);
},
insert: function (
el: IRenderItem,
parent: RenderItem,
_anchor?: IRenderItem | null
anchor?: IRenderItem | null
): void {
parent.appendChild(el);
if (anchor) {
parent.appendChild(el, anchor);
} else {
parent.appendChild(el);
}
},
remove: function (el: IRenderItem): void {
el.destroy();
el.remove();
},
createElement: function (
type: string,
_namespace?: ElementNamespace,
_isCustomizedBuiltIn?: string,
vnodeProps?: (VNodeProps & { [key: string]: any }) | null
): IRenderItem {
const tag = tagManager.getTag(type);
if (!tag) {
logger.error(20, type);
throw new Error(`Cannot create element '${type}'`);
}
return tag.onCreate(vnodeProps);
createElement: function (type: string): IRenderItem {
const el = renderer.createElement(type) as RenderItem;
if (!el) return renderer.createElement('container');
return el;
},
createText: function (text: string): IRenderItem {
@@ -70,11 +47,11 @@ export function createRendererFor(renderer: IRenderTreeRoot) {
} else {
logger.warn(38);
}
return new Text(text);
return new Text();
},
createComment: function (text: string): IRenderItem {
return renderer.createElement('comment', text);
createComment: function (): IRenderItem {
return renderer.createElement('comment');
},
setText: function (node: IRenderItem, text: string): void {
@@ -94,21 +71,17 @@ export function createRendererFor(renderer: IRenderTreeRoot) {
},
parentNode: function (node: IRenderItem): IRenderItem | null {
return node.parent ?? null;
return node.parent;
},
nextSibling: function (node: IRenderItem): IRenderItem | null {
if (!node) return null;
if (!node.parent) {
return null;
} else {
const parent = node.parent;
const list = [...parent.children];
const list = node.parent.children;
const index = list.indexOf(node);
return list[index] ?? null;
return list[index + 1] ?? null;
}
}
});
return { tagManager, createApp, render };
}
-120
View File
@@ -1,120 +0,0 @@
import {
Animated,
BezierCurve,
Circle,
Comment,
Container,
CustomContainer,
CustomRenderItem,
Ellipse,
Image,
IRenderItem,
IRenderTreeRoot,
Line,
Path,
QuadraticCurve,
Rect,
RectR,
Shader,
Text
} from '@motajs/render';
import { IRenderTagInfo, IRenderTagManager, TagCreateFunction } from './types';
import { logger } from '@motajs/common';
export class RenderTagManager implements IRenderTagManager {
/** 标签注册映射 */
private readonly tagRegistry: Map<string, IRenderTagInfo> = new Map();
constructor(readonly renderer: IRenderTreeRoot) {
const emptyImage = document.createElement('canvas');
emptyImage.width = 1;
emptyImage.height = 1;
this.resgiterIntrinsicTags();
}
/**
* 注册所有的内置标签
*/
private resgiterIntrinsicTags() {
this.registerTag(
'container',
this.createStandardElement(true, Container)
);
this.registerTag(
'custom',
this.createStandardElement(true, CustomRenderItem)
);
this.registerTag('text', props => {
if (!props) return this.renderer.createElement(Text, '', false);
const { text = '', nocache = true, cache = false } = props;
return this.renderer.createElement(Text, text, cache && !nocache);
});
this.registerTag('image', this.createStandardElement(false, Image));
this.registerTag(
'animated',
this.createStandardElement(false, Animated)
);
this.registerTag('shader', this.createNoParamElement(Shader));
this.registerTag('comment', props => {
if (!props) return this.renderer.createElement(Comment);
else return this.renderer.createElement(Comment, props.text ?? '');
});
this.registerTag(
'template',
this.createStandardElement(false, Container)
);
this.registerTag(
'container-custom',
this.createStandardElement(true, CustomContainer)
);
this.registerTag('g-rect', this.createStandardElement(false, Rect));
this.registerTag('g-circle', this.createStandardElement(false, Circle));
this.registerTag(
'g-ellipse',
this.createStandardElement(false, Ellipse)
);
this.registerTag('g-line', this.createStandardElement(false, Line));
this.registerTag(
'g-bezier',
this.createStandardElement(false, BezierCurve)
);
this.registerTag(
'g-quad',
this.createStandardElement(false, QuadraticCurve)
);
this.registerTag('g-path', this.createStandardElement(false, Path));
this.registerTag('g-rectr', this.createStandardElement(false, RectR));
}
registerTag(tag: string, onCreate: TagCreateFunction): void {
if (this.tagRegistry.has(tag)) {
logger.error(14, tag);
return;
}
const info: IRenderTagInfo = { onCreate };
this.tagRegistry.set(tag, info);
}
getTag(tag: string): IRenderTagInfo | null {
return this.tagRegistry.get(tag) ?? null;
}
createStandardElement(
cache: boolean,
Cons: new (enableCache?: boolean) => IRenderItem
): TagCreateFunction {
const enable = cache;
return props => {
if (!props) {
return this.renderer.createElement(Cons, enable);
}
const { nocache = !enable, cache = enable } = props;
return this.renderer.createElement(Cons, cache && !nocache);
};
}
createNoParamElement(Cons: new () => IRenderItem): TagCreateFunction {
return () => this.renderer.createElement(Cons);
}
}
+2 -53
View File
@@ -1,65 +1,14 @@
import {
IRenderItem,
IRenderItemBaseHooks,
IRenderTreeRoot
} from '@motajs/render';
import { Ref, VNodeProps } from 'vue';
import { IRenderItemBaseHooks } from '@motajs/render';
import { Ref } from 'vue';
import { BaseProps } from './props';
import { TagDefine } from './elements';
import { ExcitationCurve } from '@motajs/animate';
//#region 标签管理
export type TagCreateFunction = (
props?: (VNodeProps & { [key: string]: any }) | null
) => IRenderItem;
export interface IRenderTagInfo {
/** 标签创建函数 */
readonly onCreate: TagCreateFunction;
}
export interface IRenderTagManager {
/** 标签管理器对应的渲染根元素 */
readonly renderer: IRenderTreeRoot;
/**
* 注册自定义标签
* @param tag 标签名称
* @param onCreate 创建标签的函数
*/
registerTag(tag: string, onCreate: TagCreateFunction): void;
/**
* 获取指定标签的信息
* @param tag 标签名称
*/
getTag(tag: string): IRenderTagInfo | null;
/**
* 创建常规元素的创建函数
* @param cache 创建时默认是否启用缓存
* @param Cons 渲染元素构造器
*/
createStandardElement(
cache: boolean,
Cons: new (enableCache?: boolean) => IRenderItem
): TagCreateFunction;
/**
* 创建无创建参数的元素创建函数
* @param Cons 渲染元素构造器
*/
createNoParamElement(Cons: new () => IRenderItem): TagCreateFunction;
}
export type DefaultProps<
P extends BaseProps = BaseProps,
H extends IRenderItemBaseHooks = IRenderItemBaseHooks
> = TagDefine<P, H>;
//#endregion
//#region 功能接口
export interface ITransitionedController<T> {
+7 -1
View File
@@ -36,7 +36,13 @@ export function useRendererRoot(): IRenderTreeRoot | null {
if (!instance) return null;
// 尝试从几个路径获取根元素
const root = instance.root.vnode.el;
if (root instanceof MotaRenderer) return root;
if (root instanceof RenderItem) {
if (root.parent instanceof MotaRenderer) {
return root.parent;
} else {
return null;
}
}
const currEl = instance.proxy?.$el;
if (currEl instanceof RenderItem) return currEl.root;
const appEl = instance.appContext.app._container;
+11 -73
View File
@@ -2,65 +2,24 @@ import { MotaOffscreenCanvas2D } from './canvas2d';
import { ActionType, EventProgress, ActionEventMap } from './event';
import { RenderItem } from './item';
import { Transform } from './transform';
import {
CustomContainerPropagateFn,
CustomContainerRenderFn,
IRenderItem
} from './types';
import { CustomContainerPropagateFn, CustomContainerRenderFn } from './types';
export class Container extends RenderItem {
sortedChildren: RenderItem[] = [];
protected needSort: boolean = false;
protected getDefaultCache(): boolean {
return true;
}
protected render(
canvas: MotaOffscreenCanvas2D,
_transform: Transform
): void {
if (this.needSort) {
this.sortChildren();
this.needSort = false;
}
this.sortedChildren.forEach(v => {
const sorted = this.getSortedChildren() as RenderItem[];
sorted.forEach(v => {
if (v.hidden) return;
v.renderContent(canvas);
});
}
onResize(scale: number): void {
this.children.forEach(v => v.onResize(scale));
super.onResize(scale);
}
requestSort() {
this.needSort = true;
}
/**
* 添加子元素到这个容器上,然后在下一个tick执行更新
* @param children 要添加的子元素
*/
appendChild(...children: IRenderItem[]) {
children.forEach(v => {
v.appendTo(this);
});
this.requestSort();
this.update();
}
removeChild(...child: IRenderItem[]): void {
let changed = false;
child.forEach(v => {
if (v.parent !== this) return;
const success = v.remove();
if (success) {
changed = true;
}
});
if (changed) this.requestSort();
this.update();
}
appendTo(parent: RenderItem): void {
super.appendTo(parent);
if (this.root) {
@@ -71,35 +30,17 @@ export class Container extends RenderItem {
}
}
/**
* 遍历这个元素中的每个子元素,并执行传入的函数
* @param fn 对每个元素执行的函数
*/
protected forEachChild(fn: (ele: RenderItem) => void) {
const stack: RenderItem[] = [this];
while (stack.length > 0) {
const ele = stack.pop()!;
stack.push(...ele.children);
fn(ele);
}
}
protected sortChildren() {
this.sortedChildren = [...this.children]
.filter(v => !v.isComment)
.sort((a, b) => a.zIndex - b.zIndex);
}
protected propagateEvent<T extends ActionType>(
type: T,
progress: EventProgress,
event: ActionEventMap[T]
): void {
const len = this.sortedChildren.length;
const sorted = this.getSortedChildren() as RenderItem[];
const len = sorted.length;
if (progress === EventProgress.Capture) {
let success = false;
for (let i = len - 1; i >= 0; i--) {
const child = this.sortedChildren[i];
const child = sorted[i];
if (child.hidden) continue;
if (child.captureEvent(type, event)) {
success = true;
@@ -131,14 +72,11 @@ export class CustomContainer extends Container {
canvas: MotaOffscreenCanvas2D,
transform: Transform
): void {
if (this.needSort) {
this.sortChildren();
this.needSort = false;
}
if (!this.renderFn) {
super.render(canvas, transform);
} else {
this.renderFn(canvas, this.sortedChildren, transform);
const sorted = this.getSortedChildren() as RenderItem[];
this.renderFn(canvas, sorted, transform);
}
}
+6 -10
View File
@@ -2,17 +2,13 @@ import { RenderItem } from './item';
import { MotaOffscreenCanvas2D } from './canvas2d';
import { CustomRenderFunction } from './types';
export class CustomRenderItem extends RenderItem {
renderFn: CustomRenderFunction;
const EMPTY = () => {};
/**
* 创建一个精灵,可以自由在上面渲染内容
* @param type 渲染模式,absolute表示绝对位置,不会跟随自身的Transform改变
* @param cache 是否启用缓存机制
*/
constructor(cache: boolean = true) {
super(cache);
this.renderFn = () => {};
export class CustomRenderItem extends RenderItem {
renderFn: CustomRenderFunction = EMPTY;
protected getDefaultCache(): boolean {
return true;
}
protected render(canvas: MotaOffscreenCanvas2D): void {
+1 -1
View File
@@ -115,7 +115,7 @@ export abstract class GL2 extends RenderItem {
protected framebufferMap: Map<string, WebGLFramebuffer> = new Map();
constructor() {
super(false);
super();
this.canvas = document.createElement('canvas');
const gl = this.canvas.getContext('webgl2')!;
+19 -7
View File
@@ -45,24 +45,31 @@ export abstract class GraphicItemBase
miterLimit: number = 10;
fillRule: CanvasFillRule = 'nonzero';
/** props 是否启用了 fill */
private propFill: boolean = true;
/** props 是否启用了 stroke */
private propStroke: boolean = false;
/** props 是否启用了 strokeAndFill */
private strokeAndFill: boolean = false;
/** props 是否设置过 fill */
private propFillSet: boolean = false;
/** 交互是否仅在描边上判定 */
private actionStroke: boolean = false;
/** 当前的缓存 Path2D */
private cachePath?: Path2D;
/** 路径缓存是否为脏 */
protected pathDirty: boolean = true;
constructor(enableCache: boolean = false) {
super(enableCache);
}
/**
* 获取这个元素的绘制路径
*/
abstract getPath(): Path2D;
protected getDefaultCache(): boolean {
return false;
}
protected render(
canvas: MotaOffscreenCanvas2D,
_transform: Transform
@@ -108,13 +115,18 @@ export abstract class GraphicItemBase
ctx.lineCap = this.lineCap;
ctx.lineJoin = this.lineJoin;
ctx.setLineDash(this.lineDash);
if (this.actionStroke) {
return ctx.isPointInStroke(path, fixX, fixY);
}
switch (this.mode) {
case GraphicMode.Fill:
return ctx.isPointInPath(path, fixX, fixY, this.fillRule);
case GraphicMode.Stroke:
if (this.actionStroke) {
return ctx.isPointInStroke(path, fixX, fixY);
} else {
return (
ctx.isPointInPath(path, fixX, fixY, this.fillRule) ||
ctx.isPointInStroke(path, fixX, fixY)
);
}
case GraphicMode.FillAndStroke:
case GraphicMode.StrokeAndFill:
return (
+150 -247
View File
@@ -1,13 +1,12 @@
import { isEqual, isNil } from 'lodash-es';
import { MotaOffscreenCanvas2D } from './canvas2d';
import { ITransformUpdatable, Transform } from './transform';
import { Transform } from './transform';
import {
Hookable,
HookController,
IHookController,
logger
} from '@motajs/common';
import { ElementNamespace, ComponentInternalInstance } from 'vue';
import {
ActionEventMap,
ActionType,
@@ -19,7 +18,6 @@ import {
} from './event';
import { vec3 } from 'gl-matrix';
import {
ExcitableDelegation,
IRenderItem,
IRenderItemBaseHooks,
IRenderTreeRoot,
@@ -31,15 +29,9 @@ interface RenderItemCanvasData {
autoScale: boolean;
}
interface ToDelegateExcitables {
readonly excitable: ExcitableDelegation;
readonly time?: number;
readonly end?: () => void;
}
export abstract class RenderItem
extends Hookable<IRenderItemBaseHooks>
implements IRenderItem, ITransformUpdatable<Transform>
implements IRenderItem
{
//#region 元素属性
@@ -103,18 +95,22 @@ export abstract class RenderItem
/** 当前元素是否连接至了根元素 */
connected: boolean = false;
/** 该渲染元素的子元素 */
children: Set<RenderItem> = new Set();
children: RenderItem[] = [];
/** 排序后的子元素列表 */
private sortedChildren: RenderItem[] = [];
/** 当前是否需要进行排序 */
private needSort: boolean = false;
//#endregion
//#region 渲染配置与缓存
/** 渲染缓存信息 */
protected readonly cache: MotaOffscreenCanvas2D | null;
protected cache: MotaOffscreenCanvas2D | null = null;
/** 是否需要更新缓存 */
protected cacheDirty: boolean = false;
/** 是否启用缓存机制 */
readonly enableCache: boolean = true;
enableCache: boolean = false;
/** 这个渲染元素使用到的所有画布 */
protected readonly canvases: Set<MotaOffscreenCanvas2D> = new Set();
/** 这个渲染元素每个画布的配置信息 */
@@ -123,6 +119,11 @@ export abstract class RenderItem
RenderItemCanvasData
> = new WeakMap();
/** 当前传入的 cache props */
private cacheProp: boolean = false;
/** 当前传入的 nocache props */
private nocacheProp: boolean = false;
//#endregion
//#region 交互事件
@@ -152,33 +153,9 @@ export abstract class RenderItem
//#endregion
//#region 其他
/** 存储当前渲染对象的所有委托激励对象,用于在被销毁时删除 */
private delegationsIdMap: Map<number, ExcitableDelegation> = new Map();
/** 委托激励对象到其 id 的映射 */
private delegationsMap: Map<ExcitableDelegation, number> = new Map();
/** 当未绑定根元素时临时存储帧前函数 */
private beforeFrames: Set<() => void> = new Set();
/** 当未绑定根元素时临时存储帧后函数 */
private afterFrames: Set<() => void> = new Set();
/** 当未绑定根元素时临时存储委托可激励对象 */
private toDelegate: Set<ToDelegateExcitables> = new Set();
//#endregion
constructor(enableCache: boolean = true) {
constructor() {
super();
this.enableCache = enableCache;
this.position = RenderPosition.Absolute;
this.transform.bind(this);
if (enableCache) {
this.cache = this.requireCanvas();
this.cache.size(this.width, this.height);
} else {
this.cache = null;
}
this.eventNames
.add('onClick')
.add('onClickCapture')
@@ -196,6 +173,10 @@ export abstract class RenderItem
.add('onTransform');
this.addHook(this.getDefaultHook());
// 设置默认缓存
const cache = this.getDefaultCache();
this.setCacheEnabled(cache);
}
/**
@@ -212,7 +193,6 @@ export abstract class RenderItem
}
setID(id: string): void {
this.checkRoot();
const prev = this.id;
this.id = id;
this.root?.modifyId(this, prev, id);
@@ -294,7 +274,7 @@ export abstract class RenderItem
* 刷新所有子元素
*/
refreshAllChildren() {
if (this.children.size > 0) {
if (this.children.length > 0) {
const stack: RenderItem[] = [this];
while (stack.length > 0) {
const item = stack.pop();
@@ -320,6 +300,8 @@ export abstract class RenderItem
} else {
canvas.setScale(1);
}
canvas.setAntiAliasing(this.antiAliasing);
canvas.setHD(this.highResolution);
this.canvases.add(canvas);
this.canvasMap.set(canvas, { autoScale });
return canvas;
@@ -343,6 +325,7 @@ export abstract class RenderItem
v.setScale(scale);
}
});
this.children.forEach(v => v.onResize(scale));
this.update();
}
@@ -351,8 +334,24 @@ export abstract class RenderItem
//#region 渲染设置
/**
* 修改这个对象的大小
* 获取默认是否启用缓存
*/
protected abstract getDefaultCache(): boolean;
setCacheEnabled(enabled: boolean): void {
if (enabled === this.enableCache) return;
if (enabled) {
const canvas = this.requireCanvas();
this.enableCache = true;
this.cache = canvas;
} else {
this.enableCache = false;
this.cache?.clear();
this.cache = null;
}
this.update();
}
size(width: number, height: number): void {
if (width === this.width && height === this.height) return;
this.width = width;
@@ -364,20 +363,11 @@ export abstract class RenderItem
this.forEachHook(hook => hook.onResize?.(width, height));
}
/**
* 设置这个元素的位置,等效于`transform.setTranslate(x, y)`
* @param x 横坐标
* @param y 纵坐标
*/
pos(x: number, y: number) {
// 这个函数会调用 update,因此不再手动调用 update
this.transform.setTranslate(x, y);
}
/**
* 设置元素变换矩阵
* @param transform 变换矩阵对象
*/
setTransform(transform: Transform): void {
this.transform.unbind(this);
this.transform = transform;
@@ -391,30 +381,18 @@ export abstract class RenderItem
this.update();
}
/**
* 设置本元素的滤镜
* @param filter 滤镜
*/
setFilter(filter: string) {
this.filter = filter;
// 设置滤镜时,不需要更新自身的缓存,直接调用父元素的更新即可
this.parent?.update();
}
/**
* 设置本元素渲染时的混合方式
* @param composite 混合方式
*/
setComposite(composite: GlobalCompositeOperation) {
this.composite = composite;
// 设置混合模式时,不需要更新自身的缓存,直接调用父元素的更新即可
this.parent?.update();
}
/**
* 设置本元素的不透明度
* @param alpha 不透明度
*/
setAlpha(alpha: number) {
this.alpha = alpha;
// 设置不透明度时,不需要更新自身的缓存,直接调用父元素的更新即可
@@ -449,26 +427,16 @@ export abstract class RenderItem
this.parent?.update();
}
/**
* 设置光标样式
* @param cursor 光标样式
*/
setCursor(cursor: string): void {
this.cursor = cursor;
}
/**
* 隐藏这个元素
*/
hide() {
if (this.hidden) return;
this.update();
this.hidden = true;
}
/**
* 显示这个元素
*/
show() {
if (!this.hidden) return;
this.hidden = false;
@@ -479,9 +447,6 @@ export abstract class RenderItem
//#region 功能方法
/**
* 获取当前元素的绝对位置(不建议使用,因为应当很少会有获取绝对位置的需求)
*/
getAbsolutePosition(x: number = 0, y: number = 0): [number, number] {
const [px, py] = this.selfTransform
? [x, y]
@@ -493,9 +458,6 @@ export abstract class RenderItem
}
}
/**
* 获取到可以包围这个元素的最小矩形,相对于父元素
*/
getBoundingRect(): DOMRectReadOnly {
if (this.selfTransform) {
const left = -this.anchorX * this.width;
@@ -530,7 +492,7 @@ export abstract class RenderItem
updateTransform(transform: Transform) {
// 更新变换矩阵时,只需要更新有 `selfTransform` 的子元素,其他的不需要更新
let childUpdated = false;
if (this.children.size > 0) {
if (this.children.length > 0) {
const stack: RenderItem[] = [this];
while (stack.length > 0) {
const item = stack.pop();
@@ -555,196 +517,125 @@ export abstract class RenderItem
this.forEachHook(hook => hook.onTransform?.(transform));
}
requestBeforeFrame(fn: () => void): void {
if (!this.root) {
this.beforeFrames.add(fn);
} else {
this.root?.requestBeforeFrame(fn);
}
}
requestAfterFrame(fn: () => void): void {
if (!this.root) {
this.afterFrames.add(fn);
} else {
this.root?.requestAfterFrame(fn);
}
}
delegateExcitable(
excitable: ExcitableDelegation,
time?: number,
end?: () => void
): number {
if (!this.root) {
this.toDelegate.add({ excitable, time, end });
return -1;
} else {
const index = this.root.delegateExcitable(excitable, time, end);
this.delegationsIdMap.set(index, excitable);
this.delegationsMap.set(excitable, index);
return index;
}
}
removeExcitable(id: number, callEnd: boolean = true): boolean {
if (!this.root) return false;
else {
const excitable = this.delegationsIdMap.get(id);
if (excitable !== void 0) this.delegationsMap.delete(excitable);
this.delegationsIdMap.delete(id);
return this.root.removeExcitable(id, callEnd);
}
}
removeExcitableObject(
excitable: ExcitableDelegation,
callEnd?: boolean
): boolean {
if (!this.root) return false;
else {
const num = this.delegationsMap.get(excitable);
if (num !== void 0) this.delegationsIdMap.delete(num);
this.delegationsMap.delete(excitable);
return this.root.removeExcitableObject(excitable, callEnd);
}
}
hasExcitable(id: number): boolean {
if (!this.root) return false;
else return this.root?.hasExcitable(id);
}
//#endregion
//#region 父子关系
setRoot(item: IRenderTreeRoot | null) {
this.root?.disconnect(this);
if (item === this.root) return;
const before = this.root;
before?.disconnect(this);
this.root = item;
if (item) {
item.connect(item);
this.connected = true;
this.onConnected(item);
} else {
this.connected = false;
}
if (item) {
this.beforeFrames.forEach(v => item.requestBeforeFrame(v));
this.afterFrames.forEach(v => item.requestAfterFrame(v));
this.toDelegate.forEach(obj => {
const { excitable, time, end } = obj;
const id = item.delegateExcitable(excitable, time, end);
this.delegationsMap.set(excitable, id);
this.delegationsIdMap.set(id, excitable);
});
this.beforeFrames.clear();
this.afterFrames.clear();
this.toDelegate.clear();
}
}
checkRoot() {
if (this.root) return;
if (this.isRoot) return;
let ele: IRenderItem = this;
while (!ele.isRoot) {
if (ele.root) {
ele = ele.root;
break;
}
if (!ele.parent) {
return;
} else {
ele = ele.parent;
if (before) {
this.onDisconnected(before);
}
}
this.setRoot(ele as IRenderTreeRoot);
}
/**
* 将这个渲染元素添加到其他父元素上
* @param parent 父元素
*/
appendTo(parent: IRenderItem) {
this.remove();
const p = parent as RenderItem;
parent.children.add(this);
this.parent = p;
p.requestSort();
this.update();
this.checkRoot();
this.transform.bind(this);
this.onResize(parent.scale);
this.forEachHook(hook => hook.onResize?.(this.width, this.height));
appendTo(parent: IRenderItem, anchor?: IRenderItem) {
parent.appendChild(this, anchor);
}
/**
* 从渲染树中移除这个节点
* @returns 是否移除成功
*/
remove(): boolean {
if (!this.parent) return false;
this.delegationsIdMap.forEach(v =>
this.root?.removeExcitableObject(v, false)
);
this.delegationsMap.forEach(v => {
this.root?.removeExcitable(v, false);
});
this.delegationsIdMap.clear();
this.delegationsMap.clear();
this.toDelegate.clear();
this.beforeFrames.clear();
this.afterFrames.clear();
const parent = this.parent;
const success = parent.children.delete(this);
this.parent = null;
parent.requestSort();
parent.update();
this.transform.unbind(this);
if (!success) return false;
this.setRoot(null);
if (this.parent) {
return this.parent.removeChild(this);
} else {
return false;
}
}
appendChild(child: IRenderItem, anchor?: IRenderItem): void {
const el = child as RenderItem;
// TODO: 可能的性能优化点:如果元素已经是当前元素的子元素,那么直接转移过去,不再先移除再添加,收益不好说
el.remove();
if (anchor) {
const index = this.children.indexOf(anchor as RenderItem);
if (index === -1) {
this.children.push(el);
} else {
this.children.splice(index, 0, el);
}
} else {
this.children.push(el);
}
this.requestSort();
el.parent = this;
el.transform.bind(el);
el.onResize(this.scale);
el.forEachHook(hook => hook.onResize?.(el.width, el.height));
// 还需要深度遍历每个元素,给每个元素都设置根元素
if (this.root) {
el.setRoot(this.root);
el.forEachChild(item => item.setRoot(this.root));
}
el.update();
}
removeChild(child: IRenderItem): boolean {
const el = child as RenderItem;
if (!el.connected || !el.parent || !el.root) return false;
if (el.parent !== this) return false;
const index = this.children.indexOf(el);
if (index === -1) return false;
this.children.splice(index, 1);
el.parent = null;
this.requestSort();
this.update();
el.transform.unbind(el);
el.setRoot(null);
return true;
}
/**
* 添加子元素,默认没有任何行为且会抛出警告,你需要在自己的RenderItem继承类中复写它,才可以使用
* @param child 子元素
*/
appendChild(..._child: IRenderItem[]): void {
logger.warn(35);
}
/**
* 移除子元素,默认没有任何行为且会抛出警告,你需要在自己的RenderItem继承类中复写它,才可以使用
* @param child 子元素
*/
removeChild(..._child: IRenderItem[]): void {
logger.warn(36);
}
/**
* 申请对元素进行排序,默认没有任何行为且会抛出警告,你需要在自己的RenderItem继承类中复写它,才可以使用
*/
requestSort(): void {
logger.warn(37);
this.needSort = true;
}
getSortedChildren(): IRenderItem[] {
if (this.needSort) {
this.sortedChildren.length = 0;
const sorted = this.children.toSorted(
(a, b) => a.zIndex - b.zIndex
);
this.sortedChildren.push(...sorted);
}
return this.sortedChildren;
}
forEachChild(fn: (item: RenderItem) => void): void {
const stack: RenderItem[] = [this];
while (stack.length > 0) {
const ele = stack.shift()!;
stack.push(...ele.children);
fn(ele);
}
}
/**
* 获取排序后的子元素,根据 `zIndex` 排序,小的在前,大的在后。
* 包含子元素的元素应该 `override` 此方法。
* 当当前元素连接到根元素时触发,override 以自定义连接效果,是钩子在子元素中的便捷写法
* @param root 根元素
*/
getSortedChildren(): IRenderItem[] {
return [];
protected onConnected(root: IRenderTreeRoot) {
void root;
}
/**
* 当当前元素从根元素上断开连接时触发,override 以自定义连接效果,是钩子在子元素中的便捷写法
* @param prevRoot 取消连接之前,当前元素连接至的根元素
*/
protected onDisconnected(prevRoot: IRenderTreeRoot) {
void prevRoot;
}
//#endregion
//#region 交互事件
/**
* 设置是否忽略交互事件,交互事件将会直接下穿至在其下方的元素
* @param ignore 是否忽略事件
*/
ignoreEvent(ignore: boolean): void {
this.noEvent = ignore;
}
@@ -1067,19 +958,31 @@ export abstract class RenderItem
* @param key 属性键名
* @param prevValue 该属性先前的数值
* @param nextValue 该属性当前的数值
* @param _namespace 元素命名空间
* @param _parentComponent 元素的父组件
*/
patchProp(
key: string,
prevValue: any,
nextValue: any,
_namespace?: ElementNamespace,
_parentComponent?: ComponentInternalInstance | null
): void {
patchProp(key: string, prevValue: any, nextValue: any): void {
if (isNil(prevValue) && isNil(nextValue)) return;
if (this.handleProps(key, prevValue, nextValue)) return;
switch (key) {
case 'cache': {
if (!this.assertType(nextValue, 'boolean', key)) return;
this.cacheProp = nextValue;
if (this.nocacheProp) {
this.setCacheEnabled(false);
} else {
this.setCacheEnabled(nextValue);
}
return;
}
case 'nocache': {
if (!this.assertType(nextValue, 'boolean', key)) return;
this.nocacheProp = nextValue;
if (nextValue) {
this.setCacheEnabled(false);
} else {
this.setCacheEnabled(this.cacheProp);
}
return;
}
case 'x': {
if (!this.assertType(nextValue, 'number', key)) return;
this.pos(nextValue, this.transform.y);
@@ -1241,7 +1144,7 @@ export abstract class RenderItem
this.cachedEvent.clear();
this.mouseId.clear();
this.touchId.clear();
this.children.clear();
this.children.length = 0;
this.setRoot(null);
}
}
+39 -30
View File
@@ -1,34 +1,36 @@
import { RenderItem, Transform, MotaOffscreenCanvas2D } from '.';
import { CanvasStyle } from '../types';
import { Font } from '../style';
import { IRenderAnimated, IRenderImage, IRenderText } from './types';
import {
IRenderAnimated,
IRenderImage,
IRenderText,
IRenderTreeRoot
} from './types';
import { ITexture, ITextureAnimater, ITextureRenderable } from '../assets';
/** 文字的安全填充,会填充在文字的上侧和下侧,防止削顶和削底 */
const SAFE_PAD = 1;
/** 文本测量画布 */
const MEASURE = new MotaOffscreenCanvas2D();
MEASURE.setHD(false);
MEASURE.setScale(1);
MEASURE.size(1, 1);
export class Text extends RenderItem implements IRenderText {
text: string;
text: string = '';
fillStyle?: CanvasStyle = '#fff';
strokeStyle?: CanvasStyle;
font: Font = new Font();
strokeWidth: number = 1;
private length: number = 0;
/** 文本的下边缘位置 */
private descent: number = 0;
private static measureCanvas = new MotaOffscreenCanvas2D();
constructor(text: string = '', enableCache: boolean = false) {
super(enableCache);
this.text = text;
if (text.length > 0) {
this.requestBeforeFrame(() => {
this.calBox();
});
}
protected getDefaultCache(): boolean {
return false;
}
protected render(
@@ -56,7 +58,7 @@ export class Text extends RenderItem implements IRenderText {
* 获取文字的长度
*/
measure() {
const ctx = Text.measureCanvas.ctx;
const ctx = MEASURE.ctx;
ctx.textBaseline = 'bottom';
ctx.font = this.font.string();
const res = ctx.measureText(this.text);
@@ -112,7 +114,6 @@ export class Text extends RenderItem implements IRenderText {
calBox() {
const { width, actualBoundingBoxAscent, actualBoundingBoxDescent } =
this.measure();
this.length = width;
this.descent = actualBoundingBoxAscent;
const height = actualBoundingBoxAscent + actualBoundingBoxDescent;
const stroke = this.strokeWidth * 2;
@@ -148,11 +149,10 @@ export class Text extends RenderItem implements IRenderText {
}
export class Image extends RenderItem implements IRenderImage {
image: ITexture | null;
image: ITexture | null = null;
constructor(enableCache: boolean = false) {
super(enableCache);
this.image = null;
protected getDefaultCache(): boolean {
return false;
}
protected render(
@@ -209,11 +209,11 @@ export class Animated<T> extends RenderItem implements IRenderAnimated<T> {
/** 动画生成器 */
private gen: Generator<ITextureRenderable, void> | null = null;
/** 委托 Excitation 的 id */
private delegation: number = -1;
constructor(enableCache: boolean = false) {
super(enableCache);
this.delegateExcitable(time => {
protected onConnected(root: IRenderTreeRoot): void {
this.delegation = root.delegateExcitable(time => {
this.currentTime = time;
if (this.lastFrameTime === -1) {
this.lastFrameTime = time;
@@ -234,6 +234,14 @@ export class Animated<T> extends RenderItem implements IRenderAnimated<T> {
});
}
protected onDisconnected(prevRoot: IRenderTreeRoot): void {
prevRoot.removeExcitable(this.delegation);
}
protected getDefaultCache(): boolean {
return false;
}
protected render(canvas: MotaOffscreenCanvas2D): void {
const ctx = canvas.ctx;
if (!this.current) return;
@@ -303,17 +311,18 @@ export class Animated<T> extends RenderItem implements IRenderAnimated<T> {
export class Comment extends RenderItem {
readonly isComment: boolean = true;
constructor(public text: string = '') {
super(false);
constructor() {
super();
this.hide();
}
protected getDefaultCache(): boolean {
return false;
}
getBoundingRect(): DOMRectReadOnly {
return new DOMRectReadOnly(0, 0, 0, 0);
}
protected render(
_canvas: MotaOffscreenCanvas2D,
_transform: Transform
): void {}
protected render(): void {}
}
+45 -41
View File
@@ -11,17 +11,15 @@ import {
} from './event';
import {
IMotaRendererConfig,
RenderItemTags,
IRenderItem,
IRenderItemInstanceMap,
IRenderItemParameterMap,
IRenderTagMap,
IRenderTreeRoot,
RenderItemConstructor,
ExcitableDelegation
} from './types';
import { IExcitable, IExcitation, RafExcitation } from '@motajs/animate';
import { CustomRenderItem } from './custom';
import { Comment, Image, Text } from './misc';
import { Animated, Comment, Image, Text } from './misc';
import { Shader } from './shader';
import {
BezierCurve,
@@ -117,11 +115,13 @@ export class MotaRenderer
private readonly toDeleteExcitables: Set<number> = new Set();
/** 标签注册信息 */
private readonly tagRegistry: Map<string, RenderItemConstructor> =
new Map();
private readonly tagRegistry: Map<
string,
RenderItemConstructor<IRenderItem>
> = new Map();
constructor(config: IMotaRendererConfig) {
super(false);
super();
const canvas = this.getMountCanvas(config.canvas);
if (!canvas) {
@@ -143,6 +143,12 @@ export class MotaRenderer
this.excited = this.excited.bind(this);
this.excitation.add(this);
this.registerIntrinsicTags();
this.root = this;
}
protected getDefaultCache(): boolean {
return true;
}
//#region 渲染相关
@@ -193,32 +199,29 @@ export class MotaRenderer
//#region 标签元素
createElement<K extends RenderItemTags>(
tag: K,
...params: IRenderItemParameterMap[K]
): IRenderItemInstanceMap[K];
createElement<P extends any[], I extends IRenderItem>(
ele: new (...params: P) => I,
...params: P
): I;
createElement<K extends keyof IRenderTagMap>(tag: K): IRenderTagMap[K];
createElement<T extends IRenderItem>(tag: string): T | null;
createElement<T extends IRenderItem>(cons: RenderItemConstructor<T>): T;
createElement(
ele: RenderItemTags | RenderItemConstructor,
...params: any[]
): IRenderItem {
ele: keyof IRenderTagMap | string | RenderItemConstructor<IRenderItem>
): IRenderItem | null {
if (typeof ele === 'string') {
const Cons = this.tagRegistry.get(ele);
if (!Cons) {
const cons = this.tagRegistry.get(ele);
if (!cons) {
logger.error(15, ele);
return new Container(false);
return null;
} else {
return new Cons(...params);
return cons();
}
} else {
return new ele(...params);
return ele();
}
}
registerElement(tag: string, cons: RenderItemConstructor): void {
registerElement(
tag: string,
cons: RenderItemConstructor<IRenderItem>
): void {
if (this.tagRegistry.has(tag)) {
logger.error(14);
return;
@@ -235,22 +238,23 @@ export class MotaRenderer
* 注册内置渲染标签
*/
private registerIntrinsicTags() {
this.registerElement('container', Container);
this.registerElement('custom', CustomRenderItem);
this.registerElement('text', Text);
this.registerElement('image', Image);
this.registerElement('shader', Shader);
this.registerElement('comment', Comment);
this.registerElement('template', Container);
this.registerElement('custom-container', CustomContainer);
this.registerElement('g-rect', Rect);
this.registerElement('g-circle', Circle);
this.registerElement('g-ellipse', Ellipse);
this.registerElement('g-line', Line);
this.registerElement('g-bezier', BezierCurve);
this.registerElement('g-quad', QuadraticCurve);
this.registerElement('g-path', Path);
this.registerElement('g-rectr', RectR);
this.registerElement('container', () => new Container());
this.registerElement('custom', () => new CustomRenderItem());
this.registerElement('text', () => new Text());
this.registerElement('image', () => new Image());
this.registerElement('animated', () => new Animated<any>());
this.registerElement('shader', () => new Shader());
this.registerElement('comment', () => new Comment());
this.registerElement('template', () => new Container());
this.registerElement('custom-container', () => new CustomContainer());
this.registerElement('g-rect', () => new Rect());
this.registerElement('g-circle', () => new Circle());
this.registerElement('g-ellipse', () => new Ellipse());
this.registerElement('g-line', () => new Line());
this.registerElement('g-bezier', () => new BezierCurve());
this.registerElement('g-quad', () => new QuadraticCurve());
this.registerElement('g-path', () => new Path());
this.registerElement('g-rectr', () => new RectR());
}
//#endregion
@@ -859,7 +863,7 @@ export class MotaRenderer
): string {
if (item.isComment) return '';
const name = item.constructor.name;
if (item.children.size === 0) {
if (item.children.length === 0) {
return `${' '.repeat(deep * space)}<${name} ${
item.id ? `id="${item.id}" ` : ''
}uid="${item.uid}"${item.hidden ? ' hidden' : ''} />\n`;
+196 -202
View File
@@ -156,7 +156,7 @@ export interface IRenderItem
/** 当前元素的父元素 */
readonly parent: IRenderItem | null;
/** 当前元素的子元素 */
readonly children: Set<IRenderItem>;
readonly children: readonly IRenderItem[];
/** 此元素所附属的根元素 */
readonly root: IRenderTreeRoot | null;
/** 当前元素是否连接至根元素 */
@@ -257,6 +257,12 @@ export interface IRenderItem
//#region 渲染设置
/**
* 设置当前元素是否启用缓存
* @param enabled 是否启用缓存
*/
setCacheEnabled(enabled: boolean): void;
/**
* 修改这个对象的大小
*/
@@ -356,6 +362,195 @@ export interface IRenderItem
*/
getBoundingRect(): DOMRectReadOnly;
//#endregion
//#region 父子关系
/**
* 向这个元素添加子元素
* @param child 添加的元素
* @param anchor 元素添加锚点,将元素插入到指定元素的后面
*/
appendChild(child: IRenderItem, anchor?: IRenderItem): void;
/**
* 移除这个元素中的某个子元素
* @param child 要移除的元素
* @returns 是否移除成功
*/
removeChild(child: IRenderItem): boolean;
/**
* 将这个渲染元素添加到其他父元素上
* @param parent 父元素
* @param anchor 元素添加锚点,将元素插入到指定元素的后面
*/
appendTo(parent: IRenderItem, anchor?: IRenderItem): void;
/**
* 从渲染树中移除这个节点
* @returns 是否移除成功
*/
remove(): boolean;
/**
* 获取排序后的子元素,根据 `zIndex` 排序,小的在前,大的在后
*/
getSortedChildren(): readonly IRenderItem[];
/**
* 按照 DFS 规则深度遍历每一个子元素,可以确保遍历顺序稳定,按照 `children` 的顺序遍历
* @param fn 对每个子元素执行的函数
*/
forEachChild(fn: (item: IRenderItem) => void): void;
//#endregion
//#region 事件相关
/**
* 设置是否忽略交互事件,交互事件将会直接下穿至在其下方的元素
* @param ignore 是否忽略事件
*/
ignoreEvent(ignore: boolean): void;
//#endregion
//#region 其他接口
/**
* 设置元素的 id
* @param id 元素 id
*/
setID(id: string): void;
/**
* 摧毁这个渲染元素,摧毁后不应继续使用
*/
destroy(): void;
//#endregion
}
//#endregion
//#region 根元素
export interface IRenderTagMap {
container: IRenderItem;
custom: IRenderCustom;
text: IRenderText;
image: IRenderImage;
animated: IRenderAnimated<any>;
shader: IWebGL2RenderItem;
comment: IRenderItem;
template: IRenderItem;
'custom-container': ICustomContainer;
'g-rect': IGraphicRenderItem;
'g-circle': IGraphicCircle;
'g-ellipse': IGraphicEllipse;
'g-line': IGraphicLine;
'g-bezier': IGraphicBezierCurve;
'g-quad': IGraphicQuadBezierCurve;
'g-path': IGraphicPath;
'g-rectr': IGraphicRectR;
}
export interface IMotaRendererConfig {
/** 要挂载到哪个画布上,可以填 css 选择器或画布元素本身 */
readonly canvas: string | HTMLCanvasElement;
/** 画布的宽度,所有渲染操作会自行适配缩放 */
readonly width: number;
/** 画布的高度,所有渲染操作会自行适配缩放 */
readonly height: number;
/** 是否启用不透明度通道,默认启用 */
readonly alpha?: boolean;
/** 指定渲染器的激励源,默认使用 `RafExcitation` */
readonly excitaion?: IExcitation<number>;
}
export type RenderItemConstructor<T extends IRenderItem> = () => T;
export interface IRenderTreeRoot extends IRenderItem {
/** 是否是根元素 */
readonly isRoot: true;
/** 根元素的激励源 */
readonly excitation: IExcitation<number>;
/**
* 创建内置标签对应的渲染元素
* @param tag 标签名称
*/
createElement<K extends keyof IRenderTagMap>(tag: K): IRenderTagMap[K];
/**
* 创建自定义标签对应的渲染元素
* @param tag 标签名称
*/
createElement<T extends IRenderItem>(tag: string): T | null;
/**
* 传入自定义构造器,创建对应的渲染元素
* @param cons 构造器
*/
createElement<T extends IRenderItem>(cons: RenderItemConstructor<T>): T;
/**
* 注册标签渲染元素
* @param tag 标签名称
* @param cons 对应渲染元素的构造器
*/
registerElement(
tag: string,
cons: RenderItemConstructor<IRenderItem>
): void;
/**
* 当前根元素是否包含指定标签
* @param tag 标签名称
*/
hasTag(tag: string): boolean;
/**
* 将一个渲染元素连接到此根元素
* @param item 要连接到此根元素的渲染元素
*/
connect(item: IRenderItem): void;
/**
* 将已连接的渲染元素从此根元素中去掉
* @param item 要取消连接的渲染元素
*/
disconnect(item: IRenderItem): void;
/**
* 修改已连接的元素的 id
* @param item 修改了 id 的元素
* @param previous 先前的元素 id
* @param current 现在的元素 id
*/
modifyId(item: IRenderItem, previous: string, current: string): void;
/**
* 获取渲染至的目标画布,即显示在画面上的画布
*/
getCanvas(): HTMLCanvasElement;
/**
* 当鼠标覆盖在某个元素上时执行
* @param element 鼠标覆盖的元素
*/
hoverElement(element: IRenderItem): void;
/**
* 设置这个渲染器的缩放比
* @param scale 缩放比
*/
setScale(scale: number): void;
/**
* 获取当前渲染器的缩放比
*/
getScale(): number;
/**
* 在下一帧渲染之前执行函数,常用于渲染前数据更新,理论上不应当用于渲染,不保证运行顺序
* 此方法会将委托在根元素上,如果当前元素没有绑定任何根元素,那么不会有任何行为。
@@ -409,207 +604,6 @@ export interface IRenderItem
* @param id 函数id
*/
hasExcitable(id: number): boolean;
//#endregion
//#region 父子关系
/**
* 向这个元素添加子元素
* @param child 添加的元素
*/
appendChild(...child: IRenderItem[]): void;
/**
* 移除这个元素中的某个子元素
* @param child 要移除的元素
*/
removeChild(...child: IRenderItem[]): void;
/**
* 将这个渲染元素添加到其他父元素上
* @param parent 父元素
*/
appendTo(parent: IRenderItem): void;
/**
* 从渲染树中移除这个节点
* @returns 是否移除成功
*/
remove(): boolean;
/**
* 获取排序后的子元素,根据 `zIndex` 排序,小的在前,大的在后
*/
getSortedChildren(): IRenderItem[];
//#endregion
//#region 事件相关
/**
* 设置是否忽略交互事件,交互事件将会直接下穿至在其下方的元素
* @param ignore 是否忽略事件
*/
ignoreEvent(ignore: boolean): void;
//#endregion
//#region 其他接口
/**
* 设置元素的 id
* @param id 元素 id
*/
setID(id: string): void;
/**
* 摧毁这个渲染元素,摧毁后不应继续使用
*/
destroy(): void;
//#endregion
}
//#endregion
//#region 根元素
export interface IRenderItemParameterMap {
container: [enableCache?: boolean];
custom: [enableCache?: boolean];
text: [text: string, enableCache?: boolean];
image: [image: CanvasImageSource, enableCache?: boolean];
shader: [];
comment: [text?: string];
template: [enableCache?: boolean];
'custom-container': [enableCache?: boolean];
'g-rect': [enableCache?: boolean];
'g-circle': [enableCache?: boolean];
'g-ellipse': [enableCache?: boolean];
'g-line': [enableCache?: boolean];
'g-bezier': [enableCache?: boolean];
'g-quad': [enableCache?: boolean];
'g-path': [enableCache?: boolean];
'g-rectr': [enableCache?: boolean];
}
export interface IRenderItemInstanceMap {
container: IRenderItem;
custom: IRenderCustom;
text: IRenderText;
image: IRenderImage;
shader: IWebGL2RenderItem;
comment: IRenderItem;
template: IRenderItem;
'custom-container': ICustomContainer;
'g-rect': IGraphicRenderItem;
'g-circle': IGraphicCircle;
'g-ellipse': IGraphicEllipse;
'g-line': IGraphicLine;
'g-bezier': IGraphicBezierCurve;
'g-quad': IGraphicQuadBezierCurve;
'g-path': IGraphicPath;
'g-rectr': IGraphicRectR;
}
export type RenderItemTags = keyof IRenderItemParameterMap &
keyof IRenderItemInstanceMap;
export interface IMotaRendererConfig {
/** 要挂载到哪个画布上,可以填 css 选择器或画布元素本身 */
readonly canvas: string | HTMLCanvasElement;
/** 画布的宽度,所有渲染操作会自行适配缩放 */
readonly width: number;
/** 画布的高度,所有渲染操作会自行适配缩放 */
readonly height: number;
/** 是否启用不透明度通道,默认启用 */
readonly alpha?: boolean;
/** 指定渲染器的激励源,默认使用 `RafExcitation` */
readonly excitaion?: IExcitation<number>;
}
export type RenderItemConstructor = new (...params: any[]) => IRenderItem;
export interface IRenderTreeRoot extends IRenderItem {
/** 是否是根元素 */
readonly isRoot: true;
/** 根元素的激励源 */
readonly excitation: IExcitation<number>;
/**
* 根据标签名称创建对应的元素
* @param tag 标签名称
* @param params 传给标签的参数
*/
createElement<K extends RenderItemTags>(
tag: K,
...params: IRenderItemParameterMap[K]
): IRenderItemInstanceMap[K];
/**
* 根据元素类创建对应的元素
* @param ele 元素构造器
* @param params 传递给构造器的参数
*/
createElement<P extends any[], I extends IRenderItem>(
ele: new (...params: P) => I,
...params: P
): I;
/**
* 注册标签渲染元素
* @param tag 标签名称
* @param cons 对应渲染元素的构造器
*/
registerElement(tag: string, cons: RenderItemConstructor): void;
/**
* 当前根元素是否包含指定标签
* @param tag 标签名称
*/
hasTag(tag: string): boolean;
/**
* 将一个渲染元素连接到此根元素
* @param item 要连接到此根元素的渲染元素
*/
connect(item: IRenderItem): void;
/**
* 将已连接的渲染元素从此根元素中去掉
* @param item 要取消连接的渲染元素
*/
disconnect(item: IRenderItem): void;
/**
* 修改已连接的元素的 id
* @param item 修改了 id 的元素
* @param previous 先前的元素 id
* @param current 现在的元素 id
*/
modifyId(item: IRenderItem, previous: string, current: string): void;
/**
* 获取渲染至的目标画布,即显示在画面上的画布
*/
getCanvas(): HTMLCanvasElement;
/**
* 当鼠标覆盖在某个元素上时执行
* @param element 鼠标覆盖的元素
*/
hoverElement(element: IRenderItem): void;
/**
* 设置这个渲染器的缩放比
* @param scale 缩放比
*/
setScale(scale: number): void;
/**
* 获取当前渲染器的缩放比
*/
getScale(): number;
}
//#endregion
+5
View File
@@ -2,6 +2,8 @@ import { WebLoadStarter } from '@motajs/loader';
import { createClientCore } from './client/entry';
import { IClientCore } from '@user/client-modules';
import { LoadSceneUI } from './client/ui/load';
import { createRendererFor } from '@motajs/render-vue';
import { createRendererScene } from './client/ui/scene';
declare global {
interface Window {
@@ -11,6 +13,9 @@ declare global {
const client = createClientCore(new WebLoadStarter());
const { createApp } = createRendererFor(client.renderer);
createApp(createRendererScene(client)).mount(client.renderer);
// 游戏副作用启动
window.mainClient = client;
client.sceneController.open(LoadSceneUI, {});