mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
584 lines
18 KiB
JavaScript
584 lines
18 KiB
JavaScript
if (CC_DEV) {
|
|
var js = cc.js;
|
|
|
|
var INFO = cc._LogInfos.deprecated;
|
|
|
|
/**
|
|
* Inject all of the properties in source objects to target object and return the target object.
|
|
* @param {object} target
|
|
* @param {object} *sources
|
|
* @name cc.inject
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @returns {object}
|
|
*/
|
|
js.get(cc, "inject", function () {
|
|
cc.warn(INFO + " The first argument should be the destination object", 'cc.inject', 'cc.js.addon');
|
|
return js.addon;
|
|
});
|
|
|
|
/**
|
|
* Copy all of the properties in source objects to target object and return the target object.
|
|
* @param {object} target
|
|
* @param {object} *sources
|
|
* @name cc.extend
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @returns {object}
|
|
*/
|
|
js.get(cc, "extend", function () {
|
|
cc.warn(INFO, 'cc.extend', 'cc.js.mixin');
|
|
return js.mixin;
|
|
});
|
|
|
|
/**
|
|
* Create new DOM element by tag name
|
|
* @name cc.newElement
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @returns {object}
|
|
*/
|
|
js.get(cc, "newElement", function () {
|
|
cc.warn(INFO, 'cc.newElement', 'document.createElement');
|
|
return document.createElement;
|
|
});
|
|
|
|
/**
|
|
* Check the obj whether is function or not
|
|
* @name cc.isFunction
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {*} obj
|
|
* @returns {boolean}
|
|
*/
|
|
js.get(cc, "isFunction", function () {
|
|
cc.warn(INFO, 'cc.isFunction', 'cc.js.isFunction');
|
|
return js.isFunction;
|
|
});
|
|
|
|
/**
|
|
* Check the obj whether is number or not
|
|
* @name cc.isNumber
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {*} obj
|
|
* @returns {boolean}
|
|
*/
|
|
js.get(cc, "isNumber", function () {
|
|
cc.warn(INFO, 'cc.isNumber', 'cc.js.isNumber');
|
|
return js.isNumber;
|
|
});
|
|
|
|
/**
|
|
* Check the obj whether is string or not
|
|
* @name cc.isString
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {*} obj
|
|
* @returns {boolean}
|
|
*/
|
|
js.get(cc, "isString", function () {
|
|
cc.warn(INFO, 'cc.isString', 'cc.js.isString');
|
|
return js.isString;
|
|
});
|
|
|
|
/**
|
|
* Check the obj whether is array or not
|
|
* @name cc.isArray
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {*} obj
|
|
* @returns {boolean}
|
|
*/
|
|
js.get(cc, "isArray", function () {
|
|
cc.warn(INFO, 'cc.isArray', 'cc.js.isArray');
|
|
return js.isArray;
|
|
});
|
|
|
|
/**
|
|
* Check the obj whether is undefined or not
|
|
* @name cc.isUndefined
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {*} obj
|
|
* @returns {boolean}
|
|
*/
|
|
js.get(cc, "isUndefined", function () {
|
|
cc.warn(INFO, 'cc.isUndefined', 'cc.js.isUndefined');
|
|
return js.isUndefined;
|
|
});
|
|
|
|
/**
|
|
* Check the obj whether is object or not
|
|
* @name cc.isObject
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {*} obj
|
|
* @returns {boolean}
|
|
*/
|
|
js.get(cc, "isObject", function () {
|
|
cc.warn(INFO, 'cc.isObject', 'cc.js.isObject');
|
|
return js.isObject;
|
|
});
|
|
|
|
/**
|
|
* cc.Point is the class for point object, please do not use its constructor to create points, use cc.p() alias function instead.
|
|
* @class cc.Point
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {Number} x
|
|
* @param {Number} y
|
|
* @see cc.Vec2
|
|
*/
|
|
js.obsoletes(cc, 'cc', {
|
|
'Point': 'Vec2',
|
|
'EScene': 'Scene',
|
|
'ENode': 'Node',
|
|
'_ComponentInSG': '_RendererUnderSG'
|
|
});
|
|
|
|
/**
|
|
* Verify Array's Type
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {Array} arr
|
|
* @param {function} type
|
|
* @return {Boolean}
|
|
* @function
|
|
*/
|
|
js.get(cc, 'arrayVerifyType', function () {
|
|
cc.warn(INFO, 'cc.arrayVerifyType', 'cc.js.array.verifyType');
|
|
return cc.js.array.verifyType;
|
|
});
|
|
|
|
/**
|
|
* Searches for the first occurance of object and removes it. If object is not found the function has no effect.
|
|
* @function
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {Array} arr Source Array
|
|
* @param {*} delObj remove object
|
|
*/
|
|
js.get(cc, 'arrayRemoveObject', function () {
|
|
cc.warn(INFO, 'cc.arrayRemoveObject', 'cc.js.array.remove');
|
|
return cc.js.array.remove;
|
|
});
|
|
|
|
/**
|
|
* Removes from arr all values in minusArr. For each Value in minusArr, the first matching instance in arr will be removed.
|
|
* @function
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {Array} arr Source Array
|
|
* @param {Array} minusArr minus Array
|
|
*/
|
|
js.get(cc, 'arrayRemoveArray', function () {
|
|
cc.warn(INFO, 'cc.arrayRemoveArray', 'cc.js.array.removeArray');
|
|
return cc.js.array.removeArray;
|
|
});
|
|
|
|
/**
|
|
* Inserts some objects at index
|
|
* @function
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {Array} arr
|
|
* @param {Array} addObjs
|
|
* @param {Number} index
|
|
* @return {Array}
|
|
*/
|
|
js.get(cc, 'arrayAppendObjectsToIndex', function() {
|
|
cc.warn(INFO, 'cc.arrayAppendObjectsToIndex', 'cc.js.array.appendObjectsAt');
|
|
return cc.js.array.appendObjectsAt;
|
|
});
|
|
|
|
/**
|
|
* Copy an array's item to a new array (its performance is better than Array.slice)
|
|
* @memberof cc
|
|
* @deprecated
|
|
* @param {Array} arr
|
|
* @return {Array}
|
|
*/
|
|
js.get(cc, 'copyArray', function() {
|
|
cc.warn(INFO, 'cc.copyArray', 'cc.js.array.copy');
|
|
return cc.js.array.copy;
|
|
});
|
|
|
|
Object.defineProperty(cc._SGComponent.prototype, 'visible', {
|
|
get: function () {
|
|
cc.warn('The "visible" property of %s is deprecated, use "enabled" instead please.', cc.js.getClassName(this));
|
|
return this.enabled;
|
|
},
|
|
set: function (value) {
|
|
var printWarning = this.visible;
|
|
this.enabled = value;
|
|
}
|
|
});
|
|
|
|
function deprecateEnum (obj, oldPath, newPath, hasTypePrefixBefore) {
|
|
hasTypePrefixBefore = hasTypePrefixBefore !== false;
|
|
var enumDef = eval(newPath);
|
|
var entries = cc.Enum.getList(enumDef);
|
|
var delimiter = hasTypePrefixBefore ? '_' : '.';
|
|
for (var i = 0; i < entries.length; i++) {
|
|
var entry = entries[i].name;
|
|
var oldPropName;
|
|
if (hasTypePrefixBefore) {
|
|
var oldTypeName = oldPath.split('.').slice(-1)[0];
|
|
oldPropName = oldTypeName + '_' + entry;
|
|
}
|
|
else {
|
|
oldPropName = entry;
|
|
}
|
|
js.get(obj, oldPropName, function (entry) {
|
|
cc.warn(INFO, oldPath + delimiter + entry, newPath + '.' + entry);
|
|
return enumDef[entry];
|
|
}.bind(null, entry));
|
|
}
|
|
}
|
|
|
|
deprecateEnum(cc, 'cc.TEXT_ALIGNMENT', 'cc.TextAlignment');
|
|
deprecateEnum(cc, 'cc.VERTICAL_TEXT_ALIGNMENT', 'cc.VerticalTextAlignment');
|
|
deprecateEnum(_ccsg.ParticleSystem, '_ccsg.ParticleSystem.TYPE', '_ccsg.ParticleSystem.Type');
|
|
deprecateEnum(_ccsg.ParticleSystem, '_ccsg.ParticleSystem.MODE', '_ccsg.ParticleSystem.Mode');
|
|
deprecateEnum(cc.ParticleSystem, 'cc.ParticleSystem.TYPE', 'cc.ParticleSystem.PositionType');
|
|
deprecateEnum(cc.ParticleSystem, 'cc.ParticleSystem.MODE', 'cc.ParticleSystem.EmitterMode');
|
|
// deprecateEnum(cc.ProgressTimer, 'cc.ProgressTimer.TYPE', 'cc.ProgressTimer.Type');
|
|
deprecateEnum(cc.game, 'cc.game.DEBUG_MODE', 'cc.DebugMode');
|
|
deprecateEnum(cc, 'cc', 'cc.Texture2D.WrapMode', false);
|
|
if (_ccsg.EditBox) {
|
|
deprecateEnum(cc, 'cc.KEYBOARD_RETURNTYPE', '_ccsg.EditBox.KeyboardReturnType');
|
|
deprecateEnum(cc, 'cc.EDITBOX_INPUT_MODE', '_ccsg.EditBox.InputMode');
|
|
deprecateEnum(cc, 'cc.EDITBOX_INPUT_FLAG', '_ccsg.EditBox.InputFlag');
|
|
}
|
|
|
|
function markAsRemoved (ownerCtor, removedProps, ownerName) {
|
|
ownerName = ownerName || js.getClassName(ownerCtor);
|
|
removedProps.forEach(function (prop) {
|
|
function error () {
|
|
cc.error('Sorry, %s.%s is removed.', ownerName, prop);
|
|
}
|
|
js.getset(ownerCtor.prototype, prop, error, error);
|
|
});
|
|
}
|
|
|
|
function provideClearError (owner, obj, ownerName) {
|
|
var className = ownerName || cc.js.getClassName(owner);
|
|
var Info = 'Sorry, ' + className + '.%s is removed, please use %s instead.';
|
|
for (var prop in obj) {
|
|
function define (prop, getset) {
|
|
function accessor (newProp) {
|
|
cc.error(Info, prop, newProp);
|
|
}
|
|
if (!Array.isArray(getset)) {
|
|
getset = getset.split(',')
|
|
.map(function (x) {
|
|
return x.trim();
|
|
});
|
|
}
|
|
js.getset(owner, prop, accessor.bind(null, getset[0]), getset[1] && accessor.bind(null, getset[1]));
|
|
}
|
|
var getset = obj[prop];
|
|
if (prop[0] === '*') {
|
|
// get set
|
|
var etProp = prop.slice(1);
|
|
define('g' + etProp, getset);
|
|
define('s' + etProp, getset);
|
|
}
|
|
else {
|
|
prop.split(',')
|
|
.map(function (x) {
|
|
return x.trim();
|
|
})
|
|
.forEach(function (x) {
|
|
define(x, getset);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// cc.loader
|
|
|
|
markAsRemoved(cc.Pipeline, [
|
|
'loadJsWithImg',
|
|
'loadCsb',
|
|
'getUrl',
|
|
'loadAliases',
|
|
'register'
|
|
], 'cc.loader');
|
|
provideClearError(cc.loader, {
|
|
loadJs : 'load',
|
|
loadTxt : 'load',
|
|
loadJson : 'load',
|
|
loadImg : 'load'
|
|
}, 'cc.loader');
|
|
|
|
// cc.Node
|
|
|
|
markAsRemoved(cc.Node, [
|
|
'_componentContainer',
|
|
'_camera',
|
|
'_additionalTransform',
|
|
'_scheduler',
|
|
'_actionManager',
|
|
'actionManager',
|
|
'_isTransitionFinished',
|
|
'_additionalTransformDirty',
|
|
'_shaderProgram',
|
|
'shaderProgram',
|
|
'_normalizedPositionDirty',
|
|
'_normalizedPosition',
|
|
'_usingNormalizedPosition',
|
|
'_renderCmd',
|
|
'_vertexZ',
|
|
'_showNode',
|
|
'_arrayMakeObjectsPerformSelector',
|
|
'getActionManager',
|
|
'setActionManager',
|
|
'getScheduler',
|
|
'setScheduler',
|
|
'reorderChild',
|
|
'draw',
|
|
'transformAncestors',
|
|
'onEnter',
|
|
'onEnterTransitionDidFinish',
|
|
'onExitTransitionDidStart',
|
|
'onExit',
|
|
'getNumberOfRunningActions',
|
|
'scheduleUpdate',
|
|
'scheduleUpdateWithPriority',
|
|
'unscheduleUpdate',
|
|
'schedule',
|
|
'scheduleOnce',
|
|
'unschedule',
|
|
'unscheduleAllCallbacks',
|
|
'resumeSchedulerAndActions',
|
|
'resume',
|
|
'pauseSchedulerAndActions',
|
|
'pause',
|
|
'setAdditionalTransform',
|
|
'updateTransform',
|
|
'retain',
|
|
'release',
|
|
'visit',
|
|
'transform',
|
|
'getCamera',
|
|
'grid',
|
|
'getGrid',
|
|
'setGrid',
|
|
'getShaderProgram',
|
|
'setShaderProgram',
|
|
'getGLServerState',
|
|
'setGLServerState',
|
|
'_initRendererCmd',
|
|
'_createRenderCmd',
|
|
'updateDisplayedOpacity',
|
|
'updateDisplayedColor',
|
|
'userData',
|
|
'userObject',
|
|
'_cascadeColorEnabled',
|
|
'cascadeColor',
|
|
'ignoreAnchor',
|
|
'isIgnoreAnchorPointForPosition',
|
|
'ignoreAnchorPointForPosition'
|
|
]);
|
|
provideClearError(cc.Node.prototype, {
|
|
arrivalOrder: 'getSiblingIndex, setSiblingIndex',
|
|
_visible: '_activeInHierarchy, active',
|
|
_running: '_activeInHierarchy, active',
|
|
running: 'activeInHierarchy, active',
|
|
_realOpacity: '_opacity, _opacity',
|
|
_realColor: '_color, _color',
|
|
getZOrder: 'getLocalZOrder',
|
|
setZOrder: 'setLocalZOrder',
|
|
getOrderOfArrival: 'getSiblingIndex',
|
|
setOrderOfArrival: 'setSiblingIndex',
|
|
boundingBox: 'getBoundingBox',
|
|
removeFromParentAndCleanup: 'removeFromParent',
|
|
removeAllChildrenWithCleanup: 'removeAllChildren',
|
|
parentToNodeTransform: 'getParentToNodeTransform',
|
|
nodeToWorldTransform: 'getNodeToWorlshaderProgramdTransform',
|
|
worldToNodeTransform: 'getWorldToNodeTransform',
|
|
nodeToParentTransform: 'getNodeToParentTransform',
|
|
removeAllComponents: 'removeComponent',
|
|
getNodeToParentAffineTransform: 'getNodeToParentTransform',
|
|
});
|
|
|
|
// RENDERERS
|
|
|
|
function shouldNotUseNodeProp (component) {
|
|
var compProto = component.prototype;
|
|
for (var prop in cc.Node.prototype) {
|
|
(function (prop) {
|
|
if (!(prop in compProto) && prop[0] !== '_') {
|
|
Object.defineProperty(compProto, prop, {
|
|
get: function () {
|
|
var compName = cc.js.getClassName(this); // 允许继承
|
|
var Info = 'Sorry, ' + compName + '.%s is undefined, please use cc.Node.%s instead.';
|
|
cc.error(Info, prop, prop);
|
|
},
|
|
enumerable: false,
|
|
configurable: true, // 允许继承
|
|
});
|
|
}
|
|
})(prop);
|
|
}
|
|
}
|
|
shouldNotUseNodeProp(cc._SGComponent);
|
|
|
|
|
|
// cc.Sprite
|
|
|
|
markAsRemoved(cc.Sprite, [
|
|
'textureLoaded',
|
|
'setBlendFunc',
|
|
'getBlendFunc',
|
|
'setState',
|
|
'getState',
|
|
'resizableSpriteWithCapInsets',
|
|
'flippedX',
|
|
'flippedY',
|
|
'setFlippedX',
|
|
'setFlippedY',
|
|
'isFlippedX',
|
|
'isFlippedY',
|
|
'getCapInsets',
|
|
'setCapInsets',
|
|
]);
|
|
provideClearError(cc.Sprite, {
|
|
create: 'node.addComponent',
|
|
createWithTexture: 'node.addComponent',
|
|
createWithSpriteFrameName: 'node.addComponent',
|
|
createWithSpriteFrame: 'node.addComponent',
|
|
});
|
|
provideClearError(cc.Sprite.prototype, {
|
|
getPreferredSize: 'node.getContentSize',
|
|
setPreferredSize: 'node.setContentSize',
|
|
updateWithSprite: 'spriteFrame',
|
|
getSpriteFrame: 'spriteFrame',
|
|
setSpriteFrame: 'spriteFrame',
|
|
useOriginalSize: 'sizeMode',
|
|
});
|
|
|
|
// Particle
|
|
markAsRemoved(cc.ParticleSystem, [
|
|
'batchNode',
|
|
'drawMode',
|
|
'getDrawMode',
|
|
'setDrawMode',
|
|
'shapeType',
|
|
'getShapeType',
|
|
'setShapeType',
|
|
'atlasIndex',
|
|
'init',
|
|
'initParticle',
|
|
'updateWithNoTime',
|
|
]);
|
|
provideClearError(cc.ParticleSystem, {
|
|
initWithFile: 'instance.file',
|
|
initWithDictionary: 'instance.file',
|
|
initWithTotalParticles: 'instance.totalParticles'
|
|
});
|
|
provideClearError(cc.ParticleSystem.prototype, {
|
|
destroyParticleSystem: 'destroy',
|
|
clone: 'cc.instantiate',
|
|
isActive: 'active',
|
|
'*etParticleCount': 'particleCount',
|
|
'*etDuration': 'duration',
|
|
'*etSourcePosition': 'sourcePos',
|
|
'*etPosVar': 'posVar',
|
|
'*etGravity': 'gravity',
|
|
'*etSpeed': 'speed',
|
|
'*etSpeedVar': 'speedVar',
|
|
'*etTangentialAccel': 'tangentialAccel',
|
|
'*etTangentialAccelVar': 'tangentialAccelVar',
|
|
'*etRadialAccel': 'radialAccel',
|
|
'*etRadialAccelVar': 'radialAccelVar',
|
|
'*etRotationIsDir': 'rotationIsDir',
|
|
'*etStartRadius': 'startRadius',
|
|
'*etStartRadiusVar': 'startRadiusVar',
|
|
'*etEndRadius': 'endRadius',
|
|
'*etEndRadiusVar': 'endRadiusVar',
|
|
'*etRotatePerSecond': 'rotatePerS',
|
|
'*etRotatePerSecondVar': 'rotatePerSVar',
|
|
'*etStartColor': 'startColor',
|
|
'*etStartColorVar': 'startColorVar',
|
|
'*etEndColor': 'endColor',
|
|
'*etEndColorVar': 'endColorVar',
|
|
'*etTotalParticles': 'totalParticles',
|
|
'*etTexture': 'texture',
|
|
});
|
|
js.obsoletes(cc.ParticleSystem, 'cc.ParticleSystem', {
|
|
Type: 'PositionType',
|
|
Mode: 'EmitterMode'
|
|
});
|
|
|
|
// _ccsg.Node
|
|
markAsRemoved(_ccsg.Node, [
|
|
'_normalizedPositionDirty',
|
|
'_normalizedPosition',
|
|
'_usingNormalizedPosition',
|
|
'grid',
|
|
'userData',
|
|
'userObject',
|
|
'getNormalizedPosition',
|
|
'setNormalizedPosition',
|
|
'getCamera',
|
|
'getUserData',
|
|
'setUserData',
|
|
'getUserObject',
|
|
'setUserObject',
|
|
'getComponent',
|
|
'addComponent',
|
|
'removeComponent',
|
|
'removeAllComponents',
|
|
'enumerateChildren',
|
|
'setCameraMask',
|
|
'getCameraMask'
|
|
], '_ccsg.Node');
|
|
|
|
js.obsoletes(cc.Scale9Sprite.prototype, 'cc.Scale9Sprite', {
|
|
setPreferredSize: 'setContentSize',
|
|
getPreferredSize: 'getContentSize',
|
|
});
|
|
|
|
//ui
|
|
cc.js.obsolete(cc.Layout.prototype, 'Layout.layoutType', 'type');
|
|
cc.js.obsolete(cc.Layout.prototype, 'Layout.ResizeType', 'ResizeMode');
|
|
cc.js.obsolete(cc.Layout.prototype, 'Layout.resize', 'resizeMode');
|
|
|
|
markAsRemoved(cc.Scale9Sprite, [
|
|
'init',
|
|
'resizableSpriteWithCapInsets',
|
|
'updateWithSprite',
|
|
'getOriginalSize',
|
|
'setCapInsets',
|
|
'getCapInsets',
|
|
'setScale9Enabled',
|
|
'isScale9Enabled',
|
|
'getSprite',
|
|
'setFlippedX',
|
|
'isFlippedX',
|
|
'setFlippedY',
|
|
'isFlippedY'
|
|
]);
|
|
|
|
// SPINE
|
|
|
|
if (typeof sp !== 'undefined') {
|
|
deprecateEnum(sp, 'sp.ANIMATION_EVENT_TYPE', 'sp.AnimationEventType');
|
|
js.obsolete(sp, 'sp.SkeletonAnimation', 'Skeleton');
|
|
provideClearError(sp.Skeleton, {
|
|
create: 'node.addComponent',
|
|
});
|
|
provideClearError(sp.Skeleton.prototype, {
|
|
'*etDebugSlotsEnabled': 'debugSlots',
|
|
'*etDebugBonesEnabled': 'debugBones',
|
|
'setDebugSolots': 'debugSlots',
|
|
'setDebugBones': 'debugBones',
|
|
'*etTimeScale': 'timeScale',
|
|
});
|
|
}
|
|
}
|
|
|