Files
cocos4/editor/inspector/contributions/node.js
T
2022-05-20 14:40:05 +08:00

1559 lines
58 KiB
JavaScript

'use strict';
const fs = require('fs');
const path = require('path');
const utils = require('./utils');
exports.listeners = {
async 'change-dump'(event) {
const panel = this;
const target = event.target;
if (!target) {
return;
}
if (!panel.snapshotLock) {
Editor.Message.send('scene', 'snapshot');
panel.snapshotLock = true;
}
const dump = event.target.dump;
if (!dump || panel.isDialoging) {
return;
}
let setChildrenLayer = false;
if (dump.path === 'layer') {
dump.value = panel.$.nodeLayerSelect.value - 0;
if ('values' in dump) {
dump.values.forEach((val, index) => {
dump.values[index] = dump.value;
});
}
if (panel.dumps && panel.dumps.some((perdump) => perdump.children && perdump.children.length > 0)) {
// 只修改自身节点
let choose = 1;
// 有子节点的时候才弹出对话框
panel.isDialoging = true;
const warnResult = await Editor.Dialog.warn(Editor.I18n.t(`ENGINE.components.layer.confirm_message`), {
buttons: [
Editor.I18n.t('ENGINE.components.layer.change_children'),
Editor.I18n.t('ENGINE.components.layer.change_self'),
'Cancel',
],
cancel: 2,
});
choose = warnResult.response;
panel.isDialoging = false;
// 取消,需要还原数值
if (choose === 2) {
Elements.layer.update.call(panel);
return;
} else {
setChildrenLayer = choose === 0 ? true : false;
}
}
}
try {
for (let i = 0; i < panel.uuidList.length; i++) {
const uuid = panel.uuidList[i];
const { path, type, isArray } = dump;
let value = dump.value;
if (dump.values) {
value = dump.values[i];
}
if (setChildrenLayer) {
Editor.Message.send('scene', 'set-node-and-children-layer', {
uuid,
dump: {
value,
},
});
continue;
}
Editor.Message.send('scene', 'set-property', {
uuid,
path,
dump: {
type,
isArray,
value,
},
});
}
} catch (error) {
console.error(error);
}
},
'confirm-dump'() {
const panel = this;
panel.snapshotLock = false;
},
'create-dump'(event) {
const panel = this;
const target = event.target;
if (!target) {
return;
}
Editor.Message.send('scene', 'snapshot');
const dump = event.target.dump;
try {
for (let i = 0; i < panel.uuidList.length; i++) {
const uuid = panel.uuidList[i];
if (i > 0) {
dump.values[i] = dump.value;
}
Editor.Message.send('scene', 'update-property-from-null', {
uuid,
path: dump.path,
});
}
} catch (error) {
console.error(error);
}
},
'reset-dump'(event) {
const panel = this;
const target = event.target;
if (!target) {
return;
}
Editor.Message.send('scene', 'snapshot');
const dump = event.target.dump;
try {
for (let i = 0; i < panel.uuidList.length; i++) {
const uuid = panel.uuidList[i];
if (i > 0) {
dump.values[i] = dump.value;
}
Editor.Message.send('scene', 'reset-property', {
uuid,
path: dump.path,
});
}
} catch (error) {
console.error(error);
}
},
};
exports.template = /* html*/`
<ui-drag-area class="container">
<section class="prefab" hidden missing>
<ui-label value="Prefab"></ui-label>
<ui-button role="edit" tooltip="i18n:ENGINE.prefab.edit">
<ui-icon value="edit"></ui-icon>
</ui-button>
<ui-button role="unlink" tooltip="i18n:ENGINE.prefab.unlink">
<ui-icon value="unlink"></ui-icon>
</ui-button>
<ui-button role="local" tooltip="i18n:ENGINE.prefab.local">
<ui-icon value="location"></ui-icon>
</ui-button>
<ui-button role="reset" tooltip="i18n:ENGINE.prefab.reset">
<ui-icon value="reset"></ui-icon>
</ui-button>
<ui-button role="save" tooltip="i18n:ENGINE.prefab.save">
<ui-icon value="save-o"></ui-icon>
</ui-button>
</section>
<header class="header">
<ui-checkbox class="active"></ui-checkbox>
<ui-input class="name"></ui-input>
</header>
<section class="component scene">
<ui-prop class="release" type="dump"></ui-prop>
<ui-prop class="ambient" type="dump"></ui-prop>
<ui-prop class="skybox" type="dump"></ui-prop>
<ui-prop class="postProcess" type="dump"></ui-prop>
<ui-prop class="fog" type="dump"></ui-prop>
<ui-prop class="shadows" type="dump"></ui-prop>
<ui-prop class="octree" type="dump"></ui-prop>
</section>
<ui-section class="component node" expand>
<header class="component-header" slot="header">
<span class="name">Node</span>
<ui-icon class="menu" value="setting" tooltip="i18n:ENGINE.menu.component"></ui-icon>
<ui-link class="link" tooltip="i18n:ENGINE.menu.help_url">
<ui-icon value="help"></ui-icon>
</ui-link>
</header>
<ui-prop class="position" type="dump"></ui-prop>
<ui-prop class="rotation" type="dump"></ui-prop>
<ui-prop class="scale" type="dump"></ui-prop>
<ui-prop class="layer" type="dump" html="false">
<ui-label slot="label" value="Layer"></ui-label>
<div class="layer-content" slot="content">
<ui-select class="layer-select"></ui-select>
<ui-button class="layer-edit">Edit</ui-button>
</div>
</ui-prop>
<div class="node-section"></div>
</ui-section>
<section class="section-header"></section>
<section class="section-body"></section>
<section class="section-footer"></section>
<section class="section-missing"></section>
<footer class="footer">
<ui-button>
<ui-label value="i18n:ENGINE.components.add_component"></ui-label>
</ui-button>
</footer>
<section class="section-asset"></section>
</ui-drag-area>
`;
exports.style = fs.readFileSync(path.join(__dirname, './node.css'), 'utf8');
exports.$ = {
container: '.container',
prefab: '.prefab',
prefabUnlink: '.prefab > [role="unlink"]',
prefabLocal: '.prefab > [role="local"]',
prefabReset: '.prefab > [role="reset"]',
prefabSave: '.prefab > [role="save"]',
prefabEdit: '.prefab > [role="edit"]',
header: '.header',
active: '.active',
name: '.name',
scene: '.scene',
sceneRelease: '.scene > .release',
sceneAmbient: '.scene > .ambient',
sceneFog: '.scene > .fog',
sceneShadows: '.scene > .shadows',
sceneSkybox: '.scene > .skybox',
postProcess: '.scene > .postProcess',
sceneOctree: '.scene > .octree',
node: '.node',
nodeHeader: '.node > header',
nodeSection: '.node-section',
nodeMenu: '.node > header > .menu',
nodeLink: '.node > header > .link',
nodePosition: '.node > .position',
nodeRotation: '.node > .rotation',
nodeScale: '.node > .scale',
nodeLayer: '.node > .layer',
nodeLayerSelect: '.node > .layer .layer-select',
nodeLayerButton: '.node > .layer .layer-edit',
sectionHeader: '.section-header',
sectionBody: '.section-body',
sectionFooter: '.section-footer',
sectionMissing: '.section-missing',
sectionAsset: '.section-asset',
footer: '.footer',
componentAdd: '.footer > ui-button',
};
const Elements = {
panel: {
ready() {
const panel = this;
let animationId;
panel.__nodeChanged__ = (uuid) => {
if (Array.isArray(panel.uuidList) && panel.uuidList.includes(uuid)) {
window.cancelAnimationFrame(animationId);
animationId = window.requestAnimationFrame(async () => {
for (const prop in Elements) {
const element = Elements[prop];
if (element.update) {
await element.update.call(panel);
}
}
});
}
};
Editor.Message.addBroadcastListener('scene:change-node', panel.__nodeChanged__);
panel.__projectSettingChanged__ = async function(name) {
if (name !== 'layers') {
return;
}
for (const prop in Elements) {
const element = Elements[prop];
if (element.update) {
await element.update.call(panel);
}
}
};
Editor.Message.addBroadcastListener('project:setting-change', panel.__projectSettingChanged__);
// 识别拖入脚本资源
panel.$.container.addEventListener('dragover', (event) => {
event.preventDefault();
if (panel.dump.isScene) {
event.dataTransfer.dropEffect = 'none';
} else {
event.dataTransfer.dropEffect = 'copy';
}
});
panel.$.container.addEventListener('drop', async (event) => {
event.preventDefault();
event.stopPropagation();
if (panel.dump.isScene) {
return;
}
// 支持多选脚本拖入
const { additional = [], value, type } = JSON.parse(JSON.stringify(Editor.UI.DragArea.currentDragInfo)) || {};
if (value && additional.every((v) => v.value !== value)) {
additional.push({ value, type });
}
Editor.Message.send('scene', 'snapshot');
additional.forEach((o) => {
const config = panel.dropConfig[o.type];
if (config) {
Editor.Message.send(config.package, config.message, o, panel.dumps, panel.uuidList);
}
});
});
},
async update() {
const panel = this;
let dumps = [];
try {
dumps = await Promise.all(
panel.uuidList.map((uuid) => {
return Editor.Message.request('scene', 'query-node', uuid);
}),
);
} catch (err) {
console.error(err);
}
dumps = dumps.filter(Boolean);
panel.dump = dumps[0];
panel.dumps = [];
panel.uuidList = [];
panel.assets = {};
if (panel.dump) {
panel.$.container.style.display = 'flex';
panel.$.header.style.display = 'flex';
panel.$.footer.style.display = 'block';
// 以第一个节点的类型,过滤多选的其他不同类型,比如 node 和 sceneNode 就不能混为多选编辑
const type = panel.dump.__type__;
dumps.forEach((dump) => {
if (dump.__type__ === type) {
panel.uuidList.push(dump.uuid.value);
panel.dumps.push(dump);
}
});
// 补充缺失的 dump 数据,如 path values 等,收集节点内的资源
utils.translationDump(panel.dump, panel.dumps.length > 1 ? panel.dumps : undefined, panel.assets);
} else {
panel.$.container.style.display = 'none';
}
},
close() {
const panel = this;
Editor.Message.removeBroadcastListener('scene:change-node', panel.__nodeChanged__);
Editor.Message.removeBroadcastListener('project:setting-change', panel.__projectSettingChanged__);
},
},
prefab: {
ready() {
const panel = this;
panel.$.prefab.addEventListener('confirm', async (event) => {
const button = event.target;
if (!panel.dump || !panel.dump.__prefab__ || !button || !panel.dumps?.length) {
return;
}
await Editor.Message.request('scene', 'snapshot');
const role = button.getAttribute('role');
for (const dump of panel.dumps) {
const prefab = dump.__prefab__;
switch (role) {
case 'unlink': {
await Editor.Message.request('scene', 'unlink-prefab', prefab.rootUuid, false);
break;
}
case 'local': {
Editor.Message.send('assets', 'twinkle', prefab.uuid);
break;
}
case 'reset': {
await Editor.Message.request('scene', 'restore-prefab', prefab.rootUuid, prefab.uuid);
break;
}
case 'save': {
await Editor.Message.request('scene', 'apply-prefab', prefab.rootUuid);
break;
}
}
}
});
panel.$.prefabEdit.addEventListener('click', () => {
const assetId = panel.dump?.__prefab__?.prefabStateInfo?.assetUuid;
if (!assetId) {
return;
}
Editor.Message.request('asset-db', 'open-asset', assetId);
});
},
async update() {
const panel = this;
if (!panel.dump || !panel.dump.__prefab__) {
panel.$.prefab.setAttribute('hidden', '');
return;
}
panel.$.prefab.removeAttribute('hidden');
const prefab = panel.dump.__prefab__;
const prefabStateInfo = prefab.prefabStateInfo;
if (prefabStateInfo.assetUuid) {
panel.$.prefabUnlink.removeAttribute('disabled');
} else {
panel.$.prefabUnlink.setAttribute('disabled', '');
}
const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', prefab.uuid);
if (assetInfo) {
panel.$.prefab.removeAttribute('missing');
if (prefabStateInfo.isRevertable) {
panel.$.prefabReset.removeAttribute('disabled');
} else {
panel.$.prefabReset.setAttribute('disabled', '');
}
if (prefabStateInfo.isApplicable) {
panel.$.prefabSave.removeAttribute('disabled');
} else {
panel.$.prefabSave.setAttribute('disabled', '');
}
if (assetInfo.uuid.includes('@')) {
panel.$.prefabEdit.setAttribute('disabled', '');
} else {
panel.$.prefabEdit.removeAttribute('disabled');
}
} else {
panel.$.prefab.setAttribute('missing', '');
panel.$.prefabLocal.setAttribute('disabled', '');
panel.$.prefabReset.setAttribute('disabled', '');
panel.$.prefabSave.setAttribute('disabled', '');
}
if ((panel.dumps && panel.dumps.length > 1) || (Editor.EditMode.getMode() === 'prefab' && !prefabStateInfo.isUnwrappable)) {
panel.$.prefabEdit.setAttribute('disabled', '');
}
},
},
header: {
ready() {
const panel = this;
panel.$.active.addEventListener('change', (event) => {
const value = event.target.value;
const dump = event.target.dump;
dump.value = value;
if ('values' in dump) {
dump.values.forEach((val, index) => {
dump.values[index] = value;
});
}
panel.$.active.dispatch('change-dump');
});
panel.$.name.addEventListener('change', (event) => {
const value = event.target.value;
const dump = event.target.dump;
dump.value = value;
if ('values' in dump) {
dump.values.forEach((val, index) => {
dump.values[index] = value;
});
}
panel.$.name.dispatch('change-dump');
});
},
update() {
const panel = this;
if (!panel.dump) {
return;
}
let activeDisabled = false;
let activeInvalid = false;
let nameDisabled = false;
let nameInvalid = false;
if (panel.dump.isScene) {
activeDisabled = true;
nameDisabled = true;
} else {
if (panel.dumps && panel.dumps.length > 1) {
if (panel.dumps.some((dump) => dump.active.value !== panel.dump.active.value)) {
activeInvalid = true;
}
if (panel.dumps.some((dump) => dump.name.value !== panel.dump.name.value)) {
nameInvalid = true;
}
}
}
panel.$.active.value = panel.dump.active.value;
panel.$.active.dump = panel.dump.active;
panel.$.active.disabled = activeDisabled;
panel.$.active.invalid = activeInvalid;
panel.$.name.value = panel.dump.name.value;
panel.$.name.dump = panel.dump.name;
panel.$.name.disabled = nameDisabled;
panel.$.name.invalid = nameInvalid;
},
},
scene: {
ready() {},
update() {
const panel = this;
if (!panel.dump || !panel.dump.isScene) {
return;
}
panel.$this.setAttribute('sub-type', 'scene');
panel.$.container.removeAttribute('droppable');
panel.$.sceneRelease.render(panel.dump.autoReleaseAssets);
// 由于场景属性对象不是继承于 Component 所以没有修饰器,displayName, help 数据在这里配置
panel.dump._globals.ambient.displayName = 'Ambient';
panel.dump._globals.ambient.help = panel.getHelpUrl({ help: 'i18n:cc.Ambient' });
panel.$.sceneAmbient.render(panel.dump._globals.ambient);
panel.dump._globals.fog.displayName = 'Fog';
panel.dump._globals.fog.help = panel.getHelpUrl({ help: 'i18n:cc.Fog' });
panel.$.sceneFog.render(panel.dump._globals.fog);
panel.dump._globals.shadows.displayName = 'Shadows';
panel.dump._globals.shadows.help = panel.getHelpUrl({ help: 'i18n:cc.Shadow' });
panel.$.sceneShadows.render(panel.dump._globals.shadows);
panel.dump._globals.skybox.displayName = 'Skybox';
panel.dump._globals.skybox.help = panel.getHelpUrl({ help: 'i18n:cc.Skybox' });
panel.$.sceneSkybox.render(panel.dump._globals.skybox);
panel.dump._globals.octree.displayName = 'Octree Scene Culling';
panel.dump._globals.octree.help = panel.getHelpUrl({ help: 'i18n:cc.OctreeCulling' });
panel.$.sceneOctree.render(panel.dump._globals.octree);
// TODO:这个 if 暂时配合引擎调整使用,测试调通后可以去掉
if (panel.dump._globals.postProcess) {
panel.dump._globals.postProcess.displayName = 'Post Process';
panel.$.postProcess.render(panel.dump._globals.postProcess);
}
const $skyProps = panel.$.sceneSkybox.querySelectorAll('section > ui-prop');
$skyProps.forEach(($prop) => {
if ($prop.dump.name === 'envLightingType' || $prop.dump.name === 'envmap') {
if (!$prop.regenerate) {
$prop.regenerate = Elements.scene.regenerate.bind(panel);
$prop.addEventListener('change-dump', $prop.regenerate);
}
}
});
},
async regenerate() {
const panel = this;
const dump = panel.dump._globals.skybox.value;
if (!dump.envmap.value) {
return;
}
const envMapUuid = dump.envmap.value.uuid;
if (!envMapUuid) {
return;
}
const envLightingType = dump.envLightingType.value;
// DIFFUSEMAP_WITH_REFLECTION 的枚举值为 2
if (envLightingType === 2) {
await Editor.Message.request('scene', 'execute-scene-script', {
name: 'inspector',
method: 'generateDiffuseMap',
args: [envMapUuid],
});
} else {
await Editor.Message.request('scene', 'execute-scene-script', {
name: 'inspector',
method: 'generateVector',
args: [envMapUuid],
});
}
},
},
node: {
ready() {
const panel = this;
panel.$.nodeLink.value = Editor.I18n.t('ENGINE.help.cc.Node');
panel.$.nodeMenu.addEventListener('click', (event) => {
event.stopPropagation();
exports.methods.nodeContextMenu(panel.uuidList, panel.dumps);
});
panel.$.nodeLink.addEventListener('click', (event) => {
event.stopPropagation();
});
},
update() {
const panel = this;
if (!panel.dump || panel.dump.isScene) {
return;
}
panel.$this.setAttribute('sub-type', 'node');
panel.$.container.setAttribute('droppable', panel.dropConfig && Object.keys(panel.dropConfig).join());
panel.$.nodePosition.render(panel.dump.position);
panel.$.nodeRotation.render(panel.dump.rotation);
panel.$.nodeScale.render(panel.dump.scale);
panel.$.nodeLayer.render(panel.dump.layer);
// 查找需要渲染的 component 列表
const componentList = [];
for (let i = 0; i < panel.dump.__comps__.length; i++) {
const comp = panel.dump.__comps__[i];
if (
panel.dumps.every((dump) => {
return dump.__comps__[i] && dump.__comps__[i].type === comp.type;
})
) {
componentList.push(comp);
}
}
const sectionBody = panel.$.sectionBody;
const isNotEmpty = componentList.length && sectionBody.__sections__ && sectionBody.__sections__.length;
const isSameLength = isNotEmpty && sectionBody.__sections__.length === componentList.length;
const isAllSameType =
isSameLength &&
componentList.every((comp, i) => {
return (
comp.type === sectionBody.__sections__[i].__type__ &&
comp.mountedRoot === sectionBody.__sections__[i].dump?.mountedRoot
);
});
// 如果元素长度、类型一致,则直接更新现有的界面
if (isAllSameType) {
sectionBody.__sections__.forEach(($section, index) => {
const dump = componentList[index];
$section.dump = dump;
// 处理 ui-checkbox 涉及多选的情况
const $active = $section.querySelector('ui-checkbox');
$active.dump = dump.value.enabled;
$active.value = dump.value.enabled.value;
if ($active.dump.values && $active.dump.values.some((ds) => ds !== $active.dump.value)) {
$active.invalid = true;
} else {
$active.invalid = false;
}
const url = panel.getHelpUrl(dump.editor);
const $link = $section.querySelector('ui-link');
if (url) {
$link.setAttribute('value', url);
} else {
$link.removeAttribute('value');
}
Array.prototype.forEach.call($section.__panels__, ($panel) => {
$panel.update(dump);
});
});
} else {
// 如果元素不一致,说明切换了选中元素,那么需要更新整个界面
sectionBody.innerText = '';
sectionBody.__sections__ = [];
componentList.forEach((component, i) => {
const $section = document.createElement('ui-section');
$section.setAttribute('expand', '');
$section.setAttribute('class', 'component');
$section.setAttribute('cache-expand', `${component.path}:${component.type}`);
$section.innerHTML = `
<header class="component-header" slot="header">
<ui-checkbox class="active"></ui-checkbox>
<span class="name">${component.type}${component.mountedRoot ? '+' : ''}</span>
<ui-icon class="menu" value="setting" tooltip="i18n:ENGINE.menu.component"></ui-icon>
<ui-link class="link" tooltip="i18n:ENGINE.menu.help_url">
<ui-icon value="help"></ui-icon>
</ui-link>
</header>
`;
$section.dump = component;
$section.__panels__ = [];
$section.__type__ = component.type;
const $active = $section.querySelector('ui-checkbox');
$active.value = component.value.enabled.value;
$active.dump = component.value.enabled;
$active.addEventListener('change', (event) => {
event.stopPropagation();
const value = !!$active.value;
const dump = $active.dump;
dump.value = value;
if ('values' in dump) {
dump.values.forEach((val, index) => {
dump.values[index] = value;
});
}
$active.dispatch('change-dump');
});
const $link = $section.querySelector('.link');
const url = panel.getHelpUrl(component.editor);
if (url) {
$link.setAttribute('value', url);
$link.addEventListener('click', (event) => {
event.stopPropagation();
});
}
const $menu = $section.querySelector('.menu');
$menu.addEventListener('click', (event) => {
event.stopPropagation();
exports.methods.componentContextMenu(panel.uuidList, $section.dump, componentList.length, i, panel.dumps);
});
sectionBody.__sections__[i] = $section;
sectionBody.appendChild($section);
// 再处理内部
let renderList = panel.renderMap.section[$section.__type__];
// 如果都没有渲染模板,使用默认 cc.Class 模板
if (!renderList || !renderList.length) {
// 判断继承
if (Array.isArray(component.extends)) {
const parentClass = component.extends[0];
renderList = panel.renderMap.section[parentClass];
}
if (!renderList) {
renderList = panel.renderMap.section['cc.Class'];
}
}
renderList.forEach((file) => {
const $panel = document.createElement('ui-panel');
$panel.setAttribute('src', file);
$panel.injectionStyle(`
ui-prop,
ui-section { margin-top: 5px; }
ui-prop > ui-prop,
ui-section > ui-prop[slot="header"],
ui-prop [slot="content"] ui-prop { margin-top: 0; }
`);
$panel.shadowRoot.addEventListener('change-dump', (event) => {
exports.listeners['change-dump'].call(panel, event);
});
$panel.shadowRoot.addEventListener('confirm-dump', (event) => {
exports.listeners['confirm-dump'].call(panel, event);
});
$panel.shadowRoot.addEventListener('reset-dump', (event) => {
exports.listeners['reset-dump'].call(panel, event);
});
$panel.shadowRoot.addEventListener('create-dump', (event) => {
exports.listeners['create-dump'].call(panel, event);
});
$section.appendChild($panel);
$section.__panels__.push($panel);
$panel.dump = component;
$panel.update(component);
});
});
}
// 自定义 node 数据
if (panel.renderMap.section && panel.renderMap.section['cc.Node']) {
const array = (panel.$.nodeSection.__node_panels__ = panel.$.nodeSection.__node_panels__ || []);
panel.renderMap.section['cc.Node'].forEach((file, index) => {
if (!array[index]) {
array[index] = document.createElement('ui-panel');
panel.$.nodeSection.appendChild(array[index]);
}
array[index].setAttribute('src', file);
array[index].update(panel.dump);
});
for (let i = panel.renderMap.section['cc.Node'].length; i < array.length; i++) {
array[i].remove();
}
array.length = panel.renderMap.section['cc.Node'].length;
} else if (panel.$.nodeSection.__node_panels__) {
panel.$.nodeSection.__node_panels__.forEach((dom) => {
dom.remove();
});
delete panel.$.nodeSection.__node_panels__;
}
},
},
missingComponent: {
ready() {
const panel = this;
const sectionMissing = panel.$.sectionMissing;
sectionMissing.addEventListener('click', (event) => {
if (event.target.tagName !== 'UI-ICON') {
return;
}
if (!Array.isArray(panel.dump.removedComponents)) {
return;
}
const i = event.target.getAttribute('index');
const type = event.target.getAttribute('value');
const info = panel.dump.removedComponents[i];
if (!info) {
return;
}
const uuidList = panel.uuidList;
switch (type) {
case 'save-o': {
Editor.Message.request('scene', 'apply-removed-component', uuidList[0], info.fileID);
break;
}
case 'reset': {
Editor.Message.request('scene', 'revert-removed-component', uuidList[0], info.fileID);
break;
}
}
});
},
update() {
const panel = this;
if (!panel.dump || panel.dump.isScene) {
return;
}
const uuidList = panel.uuidList;
const sectionMissing = panel.$.sectionMissing;
sectionMissing.__sections__ = sectionMissing.__sections__ || [];
if (!panel.dump.removedComponents || uuidList.length !== 1) {
panel.dump.removedComponents = [];
}
for (let i = 0; i < panel.dump.removedComponents.length; i++) {
let $section = sectionMissing.__sections__[i];
if (!$section) {
$section = document.createElement('section');
sectionMissing.__sections__[i] = $section;
sectionMissing.appendChild($section);
}
$section.innerHTML = `
<span class="name">${panel.dump.removedComponents[i].name}</span>
<ui-icon value="reset" index="${i}" tooltip="i18n:ENGINE.prefab.reset"></ui-icon>
<ui-icon value="save-o" index="${i}" tooltip="i18n:ENGINE.prefab.save"></ui-icon>
`;
}
while (sectionMissing.__sections__.length > panel.dump.removedComponents.length) {
const $section = sectionMissing.__sections__.pop();
$section.parentElement.removeChild($section);
}
},
},
layer: {
ready() {
const panel = this;
panel.$.nodeLayerButton.addEventListener('change', (event) => {
event.stopPropagation();
Editor.Message.send('project', 'open-settings', 'project', 'layer');
});
},
async update() {
const panel = this;
if (!panel.dump || panel.dump.isScene) {
return;
}
const layerDump = panel.dump.layer;
const enumList = layerDump.enumList || [];
let optionHtml = '';
if (enumList) {
for (const item of enumList) {
optionHtml += `<option value="${item.value}">${item.name}</option>`;
}
}
panel.$.nodeLayerSelect.innerHTML = optionHtml;
panel.$.nodeLayerSelect.value = layerDump.value;
if (layerDump.values && layerDump.values.some((value) => value !== layerDump.value)) {
panel.$.nodeLayerSelect.invalid = true;
} else {
panel.$.nodeLayerSelect.invalid = false;
}
panel.$.nodeLayer.setReadonly(layerDump, panel.$.nodeLayerSelect);
},
},
footer: {
ready() {
const panel = this;
panel.$.componentAdd.addEventListener('click', () => {
const rawTimestamp = Date.now();
Editor.Panel._kitControl.open({
$kit: panel.$.componentAdd,
name: 'ui-kit.searcher',
timestamp: rawTimestamp,
type: 'add-component',
events: {
confirm(id, data) {
Editor.Message.send('scene', 'snapshot');
panel.uuidList.forEach((uuid) => {
Editor.Message.send('scene', 'create-component', {
uuid,
component: data.name,
});
});
},
},
});
});
},
update() {},
},
materials: {
async update() {
const panel = this;
const materialPanels = [];
const materialPanelType = 'asset';
const oldChildren = Array.from(panel.$.sectionAsset.children);
const materialUuids = panel.assets['cc.Material'];
let materialPrevPanel = null;
for (const materialUuid in materialUuids) {
let materialPanel = oldChildren.find((child) => child.getAttribute('uuid') === materialUuid);
if (!materialPanel) {
// 添加新的
materialPanel = document.createElement('ui-panel');
materialPanel.setAttribute('src', panel.typeManager[materialPanelType]);
materialPanel.setAttribute('type', materialPanelType);
materialPanel.setAttribute('uuid', materialUuid);
materialPanel.panelObject.$.container.removeAttribute('whole');
materialPanel.panelObject.$.container.setAttribute('cache-expand', materialUuid);
const { section = {} } = panel.renderManager[materialPanelType];
materialPanel.update([materialUuid], { section });
// 按数组顺序放置
if (materialPrevPanel) {
materialPrevPanel.after(materialPanel);
} else {
panel.$.sectionAsset.prepend(materialPanel);
}
materialPanel.addEventListener('focus', () => {
const children = Array.from(materialPanel.parentElement.children);
children.forEach(child => {
if (child === materialPanel) {
child.setAttribute('focused', '');
} else {
child.removeAttribute('focused');
}
});
});
materialPanel.addEventListener('blur', () => {
if (panel.blurSleep) {
return;
}
materialPanel.removeAttribute('focused');
});
}
materialPanels.push(materialPanel);
materialPrevPanel = materialPanel;
}
// 删除多余的
for (const oldChild of oldChildren) {
if (oldChild && materialPanels.indexOf(oldChild) === -1) {
await oldChild.panel.beforeClose.call(oldChild.panelObject);
oldChild.remove();
}
}
},
async beforeClose() {
const panel = this;
const children = Array.from(panel.$.sectionAsset.children);
for (const materialPanel of children) {
const next = await materialPanel.panel.beforeClose.call(materialPanel.panelObject);
if (next === false) {
return false;
} else {
materialPanel.remove();
}
}
return true;
},
},
};
exports.methods = {
undo() {
this.restore('undo');
},
redo() {
this.restore('redo');
},
restore(cmd) {
if (!cmd) {
return;
}
const panel = this;
panel.blurSleep = true;
clearTimeout(panel.blurSleepTimeId);
panel.blurSleepTimeId = setTimeout(() => {
panel.blurSleep = false;
}, 1000);
const children = Array.from(panel.$.sectionAsset.children);
for (const materialPanel of children) {
if (materialPanel.hasAttribute('focused')) {
materialPanel.panelObject[cmd]();
return;
}
}
Editor.Message.send('scene', cmd);
},
/**
* 获取组件帮助菜单的 url
* @param editor
*/
getHelpUrl(editor) {
if (!editor || !editor.help) {
return '';
}
const help = editor.help;
/**
* 约定的规则
* 翻译的都需要 i18n: 开头
* 没有的话属于直接是配置值的方式,配什么返回什么
*/
if (!help.startsWith('i18n:')) {
return help;
}
const i18nKey = help.substr(5);
const url = Editor.I18n.t('ENGINE.help.' + i18nKey);
if (url) {
return url;
}
/**
* 再在编辑器内部查找翻译一次
* 结果可能为空,也是一种需求,即组件配置了但没有合适的文档配置
*/
return Editor.I18n.t(i18nKey);
},
/**
* 组件上的右键菜单
*/
componentContextMenu(uuidList, dump, total, index, nodeDumps) {
// 是否多选节点
const isMultiple = uuidList.length > 1 ? true : false;
const uuid = uuidList[0];
const clipboardComponentInfo = Editor.Clipboard.read('_dump_component_');
Editor.Menu.popup({
menu: [
{
label: Editor.I18n.t('ENGINE.menu.reset_component'),
click() {
Editor.Message.send('scene', 'snapshot');
(dump.value.uuid.values || [dump.value.uuid.value]).forEach((compUuid) => {
Editor.Message.send('scene', 'reset-component', {
uuid: compUuid,
});
});
},
},
{ type: 'separator' },
{
label: Editor.I18n.t('ENGINE.menu.remove_component'),
click() {
Editor.Message.send('scene', 'snapshot');
(dump.value.uuid.values || [dump.value.uuid.value]).forEach((value) => {
nodeDumps.forEach((nodeDump) => {
const uuid = nodeDump.uuid.value;
const index = nodeDump.__comps__.findIndex((dumpData) => dumpData.value.uuid.value === value);
if (index !== -1) {
Editor.Message.send('scene', 'remove-array-element', {
uuid,
path: '__comps__',
index,
});
}
});
});
},
},
{
label: Editor.I18n.t('ENGINE.menu.move_up_component'),
enabled: !isMultiple && index !== 0,
click() {
Editor.Message.send('scene', 'snapshot');
Editor.Message.send('scene', 'move-array-element', {
uuid,
path: '__comps__',
target: index,
offset: -1,
});
},
},
{
label: Editor.I18n.t('ENGINE.menu.move_down_component'),
enabled: !isMultiple && index !== total - 1,
click() {
Editor.Message.send('scene', 'snapshot');
Editor.Message.send('scene', 'move-array-element', {
uuid,
path: '__comps__',
target: index,
offset: 1,
});
},
},
{ type: 'separator' },
{
label: Editor.I18n.t('ENGINE.menu.copy_component'),
enabled: !isMultiple,
async click() {
Editor.Clipboard.write('_dump_component_', {
type: dump.type,
dump: JSON.parse(JSON.stringify(dump)),
});
},
},
{
label: Editor.I18n.t('ENGINE.menu.paste_component_values'),
enabled: !!(clipboardComponentInfo && clipboardComponentInfo.type === dump.type),
async click() {
Editor.Message.send('scene', 'snapshot');
(dump.value.uuid.values || [dump.value.uuid.value]).forEach((value) => {
nodeDumps.forEach((nodeDump) => {
const uuid = nodeDump.uuid.value;
const index = nodeDump.__comps__.findIndex((dumpData) => dumpData.value.uuid.value === value);
if (index !== -1) {
Editor.Message.request('scene', 'set-property', {
uuid,
path: nodeDump.__comps__[index].path,
dump: clipboardComponentInfo.dump,
});
}
});
});
},
},
{ type: 'separator' },
{
// 这个按钮不该出现在 component 上,应该在节点上
label: Editor.I18n.t('ENGINE.menu.paste_component'),
enabled: !!clipboardComponentInfo,
async click() {
Editor.Message.send('scene', 'snapshot');
(dump.value.uuid.values || [dump.value.uuid.value]).forEach(async (dump, index) => {
const uuid = uuidList[index];
await Editor.Message.request('scene', 'create-component', {
uuid,
component: clipboardComponentInfo.type,
});
// 检查是否创建成功,是的话,给赋值
const nodeDump = await Editor.Message.request('scene', 'query-node', uuid);
const length = nodeDump.__comps__ && nodeDump.__comps__.length;
if (length) {
const lastIndex = length - 1;
const lastComp = nodeDump.__comps__[lastIndex];
if (lastComp && lastComp.type === clipboardComponentInfo.type) {
await Editor.Message.request('scene', 'set-property', {
uuid,
path: `__comps__.${lastIndex}`,
dump: clipboardComponentInfo.dump,
});
}
}
});
},
},
],
});
},
nodeContextMenu(uuidList, dumps) {
const dump = dumps[0];
// 是否多选节点
const isMultiple = dump.length > 1 ? true : false;
const clipboardNodeInfo = Editor.Clipboard.read('_dump_node_');
const clipboardNodeWorldTransform = Editor.Clipboard.read('_dump_node_world_transform_');
const clipboardComponentInfo = Editor.Clipboard.read('_dump_component_');
Editor.Menu.popup({
menu: [
{
label: Editor.I18n.t('ENGINE.menu.reset_node'),
enabled: !dump.position.readonly && !dump.rotation.readonly && !dump.scale.readonly,
click() {
Editor.Message.send('scene', 'snapshot');
for (const uuid of uuidList) {
Editor.Message.send('scene', 'reset-node', {
uuid,
});
}
},
},
{ type: 'separator' },
{
label: Editor.I18n.t('ENGINE.menu.copy_node_value'),
enabled: !isMultiple,
async click() {
Editor.Clipboard.write('_dump_node_', {
type: dump.type,
attrs: ['position', 'rotation', 'scale', 'layer'],
dump: JSON.parse(JSON.stringify(dump)),
});
},
},
{
label: Editor.I18n.t('ENGINE.menu.paste_node_value'),
enabled: !!clipboardNodeInfo,
async click() {
Editor.Message.send('scene', 'snapshot');
for (const uuid of uuidList) {
clipboardNodeInfo.attrs.forEach((attr) => {
Editor.Message.send('scene', 'set-property', {
uuid,
path: attr,
dump: clipboardNodeInfo.dump[attr],
});
});
}
},
},
{ type: 'separator' },
{
label: Editor.I18n.t('ENGINE.menu.copy_node_world_transform'),
enabled: !isMultiple,
async click() {
const data = await Editor.Message.request('scene', 'execute-scene-script', {
name: 'inspector',
method: 'queryNodeWorldTransform',
args: [dump.uuid.value],
});
if (data) {
Editor.Clipboard.write('_dump_node_world_transform_', {
data,
});
}
},
},
{
label: Editor.I18n.t('ENGINE.menu.paste_node_world_transform'),
enabled: !!clipboardNodeWorldTransform,
async click() {
Editor.Message.send('scene', 'snapshot');
if (clipboardNodeWorldTransform.data) {
for (const uuid of uuidList) {
Editor.Message.request('scene', 'execute-scene-script', {
name: 'inspector',
method: 'setNodeWorldTransform',
args: [uuid, clipboardNodeWorldTransform.data],
});
}
}
},
},
{ type: 'separator' },
{
label: Editor.I18n.t('ENGINE.menu.paste_component'),
enabled: !!clipboardComponentInfo,
async click() {
Editor.Message.send('scene', 'snapshot');
uuidList.forEach(async (uuid) => {
await Editor.Message.request('scene', 'create-component', {
uuid,
component: clipboardComponentInfo.type,
});
// 检查是否创建成功,是的话,给赋值
const nodeDump = await Editor.Message.request('scene', 'query-node', uuid);
const length = nodeDump.__comps__ && nodeDump.__comps__.length;
if (length) {
const lastIndex = length - 1;
const lastComp = nodeDump.__comps__[lastIndex];
if (lastComp && lastComp.type === clipboardComponentInfo.type) {
await Editor.Message.request('scene', 'set-property', {
uuid,
path: `__comps__.${lastIndex}`,
dump: clipboardComponentInfo.dump,
});
}
}
});
},
},
{ type: 'separator' },
{
label: Editor.I18n.t('ENGINE.menu.reset_node_position'),
enabled: !dump.position.readonly && JSON.stringify(dump.position.value) !== JSON.stringify(dump.position.default),
click() {
Editor.Message.send('scene', 'snapshot');
for (const uuid of uuidList) {
Editor.Message.send('scene', 'reset-property', {
uuid,
path: 'position',
});
}
},
},
{
label: Editor.I18n.t('ENGINE.menu.reset_node_rotation'),
enabled: !dump.rotation.readonly && JSON.stringify(dump.rotation.value) !== JSON.stringify(dump.rotation.default),
click() {
Editor.Message.send('scene', 'snapshot');
for (const uuid of uuidList) {
Editor.Message.send('scene', 'reset-property', {
uuid,
path: 'rotation',
});
}
},
},
{
label: Editor.I18n.t('ENGINE.menu.reset_node_scale'),
enabled: !dump.rotation.readonly && JSON.stringify(dump.scale.value) !== JSON.stringify(dump.scale.default),
click() {
Editor.Message.send('scene', 'snapshot');
for (const uuid of uuidList) {
Editor.Message.send('scene', 'reset-property', {
uuid,
path: 'scale',
});
}
},
},
],
});
},
replaceAssetUuidInNodes(assetUuid, newAssetUuid) {
const panel = this;
const materialUuids = panel.assets['cc.Material'];
try {
for (const dumpPath in materialUuids[assetUuid]) {
const dumpData = materialUuids[assetUuid][dumpPath];
for (let i = 0; i < panel.uuidList.length; i++) {
const nodeUuid = panel.uuidList[i];
Editor.Message.send('scene', 'set-property', {
uuid: nodeUuid,
path: dumpPath,
dump: {
type: dumpData.type,
value: { uuid: newAssetUuid },
},
});
}
}
} catch (error) {
console.error(error);
}
},
};
exports.update = async function update(uuidList, renderMap, dropConfig, typeManager, renderManager) {
const panel = this;
const enginePath = path.join('editor', 'inspector', 'components');
Object.values(renderMap).forEach(config => {
Object.values(config).forEach(renders => {
renders.sort((a, b) => {
return b.indexOf(enginePath) - a.indexOf(enginePath);
});
});
});
panel.uuidList = uuidList || [];
panel.renderMap = renderMap;
panel.dropConfig = dropConfig;
panel.typeManager = typeManager;
panel.renderManager = renderManager;
for (const prop in Elements) {
const element = Elements[prop];
if (element.update) {
await element.update.call(panel);
}
}
};
exports.ready = async function ready() {
const panel = this;
// 为了避免把 ui-num-input, ui-color 的连续 change 进行 snapshot
panel.snapshotLock = false;
for (const prop in Elements) {
const element = Elements[prop];
if (element.ready) {
element.ready.call(panel);
}
}
this.replaceAssetUuidInNodesBind = this.replaceAssetUuidInNodes.bind(this);
Editor.Message.addBroadcastListener('inspector:replace-asset-uuid-in-nodes', this.replaceAssetUuidInNodesBind);
};
exports.close = async function close() {
const panel = this;
for (const prop in Elements) {
const element = Elements[prop];
if (element.close) {
element.close.call(panel);
}
}
Editor.Message.removeBroadcastListener('inspector:replace-asset-uuid-in-nodes', this.replaceAssetUuidInNodesBind);
};
exports.beforeClose = async function beforeClose() {
const panel = this;
for (const prop in Elements) {
const element = Elements[prop];
if (element.beforeClose) {
const next = await element.beforeClose.call(panel);
if (next === false) {
return false;
}
}
}
return true;
};
exports.config = {
section: require('../components.js'),
};