Files
cocos4/cocos/core/platform/CCView.js
T
Weiliang Wang 8bb80df732 3d (#4036)
* compiler error (#4033)

* compiler error

* add gen decl module

* fix global event and other bug (#4032)

* components such as event-target to ts

* divide CCEvent and CCTouch into game coordinates and ui coordinate mod

* repair editor environment where mask does not take effect bug

* fix render component blendState modification does not take effect bug

* fix bug

* fix ts tip
2019-03-14 12:03:04 +08:00

1510 lines
54 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/****************************************************************************
Copyright (c) 2008-2010 Ricardo Quesada
Copyright (c) 2011-2012 cocos2d-x.org
Copyright (c) 2013-2016 Chukong Technologies Inc.
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
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.
****************************************************************************/
import { EventTarget } from '../event/event-target';
import '../data/class';
import macro from '../platform/CCMacro';
import Game from '../game';
import Size from '../value-types/size';
import Rect from '../value-types/rect';
var __BrowserGetter = {
init(){
if (!CC_WECHATGAME && !CC_QQPLAY) {
this.html = document.getElementsByTagName("html")[0];
}
},
availWidth(frame){
if (!frame || frame === this.html)
return window.innerWidth;
else
return frame.clientWidth;
},
availHeight(frame){
if (!frame || frame === this.html)
return window.innerHeight;
else
return frame.clientHeight;
},
meta: {
"width": "device-width"
},
adaptationType: cc.sys.browserType
};
if (cc.sys.os === cc.sys.OS_IOS) // All browsers are WebView
__BrowserGetter.adaptationType = cc.sys.BROWSER_TYPE_SAFARI;
if (CC_WECHATGAME) {
if (cc.sys.browserType === cc.sys.BROWSER_TYPE_WECHAT_GAME_SUB) {
__BrowserGetter.adaptationType = cc.sys.BROWSER_TYPE_WECHAT_GAME_SUB;
}
else {
__BrowserGetter.adaptationType = cc.sys.BROWSER_TYPE_WECHAT_GAME;
}
}
if (CC_QQPLAY) {
__BrowserGetter.adaptationType = cc.sys.BROWSER_TYPE_QQ_PLAY;
}
switch (__BrowserGetter.adaptationType) {
case cc.sys.BROWSER_TYPE_SAFARI:
__BrowserGetter.meta["minimal-ui"] = "true";
case cc.sys.BROWSER_TYPE_SOUGOU:
case cc.sys.BROWSER_TYPE_UC:
__BrowserGetter.availWidth = function(frame){
return frame.clientWidth;
};
__BrowserGetter.availHeight = function(frame){
return frame.clientHeight;
};
break;
case cc.sys.BROWSER_TYPE_WECHAT_GAME:
__BrowserGetter.availWidth = function(){
return window.innerWidth;
};
__BrowserGetter.availHeight = function(){
return window.innerHeight;
};
break;
case cc.sys.BROWSER_TYPE_WECHAT_GAME_SUB:
var sharedCanvas = window.sharedCanvas || wx.getSharedCanvas();
__BrowserGetter.availWidth = function(){
return sharedCanvas.width;
};
__BrowserGetter.availHeight = function(){
return sharedCanvas.height;
};
break;
}
var _scissorRect = null;
/**
* cc.view is the singleton object which represents the game window.<br/>
* It's main task include: <br/>
* - Apply the design resolution policy<br/>
* - Provide interaction with the window, like resize event on web, retina display support, etc...<br/>
* - Manage the game view port which can be different with the window<br/>
* - Manage the content scale and translation<br/>
* <br/>
* Since the cc.view is a singleton, you don't need to call any constructor or create functions,<br/>
* the standard way to use it is by calling:<br/>
* - cc.view.methodName(); <br/>
*
* @class View
*/
class View extends EventTarget {
constructor () {
super();
var _t = this, _strategyer = ContainerStrategy, _strategy = ContentStrategy;
// Size of parent node that contains cc.game.container and cc.game.canvas
_t._frameSize = new Size(0, 0);
// resolution size, it is the size appropriate for the app resources.
_t._designResolutionSize = new Size(0, 0);
_t._originalDesignResolutionSize = new Size(0, 0);
_t._scaleX = 1;
_t._scaleY = 1;
// Viewport is the container's rect related to content's coordinates in pixel
_t._viewportRect = new Rect(0, 0, 0, 0);
// The visible rect in content's coordinate in point
_t._visibleRect = new Rect(0, 0, 0, 0);
// Auto full screen disabled by default
_t._autoFullScreen = false;
// The device's pixel ratio (for retina displays)
_t._devicePixelRatio = 1;
// Retina disabled by default
_t._retinaEnabled = false;
// Custom callback for resize event
_t._resizeCallback = null;
_t._resizing = false;
_t._resizeWithBrowserSize = false;
_t._orientationChanging = true;
_t._isRotated = false;
_t._orientation = macro.ORIENTATION_AUTO;
_t._isAdjustViewport = true;
_t._antiAliasEnabled = false;
// Setup system default resolution policies
_t._resolutionPolicy = null;
_t._rpExactFit = new ResolutionPolicy(_strategyer.EQUAL_TO_FRAME, _strategy.EXACT_FIT);
_t._rpShowAll = new ResolutionPolicy(_strategyer.EQUAL_TO_FRAME, _strategy.SHOW_ALL);
_t._rpNoBorder = new ResolutionPolicy(_strategyer.EQUAL_TO_FRAME, _strategy.NO_BORDER);
_t._rpFixedHeight = new ResolutionPolicy(_strategyer.EQUAL_TO_FRAME, _strategy.FIXED_HEIGHT);
_t._rpFixedWidth = new ResolutionPolicy(_strategyer.EQUAL_TO_FRAME, _strategy.FIXED_WIDTH);
cc.game.once(Game.EVENT_ENGINE_INITED, this.init, this);
}
init () {
__BrowserGetter.init(this);
this._initFrameSize();
this.enableAntiAlias(true);
var w = cc.game.canvas.width, h = cc.game.canvas.height;
this._designResolutionSize.width = w;
this._designResolutionSize.height = h;
this._originalDesignResolutionSize.width = w;
this._originalDesignResolutionSize.height = h;
this._viewportRect.width = w;
this._viewportRect.height = h;
this._visibleRect.width = w;
this._visibleRect.height = h;
cc.winSize.width = this._visibleRect.width;
cc.winSize.height = this._visibleRect.height;
cc.visibleRect && cc.visibleRect.init(this._visibleRect);
}
// Resize helper functions
_resizeEvent () {
var view;
if (this.setDesignResolutionSize) {
view = this;
} else {
view = cc.view;
}
// Check frame size changed or not
var prevFrameW = view._frameSize.width, prevFrameH = view._frameSize.height, prevRotated = view._isRotated;
if (cc.sys.isMobile) {
var containerStyle = cc.game.container.style,
margin = containerStyle.margin;
containerStyle.margin = '0';
containerStyle.display = 'none';
view._initFrameSize();
containerStyle.margin = margin;
containerStyle.display = 'block';
}
else {
view._initFrameSize();
}
if (view._isRotated === prevRotated && view._frameSize.width === prevFrameW && view._frameSize.height === prevFrameH)
return;
// Frame size changed, do resize works
var width = view._originalDesignResolutionSize.width;
var height = view._originalDesignResolutionSize.height;
view._resizing = true;
if (width > 0)
view.setDesignResolutionSize(width, height, view._resolutionPolicy);
view._resizing = false;
view.emit('canvas-resize');
if (view._resizeCallback) {
view._resizeCallback.call();
}
}
_orientationChange () {
cc.view._orientationChanging = true;
cc.view._resizeEvent();
}
/**
* !#en
* Sets view's target-densitydpi for android mobile browser. it can be set to: <br/>
* 1. macro.DENSITYDPI_DEVICE, value is "device-dpi" <br/>
* 2. macro.DENSITYDPI_HIGH, value is "high-dpi" (default value) <br/>
* 3. macro.DENSITYDPI_MEDIUM, value is "medium-dpi" (browser's default value) <br/>
* 4. macro.DENSITYDPI_LOW, value is "low-dpi" <br/>
* 5. Custom value, e.g: "480" <br/>
* !#zh 设置目标内容的每英寸像素点密度。
*
* @method setTargetDensityDPI
* @param {String} densityDPI
* @deprecated since v2.0
*/
/**
* !#en
* Returns the current target-densitydpi value of cc.view.
* !#zh 获取目标内容的每英寸像素点密度。
* @method getTargetDensityDPI
* @returns {String}
* @deprecated since v2.0
*/
/**
* !#en
* Sets whether resize canvas automatically when browser's size changed.<br/>
* Useful only on web.
* !#zh 设置当发现浏览器的尺寸改变时,是否自动调整 canvas 尺寸大小。
* 仅在 Web 模式下有效。
* @method resizeWithBrowserSize
* @param {Boolean} enabled - Whether enable automatic resize with browser's resize event
*/
resizeWithBrowserSize (enabled) {
if (enabled) {
//enable
if (!this._resizeWithBrowserSize) {
this._resizeWithBrowserSize = true;
window.addEventListener('resize', this._resizeEvent);
window.addEventListener('orientationchange', this._orientationChange);
}
} else {
//disable
if (this._resizeWithBrowserSize) {
this._resizeWithBrowserSize = false;
window.removeEventListener('resize', this._resizeEvent);
window.removeEventListener('orientationchange', this._orientationChange);
}
}
}
/**
* !#en
* Sets the callback function for cc.view's resize action,<br/>
* this callback will be invoked before applying resolution policy, <br/>
* so you can do any additional modifications within the callback.<br/>
* Useful only on web.
* !#zh 设置 cc.view 调整视窗尺寸行为的回调函数,
* 这个回调函数会在应用适配模式之前被调用,
* 因此你可以在这个回调函数内添加任意附加改变,
* 仅在 Web 平台下有效。
* @method setResizeCallback
* @param {Function|Null} callback - The callback function
*/
setResizeCallback (callback) {
if (typeof callback === 'function' || callback == null) {
this._resizeCallback = callback;
}
}
/**
* !#en
* Sets the orientation of the game, it can be landscape, portrait or auto.
* When set it to landscape or portrait, and screen w/h ratio doesn't fit,
* cc.view will automatically rotate the game canvas using CSS.
* Note that this function doesn't have any effect in native,
* in native, you need to set the application orientation in native project settings
* !#zh 设置游戏屏幕朝向,它能够是横版,竖版或自动。
* 当设置为横版或竖版,并且屏幕的宽高比例不匹配时,
* cc.view 会自动用 CSS 旋转游戏场景的 canvas,
* 这个方法不会对 native 部分产生任何影响,对于 native 而言,你需要在应用设置中的设置排版。
* @method setOrientation
* @param {Number} orientation - Possible values: macro.ORIENTATION_LANDSCAPE | macro.ORIENTATION_PORTRAIT | macro.ORIENTATION_AUTO
*/
setOrientation (orientation) {
orientation = orientation & macro.ORIENTATION_AUTO;
if (orientation && this._orientation !== orientation) {
this._orientation = orientation;
var designWidth = this._originalDesignResolutionSize.width;
var designHeight = this._originalDesignResolutionSize.height;
this.setDesignResolutionSize(designWidth, designHeight, this._resolutionPolicy);
}
}
_initFrameSize () {
var locFrameSize = this._frameSize;
var w = __BrowserGetter.availWidth(cc.game.frame);
var h = __BrowserGetter.availHeight(cc.game.frame);
var isLandscape = w >= h;
if (CC_EDITOR || !cc.sys.isMobile ||
(isLandscape && this._orientation & macro.ORIENTATION_LANDSCAPE) ||
(!isLandscape && this._orientation & macro.ORIENTATION_PORTRAIT)) {
locFrameSize.width = w;
locFrameSize.height = h;
cc.game.container.style['-webkit-transform'] = 'rotate(0deg)';
cc.game.container.style.transform = 'rotate(0deg)';
this._isRotated = false;
}
else {
locFrameSize.width = h;
locFrameSize.height = w;
cc.game.container.style['-webkit-transform'] = 'rotate(90deg)';
cc.game.container.style.transform = 'rotate(90deg)';
cc.game.container.style['-webkit-transform-origin'] = '0px 0px 0px';
cc.game.container.style.transformOrigin = '0px 0px 0px';
this._isRotated = true;
// Fix for issue: https://github.com/cocos-creator/fireball/issues/8365
// Reference: https://www.douban.com/note/343402554/
// For Chrome, z-index not working after container transform rotate 90deg.
// Because 'transform' style adds canvas (the top-element of container) to a new stack context.
// That causes the DOM Input was hidden under canvas.
// This should be done after container rotated, instead of in style-mobile.css.
cc.game.canvas.style['-webkit-transform'] = 'translateZ(0px)';
cc.game.canvas.style.transform = 'translateZ(0px)';
}
if (this._orientationChanging) {
setTimeout(function () {
cc.view._orientationChanging = false;
}, 1000);
}
}
// hack
_adjustSizeKeepCanvasSize () {
var designWidth = this._originalDesignResolutionSize.width;
var designHeight = this._originalDesignResolutionSize.height;
if (designWidth > 0)
this.setDesignResolutionSize(designWidth, designHeight, this._resolutionPolicy);
}
_setViewportMeta (metas, overwrite) {
var vp = document.getElementById("cocosMetaElement");
if(vp && overwrite){
document.head.removeChild(vp);
}
var elems = document.getElementsByName("viewport"),
currentVP = elems ? elems[0] : null,
content, key, pattern;
content = currentVP ? currentVP.content : "";
vp = vp || document.createElement("meta");
vp.id = "cocosMetaElement";
vp.name = "viewport";
vp.content = "";
for (key in metas) {
if (content.indexOf(key) == -1) {
content += "," + key + "=" + metas[key];
}
else if (overwrite) {
pattern = new RegExp(key+"\s*=\s*[^,]+");
content.replace(pattern, key + "=" + metas[key]);
}
}
if(/^,/.test(content))
content = content.substr(1);
vp.content = content;
// For adopting certain android devices which don't support second viewport
if (currentVP)
currentVP.content = content;
document.head.appendChild(vp);
}
_adjustViewportMeta () {
if (this._isAdjustViewport && !CC_JSB && !CC_WECHATGAME && !CC_QQPLAY) {
this._setViewportMeta(__BrowserGetter.meta, false);
this._isAdjustViewport = false;
}
}
/**
* !#en
* Sets whether the engine modify the "viewport" meta in your web page.<br/>
* It's enabled by default, we strongly suggest you not to disable it.<br/>
* And even when it's enabled, you can still set your own "viewport" meta, it won't be overridden<br/>
* Only useful on web
* !#zh 设置引擎是否调整 viewport meta 来配合屏幕适配。
* 默认设置为启动,我们强烈建议你不要将它设置为关闭。
* 即使当它启动时,你仍然能够设置你的 viewport meta,它不会被覆盖。
* 仅在 Web 模式下有效
* @method adjustViewportMeta
* @param {Boolean} enabled - Enable automatic modification to "viewport" meta
*/
adjustViewportMeta (enabled) {
this._isAdjustViewport = enabled;
}
/**
* !#en
* Retina support is enabled by default for Apple device but disabled for other devices,<br/>
* it takes effect only when you called setDesignResolutionPolicy<br/>
* Only useful on web
* !#zh 对于 Apple 这种支持 Retina 显示的设备上默认进行优化而其他类型设备默认不进行优化,
* 它仅会在你调用 setDesignResolutionPolicy 方法时有影响。
* 仅在 Web 模式下有效。
* @method enableRetina
* @param {Boolean} enabled - Enable or disable retina display
*/
enableRetina(enabled) {
this._retinaEnabled = !!enabled;
}
/**
* !#en
* Check whether retina display is enabled.<br/>
* Only useful on web
* !#zh 检查是否对 Retina 显示设备进行优化。
* 仅在 Web 模式下有效。
* @method isRetinaEnabled
* @return {Boolean}
*/
isRetinaEnabled() {
return this._retinaEnabled;
}
/**
* !#en Whether to Enable on anti-alias
* !#zh 控制抗锯齿是否开启
* @method enableAntiAlias
* @param {Boolean} enabled - Enable or not anti-alias
*/
enableAntiAlias (enabled) {
if (this._antiAliasEnabled === enabled) {
return;
}
this._antiAliasEnabled = enabled;
if (cc.game.renderType === Game.RENDER_TYPE_WEBGL) {
var cache = cc.loader._cache;
for (var key in cache) {
var item = cache[key];
var tex = item && item.content instanceof cc.Texture2D ? item.content : null;
if (tex) {
var Filter = cc.Texture2D.Filter;
if (enabled) {
tex.setFilters(Filter.LINEAR, Filter.LINEAR);
}
else {
tex.setFilters(Filter.NEAREST, Filter.NEAREST);
}
}
}
}
else if (cc.game.renderType === Game.RENDER_TYPE_CANVAS) {
var ctx = cc.game.canvas.getContext('2d');
ctx.imageSmoothingEnabled = enabled;
ctx.mozImageSmoothingEnabled = enabled;
}
}
/**
* !#en Returns whether the current enable on anti-alias
* !#zh 返回当前是否抗锯齿
* @method isAntiAliasEnabled
* @return {Boolean}
*/
isAntiAliasEnabled () {
return this._antiAliasEnabled;
}
/**
* !#en
* If enabled, the application will try automatically to enter full screen mode on mobile devices<br/>
* You can pass true as parameter to enable it and disable it by passing false.<br/>
* Only useful on web
* !#zh 启动时,移动端游戏会在移动端自动尝试进入全屏模式。
* 你能够传入 true 为参数去启动它,用 false 参数来关闭它。
* @method enableAutoFullScreen
* @param {Boolean} enabled - Enable or disable auto full screen on mobile devices
*/
enableAutoFullScreen(enabled) {
if (enabled &&
enabled !== this._autoFullScreen &&
cc.sys.isMobile &&
cc.sys.browserType !== cc.sys.BROWSER_TYPE_WECHAT) {
// Automatically full screen when user touches on mobile version
this._autoFullScreen = true;
cc.screen.autoFullScreen(cc.game.frame);
}
else {
this._autoFullScreen = false;
}
}
/**
* !#en
* Check whether auto full screen is enabled.<br/>
* Only useful on web
* !#zh 检查自动进入全屏模式是否启动。
* 仅在 Web 模式下有效。
* @method isAutoFullScreenEnabled
* @return {Boolean} Auto full screen enabled or not
*/
isAutoFullScreenEnabled() {
return this._autoFullScreen;
}
/*
* Not support on native.<br/>
* On web, it sets the size of the canvas.
* !#zh 这个方法并不支持 native 平台,在 Web 平台下,可以用来设置 canvas 尺寸。
* @method setCanvasSize
* @param {Number} width
* @param {Number} height
*/
setCanvasSize (width, height) {
var canvas = cc.game.canvas;
var container = cc.game.container;
//canvas.width = width * this._devicePixelRatio;
//canvas.height = height * this._devicePixelRatio;
const w = width * this._devicePixelRatio;
const h = height * this._devicePixelRatio;
canvas.style.width = width + 'px';
canvas.style.height = height + 'px';
container.style.width = width + 'px';
container.style.height = height + 'px';
this._resizeEvent();
}
/**
* !#en
* Returns the canvas size of the view.<br/>
* On native platforms, it returns the screen size since the view is a fullscreen view.<br/>
* On web, it returns the size of the canvas element.
* !#zh 返回视图中 canvas 的尺寸。
* 在 native 平台下,它返回全屏视图下屏幕的尺寸。
* 在 Web 平台下,它返回 canvas 元素尺寸。
* @method getCanvasSize
* @return {Size}
*/
getCanvasSize () {
return cc.size(cc.game.canvas.width, cc.game.canvas.height);
}
/**
* !#en
* Returns the frame size of the view.<br/>
* On native platforms, it returns the screen size since the view is a fullscreen view.<br/>
* On web, it returns the size of the canvas's outer DOM element.
* !#zh 返回视图中边框尺寸。
* 在 native 平台下,它返回全屏视图下屏幕的尺寸。
* 在 web 平台下,它返回 canvas 元素的外层 DOM 元素尺寸。
* @method getFrameSize
* @return {Size}
*/
getFrameSize () {
return cc.size(this._frameSize.width, this._frameSize.height);
}
/**
* !#en
* On native, it sets the frame size of view.<br/>
* On web, it sets the size of the canvas's outer DOM element.
* !#zh 在 native 平台下,设置视图框架尺寸。
* 在 web 平台下,设置 canvas 外层 DOM 元素尺寸。
* @method setFrameSize
* @param {Number} width
* @param {Number} height
*/
setFrameSize (width, height) {
this._frameSize.width = width;
this._frameSize.height = height;
cc.frame.style.width = width + "px";
cc.game.frame.style.height = height + "px";
this._resizeEvent();
}
/**
* !#en
* Returns the visible area size of the view port.
* !#zh 返回视图窗口可见区域尺寸。
* @method getVisibleSize
* @return {Size}
*/
getVisibleSize () {
return cc.size(this._visibleRect.width,this._visibleRect.height);
}
/**
* !#en
* Returns the visible area size of the view port.
* !#zh 返回视图窗口可见区域像素尺寸。
* @method getVisibleSizeInPixel
* @return {Size}
*/
getVisibleSizeInPixel () {
return cc.size( this._visibleRect.width * this._scaleX,
this._visibleRect.height * this._scaleY );
}
/**
* !#en
* Returns the visible origin of the view port.
* !#zh 返回视图窗口可见区域原点。
* @method getVisibleOrigin
* @return {Vec2}
*/
getVisibleOrigin () {
return cc.v2(this._visibleRect.x,this._visibleRect.y);
}
/**
* !#en
* Returns the visible origin of the view port.
* !#zh 返回视图窗口可见区域像素原点。
* @method getVisibleOriginInPixel
* @return {Vec2}
*/
getVisibleOriginInPixel () {
return cc.v2(this._visibleRect.x * this._scaleX,
this._visibleRect.y * this._scaleY);
}
/**
* !#en
* Returns the current resolution policy
* !#zh 返回当前分辨率方案
* @see ResolutionPolicy
* @method getResolutionPolicy
* @return {ResolutionPolicy}
*/
getResolutionPolicy () {
return this._resolutionPolicy;
}
/**
* !#en
* Sets the current resolution policy
* !#zh 设置当前分辨率模式
* @see ResolutionPolicy
* @method setResolutionPolicy
* @param {ResolutionPolicy|Number} resolutionPolicy
*/
setResolutionPolicy (resolutionPolicy) {
var _t = this;
if (resolutionPolicy instanceof ResolutionPolicy) {
_t._resolutionPolicy = resolutionPolicy;
}
// Ensure compatibility with JSB
else {
var _locPolicy = ResolutionPolicy;
if(resolutionPolicy === _locPolicy.EXACT_FIT)
_t._resolutionPolicy = _t._rpExactFit;
if(resolutionPolicy === _locPolicy.SHOW_ALL)
_t._resolutionPolicy = _t._rpShowAll;
if(resolutionPolicy === _locPolicy.NO_BORDER)
_t._resolutionPolicy = _t._rpNoBorder;
if(resolutionPolicy === _locPolicy.FIXED_HEIGHT)
_t._resolutionPolicy = _t._rpFixedHeight;
if(resolutionPolicy === _locPolicy.FIXED_WIDTH)
_t._resolutionPolicy = _t._rpFixedWidth;
}
}
/**
* !#en
* Sets the resolution policy with designed view size in points.<br/>
* The resolution policy include: <br/>
* [1] ResolutionExactFit Fill screen by stretch-to-fit: if the design resolution ratio of width to height is different from the screen resolution ratio, your game view will be stretched.<br/>
* [2] ResolutionNoBorder Full screen without black border: if the design resolution ratio of width to height is different from the screen resolution ratio, two areas of your game view will be cut.<br/>
* [3] ResolutionShowAll Full screen with black border: if the design resolution ratio of width to height is different from the screen resolution ratio, two black borders will be shown.<br/>
* [4] ResolutionFixedHeight Scale the content's height to screen's height and proportionally scale its width<br/>
* [5] ResolutionFixedWidth Scale the content's width to screen's width and proportionally scale its height<br/>
* [ResolutionPolicy] [Web only feature] Custom resolution policy, constructed by ResolutionPolicy<br/>
* !#zh 通过设置设计分辨率和匹配模式来进行游戏画面的屏幕适配。
* @method setDesignResolutionSize
* @param {Number} width Design resolution width.
* @param {Number} height Design resolution height.
* @param {ResolutionPolicy|Number} resolutionPolicy The resolution policy desired
*/
setDesignResolutionSize (width, height, resolutionPolicy) {
// Defensive code
if( !(width > 0 || height > 0) ){
cc.logID(2200);
return;
}
this.setResolutionPolicy(resolutionPolicy);
var policy = this._resolutionPolicy;
if (policy) {
policy.preApply(this);
}
// Reinit frame size
if (cc.sys.isMobile)
this._adjustViewportMeta();
// Permit to re-detect the orientation of device.
this._orientationChanging = true;
// If resizing, then frame size is already initialized, this logic should be improved
if (!this._resizing)
this._initFrameSize();
if (!policy) {
cc.logID(2201);
return;
}
this._originalDesignResolutionSize.width = this._designResolutionSize.width = width;
this._originalDesignResolutionSize.height = this._designResolutionSize.height = height;
var result = policy.apply(this, this._designResolutionSize);
if(result.scale && result.scale.length === 2){
this._scaleX = result.scale[0];
this._scaleY = result.scale[1];
}
if(result.viewport){
var vp = this._viewportRect,
vb = this._visibleRect,
rv = result.viewport;
vp.x = rv.x;
vp.y = rv.y;
vp.width = rv.width;
vp.height = rv.height;
vb.x = 0;
vb.y = 0;
vb.width = rv.width / this._scaleX;
vb.height = rv.height / this._scaleY;
}
policy.postApply(this);
cc.winSize.width = this._visibleRect.width;
cc.winSize.height = this._visibleRect.height;
cc.visibleRect && cc.visibleRect.init(this._visibleRect);
this.emit('design-resolution-changed');
}
/**
* !#en
* Returns the designed size for the view.
* Default resolution size is the same as 'getFrameSize'.
* !#zh 返回视图的设计分辨率。
* 默认下分辨率尺寸同 `getFrameSize` 方法相同
* @method getDesignResolutionSize
* @return {Size}
*/
getDesignResolutionSize () {
return cc.size(this._designResolutionSize.width, this._designResolutionSize.height);
}
/**
* !#en
* Sets the container to desired pixel resolution and fit the game content to it.
* This function is very useful for adaptation in mobile browsers.
* In some HD android devices, the resolution is very high, but its browser performance may not be very good.
* In this case, enabling retina display is very costy and not suggested, and if retina is disabled, the image may be blurry.
* But this API can be helpful to set a desired pixel resolution which is in between.
* This API will do the following:
* 1. Set viewport's width to the desired width in pixel
* 2. Set body width to the exact pixel resolution
* 3. The resolution policy will be reset with designed view size in points.
* !#zh 设置容器(container)需要的像素分辨率并且适配相应分辨率的游戏内容。
* @method setRealPixelResolution
* @param {Number} width Design resolution width.
* @param {Number} height Design resolution height.
* @param {ResolutionPolicy|Number} resolutionPolicy The resolution policy desired
*/
setRealPixelResolution (width, height, resolutionPolicy) {
if (!CC_JSB && !CC_WECHATGAME && !CC_QQPLAY) {
// Set viewport's width
this._setViewportMeta({"width": width}, true);
// Set body width to the exact pixel resolution
document.documentElement.style.width = width + "px";
document.body.style.width = width + "px";
document.body.style.left = "0px";
document.body.style.top = "0px";
}
// Reset the resolution size and policy
this.setDesignResolutionSize(width, height, resolutionPolicy);
}
/**
* !#en
* Sets view port rectangle with points.
* !#zh 用设计分辨率下的点尺寸来设置视窗。
* @method setViewportInPoints
* @deprecated since v2.0
* @param {Number} x
* @param {Number} y
* @param {Number} w width
* @param {Number} h height
*/
setViewportInPoints (x, y, w, h) {
var locScaleX = this._scaleX, locScaleY = this._scaleY;
cc.game._renderContext.viewport((x * locScaleX + this._viewportRect.x),
(y * locScaleY + this._viewportRect.y),
(w * locScaleX),
(h * locScaleY));
}
/**
* !#en
* Sets Scissor rectangle with points.
* !#zh 用设计分辨率下的点的尺寸来设置 scissor 剪裁区域。
* @method setScissorInPoints
* @deprecated since v2.0
* @param {Number} x
* @param {Number} y
* @param {Number} w
* @param {Number} h
*/
setScissorInPoints (x, y, w, h) {
let scaleX = this._scaleX, scaleY = this._scaleY;
let sx = Math.ceil(x * scaleX + this._viewportRect.x);
let sy = Math.ceil(y * scaleY + this._viewportRect.y);
let sw = Math.ceil(w * scaleX);
let sh = Math.ceil(h * scaleY);
let gl = cc.game._renderContext;
if (!_scissorRect) {
var boxArr = gl.getParameter(gl.SCISSOR_BOX);
_scissorRect = new Rect(boxArr[0], boxArr[1], boxArr[2], boxArr[3]);
}
if (_scissorRect.x !== sx || _scissorRect.y !== sy || _scissorRect.width !== sw || _scissorRect.height !== sh) {
_scissorRect.x = sx;
_scissorRect.y = sy;
_scissorRect.width = sw;
_scissorRect.height = sh;
gl.scissor(sx, sy, sw, sh);
}
}
/**
* !#en
* Returns whether GL_SCISSOR_TEST is enable
* !#zh 检查 scissor 是否生效。
* @method isScissorEnabled
* @deprecated since v2.0
* @return {Boolean}
*/
isScissorEnabled () {
return cc.game._renderContext.isEnabled(gl.SCISSOR_TEST);
}
/**
* !#en
* Returns the current scissor rectangle
* !#zh 返回当前的 scissor 剪裁区域。
* @method getScissorRect
* @deprecated since v2.0
* @return {Rect}
*/
getScissorRect () {
if (!_scissorRect) {
var boxArr = gl.getParameter(gl.SCISSOR_BOX);
_scissorRect = new Rect(boxArr[0], boxArr[1], boxArr[2], boxArr[3]);
}
var scaleXFactor = 1 / this._scaleX;
var scaleYFactor = 1 / this._scaleY;
return new Rect(
(_scissorRect.x - this._viewportRect.x) * scaleXFactor,
(_scissorRect.y - this._viewportRect.y) * scaleYFactor,
_scissorRect.width * scaleXFactor,
_scissorRect.height * scaleYFactor
);
}
/**
* !#en
* Returns the view port rectangle.
* !#zh 返回视窗剪裁区域。
* @method getViewportRect
* @return {Rect}
*/
getViewportRect () {
return this._viewportRect;
}
/**
* !#en
* Returns scale factor of the horizontal direction (X axis).
* !#zh 返回横轴的缩放比,这个缩放比是将画布像素分辨率放到设计分辨率的比例。
* @method getScaleX
* @return {Number}
*/
getScaleX () {
return this._scaleX;
}
/**
* !#en
* Returns scale factor of the vertical direction (Y axis).
* !#zh 返回纵轴的缩放比,这个缩放比是将画布像素分辨率缩放到设计分辨率的比例。
* @method getScaleY
* @return {Number}
*/
getScaleY () {
return this._scaleY;
}
/**
* !#en
* Returns device pixel ratio for retina display.
* !#zh 返回设备或浏览器像素比例。
* @method getDevicePixelRatio
* @return {Number}
*/
getDevicePixelRatio() {
return this._devicePixelRatio;
}
/**
* !#en
* Returns the real location in view for a translation based on a related position
* !#zh 将屏幕坐标转换为游戏视图下的坐标。
* @method convertToLocationInView
* @param {Number} tx - The X axis translation
* @param {Number} ty - The Y axis translation
* @param {Object} relatedPos - The related position object including "left", "top", "width", "height" informations
* @return {Vec2}
*/
convertToLocationInView (tx, ty, relatedPos, out) {
let result = out || cc.v2();
let x = this._devicePixelRatio * (tx - relatedPos.left);
let y = this._devicePixelRatio * (relatedPos.top + relatedPos.height - ty);
if (this._isRotated) {
result.x = cc.game.canvas.width - y;
result.y = x;
}
else {
result.x = x;
result.y = y;
}
return result;
}
_convertMouseToLocation(in_out_point, relatedPos){
in_out_point.x = this._devicePixelRatio * (in_out_point.x - relatedPos.left);
in_out_point.y = this._devicePixelRatio * (relatedPos.top + relatedPos.height - in_out_point.y);
}
// _convertMouseToLocationInView (in_out_point, relatedPos) {
// var viewport = this._viewportRect, _t = this;
// in_out_point.x = ((_t._devicePixelRatio * (in_out_point.x - relatedPos.left)) - viewport.x) / _t._scaleX;
// in_out_point.y = (_t._devicePixelRatio * (relatedPos.top + relatedPos.height - in_out_point.y) - viewport.y) / _t._scaleY;
// }
_convertPointWithScale (point) {
var viewport = this._viewportRect;
point.x = (point.x - viewport.x) / this._scaleX;
point.y = (point.y - viewport.y) / this._scaleY;
}
_convertTouchWidthScale(selTouch){
const viewport = this._viewportRect;
const scaleX = this._scaleX;
const scaleY = this._scaleY;
selTouch._point.x = (selTouch._point.x - viewport.x) / scaleX;
selTouch._point.y = (selTouch._point.y - viewport.y) / scaleY;
selTouch._prevPoint.x = (selTouch._prevPoint.x - viewport.x) / scaleX;
selTouch._prevPoint.y = (selTouch._prevPoint.y - viewport.y) / scaleY;
}
_convertTouchesWithScale (touches) {
var viewport = this._viewportRect, scaleX = this._scaleX, scaleY = this._scaleY,
selTouch, selPoint, selPrePoint;
for (var i = 0; i < touches.length; i++) {
selTouch = touches[i];
selPoint = selTouch._point;
selPrePoint = selTouch._prevPoint;
selPoint.x = (selPoint.x - viewport.x) / scaleX;
selPoint.y = (selPoint.y - viewport.y) / scaleY;
selPrePoint.x = (selPrePoint.x - viewport.x) / scaleX;
selPrePoint.y = (selPrePoint.y - viewport.y) / scaleY;
}
}
};
/**
* !en
* Emit when design resolution changed.
* !zh
* 当设计分辨率改变时发送。
* @event design-resolution-changed
*/
/**
* !en
* Emit when canvas resize.
* !zh
* 当画布大小改变时发送。
* @event canvas-resize
*/
/**
* <p>cc.game.containerStrategy class is the root strategy class of container's scale strategy,
* it controls the behavior of how to scale the cc.game.container and cc.game.canvas object</p>
*
* @class ContainerStrategy
*/
class ContainerStrategy {
/**
* !#en
* Manipulation before appling the strategy
* !#zh 在应用策略之前的操作
* @method preApply
* @param {View} view - The target view
*/
preApply (view) {
}
/**
* !#en
* Function to apply this strategy
* !#zh 策略应用方法
* @method apply
* @param {View} view
* @param {Size} designedResolution
*/
apply (view, designedResolution) {
}
/**
* !#en
* Manipulation after applying the strategy
* !#zh 策略调用之后的操作
* @method postApply
* @param {View} view The target view
*/
postApply (view) {
}
_setupContainer (view, w, h) {
var locCanvas = cc.game.canvas, locContainer = cc.game.container;
if (cc.sys.platform !== cc.sys.WECHAT_GAME) {
if (cc.sys.os === cc.sys.OS_ANDROID) {
document.body.style.width = (view._isRotated ? h : w) + 'px';
document.body.style.height = (view._isRotated ? w : h) + 'px';
}
// Setup style
locContainer.style.width = locCanvas.style.width = w + 'px';
locContainer.style.height = locCanvas.style.height = h + 'px';
}
// Setup pixel ratio for retina display
var devicePixelRatio = view._devicePixelRatio = 1;
if (view.isRetinaEnabled())
devicePixelRatio = view._devicePixelRatio = Math.min(2, window.devicePixelRatio || 1);
// Setup canvas
locCanvas.width = w * devicePixelRatio;
locCanvas.height = h * devicePixelRatio;
view.emit('canvas-resize');
}
_fixContainer () {
// Add container to document body
document.body.insertBefore(cc.game.container, document.body.firstChild);
// Set body's width height to window's size, and forbid overflow, so that game will be centered
var bs = document.body.style;
bs.width = window.innerWidth + "px";
bs.height = window.innerHeight + "px";
bs.overflow = "hidden";
// Body size solution doesn't work on all mobile browser so this is the aleternative: fixed container
var contStyle = cc.game.container.style;
contStyle.position = "fixed";
contStyle.left = contStyle.top = "0px";
// Reposition body
document.body.scrollTop = 0;
}
}
ContainerStrategy.prototype.name = "ContainerStrategy";
/**
* <p>ContentStrategy class is the root strategy class of content's scale strategy,
* it controls the behavior of how to scale the scene and setup the viewport for the game</p>
*
* @class ContentStrategy
*/
class ContentStrategy {
constructor () {
this._result = {
scale: [1, 1],
viewport: null
};
}
_buildResult (containerW, containerH, contentW, contentH, scaleX, scaleY) {
// Makes content fit better the canvas
Math.abs(containerW - contentW) < 2 && (contentW = containerW);
Math.abs(containerH - contentH) < 2 && (contentH = containerH);
var viewport = new Rect(Math.round((containerW - contentW) / 2),
Math.round((containerH - contentH) / 2),
contentW, contentH);
// Translate the content
if (cc.game.renderType === Game.RENDER_TYPE_CANVAS){
//TODO: modify something for setTransform
//game._renderContext.translate(viewport.x, viewport.y + contentH);
}
this._result.scale = [scaleX, scaleY];
this._result.viewport = viewport;
return this._result;
}
/**
* !#en
* Manipulation before applying the strategy
* !#zh 策略应用前的操作
* @method preApply
* @param {View} view - The target view
*/
preApply (view) {
}
/**
* !#en Function to apply this strategy
* The return value is {scale: [scaleX, scaleY], viewport: {new Rect}},
* The target view can then apply these value to itself, it's preferred not to modify directly its private variables
* !#zh 调用策略方法
* @method apply
* @param {View} view
* @param {Size} designedResolution
* @return {Object} scaleAndViewportRect
*/
apply (view, designedResolution) {
return {"scale": [1, 1]};
}
/**
* !#en
* Manipulation after applying the strategy
* !#zh 策略调用之后的操作
* @method postApply
* @param {View} view - The target view
*/
postApply (view) {
}
}
ContentStrategy.prototype.name = "ContentStrategy";
(function () {
// Container scale strategys
/**
* @class EqualToFrame
* @extends ContainerStrategy
*/
class EqualToFrame extends ContainerStrategy {
apply (view) {
var frameH = view._frameSize.height, containerStyle = cc.game.container.style;
this._setupContainer(view, view._frameSize.width, view._frameSize.height);
// Setup container's margin and padding
if (view._isRotated) {
containerStyle.margin = '0 0 0 ' + frameH + 'px';
}
else {
containerStyle.margin = '0px';
}
containerStyle.padding = "0px";
}
}
EqualToFrame.prototype.name = "EqualToFrame";
/**
* @class ProportionalToFrame
* @extends ContainerStrategy
*/
class ProportionalToFrame extends ContainerStrategy {
apply (view, designedResolution) {
var frameW = view._frameSize.width, frameH = view._frameSize.height, containerStyle = cc.game.container.style,
designW = designedResolution.width, designH = designedResolution.height,
scaleX = frameW / designW, scaleY = frameH / designH,
containerW, containerH;
scaleX < scaleY ? (containerW = frameW, containerH = designH * scaleX) : (containerW = designW * scaleY, containerH = frameH);
// Adjust container size with integer value
var offx = Math.round((frameW - containerW) / 2);
var offy = Math.round((frameH - containerH) / 2);
containerW = frameW - 2 * offx;
containerH = frameH - 2 * offy;
this._setupContainer(view, containerW, containerH);
if (!CC_EDITOR) {
// Setup container's margin and padding
if (view._isRotated) {
containerStyle.margin = '0 0 0 ' + frameH + 'px';
}
else {
containerStyle.margin = '0px';
}
containerStyle.paddingLeft = offx + "px";
containerStyle.paddingRight = offx + "px";
containerStyle.paddingTop = offy + "px";
containerStyle.paddingBottom = offy + "px";
}
}
};
ProportionalToFrame.prototype.name = "ProportionalToFrame";
// Alias: Strategy that makes the container's size equals to the frame's size
ContainerStrategy.EQUAL_TO_FRAME = new EqualToFrame();
// Alias: Strategy that scale proportionally the container's size to frame's size
ContainerStrategy.PROPORTION_TO_FRAME = new ProportionalToFrame();
// Content scale strategys
class ExactFit extends ContentStrategy {
apply (view, designedResolution) {
var containerW = cc.game.canvas.width, containerH = cc.game.canvas.height,
scaleX = containerW / designedResolution.width, scaleY = containerH / designedResolution.height;
return this._buildResult(containerW, containerH, containerW, containerH, scaleX, scaleY);
}
}
ExactFit.prototype.name = "ExactFit";
class ShowAll extends ContentStrategy {
apply (view, designedResolution) {
var containerW = cc.game.canvas.width, containerH = cc.game.canvas.height,
designW = designedResolution.width, designH = designedResolution.height,
scaleX = containerW / designW, scaleY = containerH / designH, scale = 0,
contentW, contentH;
scaleX < scaleY ? (scale = scaleX, contentW = containerW, contentH = designH * scale)
: (scale = scaleY, contentW = designW * scale, contentH = containerH);
return this._buildResult(containerW, containerH, contentW, contentH, scale, scale);
}
}
ShowAll.prototype.name = "ShowAll";
class NoBorder extends ContentStrategy {
apply (view, designedResolution) {
var containerW = cc.game.canvas.width, containerH = cc.game.canvas.height,
designW = designedResolution.width, designH = designedResolution.height,
scaleX = containerW / designW, scaleY = containerH / designH, scale,
contentW, contentH;
scaleX < scaleY ? (scale = scaleY, contentW = designW * scale, contentH = containerH)
: (scale = scaleX, contentW = containerW, contentH = designH * scale);
return this._buildResult(containerW, containerH, contentW, contentH, scale, scale);
}
}
NoBorder.prototype.name = "NoBorder";
class FixedHeight extends ContentStrategy {
apply (view, designedResolution) {
var containerW = cc.game.canvas.width, containerH = cc.game.canvas.height,
designH = designedResolution.height, scale = containerH / designH,
contentW = containerW, contentH = containerH;
return this._buildResult(containerW, containerH, contentW, contentH, scale, scale);
}
}
FixedHeight.prototype.name = "FixedHeight";
class FixedWidth extends ContentStrategy {
apply (view, designedResolution) {
var containerW = cc.game.canvas.width, containerH = cc.game.canvas.height,
designW = designedResolution.width, scale = containerW / designW,
contentW = containerW, contentH = containerH;
return this._buildResult(containerW, containerH, contentW, contentH, scale, scale);
}
}
FixedWidth.prototype.name = "FixedWidth";
// Alias: Strategy to scale the content's size to container's size, non proportional
ContentStrategy.EXACT_FIT = new ExactFit();
// Alias: Strategy to scale the content's size proportionally to maximum size and keeps the whole content area to be visible
ContentStrategy.SHOW_ALL = new ShowAll();
// Alias: Strategy to scale the content's size proportionally to fill the whole container area
ContentStrategy.NO_BORDER = new NoBorder();
// Alias: Strategy to scale the content's height to container's height and proportionally scale its width
ContentStrategy.FIXED_HEIGHT = new FixedHeight();
// Alias: Strategy to scale the content's width to container's width and proportionally scale its height
ContentStrategy.FIXED_WIDTH = new FixedWidth();
})();
/**
* <p>ResolutionPolicy class is the root strategy class of scale strategy,
* its main task is to maintain the compatibility with Cocos2d-x</p>
*
* @class ResolutionPolicy
*/
/**
* @method constructor
* @param {ContainerStrategy} containerStg The container strategy
* @param {ContentStrategy} contentStg The content strategy
*/
class ResolutionPolicy {
/**
* Constructor of ResolutionPolicy
* @param {ContainerStrategy} containerStg
* @param {ContentStrategy} contentStg
*/
constructor (containerStg, contentStg) {
this._containerStrategy = null;
this._contentStrategy = null;
this.setContainerStrategy(containerStg);
this.setContentStrategy(contentStg);
}
get canvasSize () {
return cc.v2(cc.game.canvas.width, cc.game.canvas.height);
}
/**
* !#en Manipulation before applying the resolution policy
* !#zh 策略应用前的操作
* @method preApply
* @param {View} view The target view
*/
preApply (view) {
this._containerStrategy.preApply(view);
this._contentStrategy.preApply(view);
}
/**
* !#en Function to apply this resolution policy
* The return value is {scale: [scaleX, scaleY], viewport: {new Rect}},
* The target view can then apply these value to itself, it's preferred not to modify directly its private variables
* !#zh 调用策略方法
* @method apply
* @param {View} view - The target view
* @param {Size} designedResolution - The user defined design resolution
* @return {Object} An object contains the scale X/Y values and the viewport rect
*/
apply (view, designedResolution) {
this._containerStrategy.apply(view, designedResolution);
return this._contentStrategy.apply(view, designedResolution);
}
/**
* !#en Manipulation after appyling the strategy
* !#zh 策略应用之后的操作
* @method postApply
* @param {View} view - The target view
*/
postApply (view) {
this._containerStrategy.postApply(view);
this._contentStrategy.postApply(view);
}
/**
* !#en
* Setup the container's scale strategy
* !#zh 设置容器的适配策略
* @method setContainerStrategy
* @param {ContainerStrategy} containerStg
*/
setContainerStrategy (containerStg) {
if (containerStg instanceof ContainerStrategy)
this._containerStrategy = containerStg;
}
/**
* !#en
* Setup the content's scale strategy
* !#zh 设置内容的适配策略
* @method setContentStrategy
* @param {ContentStrategy} contentStg
*/
setContentStrategy (contentStg) {
if (contentStg instanceof ContentStrategy)
this._contentStrategy = contentStg;
}
}
ResolutionPolicy.prototype.name = "ResolutionPolicy";
/**
* The entire application is visible in the specified area without trying to preserve the original aspect ratio.<br/>
* Distortion can occur, and the application may appear stretched or compressed.
* @property {Number} EXACT_FIT
* @readonly
* @static
*/
ResolutionPolicy.EXACT_FIT = 0;
/**
* The entire application fills the specified area, without distortion but possibly with some cropping,<br/>
* while maintaining the original aspect ratio of the application.
* @property {Number} NO_BORDER
* @readonly
* @static
*/
ResolutionPolicy.NO_BORDER = 1;
/**
* The entire application is visible in the specified area without distortion while maintaining the original<br/>
* aspect ratio of the application. Borders can appear on two sides of the application.
* @property {Number} SHOW_ALL
* @readonly
* @static
*/
ResolutionPolicy.SHOW_ALL = 2;
/**
* The application takes the height of the design resolution size and modifies the width of the internal<br/>
* canvas so that it fits the aspect ratio of the device<br/>
* no distortion will occur however you must make sure your application works on different<br/>
* aspect ratios
* @property {Number} FIXED_HEIGHT
* @readonly
* @static
*/
ResolutionPolicy.FIXED_HEIGHT = 3;
/**
* The application takes the width of the design resolution size and modifies the height of the internal<br/>
* canvas so that it fits the aspect ratio of the device<br/>
* no distortion will occur however you must make sure your application works on different<br/>
* aspect ratios
* @property {Number} FIXED_WIDTH
* @readonly
* @static
*/
ResolutionPolicy.FIXED_WIDTH = 4;
/**
* Unknow policy
* @property {Number} UNKNOWN
* @readonly
* @static
*/
ResolutionPolicy.UNKNOWN = 5;
ResolutionPolicy.ContainerStrategy = ContainerStrategy;
ResolutionPolicy.ContentStrategy = ContentStrategy;
cc.ResolutionPolicy = ResolutionPolicy;
/**
* @module cc
*/
/**
* !#en cc.view is the shared view object.
* !#zh cc.view 是全局的视图对象。
* @property view
* @static
* @type {View}
*/
let view = cc.view = new View();
/**
* !#en cc.winSize is the alias object for the size of the current game window.
* !#zh cc.winSize 为当前的游戏窗口的大小。
* @property winSize
* @type Size
*/
cc.winSize = cc.v2();
export default view;