HaiDeBao/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 : ''