"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();