diff --git a/common/src/app/common/types/path/impl.cljc b/common/src/app/common/types/path/impl.cljc index 6e513f0057..bae9d4840d 100644 --- a/common/src/app/common/types/path/impl.cljc +++ b/common/src/app/common/types/path/impl.cljc @@ -29,6 +29,7 @@ #?(:clj (set! *warn-on-reflection* true)) (def ^:const SEGMENT-U8-SIZE 28) +(def ^:const SEGMENT-U32-SIZE (/ SEGMENT-U8-SIZE 4)) (defprotocol IPathData (-write-to [_ buffer offset] "write the content to the specified buffer") diff --git a/frontend/src/app/main/data/workspace/modifiers.cljs b/frontend/src/app/main/data/workspace/modifiers.cljs index 382320d6ea..74b0ea8c7d 100644 --- a/frontend/src/app/main/data/workspace/modifiers.cljs +++ b/frontend/src/app/main/data/workspace/modifiers.cljs @@ -530,25 +530,24 @@ nil))))))) modif-tree)) + +(def ^:private xf:parse-geometry-modifier + (let [default-transform (gmt/matrix)] + (keep (fn [[id data]] + (cond + (= id uuid/zero) + nil + + (ctm/has-geometry? (:modifiers data)) + (d/vec2 id (ctm/modifiers->transform (:modifiers data))) + + ;; Unit matrix is used for reflowing + :else + (d/vec2 id default-transform)))))) + (defn- parse-geometry-modifiers [modif-tree] - (into - [] - (keep - (fn [[id data]] - (cond - (= id uuid/zero) - nil - - (ctm/has-geometry? (:modifiers data)) - {:id id - :transform (ctm/modifiers->transform (:modifiers data))} - - ;; Unit matrix is used for reflowing - :else - {:id id - :transform (gmt/matrix)}))) - modif-tree)) + (into [] xf:parse-geometry-modifier modif-tree)) (defn- extract-property-changes [modif-tree] @@ -573,6 +572,8 @@ (update [_ state] (assoc state :workspace-wasm-modifiers modifiers)))) +(def ^:private xf:map-key (map key)) + #_:clj-kondo/ignore (defn set-wasm-modifiers [modif-tree & {:keys [ignore-constraints ignore-snap-pixel] @@ -591,16 +592,17 @@ (watch [_ state _] (wasm.api/clean-modifiers) (let [prev-wasm-props (:prev-wasm-props state) - wasm-props (:wasm-props state) - objects (dsh/lookup-page-objects state) + wasm-props (:wasm-props state) + objects (dsh/lookup-page-objects state) pixel-precision false] (set-wasm-props! objects prev-wasm-props wasm-props) (let [structure-entries (parse-structure-modifiers modif-tree)] (wasm.api/set-structure-modifiers structure-entries) (let [geometry-entries (parse-geometry-modifiers modif-tree) - modifiers (wasm.api/propagate-modifiers geometry-entries pixel-precision)] + modifiers (wasm.api/propagate-modifiers geometry-entries pixel-precision)] (wasm.api/set-modifiers modifiers) - (let [selrect (wasm.api/get-selection-rect (->> geometry-entries (map :id)))] + (let [ids (into [] xf:map-key geometry-entries) + selrect (wasm.api/get-selection-rect ids)] (rx/of (set-temporary-selrect selrect) (set-temporary-modifiers modifiers))))))))) @@ -649,16 +651,14 @@ ;; way we don't have to check all the attributes (assoc :attrs transform-attrs)) - geometry-entries (parse-geometry-modifiers modif-tree) + geometry-entries + (parse-geometry-modifiers modif-tree) snap-pixel? (and (not ignore-snap-pixel) (contains? (:workspace-layout state) :snap-pixel-grid)) transforms - (into - {} - (map (fn [{:keys [id transform]}] [id transform])) - (wasm.api/propagate-modifiers geometry-entries snap-pixel?)) + (into {} (wasm.api/propagate-modifiers geometry-entries snap-pixel?)) modif-tree (propagate-structure-modifiers modif-tree (dsh/lookup-page-objects state)) @@ -709,10 +709,9 @@ (gm/set-objects-modifiers objects)) modifiers - (->> modif-tree - (map (fn [[id {:keys [modifiers]}]] - {:id id - :transform (ctm/modifiers->transform modifiers)})))] + (mapv (fn [[id {:keys [modifiers]}]] + (d/vec2 id (ctm/modifiers->transform modifiers))) + modif-tree)] (wasm.api/set-modifiers modifiers)))))) diff --git a/frontend/src/app/render_wasm/api.cljs b/frontend/src/app/render_wasm/api.cljs index 1faa24b187..43cd169e6b 100644 --- a/frontend/src/app/render_wasm/api.cljs +++ b/frontend/src/app/render_wasm/api.cljs @@ -10,8 +10,6 @@ ["react-dom/server" :as rds] [app.common.data :as d :refer [not-empty?]] [app.common.data.macros :as dm] - [app.common.geom.matrix :as gmt] - [app.common.geom.point :as gpt] [app.common.types.fills :as types.fills] [app.common.types.fills.impl :as types.fills.impl] [app.common.types.path :as path] @@ -41,39 +39,17 @@ (def use-dpr? (contains? cf/flags :render-wasm-dpr)) -;; -;; List of common entry sizes. -;; -;; All of these entries are in bytes so we need to adjust -;; these values to work with TypedArrays of 32 bits. -;; (def ^:const UUID-U8-SIZE 16) (def ^:const UUID-U32-SIZE (/ UUID-U8-SIZE 4)) (def ^:const MODIFIER-U8-SIZE 40) +(def ^:const MODIFIER-U32-SIZE (/ MODIFIER-U8-SIZE 4)) (def ^:const MODIFIER-TRANSFORM-U8-OFFSET-SIZE 16) (def ^:const GRID-LAYOUT-ROW-U8-SIZE 5) (def ^:const GRID-LAYOUT-COLUMN-U8-SIZE 5) (def ^:const GRID-LAYOUT-CELL-U8-SIZE 37) -(defn modifier-get-entries-size - "Returns the list of a modifier list in bytes" - [modifiers] - (mem/get-list-size modifiers MODIFIER-U8-SIZE)) - -(defn grid-layout-get-row-entries-size - [rows] - (mem/get-list-size rows GRID-LAYOUT-ROW-U8-SIZE)) - -(defn grid-layout-get-column-entries-size - [columns] - (mem/get-list-size columns GRID-LAYOUT-COLUMN-U8-SIZE)) - -(defn grid-layout-get-cell-entries-size - [cells] - (mem/get-list-size cells GRID-LAYOUT-CELL-U8-SIZE)) - (def dpr (if use-dpr? (if (exists? js/window) js/window.devicePixelRatio 1.0) 1.0)) @@ -172,20 +148,20 @@ (defn set-shape-children [children] - (let [heap (mem/get-heap-u32) - length (count children)] - (perf/begin-measure "set-shape-children") - (when (pos? length) - (let [offset (mem/alloc->offset-32 (* UUID-U8-SIZE length))] - (reduce (fn [offset id] - (sr/heapu32-set-uuid id heap offset) - (+ offset UUID-U32-SIZE)) - offset - children))) - (let [result (h/call wasm/internal-module "_set_children")] - (perf/end-measure "set-shape-children") - result))) + (when-not ^boolean (empty? children) + (perf/begin-measure "set-shape-children") + (let [heap (mem/get-heap-u32) + size (mem/get-alloc-size children UUID-U8-SIZE) + offset (mem/alloc->offset-32 size)] + (reduce (fn [offset id] + (sr/write-uuid offset heap id)) + offset + children) + + (let [result (h/call wasm/internal-module "_set_children")] + (perf/end-measure "set-shape-children") + result)))) (defn- get-string-length [string] @@ -467,14 +443,11 @@ (defn set-grid-layout-rows [entries] - (let [size (grid-layout-get-row-entries-size entries) + (let [size (mem/get-alloc-size entries GRID-LAYOUT-ROW-U8-SIZE) offset (mem/alloc size) + heap (-> (mem/get-heap-u8) + (mem/view offset size))] - heap - (js/Uint8Array. - (.-buffer (mem/get-heap-u8)) - offset - size)] (loop [entries (seq entries) current-offset 0] (when-not (empty? entries) @@ -486,14 +459,11 @@ (defn set-grid-layout-columns [entries] - (let [size (grid-layout-get-column-entries-size entries) + (let [size (mem/get-alloc-size entries GRID-LAYOUT-COLUMN-U8-SIZE) offset (mem/alloc size) + heap (-> (mem/get-heap-u8) + (mem/view offset size))] - heap - (js/Uint8Array. - (.-buffer (mem/get-heap-u8)) - offset - size)] (loop [entries (seq entries) current-offset 0] (when-not (empty? entries) @@ -506,14 +476,10 @@ (defn set-grid-layout-cells [cells] (let [entries (vals cells) - size (grid-layout-get-cell-entries-size entries) - offset (mem/alloc size) - - heap - (js/Uint8Array. - (.-buffer (mem/get-heap-u8)) - offset - size)] + size (mem/get-alloc-size entries GRID-LAYOUT-CELL-U8-SIZE) + offset (mem/alloc size) + heap (-> (mem/get-heap-u8) + (mem/view offset size))] (loop [entries (seq entries) current-offset 0] @@ -625,7 +591,7 @@ (h/call wasm/internal-module "_add_shape_shadow" rgba blur spread x y (sr/translate-shadow-style style) hidden) (recur (inc index))))))) -(declare propagate-apply) +;; (declare propagate-apply) (defn set-shape-text-content [shape-id content] @@ -824,134 +790,90 @@ (defn set-focus-mode [entries] - (let [offset (mem/alloc->offset-32 (* (count entries) 16)) - heapu32 (mem/get-heap-u32)] + (when-not ^boolean (empty? entries) + (let [size (mem/get-alloc-size entries UUID-U8-SIZE) + heap (mem/get-heap-u32) + offset (mem/alloc->offset-32 size)] - (loop [entries (seq entries) - current-offset offset] - (when-not (empty? entries) - (let [id (first entries)] - (sr/heapu32-set-uuid id heapu32 current-offset) - (recur (rest entries) (+ current-offset (mem/->offset-32 16)))))) + (reduce (fn [offset id] + (sr/write-uuid offset heap id)) + offset + entries) - (h/call wasm/internal-module "_set_focus_mode") - (clear-drawing-cache) - (request-render "set-focus-mode"))) + (h/call wasm/internal-module "_set_focus_mode") + (clear-drawing-cache) + (request-render "set-focus-mode")))) (defn set-structure-modifiers [entries] - (when-not (empty? entries) - (let [offset (mem/alloc->offset-32 (mem/get-list-size entries 44)) + (when-not ^boolean (empty? entries) + (let [size (mem/get-alloc-size entries 44) + offset (mem/alloc->offset-32 size) heapu32 (mem/get-heap-u32) heapf32 (mem/get-heap-f32)] - (loop [entries (seq entries) - current-offset offset] - (when-not (empty? entries) - (let [{:keys [type parent id index value] :as entry} (first entries)] - (sr/heapu32-set-u32 (sr/translate-structure-modifier-type type) heapu32 (+ current-offset 0)) - (sr/heapu32-set-u32 (or index 0) heapu32 (+ current-offset 1)) - (sr/heapu32-set-uuid parent heapu32 (+ current-offset 2)) - (sr/heapu32-set-uuid id heapu32 (+ current-offset 6)) - (aset heapf32 (+ current-offset 10) value) - (recur (rest entries) (+ current-offset 11))))) + + + (reduce (fn [offset {:keys [type parent id index value]}] + (-> offset + (sr/write-u32 heapu32 (sr/translate-structure-modifier-type type)) + (sr/write-u32 heapu32 (d/nilv index 0)) + (sr/write-uuid heapu32 parent) + (sr/write-uuid heapu32 id) + (sr/write-f32 heapf32 value))) + offset + entries) + (h/call wasm/internal-module "_set_structure_modifiers")))) (defn propagate-modifiers [entries pixel-precision] - (when (d/not-empty? entries) - (let [offset (mem/alloc->offset-32 (modifier-get-entries-size entries)) - heapf32 (mem/get-heap-f32) - heapu32 (mem/get-heap-u32)] + (when-not ^boolean (empty? entries) + (let [heapf32 (mem/get-heap-f32) + heapu32 (mem/get-heap-u32) + size (mem/get-alloc-size entries MODIFIER-U8-SIZE) + offset (mem/alloc->offset-32 size)] - (loop [entries (seq entries) - current-offset offset] - (when-not (empty? entries) - (let [{:keys [id transform]} (first entries)] - (sr/heapu32-set-uuid id heapu32 current-offset) - (sr/heapf32-set-matrix transform heapf32 (+ current-offset (mem/->offset-32 MODIFIER-TRANSFORM-U8-OFFSET-SIZE))) - (recur (rest entries) (+ current-offset (mem/->offset-32 MODIFIER-U8-SIZE)))))) + (reduce (fn [offset [id transform]] + (-> offset + (sr/write-uuid heapu32 id) + (sr/write-matrix heapf32 transform))) + offset + entries) + + (let [offset (-> (h/call wasm/internal-module "_propagate_modifiers" pixel-precision) + (mem/->offset-32)) + length (aget heapu32 offset) + max-offset (+ offset 1 (* length MODIFIER-U32-SIZE)) + result (loop [result (transient []) + offset (inc offset)] + (if (< offset max-offset) + (let [entry (dr/read-modifier-entry heapu32 heapf32 offset)] + (recur (conj! result entry) + (+ offset MODIFIER-U32-SIZE))) + (persistent! result)))] - (let [result-offset (h/call wasm/internal-module "_propagate_modifiers" pixel-precision) - heapf32 (mem/get-heap-f32) - heapu32 (mem/get-heap-u32) - len (aget heapu32 (mem/->offset-32 result-offset)) - result - (->> (range 0 len) - (mapv #(dr/heap32->entry heapu32 heapf32 (mem/->offset-32 (+ result-offset 4 (* % MODIFIER-U8-SIZE))))))] (mem/free) - result)))) -(defn propagate-apply - [entries pixel-precision] - (when (d/not-empty? entries) - (let [offset (mem/alloc->offset-32 (modifier-get-entries-size entries)) - heapf32 (mem/get-heap-f32) - heapu32 (mem/get-heap-u32)] - - (loop [entries (seq entries) - current-offset offset] - (when-not (empty? entries) - (let [{:keys [id transform]} (first entries)] - (sr/heapu32-set-uuid id heapu32 current-offset) - (sr/heapf32-set-matrix transform heapf32 (+ current-offset (mem/->offset-32 MODIFIER-TRANSFORM-U8-OFFSET-SIZE))) - (recur (rest entries) (+ current-offset (mem/->offset-32 MODIFIER-U8-SIZE)))))) - - (let [offset (h/call wasm/internal-module "_propagate_apply" pixel-precision) - heapf32 (mem/get-heap-f32) - width (aget heapf32 (mem/->offset-32 (+ offset 0))) - height (aget heapf32 (mem/->offset-32 (+ offset 4))) - cx (aget heapf32 (mem/->offset-32 (+ offset 8))) - cy (aget heapf32 (mem/->offset-32 (+ offset 12))) - - a (aget heapf32 (mem/->offset-32 (+ offset 16))) - b (aget heapf32 (mem/->offset-32 (+ offset 20))) - c (aget heapf32 (mem/->offset-32 (+ offset 24))) - d (aget heapf32 (mem/->offset-32 (+ offset 28))) - e (aget heapf32 (mem/->offset-32 (+ offset 32))) - f (aget heapf32 (mem/->offset-32 (+ offset 36))) - transform (gmt/matrix a b c d e f)] - - (mem/free) - (request-render "set-modifiers") - - {:width width - :height height - :center (gpt/point cx cy) - :transform transform})))) - (defn get-selection-rect [entries] - (when (d/not-empty? entries) - (let [offset (mem/alloc->offset-32 (* (count entries) 16)) - heapu32 (mem/get-heap-u32)] - (loop [entries (seq entries) - current-offset offset] - (when-not (empty? entries) - (let [id (first entries)] - (sr/heapu32-set-uuid id heapu32 current-offset) - (recur (rest entries) (+ current-offset (mem/->offset-32 16)))))) + (when-not ^boolean (empty? entries) + (let [size (mem/get-alloc-size entries UUID-U8-SIZE) + offset (mem/alloc->offset-32 size) + heapu32 (mem/get-heap-u32) + heapf32 (mem/get-heap-f32)] - (let [offset (h/call wasm/internal-module "_get_selection_rect") - heap (mem/get-heap-f32) - width (aget heap (mem/->offset-32 (+ offset 0))) - height (aget heap (mem/->offset-32 (+ offset 4))) - cx (aget heap (mem/->offset-32 (+ offset 8))) - cy (aget heap (mem/->offset-32 (+ offset 12))) - a (aget heap (mem/->offset-32 (+ offset 16))) - b (aget heap (mem/->offset-32 (+ offset 20))) - c (aget heap (mem/->offset-32 (+ offset 24))) - d (aget heap (mem/->offset-32 (+ offset 28))) - e (aget heap (mem/->offset-32 (+ offset 32))) - f (aget heap (mem/->offset-32 (+ offset 36)))] + (reduce (fn [offset id] + (sr/write-uuid offset heapu32 id)) + offset + entries) + (let [offset (-> (h/call wasm/internal-module "_get_selection_rect") + (mem/->offset-32)) + result (dr/read-selection-rect heapf32 offset)] (mem/free) - {:width width - :height height - :center (gpt/point cx cy) - :transform (gmt/matrix a b c d e f)})))) - + result)))) (defn set-canvas-background [background] @@ -965,22 +887,26 @@ (defn set-modifiers [modifiers] - (when-not (empty? modifiers) - (let [offset (mem/alloc->offset-32 (* MODIFIER-U8-SIZE (count modifiers))) - heapu32 (mem/get-heap-u32) - heapf32 (mem/get-heap-f32)] - (loop [entries (seq modifiers) - current-offset offset] - (when-not (empty? entries) - (let [{:keys [id transform]} (first entries)] - (sr/heapu32-set-uuid id heapu32 current-offset) - (sr/heapf32-set-matrix transform heapf32 (+ current-offset (mem/->offset-32 MODIFIER-TRANSFORM-U8-OFFSET-SIZE))) - (recur (rest entries) (+ current-offset (mem/->offset-32 MODIFIER-U8-SIZE)))))) + ;; We need to ensure efficient operations + (assert (vector? modifiers) "expected a vector for `set-modifiers`") - (h/call wasm/internal-module "_set_modifiers") + (let [length (count modifiers)] + (when (pos? length) + (let [offset (mem/alloc->offset-32 (* MODIFIER-U8-SIZE length)) + heapu32 (mem/get-heap-u32) + heapf32 (mem/get-heap-f32)] - (request-render "set-modifiers")))) + (reduce (fn [offset [id transform]] + (-> offset + (sr/write-uuid heapu32 id) + (sr/write-matrix heapf32 transform))) + offset + modifiers) + + (h/call wasm/internal-module "_set_modifiers") + + (request-render "set-modifiers"))))) (defn initialize [base-objects zoom vbox background] @@ -1062,41 +988,42 @@ (defn shape-to-path [id] (use-shape id) - (let [offset (h/call wasm/internal-module "_current_to_path") - offset (mem/->offset-32 offset) - heapu32 (mem/get-heap-u32) - - length (aget heapu32 offset) - data (mem/slice heapu32 - (+ offset 1) - (+ offset 1 (* length (/ path.impl/SEGMENT-U8-SIZE 4)))) + (let [offset (-> (h/call wasm/internal-module "_current_to_path") + (mem/->offset-32)) + heap (mem/get-heap-u32) + length (aget heap offset) + data (mem/slice heap + (+ offset 1) + (* length path.impl/SEGMENT-U32-SIZE)) content (path/from-bytes data)] (mem/free) content)) +(defn- calculate-bool* + [bool-type] + (-> (h/call wasm/internal-module "_calculate_bool" (sr/translate-bool-type bool-type)) + (mem/->offset-32))) + (defn calculate-bool [bool-type ids] - (let [num-ids (count ids) - offset (mem/alloc->offset-32 (* UUID-U8-SIZE num-ids)) - heap (mem/get-heap-u32)] + + (let [size (mem/get-alloc-size ids UUID-U8-SIZE) + heap (mem/get-heap-u32) + offset (mem/alloc->offset-32 size)] (reduce (fn [offset id] - (sr/heapu32-set-uuid id heap offset) - (+ offset UUID-U32-SIZE)) + (sr/write-uuid offset heap id)) offset - (rseq ids))) + (rseq ids)) - (let [offset (h/call wasm/internal-module "_calculate_bool" (sr/translate-bool-type bool-type)) - offset (mem/->offset-32 offset) - heapu32 (mem/get-heap-u32) - - length (aget heapu32 offset) - data (mem/slice heapu32 - (+ offset 1) - (+ offset 1 (* length (/ path.impl/SEGMENT-U8-SIZE 4)))) - content (path/from-bytes data)] - (mem/free) - content)) + (let [offset (calculate-bool* bool-type) + length (aget heap offset) + data (mem/slice heap + (+ offset 1) + (* length path.impl/SEGMENT-U32-SIZE)) + content (path/from-bytes data)] + (mem/free) + content))) (defonce module (delay diff --git a/frontend/src/app/render_wasm/deserializers.cljs b/frontend/src/app/render_wasm/deserializers.cljs index 3c7f1f16c0..dd718d82c4 100644 --- a/frontend/src/app/render_wasm/deserializers.cljs +++ b/frontend/src/app/render_wasm/deserializers.cljs @@ -5,25 +5,44 @@ ;; Copyright (c) KALEIDOS INC (ns app.render-wasm.deserializers (:require + [app.common.data :as d] [app.common.geom.matrix :as gmt] + [app.common.geom.point :as gpt] [app.common.uuid :as uuid])) -(defn heap32->entry +(defn read-modifier-entry [heapu32 heapf32 offset] (let [id1 (aget heapu32 (+ offset 0)) id2 (aget heapu32 (+ offset 1)) id3 (aget heapu32 (+ offset 2)) id4 (aget heapu32 (+ offset 3)) - a (aget heapf32 (+ offset 4)) - b (aget heapf32 (+ offset 5)) - c (aget heapf32 (+ offset 6)) - d (aget heapf32 (+ offset 7)) - e (aget heapf32 (+ offset 8)) - f (aget heapf32 (+ offset 9)) + a (aget heapf32 (+ offset 4)) + b (aget heapf32 (+ offset 5)) + c (aget heapf32 (+ offset 6)) + d (aget heapf32 (+ offset 7)) + e (aget heapf32 (+ offset 8)) + f (aget heapf32 (+ offset 9))] - id (uuid/from-unsigned-parts id1 id2 id3 id4)] + (d/vec2 (uuid/from-unsigned-parts id1 id2 id3 id4) + (gmt/matrix a b c d e f)))) - {:id id + +(defn read-selection-rect + [heapf32 offset] + (let [width (aget heapf32 (+ offset 0)) + height (aget heapf32 (+ offset 1)) + cx (aget heapf32 (+ offset 2)) + cy (aget heapf32 (+ offset 3)) + a (aget heapf32 (+ offset 4)) + b (aget heapf32 (+ offset 5)) + c (aget heapf32 (+ offset 6)) + d (aget heapf32 (+ offset 7)) + e (aget heapf32 (+ offset 8)) + f (aget heapf32 (+ offset 9))] + {:width width + :height height + :center (gpt/point cx cy) :transform (gmt/matrix a b c d e f)})) + diff --git a/frontend/src/app/render_wasm/mem.cljs b/frontend/src/app/render_wasm/mem.cljs index fec386b5a5..e56ec4a01f 100644 --- a/frontend/src/app/render_wasm/mem.cljs +++ b/frontend/src/app/render_wasm/mem.cljs @@ -15,10 +15,12 @@ ;; Divides the value by 4 (bit-shift-right value 2)) -(defn get-list-size - "Returns the size of a list in bytes" - [list list-item-size] - (* list-item-size (count list))) +(defn get-alloc-size + "Calculate allocation size for a sequential collection of identical + objects of the specified size." + [coll item-size] + (assert (counted? coll) "`coll` should be constant time countable") + (* item-size (count coll))) (defn alloc "Allocates an arbitrary amount of bytes (aligned to 4 bytes). @@ -61,5 +63,11 @@ (defn slice "Returns a copy of a portion of a typed array into a new typed array object selected from start to end." - [heap start end] - (.slice ^js heap start end)) + [heap offset size] + (.slice ^js heap offset (+ offset size))) + +(defn view + "Returns a new typed array on the same ArrayBuffer store and with the + same element types as for this typed array." + [heap offset size] + (.subarray ^js heap offset (+ offset size))) diff --git a/frontend/src/app/render_wasm/serializers.cljs b/frontend/src/app/render_wasm/serializers.cljs index 1d6754a939..12a8f93616 100644 --- a/frontend/src/app/render_wasm/serializers.cljs +++ b/frontend/src/app/render_wasm/serializers.cljs @@ -55,18 +55,32 @@ (catch :default _e [uuid/zero]))) -(defn heapu32-set-u32 - [value heap offset] - (aset heap offset value)) +(defn write-u32 + [offset heap value] + (assert (instance? js/Uint32Array heap) "expected Uint32Array instance for `heap`") + (aset heap offset value) + (inc offset)) -(defn heapu32-set-uuid - [id heap offset] +(defn write-f32 + [offset heap value] + (assert (instance? js/Float32Array heap) "expected Float32Array instance for `heap`") + (aset heap offset value) + (inc offset)) + +(defn write-uuid + "Write a uuid to 32 bits addressed heap and return the offset + after write." + [offset heap id] + (assert (instance? js/Uint32Array heap) "expected Uint32Array instance for `heap`") (let [buffer (uuid/get-u32 id)] (.set heap buffer offset) - buffer)) + (+ offset 4))) -(defn heapf32-set-matrix - [matrix heap offset] +(defn write-matrix + "Write a matrix to 32 bits addressed heap and return the offset + after write." + [offset heap matrix] + (assert (instance? js/Float32Array heap) "expected Float32Array instance for `heap`") (let [a (dm/get-prop matrix :a) b (dm/get-prop matrix :b) c (dm/get-prop matrix :c) @@ -78,7 +92,8 @@ (aset heap (+ offset 2) c) (aset heap (+ offset 3) d) (aset heap (+ offset 4) e) - (aset heap (+ offset 5) f))) + (aset heap (+ offset 5) f) + (+ offset 6))) (defn translate-shape-type [type]