@shijiu/jsview 1.9.719

package/dom/jsview-dom/src/engine-js/browser/html_shared_tools/mat.js

@@ -0,0 +1,102 @@
+
+
+class Mat {
+    constructor(row, column, eles) {
+        this.element = eles;
+        this.row = row;
+        this.column = column;
+    }
+
+    toString() {
+        return `[${this.element[0]},${this.element[1]},${this.element[2]},${this.element[3]},${this.element[4]},${this.element[5]},${this.element[6]},${this.element[7]},${this.element[8]},${this.element[9]},${this.element[10]},${this.element[11]},${this.element[12]},${this.element[13]},${this.element[14]},${this.element[15]}]`;
+    }
+
+    multiply(m_2) {
+        if (this.column !== m_2.row) {
+            throw new Error("matrix multiply error");
+        }
+
+        const result = [];
+        for (let i = 0; i < this.row; i++) {
+            for (let j = 0; j < m_2.column; j++) {
+                result[i + j * m_2.column] = 0;
+                for (let k = 0; k < this.column; k++) {
+                    result[i + j * m_2.column] += (this.element[i + k * this.column] * m_2.element[k + j * m_2.column]);
+                }
+            }
+        }
+        return new Mat(this.row, m_2.column, result);
+    }
+
+    static identity() {
+        return new Mat(4, 4, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+    }
+
+    static translate(x, y, z) {
+        return new Mat(4, 4, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1]);
+    }
+
+    static scale(x, y, z) {
+        return new Mat(4, 4, [x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1]);
+    }
+
+    static rotate(x, y, z, angle) {
+        const c = Math.cos(angle / 180 * Math.PI);
+        const s = Math.sin(angle / 180 * Math.PI);
+        const len = Math.sqrt(x * x + y * y + z * z);
+        if (len !== 1) {
+            const rlen = 1 / len;
+            x *= rlen;
+            y *= rlen;
+            z *= rlen;
+        }
+        const nc = 1 - c;
+        const xy = x * y;
+        const yz = y * z;
+        const zx = z * x;
+        const xs = x * s;
+        const ys = y * s;
+        const zs = z * s;
+        const e = [];
+        e[0] = x * x * nc + c;
+        e[1] = xy * nc + zs;
+        e[2] = zx * nc - ys;
+        e[3] = 0;
+
+        e[4] = xy * nc - zs;
+        e[5] = y * y * nc + c;
+        e[6] = yz * nc + xs;
+        e[7] = 0;
+
+        e[8] = zx * nc + ys;
+        e[9] = yz * nc - xs;
+        e[10] = z * z * nc + c;
+        e[11] = 0;
+
+        e[12] = 0;
+        e[13] = 0;
+        e[14] = 0;
+        e[15] = 1.0;
+
+        return new Mat(4, 4, e);
+    }
+
+    static skew(x_angle, y_angle) {
+        const a = new Array(16).fill(0);
+        const y_rad = 2 * Math.PI * (y_angle / 360);
+        const x_rad = -2 * Math.PI * (x_angle / 360);
+        a[0] = 1 - x_rad * y_rad;
+        a[1] = -Math.tan(y_rad);
+        a[4] = Math.tan(x_rad);
+        a[5] = 1;
+        a[10] = 1;
+        a[15] = 1;
+        return new Mat(4, 4, a);
+    }
+
+    static transform2d(a, b, c, d, e, f) {
+        return new Mat(4, 4, [a, b, 0, 0, c, d, 0, 0, 0, 0, 1, 0, e, f, 0, 1]);
+    }
+}
+
+export default Mat;

package/dom/jsview-dom/src/engine-js/browser/html_shared_tools/range_model.js

@@ -0,0 +1,296 @@
+/* eslint-disable */
+class RangesModel {
+    /**
+     * 范围计算模型（用于复数范围比较）<br>
+     *     例如：范围[-10, -2] + [2, 10] 与 范围[-8,-1] + [1, 8]进行交集计算<br>
+     *         再如：范围[-10, -2] + [2, 10] 与 范围 [-8, 8]进行排除运算
+     *
+     * @public
+     * @constructor RangesModel
+     * @param {int} start	范围的初始起点
+     * @param {int} end	范围的初始终点
+     **/
+    constructor(start, end) {
+        /**
+         * 范围数组
+         * @public
+         * @name RangeModel#Ranges
+         * @type {SingleRangeModel[]}
+         */
+        this.Ranges = [];
+        if (typeof start != "undefined" && typeof end != "undefined")
+            this.Ranges.push(new SingleRangeModel(start, end));
+    }
+
+    /**
+     * 范围合并
+     *
+     * @public
+     * @func Merge
+     * @memberof RangesModel
+     * @instance
+     * @param {SingleRangeModel} merge_from
+     **/
+    Merge(merge_from) {
+        var merged_with_other = false;
+        var insert_place = this.Ranges.length;
+        for (var i = 0; i < this.Ranges.length; i++) {
+            if (merge_from.End + 1 < this.Ranges[i].Start) {
+                insert_place = i;
+                break;
+            } else {
+                // Ranges[i].start <= merge_from.End which can do the merge
+            }
+
+            if (this.Ranges[i].Merge(merge_from)) {
+                merged_with_other = true;
+                // Try merge to next range, after enlarge current range
+                while (i + 1 < this.Ranges.length && this.Ranges[i].Merge(this.Ranges[i + 1])) {
+                    this.Ranges.splice(i + 1, 1);
+                }
+                break;
+            }
+        }
+        if (!merged_with_other) {
+            this.Ranges.splice(insert_place, 0, merge_from);
+        }
+    };
+
+    /**
+     * 范围排除
+     *
+     * @public
+     * @func Exclude
+     * @memberof RangesModel
+     * @instance
+     * @param {SingleRangeModel} exclude_range
+     **/
+    Exclude(exclude_range) {
+        for (var i = 0; i < this.Ranges.length; i++) {
+            if (exclude_range.End < this.Ranges[i].Start) {
+                break;
+            }
+
+            var result = this.Ranges[i].Exclude(exclude_range);
+            if (this.Ranges[i].IsEmpty()) {
+                // Remove current range for become empty
+                this.Ranges.splice(i, 1);
+                i--;
+            }
+            if (result.newSplitedRange != null) {
+                // Append split range
+                this.Ranges.splice(i + 1, 0, result.newSplitedRange);
+                break;
+            }
+        }
+    };
+
+    /**
+     * 遍历范围数组的每个位置
+     *
+     * @public
+     * @func ForEach
+     * @memberof RangeModel
+     * @instance
+     * @param {function} callback	对于每个位置的回调处理，参数（int:当前位置值）。
+     * @param {boolean} invert		是否是倒序进行遍历，默认为正序
+     **/
+    ForEach(callback, invert) {
+        if (!callback) {
+            console.error("Callback function is invalid");
+            return;
+        }
+
+        if (invert) {
+            for (var i = this.Ranges.length - 1; i >= 0; i--) {
+                for (var j = this.Ranges[i].End; j >= this.Ranges[i].Start; j--) {
+                    callback(j);
+                }
+            }
+        } else {
+            for (var i = 0; i < this.Ranges.length; i++) {
+                for (var j = this.Ranges[i].Start; j <= this.Ranges[i].End; j++) {
+                    callback(j);
+                }
+            }
+        }
+    };
+
+}
+
+class SingleRangeModel {
+    /**
+     * 范围计算模型（RangesModel数组中的单元模型）
+     *
+     * @public
+     * @constructor SingleRangeModel
+     * @param {int} start	范围的初始起点
+     * @param {int} end	范围的初始终点
+     **/
+    constructor(start, end) {
+        /**
+         * 范围的起始位置
+         * @public
+         * @name SingleRangeModel#Start
+         * @type {int}
+         */
+        this.Start = start;
+
+        /**
+         * 范围的结束位置
+         * @public
+         * @name SingleRangeModel#End
+         * @type {int}
+         */
+        this.End = end;
+    }
+
+    /**
+     * 与给定的单元范围进行合并
+     *
+     * @public
+     * @func Merge
+     * @memberof SingleRangeModel
+     * @instance
+     * @param {SingleRangeModel} merge_from	合并对象
+     * @return {boolean}  true:合并成功（有交集或者范围恰好衔接），false:合并失败
+     **/
+    Merge(merge_from) {
+        if (!this.IsInterAct(merge_from)) {
+            if (this.End + 1 == merge_from.Start) {
+                this.End = merge_from.End;
+                return true;
+            } else if (this.Start == merge_from.End + 1) {
+                this.Start = merge_from.Start;
+                return true;
+            }
+            return false;
+        }
+
+        if (this.Start > merge_from.Start)
+            this.Start = merge_from.Start;
+        if (this.End < merge_from.End)
+            this.End = merge_from.End;
+
+        return true;
+    };
+
+    /**
+     * 检查是否与给定单元范围有交集
+     *
+     * @public
+     * @func IsInterAct
+     * @memberof SingleRangeModel
+     * @instance
+     * @param {SingleRangeModel} range	合并对象
+     * @return {boolean}  true:有交集，false:无交集
+     **/
+    IsInterAct(range) {
+        if (range.Start < this.Start) {
+            if (range.End < this.Start)
+                return false;
+            return true;
+        } else {
+            if (range.Start <= this.End)
+                return true;
+            return false;
+        }
+    };
+
+    /**
+     * 检查是否与给定单元范围有交集
+     *
+     * @public
+     * @func IsContain
+     * @memberof SingleRangeModel
+     * @instance
+     * @param {SingleRangeModel} range	合并对象
+     * @return {boolean}  true:完全包含(含端点) false:非包含
+     **/
+    IsInclude(range) {
+        return (this.Start <= range.Start && this.End >= range.End);
+    }
+
+    /**
+     * 排除指定单元范围
+     *
+     * @public
+     * @func Exclude
+     * @memberof SingleRangeModel
+     * @instance
+     * @param {SingleRangeModel} exclude	指定单元范围
+     * @return {Object}  {success(boolean):是否排除成功，如无交集则为false, <br>
+     *     					newSplitedRange(SingleRangeModel):进行排除后，被分离出来的后半段单元范围}
+     **/
+    Exclude(exclude) {
+        var result = {
+            "success": false,
+            "newSplitedRange": null
+        };
+        if (!this.IsInterAct(exclude))
+            return result;
+
+        if (exclude.Start <= this.Start) {
+            if (exclude.End < this.End)
+                this.Start = exclude.End + 1;
+            else
+                this.Clear();
+        } else {
+            if (exclude.End < this.End) {
+                result.newSplitedRange = new SingleRangeModel(exclude.End + 1, this.End);
+                result["newSplitedRange"] = result.newSplitedRange;
+            }
+            this.End = exclude.Start - 1; // Update current range end
+        }
+
+        result.success = true;
+        result["success"] = result.success;
+
+        return result;
+    };
+
+    /**
+     * 范围是否空区域
+     *
+     * @public
+     * @func IsEmpty
+     * @memberof SingleRangeModel
+     * @instance
+     * @return {boolean} true:为空区域，false:不为空
+     **/
+    IsEmpty() {
+        return (this.Start > this.End);
+    }
+
+    /**
+     * 将单元范围清成空区域
+     *
+     * @public
+     * @func Clear
+     * @memberof SingleRangeModel
+     * @instance
+     **/
+    Clear() {
+        this.End = this.Start - 1;
+    }
+
+    /**
+     * 复制单元范围
+     *
+     * @public
+     * @func Clone
+     * @memberof SingleRangeModel
+     * @instance
+     * @return {SingleRangeModel} 复制出的实例
+     **/
+    Clone() {
+        var range_model = new SingleRangeModel(this.Start, this.End);
+        return range_model;
+    }
+
+}
+
+export {
+    RangesModel,
+    SingleRangeModel
+}

package/dom/jsview-dom/src/engine-js/browser/html_shared_tools/test_collide.js

@@ -0,0 +1,10 @@
+import { getTransform } from "./element_transform";
+import gjk from './gjk';
+
+
+function testCollide(ele1, ele2) {
+    const intersected = gjk.intersect(getTransform(ele1), getTransform(ele2));
+    return intersected;
+}
+
+export default testCollide;

package/dom/jsview-dom/src/engine-js/browser/index.js

@@ -0,0 +1,38 @@
+/**
+ * Created by luocf on 2020/1/17.
+ */
+import "../ForgeDefine";
+import "./PlatformUtils";
+import "./media";
+import "./sound_pool";
+import "./console_log";
+import "./rect_utils";
+import "./text_view";
+import "./platform_timer";
+import "./easing";
+import "./texture_manager";
+import "./layout_view_debug";
+import "./layout_params";
+import "./render_texture_proxy";
+import "./renderer_deprecated";
+import "./layout_view";
+import "./text_utils";
+import "./view_store";
+import "./animation_base";
+import "./animation_proxy";
+import "./steps_animation";
+import "./render_bridge";
+import "./particle_view";
+import "./react_utils";
+import "./text_style_cache"
+import "./page_base"
+import "./view_sensor/index"
+import "./apic_decoder/libwebp-0.6.0.min";
+import "./apic_decoder/demux";
+import "./apic_decoder/gifDecoder";
+
+console.log("Using JsView HTML Forge");
+
+// roll-up规则下，总要导出点什么
+let dummy = {};
+export default dummy