resources.cljs

(ns ^:figwheel-always game.client.resources
    (:require
              [cljs.pprint :as pprint]
              [clojure.string :as string :refer [replace]]
              [com.stuartsierra.component :as component]
              [promesa.core :as p]
              [game.client.math :as math :refer [pi]]
              [game.client.config :as config]
              [game.client.models :as models :refer [transform-geometry post-transform-geometry]]
              [game.client.voxelize :as voxelize]
              [game.client.progress-manager
               :as progress-manager
               :refer [update-progress-item]])

  (:require-macros [game.shared.macros :as macros :refer [defcom]]))

(def should-load-voxels? false)

(defn
  load-json
  [path on-success on-progress on-error]
  (let
    [xhr (new js/XMLHttpRequest)]
    (doto
      xhr
      (.open "GET" path true)
      (aset "responseType" "json")
      (aset "onerror" on-error)
      (aset "onload" on-success)
      (aset "onprogress" on-progress)
      (.send))))

(defn
  load-resource
  [path on-success on-progress on-error]
  (let
    [xhr (new js/XMLHttpRequest)]
    (doto
      xhr
      (.open "GET" path true)
      (aset "responseType" "arraybuffer")
      (aset "onerror" on-error)
      (aset "onload" on-success)
      (aset "onprogress" on-progress)
      (.send))))

(defn load-texture
  [model path on-progress]
  (p/promise
    (fn [resolve reject]
      (let
        [repeat-x (first (:texture-repeat model))
         repeat-y (second (:texture-repeat model))
         on-success
         (fn []
           (this-as
             this
             (let
               [img (new js/Image)
                blob (new js/Blob #js [(.-response this)])]
               (aset img "onload"
                     (fn []
;                       (println "resolve image" path)
                       (let
                         [texture (new js/THREE.Texture img)]
                         (-> texture .-wrapS (set! js/THREE.RepeatWrapping))
                         (-> texture .-wrapT (set! js/THREE.RepeatWrapping))
                         (-> texture .-repeat (.set repeat-x repeat-y))
                         (-> texture .-needsUpdate (set! true))
                         (resolve texture))))
               (aset img "onerror" #(reject (str "image load error: " path)))
               (aset img "src" (-> js/window .-URL (.createObjectURL blob))))))]

        (load-resource path on-success on-progress reject)))))

(defn load-voxels
  [model path on-progress]
  (p/promise
    (fn [resolve reject]
      (let
        [on-success
         (fn []
           (this-as
             this
             (let
               [buffer (.-response this)
                uint8array (new js/Uint8Array buffer)
                uint8array (-> js/pako (.inflate uint8array))
                decoded (-> js/msgpack (.decode uint8array))
                ;_ (.log js/console "uvs" (aget decoded "uvs"))
                voxel-dict (js->clj decoded :keywordize-keys true)
;                _ (.log js/console "uvs" (:uvs voxel-dict))
                ;_ (println "voxels" (:voxels voxel-dict))
;                voxel-dict (assoc voxel-dict :uvs (new js/Float32Array (flatten (:uvs voxel-dict))))
                voxel-geometry (voxelize/voxelize-output voxel-dict)
                scale (:post-scale model)
                bbox (-> voxel-geometry .-boundingBox)
                bsphere (-> voxel-geometry .-boundingSphere)
                mat (new js/THREE.Matrix4)
                _ (-> mat (.makeScale scale scale scale))
                _ (-> bbox (.applyMatrix4 mat))
                _ (-> bsphere (.applyMatrix4 mat))
                ; TODO: post-transform-geometry is just a hack
                ;voxel-geometry (post-transform-geometry model voxel-geometry)
                voxel-dict (assoc voxel-dict :geometry voxel-geometry)]
;               (.log js/console "uvs" (-> voxel-geometry (.getAttribute "uv")))
               (resolve voxel-dict))))]
        (load-resource path on-success on-progress reject)))))

(defn load-geometry
  [model path on-progress]
  (p/promise
    (fn [resolve reject]
      (let
        [on-success
         (fn []
           (this-as
             this
             (let
               [buffer (.-response this)
                uint8array (new js/Uint8Array buffer)
                uint8array (-> js/pako (.inflate uint8array))
                decoded (-> js/msgpack (.decode uint8array))
                geo-loader (new js/THREE.BufferGeometryLoader)
                geo (-> geo-loader (.parse decoded))
                geo (post-transform-geometry model geo)]
               (-> geo (.computeBoundingBox))
               (-> geo (.computeBoundingSphere))
               (-> geo (.computeFaceNormals))
               (-> geo (.computeVertexNormals))
               (resolve geo))))]
        (load-resource path on-success on-progress reject)))))

;(defn load-geometry
;  [model path on-progress]
;  (p/promise
;    (fn [resolve reject]
;      (let
;        [on-success #(resolve (transform-geometry model %))
;         on-error reject
;         geo-loader (new js/THREE.BufferGeometryLoader)]
;        (-> geo-loader
;          (.load path on-success on-progress on-error))))))

(defn on-progress
  [progress-manager resource xhr]
  (update-progress-item
    progress-manager
    resource
    (-> xhr .-loaded)
    (-> xhr .-total)))

(defcom
  new-resources
  [progress-manager]
  [resource-list all-promise]
  (fn [component]
    (let
      [resource-list
       (into
         []
         (for
           [model (models/get-models)]
           (let
             [
              path (:path model)
              texture-path (:texture-path model)
              voxels-path
              (or
                (:voxels-path model)
                (replace (replace path #"/3d/" "/voxels/") #"\.json$" ".msgpack.gz"))
              path
              (if
                (string/includes? path "models-dinosaurs")
                "models/3d/missile.json"
                path)
              path (replace path #"\.json$" ".msgpack.gz")
              on-geo-progress (partial on-progress progress-manager path)
              on-texture-progress (partial on-progress progress-manager texture-path)
              on-voxels-progress (partial on-progress progress-manager voxels-path)
              load-promise (load-geometry model path on-geo-progress)
              texture-load-promise (load-texture model texture-path on-texture-progress)
              voxels-load-promise
              (if
                should-load-voxels?
                (load-voxels model voxels-path on-voxels-progress))]
             (merge
               model
               {
                :load-promise load-promise
                :texture-load-promise texture-load-promise
                :voxels-load-promise voxels-load-promise}))))]

      (-> component
        (assoc
          :all-promise
          (p/all
            (into
              []
              (concat
                (map
                  #(vector
                     (:load-promise %)
                     (:texture-load-promise %)
                     (:voxels-load-promise %)) resource-list)))))
        (assoc :resource-list resource-list))))
  (fn [component] component))