HDBYSSB/pc场景/public/static/js/manage.js

  var g_ProjectName = window.location.pathname.substring(window.location.pathname.indexOf("/") + 1, window.location.pathname.lastIndexOf("/"));
  var g_Prefix = "https://super.4dage.com/";
  // var g_Prefix="http://project.4dage.com:8017/";//有自己的大场景编辑后台的 - 线上场景调试
  // var g_Prefix=window.origin+'/';//有自己的大场景编辑后台的 - 打包
  // var g_Prefix=window.location.href.substring(0,window.location.href.indexOf("/index.html")+1);
  var s = window.location.href.split('/');
  s.pop();
  //var g_Prefix = s.join('/');
  var g_index = null;
  var g_modeldata = null;

  var g_weixinTitle = null;

  var g_Hots = null;
  var g_HotMeshes = [];
  var g_HotMeshSize = {
      g_HotMeshWidth: 0.3,
      g_HotMeshHeight: 0.3
  };

  //add表示添加，delete表示删除
  var g_HotStatus = null;
  var g_newHot = []; //存储新加热点
  var g_HotImage = {
      "point": "https://super.4dage.com/images/4dagePoint2.png",
      "point2": "https://super.4dage.com/images/4dagePoint.png"
  };
  var g_saveHot = false;

  var g_TextColor = 0x7777ff;
  var g_Text = null;
  var g_TextPlaneMesh = [];
  var g_TextIconMesh = [];
  var g_TextIcon = "./images/text.png";
  var g_SelectTextIndex = null;
  var g_TextShow = null;
  var g_audioPlay = false;
  var g_background = null;
  var g_roof = null;

  var g_data2 = null; //加载的data2.js的内容
  var g_bgAudio = null; //背景音乐
  var g_tourAudio = null; //导览音乐
  var g_play = 1; //表示播放图标状态
  var g_playAudio = null; //当前在播放或当继续播放时应该播放的，是g_bgAudio或g_tourAudio 
  var g_currentHot = null; //当前打开的热点 
  //var g_Texture=null;
  //var g_ChunknameTexture={};   //chunkname和贴图名称对应
  var g_NormalTexture = false;
  var g_SpecularTexture = false;
  var g_DirectionalLight = null;

  var g_snapShotWidth = 200; //截图下载图片的大小
  var g_snapShotHeight = 140;

  //微信分享
  var g_weixinObj = {
      "title": document.querySelector("head title").innerHTML,
      "lineLink": window.location.href,
      "imgUrl": "https://www.4dmodel.com/SuperPanoramic/images/weixintitle.jpg",
      "desc": "四维时代提供技术支持",
  }

  var settings = {
      hotClickEvent: {
          video: {
              playAndPause: true,
              examine: false,
              openHot: false
          },
          photo: {
              examine: false,
              openHot: false
          },
          shine: {
              examine: true,
              openHot: true
          }
      },
      //默认的：
      teleportTime: 1500, //瞬间过渡的时间 
      /* flytimeDistanceMultiplier:150, 
      flyTime:750,  */
      tourRotTime: 2, //默认停留2秒
      //dontExamHot:true  
      transparentBg: false,
      bgImg: null
  }
  if (window.number == '725' || window.number == '724') {
      settings.mobileNavHigh = true
  }


  //共用函数：


  window.common = null;
  window.MathLight = null;
  window.math = null
  window.easing = null
  window.lerp = null
  window.transitions = null
  window.browser = null
  window.momentTourBlackNewType = 0 //=  number == 'TEST'//true










  var dealMap = (map) => { //使不resize  when   image is not power of two
      map.wrapS = map.wrapT = THREE.ClampToEdgeWrapping;
      map.minFilter = THREE.LinearFilter;
      map.magFilter = THREE.LinearFilter;
      map.generateMipmaps = true;

  }



  var dom = {
      getOffset: function (type, element, parent) {
          left = (type == "left") ? element.offsetLeft : element.offsetTop;
          if (!parent) parent = $("body")[0];
          while (element = element.offsetParent) {
              if (element == parent) break;
              left += (type == "left") ? element.offsetLeft : element.offsetTop;
          }
          return left;
      }
  };


  var getTransformSid = function () {
      var name
      if (player.mode == 'panorama') {
          name = player.currentPano ? player.currentPano.id : 'outside'
      } else {
          name = 'outside'
      }
      return name
  }




  var convertTool = {
      getPos2d: function (point, camera, dom) { //获取一个三维坐标对应屏幕中的二维坐标
          var camera = camera || player.camera;
          var dom = dom || player.domElement;
          var pos = point.clone().project(camera) //比之前hotspot的计算方式写得简单  project用于3转2(求法同shader)； unproject用于2转3 :new r.Vector3(e.x, e.y, -1).unproject(this.camera);

          var x, y;
          x = (pos.x + 1) / 2 * dom.clientWidth;
          y = (1 - (pos.y + 1) / 2) * dom.clientHeight;

          var inSight = x <= dom.clientWidth && x >= 0 //是否在屏幕中   
              &&
              y <= dom.clientHeight && y >= 0


          return {
              pos: new THREE.Vector2(x, y), // 屏幕像素坐标
              vector: pos, //（范围 -1 ~ 1）
              trueSide: pos.z < 1, //trueSide为false时，即使在屏幕范围内可见，也是反方向的另一个不可以被渲染的点   参见Tag.update
              inSight: inSight //在屏幕范围内可见
          };
      },

      ifShelter: function (pos3d) { //检测某点在视线中是否被mesh遮挡 
          var ori = player.position
          var dir = pos3d.clone().sub(ori).normalize()
          var ray = new THREE.Raycaster(ori, dir) //由外向里 因为模型从内侧是可见的所以从外侧

          /* if(config.isEdit && publicObjectSet.editor.mainDesign.editing){
          	var o = ray.intersectObjects(publicObjectSet.editor.mainDesign.wallMeshes);
          }else{ */
          var o = ray.intersectObjects(player.model.colliders);
          //} 
          var len = pos3d.distanceTo(ori);
          if (o && o.length) {
              for (var i = 0; i < o.length; i++) {
                  if (o[i].distance < len) {
                      return true;
                  } //有遮挡
              }
          }
      },


      /* 
        拖拽时，获取鼠标在拖拽面上的位置（需要借助另一个intersectPlane面来计算，即和相机方向一样的面，可保证铺满屏幕）
        但是不一定能获取到，比如鼠标射线不朝向拖拽面时，即使获取也会是一个意外的反方向的交点。
	 */
      getPosAtPlane: function (pos, info /* , mouse, camera */ ) { //pos:与intersectPlane的交点 见笔记
          var A = pos;
          var player = player;
          var mouse = player.mouse;
          var O = new THREE.Vector3(mouse.x, mouse.y, -1).unproject(player.camera);


          if (info.y != void 0) { //地面线的

              var y = info.y;

              if (player.mode == "floorplan" /*  ||  Math.abs(O.x-pos.x)<0.0001 && Math.abs(O.z-pos.z)<0.0001) */ ) {
                  //intersectPlane和地面平行，无交点
                  var x = pos.x,
                      z = pos.z;

              } else {

                  if (y < player.camera.position.y && O.y <= A.y /* || y>player.camera.position.y && O.y >= A.y  */ ) return null; //鼠标射线向上。因为相机一定位于地面以上（地面不会抬高到相机上吧？），所以无交点。
                  if (O.y == A.y) {
                      console.log('一样？？');
                      return;
                  }
                  if (A.y == y) {
                      console.log('一样2？？');
                      return;
                  }
                  var r = (O.y - y) / (A.y - y);
                  var x = (r * A.x - O.x) / (r - 1);
                  var z = (r * A.z - O.z) / (r - 1);
              }
          } else { //垂直的也有越过消失点以后反向变化的情况，但使用时影响不大
              var N = info.normalVec;
              var P = info.pullPos;
              if (N.y != 0) {
                  console.log('N.y != 0');
                  return;
              } //仅仅支持垂直于地面的的墙壁，目前都是
              if (O.z == A.z) {
                  console.log('O.z==A.z？');
                  return;
              }
              if (N.z != 0 && N.x != 0) { //直接用这个通用的也可以，支持斜线的墙
                  //console.log('N.z==0 && N.x == 0？');  
                  var c = (N.x * (A.x - O.x) + N.y * (A.y - O.y) + N.z * (A.z - O.z));
                  if (c == 0) {
                      console.log("分母为0？？ return;");
                      return;
                  }
                  var t = -((N.x * O.x + N.y * O.y + N.z * O.z) - (P.x * N.x + P.y * N.y + P.z * N.z)) / c
                  var x = t * (A.x - O.x) + O.x;
                  var y = t * (A.y - O.y) + O.y;
                  var z = t * (A.z - O.z) + O.z;
                  /*原理： 已知空间直线L：(x-a)/m=(x-b)/n=(z-c)/p和空间平面π：Ax+By+Cz+D=0;
                  求直线L与平面π的交点的坐标。
                  把直线方程改写成参数形式：设(x-a)/m=(x-b)/n=(z-c)/p=t；
                  则x=mt+a；y=nt+b；z=pt+c；代入平面π的方程得：
                  A(mt+a)+B(nt+b)+C(pt+c)+D=0
                  由此解得t=-(Aa+Bb+Cc+D)/(Am+Bn+Cp)
                  再代入参数方程即得交点的坐标(x，y，z). */
              } else if (N.x == 0) { //z与pullPos相等
                  var z = P.z;
                  if (O.y == A.y) {
                      console.log('一样？？');
                      return;
                  }
                  if (A.y == y) {
                      console.log('一样2？？');
                      return;
                  }
                  if (A.z == z) {
                      console.log('一样3？？');
                      return;
                  }
                  var r = (O.z - z) / (A.z - z);
                  var x = (r * A.x - O.x) / (r - 1);
                  var y = (r * A.y - O.y) / (r - 1);
              } else if (N.z == 0) { //x与pullPos相等
                  var x = P.x;
                  if (O.y == A.y) {
                      console.log('一样？？');
                      return;
                  }
                  if (A.y == y) {
                      console.log('一样2？？');
                      return;
                  }
                  if (A.x == x) {
                      console.log('一样3？？');
                      return;
                  }
                  var r = (O.x - x) / (A.x - x);
                  var y = (r * A.y - O.y) / (r - 1);
                  var z = (r * A.z - O.z) / (r - 1);
              }
          }

          return new THREE.Vector3(x, y, z);
      },



      getMouseIntersect: function (camera, meshes, mouse) { //获取鼠标和meshes交点
          var raycaster = new THREE.Raycaster;
          camera.updateMatrixWorld();
          var origin = new THREE.Vector3(mouse.x, mouse.y, -1).unproject(camera),
              end = new THREE.Vector3(mouse.x, mouse.y, 1).unproject(camera);
          var dir = end.sub(origin).normalize()
          raycaster.set(origin, dir);
          var n = raycaster.intersectObjects(meshes);
          if (0 === n.length)
              return null;
          return n[0];

      },
      ifIntersectChunks: function (A, B, options = {}) { //获取某个线段/射线和meshes的交点 
          var dir = B.clone().sub(A).normalize();
          var len = options.InfinityLen ? Infinity : A.distanceTo(B) + (options.extLen || 0);
          var ray = new THREE.Raycaster(A.clone(), dir, 0, len);

          var o = ray.intersectObjects(options.model || player.model.colliders);
          if (o && o.length) return o;

          if (options.throughWidth) { //允许最小宽度，防止穿过极小的缝隙导致撞墙感
              var normal = math.getNormal({
                  points: [{
                      x: A.x,
                      y: A.z
                  }, {
                      x: B.x,
                      y: B.z
                  }]
              }); //线段法线
              normal.multiplyScalar(options.throughWidth)
              var normalVec3 = new THREE.Vector3(normal.x, 0, normal.y);

              var A2 = A.clone().add(normalVec3)
              ray.set(A2, dir);
              var o2 = ray.intersectObjects(options.model || player.model.colliders);
              ray.set(A.clone().add(normalVec3.negate()), dir);
              if (o2 && o2.length) return o2;
              var o3 = ray.intersectObjects(options.model || player.model.colliders);
              if (o3 && o3.length) return o3;
          }
          return null;
      },

      getPosAtSphere: function (pos3d, toPanoPos) {
          var dir = pos3d.clone().sub(toPanoPos);
          dir.normalize(); //然后计算在球中
          dir.multiplyScalar(Constants.skyRadius);
          dir.add(toPanoPos);
          return dir;
      },

      getScaleForConstantSize: function (op = {}) { //获得规定二维大小的mesh的scale值。可以避免因camera的projection造成的mesh视觉大小改变。  来源：tag.updateDisc
          var w;
          var i = new THREE.Vector3,
              o = new THREE.Vector3,
              l = new THREE.Vector3,
              c = new THREE.Vector3,
              h = new THREE.Vector3

          if (op.width2d) w = op.width2d //如果恒定二维宽度
          else { //否则考虑上距离，加一丢丢近大远小的效果
              var currentDis, nearBound, farBound
              if (op.camera.type == "OrthographicCamera") {
                  currentDis = (op.camera.right - op.camera.left) / op.camera.zoom
              } else {
                  currentDis = op.position.distanceTo(op.camera.position);
              }
              w = op.maxSize - (op.maxSize - op.minSize) * THREE.Math.smoothstep(currentDis, op.nearBound, op.farBound);
              //maxSize ： mesh要表现的最大像素宽度；   nearBound： 最近距离，若比nearBound近，则使用maxSize
          }
          i.copy(op.position).project(op.camera), //tag中心在屏幕上的二维坐标
              o.set(op.resolution.x / 2, op.resolution.y / 2, 1).multiply(i), //转化成px   -w/2 到 w/2的范围
              l.set(w / 2, 0, 0).add(o), //加上tag宽度的一半
              c.set(2 / op.resolution.x, 2 / op.resolution.y, 1).multiply(l), //再转回  -1 到 1的范围
              h.copy(c).unproject(op.camera); //再转成三维坐标，求得tag边缘的位置
          var g = h.distanceTo(op.position) //就能得到tag的三维半径

          return g //可能NAN  当相机和position重叠时

      }



  }








  //--------------------------------------
  //管理js文件 获取modeldata.js 判断是否有特殊的字段，如果有就先加载SpecialScene.js 里面有对特殊场景处理的代码 否则就直接加载main



  var Manage = function () {
      this.weixinURL = "https://res.wx.qq.com/open/js/jweixin-1.2.0.js",
          this.time = "?" + new Date().getTime();
      this.loadAudio();
      this.loadWeixin();
  }
  //动态加载js文件
  Manage.prototype.LoadJs = function (_files, succes) {
      /* 已加载文件缓存列表,用于判断文件是否已加载过，若已加载则不再次加载*/
      var classcodes = [];
      var FileArray = [];
      if (typeof _files === "object") {
          FileArray = _files;
      } else {
          /*如果文件列表是字符串，则用,切分成数组*/
          if (typeof _files === "string") {
              FileArray = _files.split(",");
          }
      }
      if (FileArray != null && FileArray.length > 0) {
          var LoadedCount = 0;
          for (var i = 0; i < FileArray.length; i++) {
              loadFile(FileArray[i], function () {
                  LoadedCount++;
                  if (LoadedCount == FileArray.length) {
                      try {
                          succes();
                      } catch (err) {
                          console.log("err: 您未定义回调");
                      }
                  }
              })
          }
      }
      /*加载JS文件,url:文件路径,success:加载成功回调函数*/
      function loadFile(url, success) {
          if (!FileIsExt(classcodes, url)) {
              var _ThisType = GetFileType(url);
              var ThisType = _ThisType.indexOf("?") == -1 ? _ThisType : _ThisType.substring(0, _ThisType.indexOf("?"));
              var fileObj = null;
              if (ThisType == ".js") {
                  fileObj = document.createElement('script');
                  fileObj.src = url;
              } else if (ThisType == ".css") {
                  fileObj = document.createElement('link');
                  fileObj.href = url;
                  fileObj.type = "text/css";
                  fileObj.rel = "stylesheet";
              } else if (ThisType == ".less") {
                  fileObj = document.createElement('link');
                  fileObj.href = url;
                  fileObj.type = "text/css";
                  fileObj.rel = "stylesheet/less";
              }
              success = success || function () {};
              fileObj.onload = fileObj.onreadystatechange = function () {
                  if (!this.readyState || 'loaded' === this.readyState || 'complete' === this.readyState) {
                      success();
                      classcodes.push(url)
                  }
              }
              document.getElementsByTagName('head')[0].appendChild(fileObj);
          } else {
              success();
          }
      }
      /*获取文件类型,后缀名，小写*/
      function GetFileType(url) {
          if (url != null && url.length > 0) {
              return url.substr(url.lastIndexOf(".")).toLowerCase();
          }
          return "";
      }
      /*文件是否已加载*/
      function FileIsExt(FileArray, _url) {
          if (FileArray != null && FileArray.length > 0) {
              var len = FileArray.length;
              for (var i = 0; i < len; i++) {
                  if (FileArray[i] == _url) {
                      return true;
                  }
              }
          }
          return false;
      }

  };

  //获取页面url后面的参数
  Manage.prototype.number = function (variable) {
      var query = window.location.search.substring(1);
      var vars = query.split("&");
      for (var i = 0; i < vars.length; i++) {
          var pair = vars[i].split("=");
          if (pair[0] == variable) {
              return pair[1];
          }
      }
      return (false);
  };

  Manage.prototype.loadWeixin = function () {
      var that = this;
      this.LoadJs(that.weixinURL + that.time, function () {});

  }





  Manage.prototype.weixinShare = function () {
      console.log("weixinShare")
      $.ajax({
          url: 'https://www.4dage.com/wechat/jssdk/',
          type: "post",
          data: {
              'url': location.href.split('#')[0]
          },
          dataType: "jsonp",
          jsonpCallback: "success_jsonp",
          success: function (data, textStatus) {
              console.log("weixinShare success")
              console.log(data.appId)

              wx.config({
                  // debug : true,
                  appId: data.appId,
                  timestamp: data.timestamp,
                  nonceStr: data.nonceStr,
                  signature: data.signature,
                  jsApiList: ['checkJsApi', 'onMenuShareTimeline',
                      'onMenuShareAppMessage', 'onMenuShareQQ',
                      'onMenuShareWeibo', 'hideMenuItems',
                      'showMenuItems', 'hideAllNonBaseMenuItem',
                      'showAllNonBaseMenuItem', 'translateVoice',
                      'startRecord', 'stopRecord', 'onRecordEnd',
                      'playVoice', 'pauseVoice', 'stopVoice',
                      'uploadVoice', 'downloadVoice', 'chooseImage',
                      'previewImage', 'uploadImage', 'downloadImage',
                      'getNetworkType', 'openLocation', 'getLocation',
                      'hideOptionMenu', 'showOptionMenu', 'closeWindow',
                      'scanQRCode', 'chooseWXPay',
                      'openProductSpecificView', 'addCard', 'chooseCard',
                      'openCard'
                  ]
              });
          },
          error: function (XMLHttpRequest, textStatus, errorThrown) {
              console.log("jsonp.error:" + textStatus);
          }
      });

      var success_jsonp = function (json) {
          console.log(json);
      };


      wx.ready(function () {
          // config信息验证后会执行ready方法，所有接口调用都必须在config接口获得结果之后，config是一个客户端的异步操作，所以如果需要在页面加载时就调用相关接口，则须把相关接口放在ready函数中调用来确保正确执行〿
          //对于用户触发时才调用的接口，则可以直接调用，不需要放在ready函数中〿
          //分享到朋友圈 
          console.log(g_weixinObj)
          wx.onMenuShareTimeline({
              title: g_weixinObj.title, // 分享标题 
              link: g_weixinObj.lineLink, // 分享链接 
              imgUrl: g_weixinObj.imgUrl, // 分享图标 
              desc: g_weixinObj.desc
          });

          //获取“分享给朋友”按钮点击状态及自定义分享内容接叿
          wx.onMenuShareAppMessage({
              title: g_weixinObj.title, // 分享标题 
              desc: g_weixinObj.desc, // 分享描述 
              link: g_weixinObj.lineLink, // 分享链接 
              imgUrl: g_weixinObj.imgUrl, // 分享图标 
              type: '', // 分享类型,music、video或link，不填默认为link 
              dataUrl: '' // 如果type是music或video，则要提供数据链接，默认为空 
          });

          wx.onMenuShareWeibo({
              title: g_weixinObj.title, // 分享标题
              desc: g_weixinObj.desc, // 分享描述
              link: g_weixinObj.lineLink, // 分享链接
              imgUrl: g_weixinObj.imgUrl, // 分享图标
              success: function () {
                  // 用户确认分享后执行的回调函数
              },
              cancel: function () {
                  // 用户取消分享后执行的回调函数
              }
          });

          wx.onMenuShareQZone({
              title: g_weixinObj.title, // 分享标题
              desc: g_weixinObj.desc, // 分享描述
              link: g_weixinObj.lineLink, // 分享链接
              imgUrl: g_weixinObj.imgUrl, // 分享图标
              success: function () {
                  // 用户确认分享后执行的回调函数
              },
              cancel: function () {
                  // 用户取消分享后执行的回调函数
              }
          });

          wx.onMenuShareQQ({
              title: g_weixinObj.title, // 分享标题
              desc: g_weixinObj.desc, // 分享描述
              link: g_weixinObj.lineLink, // 分享链接
              imgUrl: g_weixinObj.imgUrl, // 分享图标
              success: function () {
                  // 用户确认分享后执行的回调函数
              },
              cancel: function () {
                  // 用户取消分享后执行的回调函数
              }
          });

          wx.error(function (res) {
              // config信息验证失败会执行error函数，如签名过期导致验证失败，具体错误信息可以打开config的debug模式查看，也可以在返回的res参数中查看，对于SPA可以在这里更新签名〿

          });
      });


  }



  Manage.prototype.dealURL = function (src, type) {
      //music: "///super.4dage.com/data/LYW/edit/20200928_151633415.mp3"
      //"https://super.4dage.com/data/LYW/edit/20200928_165319399.jpg"]


      if (window.isLocal && settings.localPrefix != void 0) { //本地将线上的前缀替换
          var oldPrefix = 'super.4dage.com/'; //最简单的地址写一个，如果有其他完全不一样的地址就用数组逐个判断
          var index = src.indexOf(oldPrefix);
          if (index > -1) {
              var wholeOldPrefix = src.slice(0, index + oldPrefix.length);
              return src.replace(wholeOldPrefix, settings.localPrefix)
          }

          console.error("没有找到合适的本地链接")
          return src
      } else {
          //add https://
          var prefix = g_Prefix.replace('https://', '').replace('http://', '')
          if (!src.includes('http:/') && !src.includes('https:/') && src.includes(prefix)) {
              src = 'https://' + src
          }
          return src
      }


  }


  Manage.prototype.removeSrcPostMark = function (url) { //去除texture.load时自动加上的'?'
      var index = url.indexOf('?')
      if (index > -1) {
          return url.slice(0, index)
      } else return url
  }


  Manage.prototype.showInfo = function (o) { // ({result:true, title:"发布成功"}); 

      var box = $(".resultBox");

      var title = o.title || o || i18n.get('保存成功');
      box.children().eq(0).html(title)


      //var time = o.time || THREE.Math.clamp((Config.lang=='en') ? title.length*50 : title.length*130 ,1300,5000);
      var time = o.time || THREE.Math.clamp(title.length * 130, 1300, 5000);
      o.time || console.log("showtime  " + time)

      //实际有一半的时间在渐变透明度
      this.showInfoTimer && clearTimeout(this.showInfoTimer)
      box.removeClass("animate"); //如果之后不久又要showinfo一个的话，先停止前面的animate
      setTimeout(function () {
          box.css({
              '-webkit-animation-duration': time + 'ms',
              'animation-duration': time + 'ms'
          })
          if (o.top) {
              box.children().css('top', o.top + "%");
          } else {
              box.children().css('top', '')
          }
          box.removeClass("hide");
          box.addClass("animate");
          if (o.dontInteract) { //遮挡对屏幕的操作
              box.css('pointer-events', 'auto')
          } else {
              box.css('pointer-events', 'none')
          }


          this.showInfoTimer = setTimeout(function () {
              box.removeClass("animate");
              box.addClass("hide");
              this.showInfoTimer = null;
          }.bind(this), time + 20)

      }.bind(this), 50) //这个数字太小的话后面触发的没有重新animate的效果 应该要比帧率大吧


  } //like:  manage.showInfo({title:'a', top:20})




  //公用的函数

  function getQueryVariable(variable) {
      var query = window.location.search.substring(1);
      var vars = query.split("&");
      for (var i = 0; i < vars.length; i++) {
          var pair = vars[i].split("=");
          if (pair[0] == variable) {
              return pair[1];
          }
      }
      return (false);
  }

  //隐藏公司Logo
  function showLogo() {
      $("#myCompany").hide();
      $("#loaderCoBrandName").hide();
      $("#title-logo").hide();
      $(".title-container").css("justify-content", "center")
  }
  //czj 添加随机的时间
  function randomTime() {
      return new Date()
  }

  function matcher(data) {
      if (!data || !g_version) return data;
      delete data.model.vision_version;
      var _data = {
          files: {
              "templates": ["images/images{{number}}/{{filename}}"]
          },
          model: {
              sid: window.number,
              camera_start: data.model.images && data.model.images.length != 0 ? {
                  camera: {
                      zoom: "-1",
                      quaternion: [
                          JSON.parse(data.model.images[0].metadata).camera_quaternion.z,
                          JSON.parse(data.model.images[0].metadata).camera_quaternion.w,
                          JSON.parse(data.model.images[0].metadata).camera_quaternion.x,
                          JSON.parse(data.model.images[0].metadata).camera_quaternion.y
                      ]
                  },
                  pano: {
                      uuid: JSON.parse(data.model.images[0].metadata).scan_id
                  },
                  mode: "0"
              } : ''
          },
          sid: window.number,
          hoticon: {
              default: "https://super.4dage.com/images/4dagePoint2.png",
              higt: "https://super.4dage.com/images/4dagePoint.png"
          },
          special: "false",
          weixinDesc: ""
      };
      $.extend(true, data, _data)
      return data;
  }

  function hotMatcher(data = {}) {
      //if(!data || !g_version) return data; 
      if (g_version) {
          data.tourAudio = data.audio || {};
      } else {
          data.tourAudio = {}
      }
      return data;
  }


  var GifTexDeal = {

      animateObjects: [],
      animateTexs: [],
      addAnimation: function (texture, owner, info, id) {
          /* if(this.animateObjects.find(e=> 
              e.texture == texture && !ifSame(info, e.info) 
          )) */

          var animation
          var tex = this.animateTexs.find(e => e.texture == texture)
          if (tex) {
              animation = tex
          } else {
              animation = {
                  texture,
                  info
              }
              this.animateTexs.push(animation)
              this.setRepeart(animation)
          }

          var object = {
              animation, //默认相同的texture对应的info是一样的, 对应一个animation
              owner,
          }

          this.animateObjects.push(object)
          return object
      },


      remove: function (object) {
          var index = this.animateObjects.indexOf(object)
          if (index > -1) {
              this.animateObjects.splice(index, 1)

              if (!this.animateObjects.find(e => e.animation == object.animation)) {
                  let i = this.animateTexs.indexOf(object.animation)
                  this.animateTexs.splice(i, 1)
                  object.animation.texture.repeat.set(1, 1)
              }

              this.stop(object)

          }
      },
      setRepeart: function (animation) {
          animation.texture.repeat.set(1 / animation.info.cellXcount, 1 / animation.info.cellYcount)
      },
      start: function (object) {

          if (!object || object.started) return;
          object.started = true
          if (object.animation.started) return;
          object.animation.started = true

          var info = object.animation.info
          var count = info.cellXcount * info.cellYcount - (info.voidCount || 0)

          if (count <= 1) return;

          transitions.start((progress) => {
                  var index = Math.floor(count * progress);
                  var indexX = index % info.cellXcount
                  var indexY = info.cellYcount - Math.floor(index / info.cellXcount) - 1; //uv.offset.y是从下到上的
                  object.animation.texture.offset.x = indexX / info.cellXcount;
                  object.animation.texture.offset.y = indexY / info.cellYcount;

                  //console.log(object.id + " : "+ object.texture.offset.toArray())
              }, info.duration * (-1), null,
              /* ()=>{//done  (-1):循环
                          object.started = false
                          object.texture.offset.x = 0;
                          object.texture.offset.y = 0;
                          this.start(object)
                      }, */
              0, null, object.id, "gif_" + object.animation.texture.id);



      },


      stop: function (object) {
          if (!object || !object.started) return;
          object.started = false
          //只有该object对应的texture对应的所有object都停止了，才能真的停止动画:
          if (this.animateObjects.find(e => e.animation == object.animation && e.started)) return;


          transitions.cancelById("gif_" + object.animation.texture.id);
          object.animation.texture.offset.set(0, 0)
          object.animation.started = false

      }
  }

  var CloneObject = function (copyObj, result, isSimpleCopy, extraReplace) {
      //isSimpleCopy只复制最外层
      //复制json		result的可能：普通数字或字符串、普通数组、复杂对象
      if (!copyObj) return copyObj //0 null undefined ''
      result = result || {};
      if (copyObj instanceof Array) {
          /*  if (copyObj[0]instanceof Object) {
              //不支持含有 [[Object]] 这样二级数组里面还是复杂数据的，普通和复杂的数据混合可能也不支持
              console.error("不支持含有 [[Object]] 这样二级数组里面还是复杂数据的...")
          }  
          
          return copyObj.slice(0);*/ //如果是数组，直接复制返回（排除数组内是object 
          return copyObj.map(e => {
              if (e instanceof Object) {
                  return CloneObject(e)
              } else return e
          })

      } else {
          if (copyObj.clone instanceof Function) { //解决一部分
              return copyObj.clone()
          }
      }
      for (var key in copyObj) {
          if (copyObj[key] instanceof Object && !isSimpleCopy)
              result[key] = CloneObject(copyObj[key]);
          else
              result[key] = copyObj[key];
          //如果是函数类同基本数据，即复制引用
      }
      return result;
  };
  var ifSame = function (object1, object2) {
      if (object1 == object2) return true // 0 != undefined  , 0 == ''
      else if (!object1 || !object2) return false
      else if (object1.constructor != object2.constructor) {
          return false
      } else if (object1 instanceof Array) {
          if (object1.length != object2.length) return false;
          var _object2 = object2.slice(0);

          for (let i = 0; i < object1.length; i++) {
              var u = _object2.find(e => ifSame(object1[i], e));
              if (u == void 0 && !_object2.includes(u) && !object1.includes(u)) return false;
              else {
                  let index = _object2.indexOf(u);
                  _object2.splice(index, 1);
              }
          }

          return true
      } else if (object1.equals instanceof Function) { //复杂数据仅支持这种，其他的可能卡住？

          return object1.equals(object2)

      } else if (typeof object1 == 'number' || typeof object1 == 'string') {
          if (isNaN(object1) && isNaN(object2)) return true
          else return object1 == object2

      } else if (typeof object1 == "object") {
          var keys1 = Object.keys(object1)
          var keys2 = Object.keys(object2)
          if (!ifSame(keys1, keys2)) return false;

          for (let i in object1) {
              var same = ifSame(object1[i], object2[i]);
              if (!same) return false
          }
          return true
      } else {
          console.log('isSame出现例外')
      }





  }




  /* var SoundManager = {//暂不支持同时播放
      currentAudio:null,//当前正在播放list中的哪一个
      list:[
          {
              name:"bg", 
              level : 0,//越大优先级越高
              canBeInterrupted : true ,
              
          },
          {
              name:"boxVideo", 
              level : 1, 
              canBeInterrupted : true,
              checkIfNeedPlay:function(){
                  
                  
              }
          },
          {
              name:"hot", 
              level : 2, 
              canBeInterrupted : true
          },
          {
              name:"tour", 
              level : 3, 
              canBeInterrupted : true
          },
          
          
      ],
      switchPlay:function(){
          
      },
      register:function(){
          
          
          
      } 
      
  }
   */



  //最好能知道应该播放到的currentTime
  var SoundManager = { //暂不支持同时播放
      currentAudio: null, //当前正在播放list中的哪一个
      enableSound: true, //是否允许有声音


      playHistory: [], //被打断的加入播放历史

      list: [], //同一级别可以互相打断 //暂时不做多级别



      play: function (name, src, currentTime) {
          // 点击开始自动导览的时候，手动停止背景音乐播放
          window.manage.switchBgmState(false);

          var object = this.list.find(e => e.name == name)
          if (object) {
              if (this.currentAudio) {
                  this.pause(this.currentAudio.name, false, true)

              }

              { //将当前要播放的播放历史中清除
                  let index = this.playHistory.indexOf(object)
                  if (index > -1) this.playHistory.splice(index, 1);

              }


              this.currentAudio = object
              if (src) {
                  this.setSrc(name, src)
              }
              if (currentTime != void 0) {
                  object.audio.currentTime = currentTime
              }
              if (object.audio) {
                  object.audio.load(); // iOS 9   还需要额外的 load 一下, 否则直接 play 无效 *///https://www.cnblogs.com/interdrp/p/4211883.html   部分资料
                  object.audio.play();
                  object.callback && object.callback(true)
              }
              Log(name + '  播放 ')
          }

      },


      pause: function (name, autoReplayLast, isInterrupt) { //需要能自动恢复上一个被打算的音频。恢复前判断是否还需要播放
          var object = this.list.find(e => e.name == name)
          if (object) {
              this.currentAudio = null


              if (object.audio) {
                  object.audio.pause()
                  object.callback && object.callback(false)
                  Log(name + ' 中断音频 ' + "(" + common.getFileNameFromUrl(object.audio.src) + ')')
              }



              if (isInterrupt) { //一般主动调用不需要加这个
                  this.playHistory.push(object) //如果是被中断的，加入播放历史，等待恢复播放
              }


              if (autoReplayLast) { //播放之前的音频。它们是被打断过的。
                  while (this.playHistory.length) {
                      var last = this.playHistory.pop();
                      if (last.src && last.canplay(last.audio)) {
                          this.play(last.name)
                      }

                  }

              }


          }

      },



      setSrc: function (name, src) { //不能直接给audio赋src！一定要用这个函数！因为我要拿这里的src来判断有无src,因为貌似audio的src会自动变，''时会变成html的链接
          var object = this.list.find(e => e.name == name)
          object.src = src
          object.audio.src = src
          Log(`${object.name} 设置src: ${src}`)
      },

      createAudio: function (object = {}) { //name, level, canplay
          if (!object.fake) {
              object.audio = new Audio();
              object.audio.loop = !!object.loop;
              //object.audio.autoplay = true;


              object.audio.addEventListener('ended', () => {
                  if (object.loop) { //循环
                      Log(`${object.name} 播放完毕，重新播放`)
                      object.audio.play()
                  } else {
                      this.pause(object.name, true); //停止后的后续处理
                  }
              });


              object.audio.oncanplaythrough = () => {
                  Log(`${object.name} canplaythrough  `)
              }
          }

          this.list.push(object)

      },



      initAutoPlay: function () { //处理设备自动播放限制
          let play = function () {
              if (this.currentAudio && this.currentAudio.audio) {
                  this.currentAudio.audio.play()
                  Log(`${this.currentAudio.name} 自动播放成功`) //即使设置src在这之后好像也能成功播放
              } else {

              }
              document.removeEventListener("touchstart", play);
              document.removeEventListener("click", play);
              $('#player')[0].removeEventListener("touchstart", play);
          }.bind(this);


          document.addEventListener("WeixinJSBridgeReady", play, false);
          document.addEventListener("touchstart", play); //ios需要加个事件才能播放 不能自动播放；如果还有浏览器不行，换成别的交互事件
          document.addEventListener("click", play);
          $('#player')[0].addEventListener("touchstart", play);


      }
  }


  function Log(value, color, fontSize) {
      color = color || '#13f'
      fontSize = fontSize || 14
      console.warn(`%c${value}`, `color:${color};font-size:${fontSize}px`)
  }






  Manage.prototype.loadAudio = function () { //相关：g_tourAudio \  g_playAudio




      //热点页面因为挡住了界面，所以暂时不存在别的音频阻止热点音频的可能
      //box视频都静音，所以暂时不考虑

      SoundManager.createAudio({
          name: 'bgm',
          level: 0,
          src: '',
          loop: true,
          canplay: (audio) => {
              return this.bgmShouldPlay
          },
          callback: (state) => { //play或pause时随之触发的函数（即使还没开始播放）

              if (state) {
                  console.log('播放背景音乐');
                  document.querySelector('#openMusic').style.display = 'none'
                  document.querySelector('#closeMusic').style.display = 'block'
              } else {
                  console.log('暂停背景音乐');
                  document.querySelector('#openMusic').style.display = 'block'
                  document.querySelector('#closeMusic').style.display = 'none'
              }
          }
      })
      SoundManager.createAudio({
          name: 'tour',
          level: 0,
          src: '',
          loop: false,
          canplay: (audio) => {
              return player.director && player.director.tourIsPlaying && player.director.getAudio()
          }
      })
      SoundManager.createAudio({
          name: 'hot',
          fake: true, //实际上没有audio. 只是为了来停止和续播其他音频
          level: 1,
          src: '',
          loop: false,
          canplay: (audio) => {

          }
      })


      $("#volume").find("a").on("click", () => {
          if ($("#volume img")[0].src.indexOf("btn_on.png") > -1) {
              this.switchBgmState(true);
          } else if ($("#volume img")[0].src.indexOf("btn_off.png") > -1) {
              this.switchBgmState(false);
          }
      })

      // this.switchBgmState(true);//初始设置允许播放bgm 
      // SoundManager.initAutoPlay()


  }



  Manage.prototype.switchBgmState = function (state) { //按钮的状态完全代表是否应该播放bgm，即使还没加载完
      this.bgmShouldPlay = state


      if (state) {

          SoundManager.play('bgm')
      } else {

          SoundManager.pause('bgm')
      }


      /* if(!g_bgAudio || !g_bgAudio.src) return;
      
      
      var played = function(){
          console.log('begin play bgm');
          g_play = 1; 
          g_playAudio = g_bgAudio;
          
          g_tourAudio && g_tourAudio.pause()
      }
      var paused = function(){ 
          g_play = 0;
          g_playAudio == g_bgAudio && (g_playAudio =  null)
          
      }
      
      if(state ){
          g_bgAudio.play(); 
          if(g_bgAudio.paused){
              paused()
          }else{
              played()
              return true
          }            
      }else{
          g_bgAudio.pause();
          paused()
      } 
      
      
      g_bgAudio.pauseByHot = false
      g_bgAudio.pauseByTour = false */
  }





  var manage = new Manage();





  //兼容一代的場景
  //請求地址統一管理
  var g_onePregix = "https://bigscene.4dage.com/" //对应一代  http://www.4dmodel.com/SuperPanoramic/index.html?m=55
  var g_version = manage.number("version");
  g_version === "one" ? g_Prefix = g_onePregix : '';