@antv/l7-renderer 2.21.0 → 2.21.2

package/es/device/DeviceTexture2D.js

@@ -1,28 +1,28 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { TextureUsage as DeviceTextureUsage, FilterMode, Format, MipmapFilterMode } from '@antv/g-device-api';
-import { TextureUsage, gl } from '@antv/l7-core';
+// src/device/DeviceTexture2D.ts
+import {
+  TextureUsage as DeviceTextureUsage,
+  FilterMode,
+  Format,
+  MipmapFilterMode
+} from "@antv/g-device-api";
+import { TextureUsage, gl } from "@antv/l7-core";
 import { wrapModeMap } from "./constants";
 import { extend3ChannelsTo4 } from "./utils/typedarray";
-export function isTexture2D(t) {
-  return !!(t && t['texture']);
+function isTexture2D(t) {
+  return !!(t && t["texture"]);
 }
-var DeviceTexture2D = /*#__PURE__*/function () {
-  function DeviceTexture2D(device, options) {
-    _classCallCheck(this, DeviceTexture2D);
-    _defineProperty(this, "isDestroy", false);
+var DeviceTexture2D = class {
+  constructor(device, options) {
     this.device = device;
     this.options = options;
-    var _options$wrapS = options.wrapS,
-      wrapS = _options$wrapS === void 0 ? gl.CLAMP_TO_EDGE : _options$wrapS,
-      _options$wrapT = options.wrapT,
-      wrapT = _options$wrapT === void 0 ? gl.CLAMP_TO_EDGE : _options$wrapT,
-      aniso = options.aniso,
-      _options$mag = options.mag,
-      mag = _options$mag === void 0 ? gl.NEAREST : _options$mag,
-      _options$min = options.min,
-      min = _options$min === void 0 ? gl.NEAREST : _options$min;
+    this.isDestroy = false;
+    const {
+      wrapS = gl.CLAMP_TO_EDGE,
+      wrapT = gl.CLAMP_TO_EDGE,
+      aniso,
+      mag = gl.NEAREST,
+      min = gl.NEAREST
+    } = options;
     this.createTexture(options);
     this.sampler = device.createSampler({
       addressModeU: wrapModeMap[wrapS],
@@ -35,115 +35,96 @@ var DeviceTexture2D = /*#__PURE__*/function () {
       maxAnisotropy: aniso
     });
   }
-  _createClass(DeviceTexture2D, [{
-    key: "createTexture",
-    value: function createTexture(options) {
-      var _options$type = options.type,
-        type = _options$type === void 0 ? gl.UNSIGNED_BYTE : _options$type,
-        width = options.width,
-        height = options.height,
-        _options$flipY = options.flipY,
-        flipY = _options$flipY === void 0 ? false : _options$flipY,
-        _options$format = options.format,
-        format = _options$format === void 0 ? gl.RGBA : _options$format,
-        _options$alignment = options.alignment,
-        alignment = _options$alignment === void 0 ? 1 : _options$alignment,
-        _options$usage = options.usage,
-        usage = _options$usage === void 0 ? TextureUsage.SAMPLED : _options$usage,
-        _options$unorm = options.unorm,
-        unorm = _options$unorm === void 0 ? false : _options$unorm,
-        label = options.label;
-      var data = options.data;
-      this.width = width;
-      this.height = height;
-      var pixelFormat = Format.U8_RGBA_RT;
-      if (type === gl.UNSIGNED_BYTE && format === gl.RGBA) {
-        pixelFormat = unorm ? Format.U8_RGBA_NORM : Format.U8_RGBA_RT;
-      } else if (type === gl.UNSIGNED_BYTE && format === gl.LUMINANCE) {
-        pixelFormat = Format.U8_LUMINANCE;
-      } else if (type === gl.FLOAT && format === gl.RGB) {
-        // @see https://github.com/antvis/L7/pull/2262
-        if (this.device.queryVendorInfo().platformString === 'WebGPU') {
-          if (data) {
-            // @ts-ignore
-            data = extend3ChannelsTo4(data, 0);
-          }
-          pixelFormat = Format.F32_RGBA;
-        } else {
-          pixelFormat = Format.F32_RGB;
+  createTexture(options) {
+    const {
+      type = gl.UNSIGNED_BYTE,
+      width,
+      height,
+      flipY = false,
+      format = gl.RGBA,
+      alignment = 1,
+      usage = TextureUsage.SAMPLED,
+      // premultiplyAlpha = false,
+      unorm = false,
+      // colorSpace = gl.BROWSER_DEFAULT_WEBGL,
+      // x = 0,
+      // y = 0,
+      // copy = false,
+      label
+    } = options;
+    let { data } = options;
+    this.width = width;
+    this.height = height;
+    let pixelFormat = Format.U8_RGBA_RT;
+    if (type === gl.UNSIGNED_BYTE && format === gl.RGBA) {
+      pixelFormat = unorm ? Format.U8_RGBA_NORM : Format.U8_RGBA_RT;
+    } else if (type === gl.UNSIGNED_BYTE && format === gl.LUMINANCE) {
+      pixelFormat = Format.U8_LUMINANCE;
+    } else if (type === gl.FLOAT && format === gl.RGB) {
+      if (this.device.queryVendorInfo().platformString === "WebGPU") {
+        if (data) {
+          data = extend3ChannelsTo4(data, 0);
         }
-      } else if (type === gl.FLOAT && format === gl.RGBA) {
         pixelFormat = Format.F32_RGBA;
-      } else if (type === gl.FLOAT && format === gl.RED) {
-        pixelFormat = Format.F32_R;
       } else {
-        throw new Error("create texture error, type: ".concat(type, ", format: ").concat(format));
-      }
-      this.texture = this.device.createTexture({
-        format: pixelFormat,
-        width: width,
-        height: height,
-        usage: usage === TextureUsage.SAMPLED ? DeviceTextureUsage.SAMPLED : DeviceTextureUsage.RENDER_TARGET,
-        pixelStore: {
-          unpackFlipY: flipY,
-          packAlignment: alignment
-        },
-        // mipLevelCount: usage === TextureUsage.RENDER_TARGET ? 1 : mipmap ? 1 : 0,
-        mipLevelCount: 1
-      });
-      if (label) {
-        this.device.setResourceName(this.texture, label);
-      }
-      if (data) {
-        // @ts-ignore
-        this.texture.setImageData([data]);
+        pixelFormat = Format.F32_RGB;
       }
+    } else if (type === gl.FLOAT && format === gl.RGBA) {
+      pixelFormat = Format.F32_RGBA;
+    } else if (type === gl.FLOAT && format === gl.RED) {
+      pixelFormat = Format.F32_R;
+    } else {
+      throw new Error(`create texture error, type: ${type}, format: ${format}`);
     }
-  }, {
-    key: "get",
-    value: function get() {
-      return this.texture;
+    this.texture = this.device.createTexture({
+      format: pixelFormat,
+      width,
+      height,
+      usage: usage === TextureUsage.SAMPLED ? DeviceTextureUsage.SAMPLED : DeviceTextureUsage.RENDER_TARGET,
+      pixelStore: {
+        unpackFlipY: flipY,
+        packAlignment: alignment
+      },
+      // mipLevelCount: usage === TextureUsage.RENDER_TARGET ? 1 : mipmap ? 1 : 0,
+      mipLevelCount: 1
+    });
+    if (label) {
+      this.device.setResourceName(this.texture, label);
     }
-  }, {
-    key: "update",
-    value: function update(props) {
-      var data = props.data;
+    if (data) {
       this.texture.setImageData([data]);
     }
-  }, {
-    key: "bind",
-    value: function bind() {
-      // this.texture._texture.bind();
-    }
-  }, {
-    key: "resize",
-    value: function resize(_ref) {
-      var width = _ref.width,
-        height = _ref.height;
-      if (this.width !== width || this.height !== height) {
-        this.destroy();
-      }
-      this.options.width = width;
-      this.options.height = height;
-      this.createTexture(this.options);
-      this.isDestroy = false;
-    }
-  }, {
-    key: "getSize",
-    value: function getSize() {
-      return [this.width, this.height];
+  }
+  get() {
+    return this.texture;
+  }
+  update(props) {
+    const { data } = props;
+    this.texture.setImageData([data]);
+  }
+  bind() {
+  }
+  resize({ width, height }) {
+    if (this.width !== width || this.height !== height) {
+      this.destroy();
     }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      // @ts-ignore
-      if (!this.isDestroy && !this.texture.destroyed) {
-        var _this$texture;
-        (_this$texture = this.texture) === null || _this$texture === void 0 || _this$texture.destroy();
-      }
-      this.isDestroy = true;
+    this.options.width = width;
+    this.options.height = height;
+    this.createTexture(this.options);
+    this.isDestroy = false;
+  }
+  getSize() {
+    return [this.width, this.height];
+  }
+  destroy() {
+    var _a;
+    if (!this.isDestroy && !this.texture.destroyed) {
+      (_a = this.texture) == null ? void 0 : _a.destroy();
     }
-  }]);
-  return DeviceTexture2D;
-}();
-export { DeviceTexture2D as default };
+    this.isDestroy = true;
+  }
+};
+export {
+  DeviceTexture2D as default,
+  isTexture2D
+};

package/es/device/constants.js

@@ -1,34 +1,117 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-var _typedArrayCtorMap, _primitiveMap, _sizeFormatMap, _hintMap, _wrapModeMap, _depthFuncMap, _cullFaceMap, _blendEquationMap, _blendFuncMap, _stencilOpMap, _stencilFuncMap;
-import { AddressMode, BlendFactor, BlendMode, BufferFrequencyHint, CompareFunction, CullMode, Format, PrimitiveTopology, StencilOp } from '@antv/g-device-api';
-import { gl } from '@antv/l7-core';
-export var typedArrayCtorMap = (_typedArrayCtorMap = {}, _defineProperty(_typedArrayCtorMap, gl.FLOAT, Float32Array), _defineProperty(_typedArrayCtorMap, gl.UNSIGNED_BYTE, Uint8Array), _defineProperty(_typedArrayCtorMap, gl.SHORT, Int16Array), _defineProperty(_typedArrayCtorMap, gl.UNSIGNED_SHORT, Uint16Array), _defineProperty(_typedArrayCtorMap, gl.INT, Int32Array), _defineProperty(_typedArrayCtorMap, gl.UNSIGNED_INT, Uint32Array), _typedArrayCtorMap);
-export var primitiveMap = (_primitiveMap = {}, _defineProperty(_primitiveMap, gl.POINTS, PrimitiveTopology.POINTS), _defineProperty(_primitiveMap, gl.LINES, PrimitiveTopology.LINES), _defineProperty(_primitiveMap, gl.LINE_LOOP, PrimitiveTopology.LINES), _defineProperty(_primitiveMap, gl.LINE_STRIP, PrimitiveTopology.LINE_STRIP), _defineProperty(_primitiveMap, gl.TRIANGLES, PrimitiveTopology.TRIANGLES), _defineProperty(_primitiveMap, gl.TRIANGLE_FAN, PrimitiveTopology.TRIANGLES), _defineProperty(_primitiveMap, gl.TRIANGLE_STRIP, PrimitiveTopology.TRIANGLE_STRIP), _primitiveMap);
-export var sizeFormatMap = (_sizeFormatMap = {}, _defineProperty(_sizeFormatMap, 1, Format.F32_R), _defineProperty(_sizeFormatMap, 2, Format.F32_RG), _defineProperty(_sizeFormatMap, 3, Format.F32_RGB), _defineProperty(_sizeFormatMap, 4, Format.F32_RGBA), _sizeFormatMap);
-export var hintMap = (_hintMap = {}, _defineProperty(_hintMap, gl.STATIC_DRAW, BufferFrequencyHint.STATIC), _defineProperty(_hintMap, gl.DYNAMIC_DRAW, BufferFrequencyHint.DYNAMIC), _defineProperty(_hintMap, gl.STREAM_DRAW, BufferFrequencyHint.DYNAMIC), _hintMap);
-export var wrapModeMap = (_wrapModeMap = {}, _defineProperty(_wrapModeMap, gl.REPEAT, AddressMode.REPEAT), _defineProperty(_wrapModeMap, gl.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE), _defineProperty(_wrapModeMap, gl.MIRRORED_REPEAT, AddressMode.MIRRORED_REPEAT), _wrapModeMap);
-export var depthFuncMap = (_depthFuncMap = {}, _defineProperty(_depthFuncMap, gl.NEVER, CompareFunction.NEVER), _defineProperty(_depthFuncMap, gl.ALWAYS, CompareFunction.ALWAYS), _defineProperty(_depthFuncMap, gl.LESS, CompareFunction.LESS), _defineProperty(_depthFuncMap, gl.LEQUAL, CompareFunction.LEQUAL), _defineProperty(_depthFuncMap, gl.GREATER, CompareFunction.GREATER), _defineProperty(_depthFuncMap, gl.GEQUAL, CompareFunction.GEQUAL), _defineProperty(_depthFuncMap, gl.EQUAL, CompareFunction.EQUAL), _defineProperty(_depthFuncMap, gl.NOTEQUAL, CompareFunction.NOTEQUAL), _depthFuncMap);
-export var cullFaceMap = (_cullFaceMap = {}, _defineProperty(_cullFaceMap, gl.FRONT, CullMode.FRONT), _defineProperty(_cullFaceMap, gl.BACK, CullMode.BACK), _cullFaceMap);
-export var blendEquationMap = (_blendEquationMap = {}, _defineProperty(_blendEquationMap, gl.FUNC_ADD, BlendMode.ADD), _defineProperty(_blendEquationMap, gl.MIN_EXT, BlendMode.MIN), _defineProperty(_blendEquationMap, gl.MAX_EXT, BlendMode.MAX), _defineProperty(_blendEquationMap, gl.FUNC_SUBTRACT, BlendMode.SUBSTRACT), _defineProperty(_blendEquationMap, gl.FUNC_REVERSE_SUBTRACT, BlendMode.REVERSE_SUBSTRACT), _blendEquationMap);
-export var blendFuncMap = (_blendFuncMap = {}, _defineProperty(_blendFuncMap, gl.ZERO, BlendFactor.ZERO), _defineProperty(_blendFuncMap, gl.ONE, BlendFactor.ONE), _defineProperty(_blendFuncMap, gl.SRC_COLOR, BlendFactor.SRC), _defineProperty(_blendFuncMap, gl.ONE_MINUS_SRC_COLOR, BlendFactor.ONE_MINUS_SRC), _defineProperty(_blendFuncMap, gl.SRC_ALPHA, BlendFactor.SRC_ALPHA), _defineProperty(_blendFuncMap, gl.ONE_MINUS_SRC_ALPHA, BlendFactor.ONE_MINUS_SRC_ALPHA), _defineProperty(_blendFuncMap, gl.DST_COLOR, BlendFactor.DST), _defineProperty(_blendFuncMap, gl.ONE_MINUS_DST_COLOR, BlendFactor.ONE_MINUS_DST), _defineProperty(_blendFuncMap, gl.DST_ALPHA, BlendFactor.DST_ALPHA), _defineProperty(_blendFuncMap, gl.ONE_MINUS_DST_ALPHA, BlendFactor.ONE_MINUS_DST_ALPHA), _defineProperty(_blendFuncMap, gl.CONSTANT_COLOR, BlendFactor.CONST), _defineProperty(_blendFuncMap, gl.ONE_MINUS_CONSTANT_COLOR, BlendFactor.ONE_MINUS_CONSTANT), _defineProperty(_blendFuncMap, gl.CONSTANT_ALPHA, BlendFactor.CONST), _defineProperty(_blendFuncMap, gl.ONE_MINUS_CONSTANT_ALPHA, BlendFactor.ONE_MINUS_CONSTANT), _defineProperty(_blendFuncMap, gl.SRC_ALPHA_SATURATE, BlendFactor.SRC_ALPHA_SATURATE), _blendFuncMap);
-export var stencilOpMap = (_stencilOpMap = {}, _defineProperty(_stencilOpMap, gl.REPLACE, StencilOp.REPLACE), _defineProperty(_stencilOpMap, gl.KEEP, StencilOp.KEEP), _defineProperty(_stencilOpMap, gl.ZERO, StencilOp.ZERO), _defineProperty(_stencilOpMap, gl.INVERT, StencilOp.INVERT), _defineProperty(_stencilOpMap, gl.INCR, StencilOp.INCREMENT_CLAMP), _defineProperty(_stencilOpMap, gl.DECR, StencilOp.DECREMENT_CLAMP), _defineProperty(_stencilOpMap, gl.INCR_WRAP, StencilOp.INCREMENT_WRAP), _defineProperty(_stencilOpMap, gl.DECR_WRAP, StencilOp.DECREMENT_WRAP), _stencilOpMap);
-export var stencilFuncMap = (_stencilFuncMap = {}, _defineProperty(_stencilFuncMap, gl.ALWAYS, CompareFunction.ALWAYS), _defineProperty(_stencilFuncMap, gl.EQUAL, CompareFunction.EQUAL), _defineProperty(_stencilFuncMap, gl.GEQUAL, CompareFunction.GEQUAL), _defineProperty(_stencilFuncMap, gl.GREATER, CompareFunction.GREATER), _defineProperty(_stencilFuncMap, gl.LEQUAL, CompareFunction.LEQUAL), _defineProperty(_stencilFuncMap, gl.LESS, CompareFunction.LESS), _defineProperty(_stencilFuncMap, gl.NEVER, CompareFunction.NEVER), _defineProperty(_stencilFuncMap, gl.NOTEQUAL, CompareFunction.NOTEQUAL), _stencilFuncMap);
-
-// export const filterMap: {
-//   [key: string]: FilterMode;
-// } = {
-//   [gl.NEAREST]: 'nearest',
-//   [gl.LINEAR]: 'linear',
-//   [gl.LINEAR_MIPMAP_LINEAR]: 'mipmap',
-//   [gl.NEAREST_MIPMAP_LINEAR]: 'nearest mipmap linear',
-//   [gl.LINEAR_MIPMAP_NEAREST]: 'linear mipmap nearest',
-//   [gl.NEAREST_MIPMAP_NEAREST]: 'nearest mipmap nearest',
-// };
-
-// export const mipmapMap: {
-//   [key: string]: MipmapFilterMode;
-// } = {
-//   [gl.DONT_CARE]: MipmapFilterMode,
-//   [gl.NICEST]: 'nice',
-//   [gl.FASTEST]: 'fast',
-// };
+// src/device/constants.ts
+import {
+  AddressMode,
+  BlendFactor,
+  BlendMode,
+  BufferFrequencyHint,
+  CompareFunction,
+  CullMode,
+  Format,
+  PrimitiveTopology,
+  StencilOp
+} from "@antv/g-device-api";
+import { gl } from "@antv/l7-core";
+var typedArrayCtorMap = {
+  [gl.FLOAT]: Float32Array,
+  [gl.UNSIGNED_BYTE]: Uint8Array,
+  [gl.SHORT]: Int16Array,
+  [gl.UNSIGNED_SHORT]: Uint16Array,
+  [gl.INT]: Int32Array,
+  [gl.UNSIGNED_INT]: Uint32Array
+};
+var primitiveMap = {
+  [gl.POINTS]: PrimitiveTopology.POINTS,
+  [gl.LINES]: PrimitiveTopology.LINES,
+  [gl.LINE_LOOP]: PrimitiveTopology.LINES,
+  [gl.LINE_STRIP]: PrimitiveTopology.LINE_STRIP,
+  [gl.TRIANGLES]: PrimitiveTopology.TRIANGLES,
+  [gl.TRIANGLE_FAN]: PrimitiveTopology.TRIANGLES,
+  [gl.TRIANGLE_STRIP]: PrimitiveTopology.TRIANGLE_STRIP
+};
+var sizeFormatMap = {
+  [1]: Format.F32_R,
+  [2]: Format.F32_RG,
+  [3]: Format.F32_RGB,
+  [4]: Format.F32_RGBA
+};
+var hintMap = {
+  [gl.STATIC_DRAW]: BufferFrequencyHint.STATIC,
+  [gl.DYNAMIC_DRAW]: BufferFrequencyHint.DYNAMIC,
+  [gl.STREAM_DRAW]: BufferFrequencyHint.DYNAMIC
+};
+var wrapModeMap = {
+  [gl.REPEAT]: AddressMode.REPEAT,
+  [gl.CLAMP_TO_EDGE]: AddressMode.CLAMP_TO_EDGE,
+  [gl.MIRRORED_REPEAT]: AddressMode.MIRRORED_REPEAT
+};
+var depthFuncMap = {
+  [gl.NEVER]: CompareFunction.NEVER,
+  [gl.ALWAYS]: CompareFunction.ALWAYS,
+  [gl.LESS]: CompareFunction.LESS,
+  [gl.LEQUAL]: CompareFunction.LEQUAL,
+  [gl.GREATER]: CompareFunction.GREATER,
+  [gl.GEQUAL]: CompareFunction.GEQUAL,
+  [gl.EQUAL]: CompareFunction.EQUAL,
+  [gl.NOTEQUAL]: CompareFunction.NOTEQUAL
+};
+var cullFaceMap = {
+  [gl.FRONT]: CullMode.FRONT,
+  [gl.BACK]: CullMode.BACK
+};
+var blendEquationMap = {
+  [gl.FUNC_ADD]: BlendMode.ADD,
+  [gl.MIN_EXT]: BlendMode.MIN,
+  [gl.MAX_EXT]: BlendMode.MAX,
+  [gl.FUNC_SUBTRACT]: BlendMode.SUBSTRACT,
+  [gl.FUNC_REVERSE_SUBTRACT]: BlendMode.REVERSE_SUBSTRACT
+};
+var blendFuncMap = {
+  [gl.ZERO]: BlendFactor.ZERO,
+  [gl.ONE]: BlendFactor.ONE,
+  [gl.SRC_COLOR]: BlendFactor.SRC,
+  [gl.ONE_MINUS_SRC_COLOR]: BlendFactor.ONE_MINUS_SRC,
+  [gl.SRC_ALPHA]: BlendFactor.SRC_ALPHA,
+  [gl.ONE_MINUS_SRC_ALPHA]: BlendFactor.ONE_MINUS_SRC_ALPHA,
+  [gl.DST_COLOR]: BlendFactor.DST,
+  [gl.ONE_MINUS_DST_COLOR]: BlendFactor.ONE_MINUS_DST,
+  [gl.DST_ALPHA]: BlendFactor.DST_ALPHA,
+  [gl.ONE_MINUS_DST_ALPHA]: BlendFactor.ONE_MINUS_DST_ALPHA,
+  [gl.CONSTANT_COLOR]: BlendFactor.CONST,
+  [gl.ONE_MINUS_CONSTANT_COLOR]: BlendFactor.ONE_MINUS_CONSTANT,
+  [gl.CONSTANT_ALPHA]: BlendFactor.CONST,
+  [gl.ONE_MINUS_CONSTANT_ALPHA]: BlendFactor.ONE_MINUS_CONSTANT,
+  [gl.SRC_ALPHA_SATURATE]: BlendFactor.SRC_ALPHA_SATURATE
+};
+var stencilOpMap = {
+  [gl.REPLACE]: StencilOp.REPLACE,
+  [gl.KEEP]: StencilOp.KEEP,
+  [gl.ZERO]: StencilOp.ZERO,
+  [gl.INVERT]: StencilOp.INVERT,
+  [gl.INCR]: StencilOp.INCREMENT_CLAMP,
+  [gl.DECR]: StencilOp.DECREMENT_CLAMP,
+  [gl.INCR_WRAP]: StencilOp.INCREMENT_WRAP,
+  [gl.DECR_WRAP]: StencilOp.DECREMENT_WRAP
+};
+var stencilFuncMap = {
+  [gl.ALWAYS]: CompareFunction.ALWAYS,
+  [gl.EQUAL]: CompareFunction.EQUAL,
+  [gl.GEQUAL]: CompareFunction.GEQUAL,
+  [gl.GREATER]: CompareFunction.GREATER,
+  [gl.LEQUAL]: CompareFunction.LEQUAL,
+  [gl.LESS]: CompareFunction.LESS,
+  [gl.NEVER]: CompareFunction.NEVER,
+  [gl.NOTEQUAL]: CompareFunction.NOTEQUAL
+};
+export {
+  blendEquationMap,
+  blendFuncMap,
+  cullFaceMap,
+  depthFuncMap,
+  hintMap,
+  primitiveMap,
+  sizeFormatMap,
+  stencilFuncMap,
+  stencilOpMap,
+  typedArrayCtorMap,
+  wrapModeMap
+};