2.0.69

beta/OrbitControls.js

+import { EventDispatcher } from '../core/EventDispatcher';
+import { TOUCH } from '../constants';
+import { Quaternion } from '../math/Quaternion';
+import { Vector2 } from '../math/Vector2';
+import { Vector3 } from '../math/Vector3';
+import { Spherical } from '../math/Spherical';
+
+export class OrbitControls {
+	enabled = true
+	enableDamping = true
+	dampingFactor = 0.25
+	userZoom = true
+	userZoomSpeed = 1.0
+	userRotate = true
+	userRotateSpeed = 1.0
+	autoRotate = false
+	autoRotateSpeed = 2.0
+	//最小旋转角
+	minPolarAngle = 0
+	//最大旋转角
+	maxPolarAngle = Math.PI
+	minDistance = 0
+	maxDistance = Infinity
+	enablePitch = true
+	constructor(camera) {
+		this.camera = camera
+		//相机目标点
+		var center = this.center = new Vector3();
+
+		// this.userPan = true;
+		// this.userPanSpeed = 2.0;
+		var EPS = 0.000001;
+		var PIXELS_PER_ROUND = 1800;
+
+		var rotateStart = new Vector2();
+		var rotateEnd = new Vector2();
+		var rotateDelta = new Vector2();
+
+		var phiDelta = 0;
+		var thetaDelta = 0;
+		var scale = 1;
+
+		function getAutoRotationAngle() {
+			return 2 * Math.PI / 60 / 60 * this.autoRotateSpeed;
+		}
+
+		function getZoomScale() {
+			return Math.pow(0.95, this.userZoomSpeed);
+		}
+
+		function rotateLeft(angle = getAutoRotationAngle()) {
+			thetaDelta -= angle;
+		};
+
+
+		function rotateUp(angle = getAutoRotationAngle()) {
+			phiDelta -= angle;
+		};
+
+		function zoomIn(zoomScale = getZoomScale()) {
+			scale /= zoomScale;
+		};
+		function zoomOut(zoomScale = getZoomScale()) {
+			scale *= zoomScale;
+		};
+
+		this.update = () => {
+			if (
+				Math.abs(thetaDelta) < 0.0001 &&
+				Math.abs(phiDelta) < 0.0001 &&
+				Math.abs(scale - 1) < 0.0001 &&
+				!this.autoRotate
+			) {
+				return
+			}
+
+			var position = this.camera.position;
+			var offset = position.clone().sub(center);
+			var theta = Math.atan2(offset.x, offset.z);
+			var phi = Math.atan2(Math.sqrt(offset.x * offset.x + offset.z * offset.z), offset.y);
+
+			if (this.autoRotate) rotateLeft();
+
+			theta += thetaDelta;
+			phi += phiDelta;
+
+			phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, phi));
+
+			phi = Math.max(EPS, Math.min(Math.PI - EPS, phi));
+
+			var radius = offset.length() * scale;
+
+			// restrict radius to be between desired limits
+			radius = Math.max(this.minDistance, Math.min(this.maxDistance, radius));
+
+			offset.x = radius * Math.sin(phi) * Math.sin(theta);
+			offset.y = radius * Math.cos(phi);
+			offset.z = radius * Math.sin(phi) * Math.cos(theta);
+
+			//相机位置
+			position.copy(center).add(offset);
+
+			//相机目标点
+			this.camera.lookAt(center.x, center.y, center.z);
+
+			//恢复
+			if (this.enableDamping) {
+				thetaDelta *= (1 - this.dampingFactor);
+				phiDelta *= (1 - this.dampingFactor);
+			} else {
+				thetaDelta = 0;
+				phiDelta = 0;
+			}
+
+			scale = 1;
+			// if (lastPosition.distanceTo(this.object.position) > 0) {
+			//     this.dispatchEvent(changeEvent);
+			//     lastPosition.copy(this.object.position);
+			// }
+		};
+		//记录两个手指唯一标识
+		let fingles = [];
+		//距离
+		let deltaDis = 0;
+		this.onTouchStart = (e) => {
+			if (!this.enabled) return;
+			//每个处理
+			for (var i = 0; i < e.changedTouches.length; i++) {
+				let { x, y, identifier } = e.changedTouches[i];
+				fingles.push({ x, y, id: identifier })
+				if (fingles.length >= 2) {
+					let f1 = fingles[fingles.length - 1];
+					let f2 = fingles[fingles.length - 2];
+					deltaDis = Math.sqrt(Math.pow(f1.x - f2.x, 2) + Math.pow(f1.y - f2.y, 2));
+				}
+				rotateStart.set(e.changedTouches[0].x, e.changedTouches[0].y);
+			}
+		}
+		this.onTouchMove = (e) => {
+			if (!this.enabled) return
+			if (!fingles.length) return;
+			for (var i = 0; i < e.changedTouches.length; i++) {
+				if (!e.changedTouches[i]) continue;
+				let { x, y, identifier } = e.changedTouches[i];
+				if (fingles.length == 1) {
+					if (!this.userRotate) return;
+					if (!rotateStart.x && !rotateStart.y) return;
+					rotateEnd.set(x, y);
+					rotateDelta.subVectors(rotateEnd, rotateStart);
+					rotateLeft(2 * Math.PI * rotateDelta.x / PIXELS_PER_ROUND * this.userRotateSpeed);
+					if (this.enablePitch) rotateUp(2 * Math.PI * rotateDelta.y / PIXELS_PER_ROUND * this.userRotateSpeed);
+					rotateStart.copy(rotateEnd);
+				}
+				//多指，取最后两个
+				else {
+					if (this.userZoom === false) return;
+					var oneF = fingles[fingles.length - 1];
+					var twoF = fingles[fingles.length - 2];
+					if (identifier == oneF.id) {
+						oneF.x = x
+						oneF.y = y
+					} else if (identifier == twoF.id) {
+						twoF.x = x
+						twoF.y = y
+					} else {
+						continue
+					}
+					var cDelta = Math.sqrt(Math.pow(oneF.x - twoF.x, 2) + Math.pow(oneF.y - twoF.y, 2));
+					if (cDelta - deltaDis > 0) {
+						zoomOut(Math.pow(0.95, cfg.userZoomSpeed / 3));//手势的执行太快了
+					} else {
+						zoomIn(Math.pow(0.95, cfg.userZoomSpeed / 3));
+					}
+					deltaDis = cDelta;
+				}
+			}
+			this.update();
+		}
+
+		this.onTouchEnd = (e) => {//淘宝有bug，全部移除先
+			fingles.length = 0;
+		}
+
+	}
+}
+
+
+
+
+
+

beta/meshOpt.js

+// This file is part of meshoptimizer library and is distributed under the terms of MIT License.
+// Copyright (C) 2016-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+var MeshoptDecoder = (function(path) {
+  // Built with clang version 11.0.0 (https://github.com/llvm/llvm-project.git 0160ad802e899c2922bc9b29564080c22eb0908c)
+  // Built from meshoptimizer 0.14
+
+  if (typeof WXWebAssembly !== 'object') {
+    // This module requires WebAssembly to function
+    return {
+      supported: false
+    };
+  }
+
+  var instance;
+  var readyResolve;
+  var promise = new Promise(resovle => {
+    readyResolve = resovle;
+  });
+
+  function setWasmPath(path) {
+    WXWebAssembly.instantiate(path, {}).then(function(result) {
+      instance = result.instance;
+      instance.exports.__wasm_call_ctors();
+      readyResolve();
+    });
+  }
+
+  function decode(fun, target, count, size, source, filter) {
+    var sbrk = instance.exports.sbrk;
+    var count4 = (count + 3) & ~3; // pad for SIMD filter
+    var tp = sbrk(count4 * size);
+    var sp = sbrk(source.length);
+    var heap = new Uint8Array(instance.exports.memory.buffer);
+    heap.set(source, sp);
+    var res = fun(tp, count, size, sp, source.length);
+    if (res == 0 && filter) {
+      filter(tp, count4, size);
+    }
+    target.set(heap.subarray(tp, tp + count * size));
+    sbrk(tp - sbrk(0));
+    if (res != 0) {
+      throw new Error('Malformed buffer data: ' + res);
+    }
+  }
+  var filters = {
+    // legacy index-based enums for glTF
+    0: '',
+    1: 'meshopt_decodeFilterOct',
+    2: 'meshopt_decodeFilterQuat',
+    3: 'meshopt_decodeFilterExp',
+    // string-based enums for glTF
+    NONE: '',
+    OCTAHEDRAL: 'meshopt_decodeFilterOct',
+    QUATERNION: 'meshopt_decodeFilterQuat',
+    EXPONENTIAL: 'meshopt_decodeFilterExp'
+  };
+
+  var decoders = {
+    // legacy index-based enums for glTF
+    0: 'meshopt_decodeVertexBuffer',
+    1: 'meshopt_decodeIndexBuffer',
+    2: 'meshopt_decodeIndexSequence',
+    // string-based enums for glTF
+    ATTRIBUTES: 'meshopt_decodeVertexBuffer',
+    TRIANGLES: 'meshopt_decodeIndexBuffer',
+    INDICES: 'meshopt_decodeIndexSequence'
+  };
+
+  return {
+    setWasmPath,
+    ready: promise,
+    supported: true,
+    decodeVertexBuffer: function(target, count, size, source, filter) {
+      decode(
+        instance.exports.meshopt_decodeVertexBuffer,
+        target,
+        count,
+        size,
+        source,
+        instance.exports[filters[filter]]
+      );
+    },
+    decodeIndexBuffer: function(target, count, size, source) {
+      decode(
+        instance.exports.meshopt_decodeIndexBuffer,
+        target,
+        count,
+        size,
+        source
+      );
+    },
+    decodeIndexSequence: function(target, count, size, source) {
+      decode(
+        instance.exports.meshopt_decodeIndexSequence,
+        target,
+        count,
+        size,
+        source
+      );
+    },
+    decodeGltfBuffer: function(target, count, size, source, mode, filter) {
+      decode(
+        instance.exports[decoders[mode]],
+        target,
+        count,
+        size,
+        source,
+        instance.exports[filters[filter]]
+      );
+    }
+  };
+})();
+
+export { MeshoptDecoder };

beta/meshopt_decoder.asm.module.js

+// This file is part of meshoptimizer library and is distributed under the terms of MIT License.
+// Copyright (C) 2016-2020, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+import * as DECODER from './decoder_base.js';
+
+var MeshoptDecoder = (function () {
+  'use strict';
+
+  var instance = { exports: DECODER };
+
+  function decode(fun, target, count, size, source, filter) {
+    var sbrk = instance.exports.sbrk;
+    var count4 = (count + 3) & ~3; // pad for SIMD filter
+    var tp = sbrk(count4 * size);
+    var sp = sbrk(source.length);
+    var heap = new Uint8Array(instance.exports.memory.buffer);
+    heap.set(source, sp);
+    var res = fun(tp, count, size, sp, source.length);
+    if (res == 0 && filter) {
+      filter(tp, count4, size);
+    }
+    target.set(heap.subarray(tp, tp + count * size));
+    sbrk(tp - sbrk(0));
+    if (res != 0) {
+      throw new Error('Malformed buffer data: ' + res);
+    }
+  }
+
+  var filters = {
+    // legacy index-based enums for glTF
+    0: '',
+    1: 'meshopt_decodeFilterOct',
+    2: 'meshopt_decodeFilterQuat',
+    3: 'meshopt_decodeFilterExp',
+    // string-based enums for glTF
+    NONE: '',
+    OCTAHEDRAL: 'meshopt_decodeFilterOct',
+    QUATERNION: 'meshopt_decodeFilterQuat',
+    EXPONENTIAL: 'meshopt_decodeFilterExp',
+  };
+
+  var decoders = {
+    // legacy index-based enums for glTF
+    0: 'meshopt_decodeVertexBuffer',
+    1: 'meshopt_decodeIndexBuffer',
+    2: 'meshopt_decodeIndexSequence',
+    // string-based enums for glTF
+    ATTRIBUTES: 'meshopt_decodeVertexBuffer',
+    TRIANGLES: 'meshopt_decodeIndexBuffer',
+    INDICES: 'meshopt_decodeIndexSequence',
+  };
+
+  return {
+    ready: Promise.resolve(),
+    supported: true,
+    decodeVertexBuffer: function (target, count, size, source, filter) {
+      decode(
+        instance.exports.meshopt_decodeVertexBuffer,
+        target,
+        count,
+        size,
+        source,
+        instance.exports[filters[filter]],
+      );
+    },
+    decodeIndexBuffer: function (target, count, size, source) {
+      decode(
+        instance.exports.meshopt_decodeIndexBuffer,
+        target,
+        count,
+        size,
+        source,
+      );
+    },
+    decodeIndexSequence: function (target, count, size, source) {
+      decode(
+        instance.exports.meshopt_decodeIndexSequence,
+        target,
+        count,
+        size,
+        source,
+      );
+    },
+    decodeGltfBuffer: function (target, count, size, source, mode, filter) {
+      decode(
+        instance.exports[decoders[mode]],
+        target,
+        count,
+        size,
+        source,
+        instance.exports[filters[filter]],
+      );
+    },
+  };
+})();
+
+export { MeshoptDecoder };

build/FYGE.d.ts

-declare namespace FYGE{export  const VERSION = "2.0.68";
+declare namespace FYGE{export  const VERSION = "2.0.69";
 
 export  function cos(angle: number): number;
 
@@ -8887,12 +8887,14 @@ export interface ScrollEvent extends Event {
 
 export  class ScrollListItem extends Container {
     data: any;
+    index: number;
     /**
      * 列表滚动时各项item有数据变更时会触发
      * @param data 参数会传入data，也可直接使用this.data
+     * @param index data所在数组的索引
      * @protected
      */
-    onDataChanged(data?: any): void;
+    onDataChanged(data?: any, index?: number): void;
 }
 
 export  class ScrollList extends ScrollView {

build/types.d.ts

-export  const VERSION = "2.0.68";
+export  const VERSION = "2.0.69";
 
 export  function cos(angle: number): number;
 
@@ -8887,12 +8887,14 @@ export interface ScrollEvent extends Event {
 
 export  class ScrollListItem extends Container {
     data: any;
+    index: number;
     /**
      * 列表滚动时各项item有数据变更时会触发
      * @param data 参数会传入data，也可直接使用this.data
+     * @param index data所在数组的索引
      * @protected
      */
-    onDataChanged(data?: any): void;
+    onDataChanged(data?: any, index?: number): void;
 }
 
 export  class ScrollList extends ScrollView {

package.json

 {
     "name": "fyge",
-    "version": "2.0.68",
+    "version": "2.0.69",
     "description": "canvas渲染引擎",
     "main": "./build/fyge.min.js",
     "module": "./build/fyge.esm.js",

record.txt

@@ -615,6 +615,13 @@
             boneTexture.premultipliedAlpha = false;
         SpineAniManager的showAni的callback回调函数去掉参数loop
 
+2.0.69  ScrollList文件里ScrollListItem添加index属性，并在onDataChanged第二个参数返回
+        ScrollList里去掉sroll_id，用index代替
+
+
+
+
+
 
 getElementsByName到时要处理下
 

src/2d/const.ts

@@ -7,7 +7,7 @@
  * @name VERSION
  * @type {string}
  */
-export const VERSION = "2.0.68";
+export const VERSION = "2.0.69";
 
 
 /**

src/2d/ui/ScrollList.ts

@@ -11,13 +11,15 @@ import { ScrollView, ScrollEvent } from "./ScrollView";
  * @since 2.0.0
  */
 export class ScrollListItem extends Container {
-    data: any
+    data: any;
+    index: number;
     /**
      * 列表滚动时各项item有数据变更时会触发
      * @param data 参数会传入data，也可直接使用this.data
+     * @param index data所在数组的索引
      * @protected
      */
-    onDataChanged(data?: any) {
+    onDataChanged(data?: any, index?: number) {
 
     };
 }
@@ -178,21 +180,21 @@ export class ScrollList extends ScrollView {
         for (let i = 0; i < s._itemCount; i++) {
             let item: ScrollListItem = s._items[i];
             if (s._isInit == 1) {
-                item["sroll_id"] = -1;
+                item.index = -1;
             }
-            if (item["sroll_id"] !== id) {
+            if (item.index !== id) {
                 //id在data数组列表内就执行
                 if (id < s.data.length) {
-                    item.onDataChanged(item.data = s.data[id]);
+                    item.index = id;
+                    item.onDataChanged(item.data = s.data[id], id);
                     item.visible = true;
                     //位置
                     item[dimension] = Math.floor(id / s._cols) * s._itemRow;
                     item[antDimension] = (id % s._cols) * s._itemCol;
-                    item["sroll_id"] = id;
                 } else {
                     item.data = null;
+                    item.index = -1;
                     item.visible = false;
-                    item["sroll_id"] = -1;
                     //位置需要刷新吗？
                 }
             }