mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-19 14:52:40 +08:00
0319477911
* fix decorator warning of ValueTypes (sync #6285) * refresh copyright
896 lines
32 KiB
TypeScript
896 lines
32 KiB
TypeScript
/*
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
Copyright (c) 2017-2020 Xiamen Yaji Software Co., Ltd.
|
|
|
|
http://www.cocos.com
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated engine source code (the "Software"), a limited,
|
|
worldwide, royalty-free, non-assignable, revocable and non-exclusive license
|
|
to use Cocos Creator solely to develop games on your target platforms. You shall
|
|
not use Cocos Creator software for developing other software or tools that's
|
|
used for developing games. You are not granted to publish, distribute,
|
|
sublicense, and/or sell copies of Cocos Creator.
|
|
|
|
The software or tools in this License Agreement are licensed, not sold.
|
|
Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* @packageDocumentation
|
|
* @hidden
|
|
*/
|
|
|
|
import { warnID } from '../platform/debug';
|
|
import * as js from '../utils/js';
|
|
import * as misc from '../utils/misc';
|
|
import { CCClass } from './class';
|
|
import * as Attr from './utils/attribute';
|
|
import MissingScript from '../components/missing-script';
|
|
import { EDITOR, TEST, DEV, JSB, PREVIEW, SUPPORT_JIT } from 'internal:constants';
|
|
import { legacyCC } from '../global-exports';
|
|
|
|
// HELPERS
|
|
|
|
// tslint:disable: no-shadowed-variable
|
|
|
|
/**
|
|
* @en Contains information collected during deserialization
|
|
* @zh 包含反序列化时的一些信息。
|
|
* @class Details
|
|
*
|
|
*/
|
|
export class Details {
|
|
|
|
public static pool: js.Pool<{}>;
|
|
|
|
public assignAssetsBy!: Function;
|
|
public uuidList: string[];
|
|
public uuidObjList: object[];
|
|
public uuidPropList: string[];
|
|
private _stillUseUrl: any;
|
|
|
|
constructor () {
|
|
/**
|
|
* list of the depends assets' uuid
|
|
*/
|
|
this.uuidList = [];
|
|
/**
|
|
* the obj list whose field needs to load asset by uuid
|
|
*/
|
|
this.uuidObjList = [];
|
|
/**
|
|
* the corresponding field name which referenced to the asset
|
|
*/
|
|
this.uuidPropList = [];
|
|
|
|
// TODO - DELME since 2.0
|
|
this._stillUseUrl = js.createMap(true);
|
|
|
|
if (EDITOR || TEST) {
|
|
this.assignAssetsBy = (getter) => {
|
|
// ignore this._stillUseUrl
|
|
for (let i = 0, len = this.uuidList.length; i < len; i++) {
|
|
const uuid = this.uuidList[i];
|
|
const obj = this.uuidObjList[i];
|
|
const prop = this.uuidPropList[i];
|
|
obj[prop] = getter(uuid);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @zh
|
|
* 重置。
|
|
* @method reset
|
|
*/
|
|
public reset () {
|
|
this.uuidList.length = 0;
|
|
this.uuidObjList.length = 0;
|
|
this.uuidPropList.length = 0;
|
|
js.clear(this._stillUseUrl);
|
|
}
|
|
|
|
// /**
|
|
// * @method getUuidOf
|
|
// * @param {Object} obj
|
|
// * @param {String} propName
|
|
// * @return {String}
|
|
// */
|
|
// getUuidOf (obj, propName) {
|
|
// for (var i = 0; i < this.uuidObjList.length; i++) {
|
|
// if (this.uuidObjList[i] === obj && this.uuidPropList[i] === propName) {
|
|
// return this.uuidList[i];
|
|
// }
|
|
// }
|
|
// return "";
|
|
// }
|
|
/**
|
|
* @method push
|
|
* @param {Object} obj
|
|
* @param {String} propName
|
|
* @param {String} uuid
|
|
*/
|
|
public push (obj: Object, propName: string, uuid: string, _stillUseUrl: any) {
|
|
if (_stillUseUrl) {
|
|
this._stillUseUrl[this.uuidList.length] = true;
|
|
}
|
|
this.uuidList.push(uuid);
|
|
this.uuidObjList.push(obj);
|
|
this.uuidPropList.push(propName);
|
|
}
|
|
}
|
|
|
|
Details.pool = new js.Pool((obj: any) => {
|
|
obj.reset();
|
|
}, 10);
|
|
|
|
Details.pool.get = function () {
|
|
return this._get() || new Details();
|
|
};
|
|
|
|
// IMPLEMENT OF DESERIALIZATION
|
|
|
|
function _dereference (self) {
|
|
// 这里不采用遍历反序列化结果的方式,因为反序列化的结果如果引用到复杂的外部库,很容易堆栈溢出。
|
|
const deserializedList = self.deserializedList;
|
|
const idPropList = self._idPropList;
|
|
const idList = self._idList;
|
|
const idObjList = self._idObjList;
|
|
const onDereferenced = self._classFinder && self._classFinder.onDereferenced;
|
|
let i;
|
|
let propName;
|
|
let id;
|
|
if (EDITOR && onDereferenced) {
|
|
for (i = 0; i < idList.length; i++) {
|
|
propName = idPropList[i];
|
|
id = idList[i];
|
|
idObjList[i][propName] = deserializedList[id];
|
|
onDereferenced(deserializedList, id, idObjList[i], propName);
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < idList.length; i++) {
|
|
propName = idPropList[i];
|
|
id = idList[i];
|
|
idObjList[i][propName] = deserializedList[id];
|
|
}
|
|
}
|
|
}
|
|
|
|
function compileObjectTypeJit (sources, defaultValue, accessorToSet, propNameLiteralToSet, assumeHavePropIfIsValue, stillUseUrl) {
|
|
if (defaultValue instanceof legacyCC.ValueType) {
|
|
// fast case
|
|
if (!assumeHavePropIfIsValue) {
|
|
sources.push('if(prop){');
|
|
}
|
|
const ctorCode = js.getClassName(defaultValue);
|
|
sources.push(`s._deserializeTypedObject(o${accessorToSet},prop,${ctorCode});`);
|
|
if (!assumeHavePropIfIsValue) {
|
|
sources.push('}else o' + accessorToSet + '=null;');
|
|
}
|
|
}
|
|
else {
|
|
sources.push('if(prop){');
|
|
sources.push('s._deserializeObjField(o,prop,' +
|
|
propNameLiteralToSet +
|
|
((EDITOR || TEST) ? ',t&&o,' : ',null,') +
|
|
!!stillUseUrl +
|
|
');');
|
|
sources.push('}else o' + accessorToSet + '=null;');
|
|
}
|
|
}
|
|
|
|
const compileDeserialize = SUPPORT_JIT ? (self, klass) => {
|
|
const TYPE = Attr.DELIMETER + 'type';
|
|
const EDITOR_ONLY = Attr.DELIMETER + 'editorOnly';
|
|
const DEFAULT = Attr.DELIMETER + 'default';
|
|
const SAVE_URL_AS_ASSET = Attr.DELIMETER + 'saveUrlAsAsset';
|
|
const FORMERLY_SERIALIZED_AS = Attr.DELIMETER + 'formerlySerializedAs';
|
|
const attrs = Attr.getClassAttrs(klass);
|
|
|
|
const props = klass.__values__;
|
|
// self, obj, serializedData, klass, target
|
|
const sources = [
|
|
'var prop;',
|
|
];
|
|
const fastMode = misc.BUILTIN_CLASSID_RE.test(js._getClassId(klass));
|
|
// sources.push('var vb,vn,vs,vo,vu,vf;'); // boolean, number, string, object, undefined, function
|
|
// tslint:disable-next-line: prefer-for-of
|
|
for (let p = 0; p < props.length; p++) {
|
|
const propName = props[p];
|
|
if ((PREVIEW || (EDITOR && self._ignoreEditorOnly)) && attrs[propName + EDITOR_ONLY]) {
|
|
continue; // skip editor only if in preview
|
|
}
|
|
|
|
let accessorToSet;
|
|
let propNameLiteralToSet;
|
|
if (CCClass.IDENTIFIER_RE.test(propName)) {
|
|
propNameLiteralToSet = '"' + propName + '"';
|
|
accessorToSet = '.' + propName;
|
|
}
|
|
else {
|
|
propNameLiteralToSet = CCClass.escapeForJS(propName);
|
|
accessorToSet = '[' + propNameLiteralToSet + ']';
|
|
}
|
|
|
|
let accessorToGet = accessorToSet;
|
|
if (attrs[propName + FORMERLY_SERIALIZED_AS]) {
|
|
const propNameToRead = attrs[propName + FORMERLY_SERIALIZED_AS];
|
|
if (CCClass.IDENTIFIER_RE.test(propNameToRead)) {
|
|
accessorToGet = '.' + propNameToRead;
|
|
}
|
|
else {
|
|
accessorToGet = '[' + CCClass.escapeForJS(propNameToRead) + ']';
|
|
}
|
|
}
|
|
|
|
sources.push('prop=d' + accessorToGet + ';');
|
|
sources.push(`if(typeof ${JSB ? '(prop)' : 'prop'}!=="undefined"){`);
|
|
|
|
const stillUseUrl = attrs[propName + SAVE_URL_AS_ASSET];
|
|
// function undefined object(null) string boolean number
|
|
const defaultValue = CCClass.getDefault(attrs[propName + DEFAULT]);
|
|
if (fastMode) {
|
|
let isPrimitiveType;
|
|
const userType = attrs[propName + TYPE];
|
|
if (defaultValue === undefined && userType) {
|
|
isPrimitiveType = userType === legacyCC.String ||
|
|
userType === legacyCC.Integer ||
|
|
userType === legacyCC.Float ||
|
|
userType === legacyCC.Boolean;
|
|
}
|
|
else {
|
|
const defaultType = typeof defaultValue;
|
|
isPrimitiveType = (defaultType === 'string' && !stillUseUrl) ||
|
|
defaultType === 'number' ||
|
|
defaultType === 'boolean';
|
|
}
|
|
|
|
if (isPrimitiveType) {
|
|
sources.push(`o${accessorToSet}=prop;`);
|
|
}
|
|
else {
|
|
compileObjectTypeJit(sources, defaultValue, accessorToSet, propNameLiteralToSet, true, stillUseUrl);
|
|
}
|
|
}
|
|
else {
|
|
sources.push(`if(typeof ${JSB ? '(prop)' : 'prop'}!=="object"){` +
|
|
'o' + accessorToSet + '=prop;' +
|
|
'}else{');
|
|
compileObjectTypeJit(sources, defaultValue, accessorToSet, propNameLiteralToSet, false, stillUseUrl);
|
|
sources.push('}');
|
|
}
|
|
sources.push('}');
|
|
}
|
|
if (legacyCC.js.isChildClassOf(klass, legacyCC._BaseNode) || legacyCC.js.isChildClassOf(klass, legacyCC.Component)) {
|
|
if (PREVIEW || (EDITOR && self._ignoreEditorOnly)) {
|
|
const mayUsedInPersistRoot = js.isChildClassOf(klass, legacyCC.Node);
|
|
if (mayUsedInPersistRoot) {
|
|
sources.push('d._id&&(o._id=d._id);');
|
|
}
|
|
}
|
|
else {
|
|
sources.push('d._id&&(o._id=d._id);');
|
|
}
|
|
}
|
|
if (props[props.length - 1] === '_$erialized') {
|
|
// deep copy original serialized data
|
|
sources.push('o._$erialized=JSON.parse(JSON.stringify(d));');
|
|
// parse the serialized data as primitive javascript object, so its __id__ will be dereferenced
|
|
sources.push('s._deserializePrimitiveObject(o._$erialized,d);');
|
|
}
|
|
return Function('s', 'o', 'd', 'k', 't', sources.join(''));
|
|
} : (self, klass) => {
|
|
const fastMode = misc.BUILTIN_CLASSID_RE.test(js._getClassId(klass));
|
|
const shouldCopyId = legacyCC.js.isChildClassOf(klass, legacyCC._BaseNode) || legacyCC.js.isChildClassOf(klass, legacyCC.Component);
|
|
let shouldCopyRawData;
|
|
|
|
const simpleProps: any = [];
|
|
let simplePropsToRead = simpleProps;
|
|
const advancedProps: any = [];
|
|
let advancedPropsToRead = advancedProps;
|
|
const advancedPropsUseUrl: any = [];
|
|
const advancedPropsValueType: any = [];
|
|
|
|
(() => {
|
|
const props = klass.__values__;
|
|
shouldCopyRawData = props[props.length - 1] === '_$erialized';
|
|
|
|
const attrs = Attr.getClassAttrs(klass);
|
|
const TYPE = Attr.DELIMETER + 'type';
|
|
const DEFAULT = Attr.DELIMETER + 'default';
|
|
const SAVE_URL_AS_ASSET = Attr.DELIMETER + 'saveUrlAsAsset';
|
|
const FORMERLY_SERIALIZED_AS = Attr.DELIMETER + 'formerlySerializedAs';
|
|
|
|
// tslint:disable-next-line: prefer-for-of
|
|
for (let p = 0; p < props.length; p++) {
|
|
const propName = props[p];
|
|
let propNameToRead = propName;
|
|
if (attrs[propName + FORMERLY_SERIALIZED_AS]) {
|
|
propNameToRead = attrs[propName + FORMERLY_SERIALIZED_AS];
|
|
}
|
|
const stillUseUrl = attrs[propName + SAVE_URL_AS_ASSET];
|
|
// function undefined object(null) string boolean number
|
|
const defaultValue = CCClass.getDefault(attrs[propName + DEFAULT]);
|
|
let isPrimitiveType = false;
|
|
if (fastMode) {
|
|
const userType = attrs[propName + TYPE];
|
|
if (defaultValue === undefined && userType) {
|
|
isPrimitiveType = userType === legacyCC.String ||
|
|
userType === legacyCC.Integer ||
|
|
userType === legacyCC.Float ||
|
|
userType === legacyCC.Boolean;
|
|
}
|
|
else {
|
|
const defaultType = typeof defaultValue;
|
|
isPrimitiveType = (defaultType === 'string' && !stillUseUrl) ||
|
|
defaultType === 'number' ||
|
|
defaultType === 'boolean';
|
|
}
|
|
}
|
|
if (fastMode && isPrimitiveType) {
|
|
if (propNameToRead !== propName && simplePropsToRead === simpleProps) {
|
|
simplePropsToRead = simpleProps.slice();
|
|
}
|
|
simpleProps.push(propName);
|
|
if (simplePropsToRead !== simpleProps) {
|
|
simplePropsToRead.push(propNameToRead);
|
|
}
|
|
}
|
|
else {
|
|
if (propNameToRead !== propName && advancedPropsToRead === advancedProps) {
|
|
advancedPropsToRead = advancedProps.slice();
|
|
}
|
|
advancedProps.push(propName);
|
|
if (advancedPropsToRead !== advancedProps) {
|
|
advancedPropsToRead.push(propNameToRead);
|
|
}
|
|
advancedPropsUseUrl.push(stillUseUrl);
|
|
advancedPropsValueType.push((defaultValue instanceof legacyCC.ValueType) && defaultValue.constructor);
|
|
}
|
|
}
|
|
})();
|
|
|
|
return (s, o, d, k, t) => {
|
|
for (let i = 0; i < simpleProps.length; ++i) {
|
|
const prop = d[simplePropsToRead[i]];
|
|
if (prop !== undefined) {
|
|
o[simpleProps[i]] = prop;
|
|
}
|
|
}
|
|
for (let i = 0; i < advancedProps.length; ++i) {
|
|
const propName = advancedProps[i];
|
|
const prop = d[advancedPropsToRead[i]];
|
|
if (prop === undefined) {
|
|
continue;
|
|
}
|
|
if (!fastMode && typeof prop !== 'object') {
|
|
o[propName] = prop;
|
|
}
|
|
else {
|
|
// fastMode (so will not simpleProp) or object
|
|
const valueTypeCtor = advancedPropsValueType[i];
|
|
if (valueTypeCtor) {
|
|
if (fastMode || prop) {
|
|
s._deserializeTypedObject(o[propName], prop, valueTypeCtor);
|
|
}
|
|
else {
|
|
o[propName] = null;
|
|
}
|
|
}
|
|
else {
|
|
if (prop) {
|
|
s._deserializeObjField(
|
|
o,
|
|
prop,
|
|
propName,
|
|
(EDITOR || TEST) ? (t && o) : null,
|
|
advancedPropsUseUrl[i],
|
|
);
|
|
}
|
|
else {
|
|
o[propName] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (shouldCopyId && d._id) {
|
|
o._id = d._id;
|
|
}
|
|
if (shouldCopyRawData) {
|
|
// deep copy original serialized data
|
|
o._$erialized = JSON.parse(JSON.stringify(d));
|
|
// parse the serialized data as primitive javascript object, so its __id__ will be dereferenced
|
|
s._deserializePrimitiveObject(o._$erialized, d);
|
|
}
|
|
};
|
|
};
|
|
|
|
function unlinkUnusedPrefab (self, serialized, obj) {
|
|
const uuid = serialized.asset && serialized.asset.__uuid__;
|
|
if (uuid) {
|
|
const last = self.result.uuidList.length - 1;
|
|
if (self.result.uuidList[last] === uuid &&
|
|
self.result.uuidObjList[last] === obj &&
|
|
self.result.uuidPropList[last] === 'asset') {
|
|
self.result.uuidList.pop();
|
|
self.result.uuidObjList.pop();
|
|
self.result.uuidPropList.pop();
|
|
} else {
|
|
warnID(4935);
|
|
}
|
|
}
|
|
}
|
|
|
|
function _deserializeFireClass (self, obj, serialized, klass, target) {
|
|
let deserialize;
|
|
if (klass.hasOwnProperty('__deserialize__')) {
|
|
deserialize = klass.__deserialize__;
|
|
}
|
|
else {
|
|
deserialize = compileDeserialize(self, klass);
|
|
// if (TEST && !isPhantomJS) {
|
|
// log(deserialize);
|
|
// }
|
|
js.value(klass, '__deserialize__', deserialize, true);
|
|
}
|
|
deserialize(self, obj, serialized, klass, target);
|
|
// if preview or build worker
|
|
if (PREVIEW || (EDITOR && self._ignoreEditorOnly)) {
|
|
if (klass === legacyCC._PrefabInfo && !obj.sync) {
|
|
unlinkUnusedPrefab(self, serialized, obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
// function _compileTypedObject (accessor, klass, ctorCode) {
|
|
// if (klass === cc.Vec2) {
|
|
// return `{` +
|
|
// `o${accessor}.x=prop.x||0;` +
|
|
// `o${accessor}.y=prop.y||0;` +
|
|
// `}`;
|
|
// }
|
|
// else if (klass === cc.Color) {
|
|
// return `{` +
|
|
// `o${accessor}.r=prop.r||0;` +
|
|
// `o${accessor}.g=prop.g||0;` +
|
|
// `o${accessor}.b=prop.b||0;` +
|
|
// `o${accessor}.a=(prop.a===undefined?255:prop.a);` +
|
|
// `}`;
|
|
// }
|
|
// else if (klass === cc.Size) {
|
|
// return `{` +
|
|
// `o${accessor}.width=prop.width||0;` +
|
|
// `o${accessor}.height=prop.height||0;` +
|
|
// `}`;
|
|
// }
|
|
// else {
|
|
// return `s._deserializeTypedObject(o${accessor},prop,${ctorCode});`;
|
|
// }
|
|
// }
|
|
|
|
// tslint:disable-next-line: class-name
|
|
export class _Deserializer {
|
|
|
|
public static pool: js.Pool<{}>;
|
|
public result: any;
|
|
public customEnv: any;
|
|
public deserializedList: any[];
|
|
public deserializedData: any;
|
|
private _classFinder: any;
|
|
private _target: any;
|
|
private _ignoreEditorOnly: any;
|
|
private _idList: any[];
|
|
private _idObjList: any[];
|
|
private _idPropList: any[];
|
|
|
|
constructor (result, target, classFinder, customEnv, ignoreEditorOnly) {
|
|
this.result = result;
|
|
this.customEnv = customEnv;
|
|
this.deserializedList = [];
|
|
this.deserializedData = null;
|
|
this._classFinder = classFinder;
|
|
if (DEV) {
|
|
this._target = target;
|
|
this._ignoreEditorOnly = ignoreEditorOnly;
|
|
}
|
|
this._idList = [];
|
|
this._idObjList = [];
|
|
this._idPropList = [];
|
|
}
|
|
|
|
public deserialize (jsonObj) {
|
|
if (Array.isArray(jsonObj)) {
|
|
const jsonArray = jsonObj;
|
|
const refCount = jsonArray.length;
|
|
this.deserializedList.length = refCount;
|
|
// deserialize
|
|
for (let i = 0; i < refCount; i++) {
|
|
if (jsonArray[i]) {
|
|
if (EDITOR || TEST) {
|
|
const mainTarget = (i === 0 && this._target);
|
|
this.deserializedList[i] = this._deserializeObject(jsonArray[i], false, mainTarget, this.deserializedList, '' + i);
|
|
}
|
|
else {
|
|
this.deserializedList[i] = this._deserializeObject(jsonArray[i], false);
|
|
}
|
|
}
|
|
}
|
|
this.deserializedData = refCount > 0 ? this.deserializedList[0] : [];
|
|
|
|
//// callback
|
|
// for (var j = 0; j < refCount; j++) {
|
|
// if (referencedList[j].onAfterDeserialize) {
|
|
// referencedList[j].onAfterDeserialize();
|
|
// }
|
|
// }
|
|
}
|
|
else {
|
|
this.deserializedList.length = 1;
|
|
if (EDITOR || TEST) {
|
|
this.deserializedData = jsonObj ? this._deserializeObject(jsonObj, false, this._target, this.deserializedList, '0') : null;
|
|
}
|
|
else {
|
|
this.deserializedData = jsonObj ? this._deserializeObject(jsonObj, false) : null;
|
|
}
|
|
this.deserializedList[0] = this.deserializedData;
|
|
|
|
//// callback
|
|
// if (deserializedData.onAfterDeserialize) {
|
|
// deserializedData.onAfterDeserialize();
|
|
// }
|
|
}
|
|
|
|
// dereference
|
|
_dereference(this);
|
|
|
|
return this.deserializedData;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} serialized - The obj to deserialize, must be non-nil
|
|
* @param {Boolean} _stillUseUrl
|
|
* @param {Object} [target=null] - editor only
|
|
* @param {Object} [owner] - debug only
|
|
* @param {String} [propName] - debug only
|
|
*/
|
|
private _deserializeObject (serialized, _stillUseUrl: Boolean, target?, owner?: Object, propName?: String) {
|
|
let prop;
|
|
let obj: any = null; // the obj to return
|
|
let klass: any = null;
|
|
const type = serialized.__type__;
|
|
if (type === 'TypedArray') {
|
|
const array = serialized.array;
|
|
// @ts-ignore
|
|
obj = new window[serialized.ctor](array.length);
|
|
for (let i = 0; i < array.length; ++i) {
|
|
obj[i] = array[i];
|
|
}
|
|
return obj;
|
|
}
|
|
else if (type) {
|
|
|
|
// Type Object (including CCClass)
|
|
|
|
klass = this._classFinder(type, serialized, owner, propName);
|
|
if (!klass) {
|
|
const notReported = this._classFinder === js._getClassById;
|
|
if (notReported) {
|
|
legacyCC.deserialize.reportMissingClass(type);
|
|
}
|
|
return null;
|
|
}
|
|
const self = this;
|
|
// @ts-ignore
|
|
function deserializeByType () {
|
|
if ((EDITOR || TEST) && target) {
|
|
// use target
|
|
if ( !(target instanceof klass) ) {
|
|
warnID(5300, js.getClassName(target), klass);
|
|
}
|
|
obj = target;
|
|
}
|
|
else {
|
|
// instantiate a new object
|
|
obj = new klass();
|
|
}
|
|
|
|
if (obj._deserialize) {
|
|
obj._deserialize(serialized.content, self);
|
|
return;
|
|
}
|
|
if (legacyCC.Class._isCCClass(klass)) {
|
|
_deserializeFireClass(self, obj, serialized, klass, target);
|
|
}
|
|
else {
|
|
self._deserializeTypedObject(obj, serialized, klass);
|
|
}
|
|
}
|
|
|
|
// @ts-ignore
|
|
function checkDeserializeByType () {
|
|
try {
|
|
deserializeByType();
|
|
}
|
|
catch (e) {
|
|
console.error('deserialize ' + klass.name + ' failed, ' + e.stack);
|
|
klass = MissingScript.getMissingWrapper(type, serialized);
|
|
legacyCC.deserialize.reportMissingClass(type);
|
|
deserializeByType();
|
|
}
|
|
}
|
|
|
|
if (EDITOR && legacyCC.js.isChildClassOf(klass, legacyCC.Component)) {
|
|
checkDeserializeByType();
|
|
}
|
|
else {
|
|
deserializeByType();
|
|
}
|
|
}
|
|
else if ( !Array.isArray(serialized) ) {
|
|
|
|
// embedded primitive javascript object
|
|
|
|
obj = ((EDITOR || TEST) && target) || {};
|
|
this._deserializePrimitiveObject(obj, serialized);
|
|
}
|
|
else {
|
|
|
|
// Array
|
|
|
|
if ((EDITOR || TEST) && target) {
|
|
target.length = serialized.length;
|
|
obj = target;
|
|
}
|
|
else {
|
|
obj = new Array(serialized.length);
|
|
}
|
|
|
|
for (let i = 0; i < serialized.length; i++) {
|
|
prop = serialized[i];
|
|
if (typeof prop === 'object' && prop) {
|
|
if (EDITOR || TEST) {
|
|
this._deserializeObjField(obj, prop, '' + i, target && obj, _stillUseUrl);
|
|
}
|
|
else {
|
|
this._deserializeObjField(obj, prop, '' + i, null, _stillUseUrl);
|
|
}
|
|
}
|
|
else {
|
|
obj[i] = prop;
|
|
}
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
// 和 _deserializeObject 不同的地方在于会判断 id 和 uuid
|
|
private _deserializeObjField (obj, jsonObj, propName, target?, _stillUseUrl?) {
|
|
const id = jsonObj.__id__;
|
|
if (id === undefined) {
|
|
const uuid = jsonObj.__uuid__;
|
|
if (uuid) {
|
|
// if (ENABLE_TARGET) {
|
|
// 这里不做任何操作,因为有可能调用者需要知道依赖哪些 asset。
|
|
// 调用者使用 uuidList 时,可以判断 obj[propName] 是否为空,为空则表示待进一步加载,
|
|
// 不为空则只是表明依赖关系。
|
|
// if (target && target[propName] && target[propName]._uuid === uuid) {
|
|
// console.assert(obj[propName] === target[propName]);
|
|
// return;
|
|
// }
|
|
// }
|
|
this.result.push(obj, propName, uuid, _stillUseUrl);
|
|
}
|
|
else {
|
|
if (EDITOR || TEST) {
|
|
obj[propName] = this._deserializeObject(jsonObj, _stillUseUrl, target && target[propName], obj, propName);
|
|
}
|
|
else {
|
|
obj[propName] = this._deserializeObject(jsonObj, _stillUseUrl);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
const dObj = this.deserializedList[id];
|
|
if (dObj) {
|
|
obj[propName] = dObj;
|
|
}
|
|
else {
|
|
this._idList.push(id);
|
|
this._idObjList.push(obj);
|
|
this._idPropList.push(propName);
|
|
}
|
|
}
|
|
}
|
|
|
|
private _deserializePrimitiveObject (instance, serialized) {
|
|
const self = this;
|
|
for (const propName in serialized) {
|
|
if (serialized.hasOwnProperty(propName)) {
|
|
const prop = serialized[propName];
|
|
if (typeof prop !== 'object') {
|
|
if (propName !== '__type__'/* && k != '__id__'*/) {
|
|
instance[propName] = prop;
|
|
}
|
|
}
|
|
else {
|
|
if (prop) {
|
|
if (EDITOR || TEST) {
|
|
self._deserializeObjField(instance, prop, propName, self._target && instance);
|
|
}
|
|
else {
|
|
self._deserializeObjField(instance, prop, propName);
|
|
}
|
|
}
|
|
else {
|
|
instance[propName] = null;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private _deserializeTypedObject (instance, serialized, klass) {
|
|
if (klass === legacyCC.Vec2) {
|
|
instance.x = serialized.x || 0;
|
|
instance.y = serialized.y || 0;
|
|
return;
|
|
} else if (klass === legacyCC.Vec3) {
|
|
instance.x = serialized.x || 0;
|
|
instance.y = serialized.y || 0;
|
|
instance.z = serialized.z || 0;
|
|
return;
|
|
} else if (klass === legacyCC.Color) {
|
|
instance.r = serialized.r || 0;
|
|
instance.g = serialized.g || 0;
|
|
instance.b = serialized.b || 0;
|
|
const a = serialized.a;
|
|
instance.a = (a === undefined ? 255 : a);
|
|
return;
|
|
} else if (klass === legacyCC.Size) {
|
|
instance.width = serialized.width || 0;
|
|
instance.height = serialized.height || 0;
|
|
return;
|
|
}
|
|
|
|
const DEFAULT = Attr.DELIMETER + 'default';
|
|
const attrs = Attr.getClassAttrs(klass);
|
|
const fastDefinedProps = klass.__props__ || Object.keys(instance); // 遍历 instance,如果具有类型,才不会把 __type__ 也读进来
|
|
// tslint:disable-next-line: prefer-for-of
|
|
for (let i = 0; i < fastDefinedProps.length; i++) {
|
|
const propName = fastDefinedProps[i];
|
|
let value = serialized[propName];
|
|
if (value === undefined || !serialized.hasOwnProperty(propName)) {
|
|
// not serialized,
|
|
// recover to default value in ValueType, because eliminated properties equals to
|
|
// its default value in ValueType, not default value in user class
|
|
value = CCClass.getDefault(attrs[propName + DEFAULT]);
|
|
}
|
|
|
|
if (typeof value !== 'object') {
|
|
instance[propName] = value;
|
|
} else if (value) {
|
|
if (EDITOR || TEST) {
|
|
this._deserializeObjField(instance, value, propName, this._target && instance);
|
|
} else {
|
|
this._deserializeObjField(instance, value, propName);
|
|
}
|
|
} else {
|
|
instance[propName] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_Deserializer.pool = new js.Pool((obj: any) => {
|
|
obj.result = null;
|
|
obj.customEnv = null;
|
|
obj.deserializedList.length = 0;
|
|
obj.deserializedData = null;
|
|
obj._classFinder = null;
|
|
if (DEV) {
|
|
obj._target = null;
|
|
}
|
|
obj._idList.length = 0;
|
|
obj._idObjList.length = 0;
|
|
obj._idPropList.length = 0;
|
|
}, 1);
|
|
// @ts-ignore
|
|
_Deserializer.pool.get = function (result, target, classFinder, customEnv, ignoreEditorOnly) {
|
|
const cache: any = this._get();
|
|
if (cache) {
|
|
cache.result = result;
|
|
cache.customEnv = customEnv;
|
|
cache._classFinder = classFinder;
|
|
if (DEV) {
|
|
cache._target = target;
|
|
cache._ignoreEditorOnly = ignoreEditorOnly;
|
|
}
|
|
return cache;
|
|
}
|
|
else {
|
|
return new _Deserializer(result, target, classFinder, customEnv, ignoreEditorOnly);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @module cc
|
|
*/
|
|
|
|
/**
|
|
* @en Deserialize json to `Asset`.
|
|
* @zh 将 JSON 反序列化为对象实例。
|
|
*
|
|
* 当指定了 target 选项时,如果 target 引用的其它 asset 的 uuid 不变,则不会改变 target 对 asset 的引用,
|
|
* 也不会将 uuid 保存到 result 对象中。
|
|
*
|
|
* @method deserialize
|
|
* @param {String|Object} data - the serialized `Asset` json string or json object.
|
|
* @param {Details} [details] - additional loading result
|
|
* @param {Object} [options]
|
|
* @return {object} the main data(asset)
|
|
*/
|
|
export function deserialize (data, details, options) {
|
|
options = options || {};
|
|
const classFinder = options.classFinder || js._getClassById;
|
|
// 启用 createAssetRefs 后,如果有 url 属性则会被统一强制设置为 { uuid: 'xxx' },必须后面再特殊处理
|
|
const createAssetRefs = options.createAssetRefs || legacyCC.sys.platform === legacyCC.sys.EDITOR_CORE;
|
|
const target = (EDITOR || TEST) && options.target;
|
|
const customEnv = options.customEnv;
|
|
const ignoreEditorOnly = options.ignoreEditorOnly;
|
|
|
|
if (typeof data === 'string') {
|
|
data = JSON.parse(data);
|
|
}
|
|
|
|
// var oldJson = JSON.stringify(data, null, 2);
|
|
|
|
const tempDetails = !details;
|
|
details = details || Details.pool.get!();
|
|
// @ts-ignore
|
|
const deserializer: _Deserializer = _Deserializer.pool.get(details, target, classFinder, customEnv, ignoreEditorOnly);
|
|
|
|
legacyCC.game._isCloning = true;
|
|
const res = deserializer.deserialize(data);
|
|
legacyCC.game._isCloning = false;
|
|
|
|
_Deserializer.pool.put(deserializer);
|
|
if (createAssetRefs) {
|
|
details.assignAssetsBy(EditorExtends.serialize.asAsset);
|
|
}
|
|
if (tempDetails) {
|
|
Details.pool.put(details);
|
|
}
|
|
|
|
// var afterJson = JSON.stringify(data, null, 2);
|
|
// if (oldJson !== afterJson) {
|
|
// throw new Error('JSON SHOULD not changed');
|
|
// }
|
|
|
|
return res;
|
|
}
|
|
deserialize.Details = Details;
|
|
deserialize.reportMissingClass = (id) => {
|
|
if (EDITOR && EditorExtends.UuidUtils.isUuid(id)) {
|
|
id = EditorExtends.UuidUtils.decompressUuid(id);
|
|
warnID(5301, id);
|
|
}
|
|
else {
|
|
warnID(5302, id);
|
|
}
|
|
};
|
|
|
|
deserialize._Deserializer = _Deserializer;
|
|
legacyCC.deserialize = deserialize;
|