231 lines
8.1 KiB
JavaScript
231 lines
8.1 KiB
JavaScript
"use strict";
|
|
cc._RF.push(module, '308552aGF9D9bQ5I4j3sIIt', 'nx.jsr');
|
|
// Scripts/nx/kernel/nx.jsr.js
|
|
|
|
"use strict";
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Nx JS扩展
|
|
*
|
|
*
|
|
*
|
|
* 2021.12.10
|
|
******************************************************************************/
|
|
|
|
var NxObject = require("nx.object");
|
|
|
|
// DataView扩展
|
|
var exDataView = function exDataView() {
|
|
// DataView 64位UINT解析
|
|
DataView.prototype.getUint64 = function (byteOffset, littleEndian) {
|
|
var left = this.getUint32(byteOffset, littleEndian);
|
|
var right = this.getUint32(byteOffset + 4, littleEndian);
|
|
var combine = littleEndian ? left + Math.pow(2, 32) * right : Math.pow(2, 32) * left + right;
|
|
if (!Number.isSafeInteger(combine)) {
|
|
cc.warn("64Int精度丢失!");
|
|
}
|
|
return combine;
|
|
};
|
|
};
|
|
|
|
// MeshBuffer扩展
|
|
var exMeshBuffer = function exMeshBuffer() {
|
|
var FIX_IOS14_BUFFER = (cc.sys.os === cc.sys.OS_IOS || cc.sys.os === cc.sys.MACOS) && cc.sys.isBrowser && /(OS 1[4-9])|(Version\/1[4-9])/.test(window.navigator.userAgent);
|
|
if (FIX_IOS14_BUFFER) {
|
|
cc.MeshBuffer.prototype.checkAndSwitchBuffer = function (vertexCount) {
|
|
if (this.vertexOffset + vertexCount > 65535) {
|
|
this.uploadData();
|
|
this._batcher._flush();
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
// RenderFlower扩展
|
|
var exRenderFlower = function exRenderFlower() {
|
|
var FlagOfset = 0;
|
|
var DONOTHING = 1 << FlagOfset++;
|
|
var BREAK_FLOW = 1 << FlagOfset++;
|
|
var LOCAL_TRANSFORM = 1 << FlagOfset++;
|
|
var WORLD_TRANSFORM = 1 << FlagOfset++;
|
|
var TRANSFORM = LOCAL_TRANSFORM | WORLD_TRANSFORM;
|
|
var UPDATE_RENDER_DATA = 1 << FlagOfset++;
|
|
var OPACITY = 1 << FlagOfset++;
|
|
var COLOR = 1 << FlagOfset++;
|
|
var OPACITY_COLOR = OPACITY | COLOR;
|
|
var RENDER = 1 << FlagOfset++;
|
|
var CHILDREN = 1 << FlagOfset++;
|
|
var POST_RENDER = 1 << FlagOfset++;
|
|
var FINAL = 1 << FlagOfset++;
|
|
var renderFlow = cc["RenderFlow"];
|
|
var _batcher = renderFlow.getBachther();
|
|
var __levelBatcher = [];
|
|
var __renderQueue = [];
|
|
Object.defineProperty(renderFlow.prototype, "_opacity", {
|
|
value: function value(node) {
|
|
_batcher.parentOpacityDirty++;
|
|
if (node["__levelRender"] && __levelBatcher[node["__itemIndex"]]) {
|
|
__levelBatcher[node["__itemIndex"]].parentOpacityDirty = 1;
|
|
}
|
|
this._next._func(node);
|
|
node._renderFlag &= ~OPACITY;
|
|
if (node["__levelRender"] && __levelBatcher[node["__itemIndex"]] && node["__lastChildren"]) {
|
|
__levelBatcher[node.__itemIndex].parentOpacityDirty = 0;
|
|
}
|
|
_batcher.parentOpacityDirty--;
|
|
}
|
|
});
|
|
Object.defineProperty(renderFlow.prototype, "_worldTransform", {
|
|
value: function value(node) {
|
|
_batcher.worldMatDirty++;
|
|
if (node["__levelRender"] && __levelBatcher[node["__itemIndex"]]) {
|
|
__levelBatcher[node["__itemIndex"]].worldMatDirty = 1;
|
|
}
|
|
var t = node._matrix;
|
|
var trs = node._trs;
|
|
var tm = t.m;
|
|
tm[12] = trs[0];
|
|
tm[13] = trs[1];
|
|
tm[14] = trs[2];
|
|
node._mulMat(node._worldMatrix, node._parent._worldMatrix, t);
|
|
node._renderFlag &= ~WORLD_TRANSFORM;
|
|
this._next._func(node);
|
|
if (node["__levelRender"] && __levelBatcher[node["__itemIndex"]] && node["__lastChildren"]) {
|
|
__levelBatcher[node.__itemIndex].worldMatDirty = 0;
|
|
}
|
|
_batcher.worldMatDirty--;
|
|
}
|
|
});
|
|
var levelSplit = function levelSplit(node, lv, itemIndex) {
|
|
if (!__renderQueue[lv]) {
|
|
__renderQueue[lv] = [];
|
|
}
|
|
__renderQueue[lv].push(node);
|
|
lv++;
|
|
node["__renderLv"] = lv;
|
|
node["__levelRender"] = true;
|
|
node["__itemIndex"] = itemIndex;
|
|
var cs = node.children;
|
|
for (var i = 0; i < cs.length; ++i) {
|
|
var c = cs[i];
|
|
if (!__renderQueue[lv]) {
|
|
__renderQueue[lv] = [];
|
|
}
|
|
lv = levelSplit(c, lv, itemIndex);
|
|
}
|
|
return lv;
|
|
};
|
|
var checkLevelRender = function checkLevelRender(levelRenderNode) {
|
|
var cs = levelRenderNode.children;
|
|
var rootOpacityInHierarchy = levelRenderNode["opacity"] / 255;
|
|
__levelBatcher = [];
|
|
for (var i = 0; i < cs.length; ++i) {
|
|
__levelBatcher.push({
|
|
worldMatDirty: 0,
|
|
parentOpacityDirty: 0
|
|
});
|
|
levelSplit(cs[i], 0, i);
|
|
}
|
|
while (__renderQueue.length > 0) {
|
|
var list = __renderQueue.shift();
|
|
if (list.length > 0) {
|
|
while (list.length > 0) {
|
|
var n = list.shift();
|
|
n["__lastChildren"] = __renderQueue.length == 0;
|
|
n["__levelRender"] = true;
|
|
var opacityInHierarchy = n.parent["__opacityInHierarchy"];
|
|
if (opacityInHierarchy === undefined) {
|
|
opacityInHierarchy = rootOpacityInHierarchy;
|
|
}
|
|
var opacity = opacityInHierarchy * (n["_opacity"] / 255);
|
|
n["__opacityInHierarchy"] = opacity;
|
|
var cullingMask = n["_cullingMask"];
|
|
var worldMatDirty = 0;
|
|
if (__levelBatcher[n["__itemIndex"]]) {
|
|
worldMatDirty = __levelBatcher[n["__itemIndex"]].worldMatDirty || 0;
|
|
}
|
|
var parentOpacityDirty = 0;
|
|
if (__levelBatcher[n["__itemIndex"]]) {
|
|
parentOpacityDirty = __levelBatcher[n["__itemIndex"]].parentOpacityDirty || 0;
|
|
}
|
|
var worldTransformFlag = worldMatDirty || _batcher.worldMatDirty ? WORLD_TRANSFORM : 0;
|
|
var worldOpacityFlag = parentOpacityDirty || _batcher.parentOpacityDirty ? OPACITY_COLOR : 0;
|
|
var worldDirtyFlag = worldTransformFlag | worldOpacityFlag;
|
|
n["_renderFlag"] |= worldDirtyFlag;
|
|
if (!n["_activeInHierarchy"] || n["_opacity"] === 0) continue;
|
|
n["_cullingMask"] = n.groupIndex === 0 ? cullingMask : 1 << n.groupIndex;
|
|
// TODO: Maybe has better way to implement cascade opacity
|
|
var colorVal = n["_color"]._val;
|
|
n["_color"]._fastSetA(n["_opacity"] * opacity);
|
|
renderFlow.flows[n["_renderFlag"]]._func(n);
|
|
n["_color"]._val = colorVal;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
Object.defineProperty(renderFlow.prototype, "_children", {
|
|
value: function value(node) {
|
|
if (node.__levelRender) return;
|
|
var cullingMask = node._cullingMask;
|
|
var enableLevelRender = node["__enableLevelRender"];
|
|
var parentOpacityInHierarchy = node.parent ? node.parent["__opacityInHierarchy"] : undefined;
|
|
var parentOpacity = parentOpacityInHierarchy !== undefined ? parentOpacityInHierarchy : _batcher.parentOpacity;
|
|
if (!enableLevelRender && !node.__levelRender) {
|
|
var opacity = parentOpacity *= node._opacity / 255;
|
|
node["__opacityInHierarchy"] = opacity;
|
|
var worldTransformFlag = _batcher.worldMatDirty ? WORLD_TRANSFORM : 0;
|
|
var worldOpacityFlag = _batcher.parentOpacityDirty ? OPACITY_COLOR : 0;
|
|
var worldDirtyFlag = worldTransformFlag | worldOpacityFlag;
|
|
var children = node._children;
|
|
for (var i = 0, l = children.length; i < l; i++) {
|
|
var c = children[i];
|
|
// Advance the modification of the flag to avoid node attribute modification is invalid when opacity === 0.
|
|
c._renderFlag |= worldDirtyFlag;
|
|
c["__opacityInHierarchy"] = c._opacity * opacity / 255;
|
|
if (!c._activeInHierarchy || c._opacity === 0) continue;
|
|
c._cullingMask = c.groupIndex === 0 ? cullingMask : 1 << c.groupIndex;
|
|
|
|
// TODO: Maybe has better way to implement cascade opacity
|
|
var colorVal = c._color._val;
|
|
c._color._fastSetA(c._opacity * opacity);
|
|
renderFlow.flows[c._renderFlag]._func(c);
|
|
c._color._val = colorVal;
|
|
}
|
|
} else {
|
|
checkLevelRender(node);
|
|
}
|
|
_batcher.parentOpacity = parentOpacity;
|
|
this._next._func(node);
|
|
}
|
|
});
|
|
};
|
|
var nxJS = cc.Class({
|
|
"extends": NxObject,
|
|
name: "nxJS",
|
|
// 初始化
|
|
initialize: function initialize(_args) {
|
|
// USPER
|
|
this._super(_args);
|
|
|
|
// DataView扩展
|
|
exDataView();
|
|
|
|
// MeshBuffer扩展
|
|
exMeshBuffer();
|
|
|
|
// RenderFlower扩展
|
|
exRenderFlower();
|
|
return true;
|
|
},
|
|
// 销毁
|
|
uninitialize: function uninitialize() {
|
|
// USPER
|
|
return this._super();
|
|
}
|
|
});
|
|
|
|
// 模块导出
|
|
module.exports = nxJS;
|
|
|
|
cc._RF.pop(); |