GE Lua Documentation

			lo('?? to_SET:')
		Render.set(s.set, s.c, s.w)
	end

  end
  startEndPosTable.pos:set(pos)
  fixStartEnd(startEndPosTable, self.path[1], self.path[2])

    if not self.hiddenAfterReset then
      self.mgr.modules.button:set(self.pinOut.buttonId.value, "active", false)
      self.hiddenAfterReset = true

  if self.hiddenAfterReset then
    self.mgr.modules.button:set(id, "active", true)
  end

  if self.pinIn.hideWhenDone.value and not self.hiddenAfterDone and button.used.value then
    self.mgr.modules.button:set(id, "active", false)
    self.hiddenAfterDone = true

                    var marker = this._highlightTextForBasicBlock(block);
                    this._basicBlockMarkers.set(key, marker);
                }

  local beam = vEditor.vdata.beams[beamID]
  tempVec:set(vEditor.vehicle:getNodeAbsPosition(beam.id1))
  tempVec:setSub(vEditor.vehicle:getNodeAbsPosition(beam.id2))

  local d0, d1, d2, d3 = ribbon.depths[i1], ribbon.depths[i2], ribbon.depths[i3], ribbon.depths[i4]
  tmp0:set(c0)
  tmp1:set(c1)

  tmp0:set(c0)
  tmp1:set(c1)
  tmp2:set(c2)

  tmp1:set(c1)
  tmp2:set(c2)
  tmp3:set(c3)

  tmp2:set(c2)
  tmp3:set(c3)
  if isAmbient or isQuadAndVolume then

  if dSq2 < dSq1 then
    retP:set(tmp5)
    return retP, dSq2, u2, v2, true

  end
  retP:set(tmp4)
  return retP, dSq1, u1, v1, false

  if pClosest then
    emit.pos:set(pClosest.x, pClosest.y, pClosest.z)

        bestSqDist = dSq
        emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
        emit.bestSeg = emit.bestSeg - 1

        bestSqDist = dSq
        emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
        emit.bestSeg = emit.bestSeg + 1

        bestSqDist = dSq
        emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
        emit.bestSeg = segSample

    tmpBlueP:set(pClosest.x, pClosest.y, pClosest.z)
    return tmpBlueP, segSample, u, v, isFirstTriangle

  local pClosest, bestSqDist, u, v, isFirstTriangle = closestPoint(emit.bestSeg, p, ribbon, tmpEmitP)
  emit.pos:set(pClosest.x, pClosest.y, pClosest.z)

      bestSqDist = dSq
      emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
      emit.bestSeg = emit.bestSeg - 1

      bestSqDist = dSq
      emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
      emit.bestSeg = emit.bestSeg + 1

      bestSqDist = dSq
      emit.pos:set(bluePoint.x, bluePoint.y, bluePoint.z)
      emit.bestSeg = blueSeg

      axis[emit.eventNameStr].texture = volCoeff
      axis[emit.eventNameStr].pos:set(p)
    end

      axis[emit.eventNameStr].texture = volCoeff
      axis[emit.eventNameStr].pos:set(emit.pos)
    end

  -- Fetch the latest SFX listener pose.
  lPosition:set(SFXSystem.getPositionXYZ())
  lForward:set(SFXSystem.getForwardXYZ())

  lPosition:set(SFXSystem.getPositionXYZ())
  lForward:set(SFXSystem.getForwardXYZ())
  lRight:set(SFXSystem.getRightXYZ())

  lForward:set(SFXSystem.getForwardXYZ())
  lRight:set(SFXSystem.getRightXYZ())

      extMatPreviewRenderSize = previewSize
      extDimRdr:set(0, 0, extMatPreviewRenderSize, extMatPreviewRenderSize)
      extMatPreview:renderWorld(extDimRdr)

      matPreviewRenderSize = matPreviewRenderSize > options.maxMaterialPreviewSize and options.maxMaterialPreviewSize or matPreviewRenderSize
      dimRdr:set(0, 0, matPreviewRenderSize, matPreviewRenderSize)
      matPreview:renderWorld(dimRdr)

    if self.camLastBulletSpeed ~= cam.Speed then
      simTimeAuthority.set(1/cam.Speed)
      self.camLastBulletSpeed = cam.Speed

  elseif self.camLastBulletSpeed then
      simTimeAuthority.set(1)
      self.camLastBulletSpeed = nil

  if self.camLastBulletSpeed then
    simTimeAuthority.set(1)
    self.camLastBulletSpeed = nil

function C:work()
  posA:set(self:getPosition(self.pinIn.posA.value))
  posB:set(self:getPosition(self.pinIn.posB.value))

  posA:set(self:getPosition(self.pinIn.posA.value))
  posB:set(self:getPosition(self.pinIn.posB.value))

  local rotationValues = self.pinIn.rotation.value or zerosTable4
  tr:set(rotationValues[1], rotationValues[2], rotationValues[3], rotationValues[4])
  local yVec = tr * vecY

  self.xOffset:set(veh:getDirectionVector():cross(veh:getDirectionVectorUp()) * (self.pinIn.widthOffset.value or 0))
  self.yOffset:set(veh:getDirectionVector() * (self.pinIn.lengthOffset.value or 0))

  self.xOffset:set(veh:getDirectionVector():cross(veh:getDirectionVectorUp()) * (self.pinIn.widthOffset.value or 0))
  self.yOffset:set(veh:getDirectionVector() * (self.pinIn.lengthOffset.value or 0))
  self.zOffset:set(veh:getDirectionVectorUp() * (self.pinIn.heightOffset.value or 0.5))

  self.yOffset:set(veh:getDirectionVector() * (self.pinIn.lengthOffset.value or 0))
  self.zOffset:set(veh:getDirectionVectorUp() * (self.pinIn.heightOffset.value or 0.5))

  self.points.FL.pos:set(oobb:getPoint(0) - self.xOffset + self.yOffset + self.zOffset)
  self.points.FR.pos:set(oobb:getPoint(3) + self.xOffset + self.yOffset + self.zOffset)

  self.points.FL.pos:set(oobb:getPoint(0) - self.xOffset + self.yOffset + self.zOffset)
  self.points.FR.pos:set(oobb:getPoint(3) + self.xOffset + self.yOffset + self.zOffset)
  self.points.BR.pos:set(oobb:getPoint(7) + self.xOffset - self.yOffset + self.zOffset)

  self.points.FR.pos:set(oobb:getPoint(3) + self.xOffset + self.yOffset + self.zOffset)
  self.points.BR.pos:set(oobb:getPoint(7) + self.xOffset - self.yOffset + self.zOffset)
  self.points.BL.pos:set(oobb:getPoint(4) - self.xOffset - self.yOffset + self.zOffset)

  self.points.BR.pos:set(oobb:getPoint(7) + self.xOffset - self.yOffset + self.zOffset)
  self.points.BL.pos:set(oobb:getPoint(4) - self.xOffset - self.yOffset + self.zOffset)

  self.points.F.pos:set(linePointFromXnorm(self.points.FL.pos, self.points.FR.pos, 0.5))
  self.points.R.pos:set(linePointFromXnorm(self.points.FR.pos, self.points.BR.pos, 0.5))

  self.points.F.pos:set(linePointFromXnorm(self.points.FL.pos, self.points.FR.pos, 0.5))
  self.points.R.pos:set(linePointFromXnorm(self.points.FR.pos, self.points.BR.pos, 0.5))
  self.points.B.pos:set(linePointFromXnorm(self.points.BR.pos, self.points.BL.pos, 0.5))

  self.points.R.pos:set(linePointFromXnorm(self.points.FR.pos, self.points.BR.pos, 0.5))
  self.points.B.pos:set(linePointFromXnorm(self.points.BR.pos, self.points.BL.pos, 0.5))
  self.points.L.pos:set(linePointFromXnorm(self.points.BL.pos, self.points.FL.pos, 0.5))

  self.points.B.pos:set(linePointFromXnorm(self.points.BR.pos, self.points.BL.pos, 0.5))
  self.points.L.pos:set(linePointFromXnorm(self.points.BL.pos, self.points.FL.pos, 0.5))

  self.center:set(linePointFromXnorm(self.points.F.pos, self.points.B.pos, 0.5))

    // Cache focus info for performance
    this.focusCache.set(target, {
      scopeId: scope.id,

    this.debouncedActions.set(key, timeoutId)
  }

  -- calculate some stats about the impact / sanitize the data
  tempAveragePos:set(0, 0, 0)
  local totalDamage = 0

  end
  tempAveragePos:set(tempAveragePos / #crashData.currentImpactData.frameDamages)
  crashData.currentImpactData.averagePos = tempAveragePos

  for _, point in pairs(crashData.accelData) do
    tempVecPos:set(vehData.pos + point.offsetFromCenter * vehData.dirVec)
    tempVecCurrVel:set((point.lastFramePos and (tempVecPos - point.lastFramePos) or vec3()) / dtSim)

    tempVecPos:set(vehData.pos + point.offsetFromCenter * vehData.dirVec)
    tempVecCurrVel:set((point.lastFramePos and (tempVecPos - point.lastFramePos) or vec3()) / dtSim)
    tempVecCurrAccel:set((point.lastFrameVel and (tempVecCurrVel - point.lastFrameVel) or vec3()) / dtSim)

    tempVecCurrVel:set((point.lastFramePos and (tempVecPos - point.lastFramePos) or vec3()) / dtSim)
    tempVecCurrAccel:set((point.lastFrameVel and (tempVecCurrVel - point.lastFrameVel) or vec3()) / dtSim)

    point.lastFrameVel:set(tempVecCurrVel)
    point.lastFramePos:set(tempVecPos)

    point.lastFrameVel:set(tempVecCurrVel)
    point.lastFramePos:set(tempVecPos)

    point.vel:set(tempVecCurrVel)

        this._timelineViewMap.set(timeline, WI.ContentView.createFromRepresentedObject(timeline, {recording: this._recording}));
        if (timeline.type === WI.TimelineRecord.Type.RenderingFrame)

        pathComponent.addEventListener(WI.HierarchicalPathComponent.Event.SiblingWasSelected, this._timelinePathComponentSelected, this);
        this._pathComponentMap.set(timeline, pathComponent);

    local q = rData[i][cenIdx1][cenIdx2]
    tmp:set(q.x, q.y, 0.0)
    if p_2D:squaredDistance(tmp) < distTolSq then

  local zTerrain = core_terrain.getTerrainHeight(p)
  tmp:set(p.x, p.y, p.z + 4.5)
  local zCast = tmp.z - castRayStatic(tmp, downVec, 1000)

    --print(self.oldSet)
    self.smoother:set(self.oldSet)
  end

  state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
  state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())

  state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
  state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())

  if prop.baseTranslationGlobalRigidWithNodeTransforms then
    prop.baseTranslationGlobalRigidWithNodeTransforms:set(state.lastPropBaseTranslationGlobal)
  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then

  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then
    prop.baseTranslationGlobalElasticWithNodeTransforms:set(state.lastPropBaseTranslationGlobal)
  else

    end
    prop.baseTranslationGlobalWithNodeTransforms:set(state.lastPropBaseTranslationGlobal)
  end

  if prop.baseTranslationGlobalRigidWithNodeTransforms then
    prop.baseTranslationGlobalRigidWithNodeTransforms:set(prevBaseTranslationGlobal)
  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then

  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then
    prop.baseTranslationGlobalElasticWithNodeTransforms:set(prevBaseTranslationGlobal)
  else

  else
    prop.baseTranslationGlobalWithNodeTransforms:set(prevBaseTranslationGlobal)
  end

        state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
        state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())

        state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
        state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())
        state.lastPropBaseRotationGlobal = propObj:getBaseRotationGlobal()

        this._childFrameCollection.add(frame);
        this._childFrameIdentifierMap.set(frame._id, frame);

      max = max+1
      updateData.bbCenter:set(be:getObjectOOBBCenterXYZ(id))
      updateData.bbHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(id, 0))

      updateData.bbCenter:set(be:getObjectOOBBCenterXYZ(id))
      updateData.bbHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(id, 0))
      updateData.bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(id, 1))

      updateData.bbHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(id, 0))
      updateData.bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(id, 1))
      updateData.bbHalfAxis2:set(be:getObjectOOBBHalfAxisXYZ(id, 2))

      updateData.bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(id, 1))
      updateData.bbHalfAxis2:set(be:getObjectOOBBHalfAxisXYZ(id, 2))
      local dist = OBBsquaredDistance(updateData.bbCenter, updateData.bbHalfAxis0, updateData.bbHalfAxis1, updateData.bbHalfAxis2, center)

      segmentDir:normalize()
      perpDir:set(-segmentDir.y, segmentDir.x, 0.0)
      local sign = toNode:dot(perpDir) >= 0.0 and -1 or 1

    local binPos = binormals[divIdx]
    binNeg:set(-binPos.x, -binPos.y, -binPos.z)

    -- Set this node in the reference spline.
    tmp1:set(negEdgeTmp.x + posEdgeTmp.x, negEdgeTmp.y + posEdgeTmp.y, negEdgeTmp.z + posEdgeTmp.z)
    tmp1:setScaled2(tmp1, 0.5)

    --print(self.oldSet)
    self.smoother:set(self.oldSet)
  end

        let snapshot = new HeapSnapshot(objectId, snapshotString, title, imported);
        this._objects.set(objectId, snapshot);

        let snapshotDiff = new HeapSnapshotDiff(objectId, snapshot1, snapshot2);
        this._objects.set(objectId, snapshotDiff);
        return {objectId, snapshotDiff: snapshotDiff.serialize()};

  -- end
  -- local id = wheel:set(5, cb, "hello world")
  --

  -- wheel:cancel(id)  -- cancel the timer again
  function wheel:set(expire_in, cb, arg)
    local time_expire = now() + expire_in

  if not data.pos then -- if no position was given, use the camera position instead
    o.pos:set(core_camera.getPosition())
    o.pos.z = be:getSurfaceHeightBelow(o.pos)

    if o.road then
      o.dir:set(o.road.dir)
    else

    else
      o.dir:set(core_camera.getForward())
    end

  debugPos:set(self.pos)
  debugPos.z = debugPos.z + cylinderScl

        if obj then
          debugPos:set(obj:getWorldBox():getCenter())
          debugPos.z = debugPos.z + obj:getWorldBox():getExtents().z * 0.5 + 0.25

          debugPos.z = debugPos.z + obj:getWorldBox():getExtents().z * 0.5 + 0.25
          debugTarget:set(debugPos)
          debugTarget.z = debugTarget.z + 1

      checkAborted()
      previews.value.set(key, {
        bitmap: bmp,

        const others = [...existing.others]
        pendingRenders.value.set(key, {
          paintHash,

    const others = []
    pendingRenders.value.set(key, {
      paintHash,

  -- Get vehicle front center (set module-level vehPos, vehVel)
  vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
  vehVel:set(vehicleData.vel)

  vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
  vehVel:set(vehicleData.vel)

--   -- The plane normal is the y-axis (since plane is drawn in x-z) - reuse tmpVec1
--   tmpVec1:set(0, 1, 0)
--   tmpVec1:set(rot * tmpVec1)

--   tmpVec1:set(0, 1, 0)
--   tmpVec1:set(rot * tmpVec1)
--   tmpVec1:normalize()

  -- The plane normal is the y-axis (since plane is drawn in x-z) - reuse tmpPlaneNormal
  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)

  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)
  tmpPlaneNormal:normalize()

      -- Array format
      self.pos:set(posVal[1], posVal[2], posVal[3])
    else

      -- vec3 object format
      self.pos:set(posVal)
    end

      -- Array format
      self.rot:set(rotVal[1], rotVal[2], rotVal[3], rotVal[4])
    else

      -- quat object format
      self.rot:set(rotVal)
    end

    setExtensionUnloadMode("core_loadMapCmd", "manual")
    core_loadMapCmd.set(jsondata, isStartingArg)
    return

  -- Rotational acceleration compensation at sensor location
  refNodeCoGTransformationOmega:set(sensorHub.rollAV, sensorHub.pitchAV, sensorHub.yawAV)
  refNodeCoGTransformationAlpha:set((refNodeCoGTransformationOmega.x - refNodeCoGTransformationLastOmega.x) / dt, (refNodeCoGTransformationOmega.y - refNodeCoGTransformationLastOmega.y) / dt, (refNodeCoGTransformationOmega.z - refNodeCoGTransformationLastOmega.z) / dt)

  refNodeCoGTransformationOmega:set(sensorHub.rollAV, sensorHub.pitchAV, sensorHub.yawAV)
  refNodeCoGTransformationAlpha:set((refNodeCoGTransformationOmega.x - refNodeCoGTransformationLastOmega.x) / dt, (refNodeCoGTransformationOmega.y - refNodeCoGTransformationLastOmega.y) / dt, (refNodeCoGTransformationOmega.z - refNodeCoGTransformationLastOmega.z) / dt)
  refNodeCoGTransformationLastOmega:set(refNodeCoGTransformationOmega.x, refNodeCoGTransformationOmega.y, refNodeCoGTransformationOmega.z)

  refNodeCoGTransformationAlpha:set((refNodeCoGTransformationOmega.x - refNodeCoGTransformationLastOmega.x) / dt, (refNodeCoGTransformationOmega.y - refNodeCoGTransformationLastOmega.y) / dt, (refNodeCoGTransformationOmega.z - refNodeCoGTransformationLastOmega.z) / dt)
  refNodeCoGTransformationLastOmega:set(refNodeCoGTransformationOmega.x, refNodeCoGTransformationOmega.y, refNodeCoGTransformationOmega.z)

  refNodeCoGTransformationAccRefNode:set(sensorHub.accelerationX, sensorHub.accelerationY, sensorHub.accelerationZ)
  refNodeCoGTransformationAccCoG:set(refNodeCoGTransformationAccRefNode.x - rotAcc.x, refNodeCoGTransformationAccRefNode.y - rotAcc.y, refNodeCoGTransformationAccRefNode.z - rotAcc.z)

  refNodeCoGTransformationAccRefNode:set(sensorHub.accelerationX, sensorHub.accelerationY, sensorHub.accelerationZ)
  refNodeCoGTransformationAccCoG:set(refNodeCoGTransformationAccRefNode.x - rotAcc.x, refNodeCoGTransformationAccRefNode.y - rotAcc.y, refNodeCoGTransformationAccRefNode.z - rotAcc.z)

              -- Check if there are at least 2 enabled meshes in this component set (base + variations).
              local enabledCount = 0

        let lineNumberWithIndicator = sourceCodeLocation.formattedLineNumber;
        this._threadTargetMap.set(target, lineNumberWithIndicator);

            threads = [];
            this._threadLineNumberMap.set(lineNumberWithIndicator, threads);
        }

        this._threadWidgetMap.set(lineNumber, widget);

            lineNumberIssues = [];
            this._issuesLineNumberMap.set(lineNumber, lineNumberIssues);
        }

        this._widgetMap.set(lineNumber, widget);

        this._connections.set(workerId, connection);

  edge2:setSub2(node3, node1)
  edge1Norm:set(edge1)
  edge1Norm:normalize()

  edge1Norm:normalize()
  edge2Norm:set(edge2)
  edge2Norm:normalize()

  -- Compute the local triangle Frenet frame (triangle space).
  forwardTS:set(state.triangleSpaceForward)
  upTS:set(state.triangleSpaceUp)

  forwardTS:set(state.triangleSpaceForward)
  upTS:set(state.triangleSpaceUp)
  rightTS:setCross(edge1Norm, normal)

  edge2:setSub2(node3, node1)
  edge1Norm:set(edge1)
  edge1Norm:normalize()

  edge1Norm:normalize()
  edge2Norm:set(edge2)
  edge2Norm:normalize()

  a3:setScaled2(obj:getNodeForceVector(state.node3Idx), 1.0 / m3)
  v1:set(obj:getNodeVelocityVector(state.node1Idx)) -- Velocity vectors at each node.
  v2:set(obj:getNodeVelocityVector(state.node2Idx))

  v1:set(obj:getNodeVelocityVector(state.node1Idx)) -- Velocity vectors at each node.
  v2:set(obj:getNodeVelocityVector(state.node2Idx))
  v3:set(obj:getNodeVelocityVector(state.node3Idx))

  v2:set(obj:getNodeVelocityVector(state.node2Idx))
  v3:set(obj:getNodeVelocityVector(state.node3Idx))

  -- Compute the local triangle Frenet frame (triangle space).
  forwardTS:set(state.triangleSpaceForward) -- The 'forward' vector in triangle space.
  upTS:set(state.triangleSpaceUp) -- The 'up' vector in triangle space.

  forwardTS:set(state.triangleSpaceForward) -- The 'forward' vector in triangle space.
  upTS:set(state.triangleSpaceUp) -- The 'up' vector in triangle space.
  rightTS:setCross(edge1Norm, normal) -- The 'right' vector in triangle space.

  -- Transform the total acceleration vector to world space.
  accel:set(totalAccel:dot(forwardWS), totalAccel:dot(upWS), totalAccel:dot(rightWS))

  -- Set final smoothed readings.
  state.smoothedAccelReading:set(accel2X, accel2Y, accel2Z)
  state.smoothedGyroReading:set(gyro2X, gyro2Y, gyro2Z)

  state.smoothedAccelReading:set(accel2X, accel2Y, accel2Z)
  state.smoothedGyroReading:set(gyro2X, gyro2Y, gyro2Z)

  self.cluster = cluster
  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(0)

  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(0)

    -- camera-oriented vectors
    tmpX:set(1,0,0)
    tmpX:setRotate(data.camRot)

    tmpX:setRotate(data.camRot)
    tmpY:set(0,1,0)
    tmpY:setRotate(data.camRot)

    tmpY:setRotate(data.camRot)
    tmpZ:set(0,0,1)
    tmpZ:setRotate(data.camRot)

    local fovRadians = core_camera.getFovRad()
    tmpNormal:set(tmpZ)
    tmpNormal:setScaled(math.tan(fovRadians/2))

    -- icon position with added height
    self.iconPos:set(self.pos)
    self.iconPos:setAddXYZ(0,0,iconHeight)

    tmpVec:set(self.iconPos)
    tmpVec:setSub(data.camPos)

    -- iconPos with inverse screenspace offset
    self.iconOff:set(self.iconPos)
    tmpVec:set(self.pos)

    self.iconOff:set(self.iconPos)
    tmpVec:set(self.pos)
    tmpVec:setAddXYZ(0,0,iconHeight)

    tmpVec:set(data.camPos)
    tmpVec:setSub(self.iconPos)

  if data.isFreeCam then
    tmpCorner:set(data.camPos)
    tmpCorner:setSub(self.pos)

  else
    tmpCorner:set(data.playerPosition)
    tmpCorner:setSub(self.pos)

  -- Convert center position to map coordinates
  center:set(self.pos)
  ui_apps_minimap_utils.worldToMapXYZ(center, center)

    -- Triangle vertices: center, current vertex, next vertex
    a:set(center)
    b:set(center)

    a:set(center)
    b:set(center)
    b.x = b.x + hexagonVertices[i].x * radius

    b.y = b.y + hexagonVertices[i].y * radius
    c:set(center)
    c.x = c.x + hexagonVertices[nextI].x * radius

    -- Triangle vertices: center, current vertex, next vertex
    a:set(center)
    b:set(center)

    a:set(center)
    b:set(center)
    b.x = b.x + hexagonVertices[i].x * smallerRadius

    b.y = b.y + hexagonVertices[i].y * smallerRadius
    c:set(center)
    c.x = c.x + hexagonVertices[nextI].x * smallerRadius

  else
    dirVecUp:set(0, 0, 1)
  end

    local rot = self.pinIn.rot.value
    tempQuat:set(rot[1], rot[2], rot[3], rot[4])
    vecOut:set(vecY:rotated(tempQuat))

    tempQuat:set(rot[1], rot[2], rot[3], rot[4])
    vecOut:set(vecY:rotated(tempQuat))
    self.pinOut.value.value = {vecOut.x, vecOut.y, vecOut.z}

      local pWS_3F = te:gridToWorldByPoint2I(Point2I(gX, gY), tb)
      pWS:set(pWS_3F.x, pWS_3F.y, 0)

      local pWS_3F = te:gridToWorldByPoint2I(Point2I(gX, gY), tb)
      pWS:set(pWS_3F.x, pWS_3F.y, 0)

      pDiv[ctr] = catmullRom(p1, p2, p3, p4, q)
      tmp1:set(p1.x, p1.y, widths[i1] * 0.5)
      tmp2:set(p2.x, p2.y, widths[i2] * 0.5)

      tmp1:set(p1.x, p1.y, widths[i1] * 0.5)
      tmp2:set(p2.x, p2.y, widths[i2] * 0.5)
      tmp3:set(p3.x, p3.y, widths[i3] * 0.5)

      tmp2:set(p2.x, p2.y, widths[i2] * 0.5)
      tmp3:set(p3.x, p3.y, widths[i3] * 0.5)
      tmp4:set(p4.x, p4.y, widths[i4] * 0.5)

      tmp3:set(p3.x, p3.y, widths[i3] * 0.5)
      tmp4:set(p4.x, p4.y, widths[i4] * 0.5)
      wDiv[ctr] = catmullRom(tmp1, tmp2, tmp3, tmp4, q).z

      local d = json[j]
      tmp1:set(d.x, d.y, 0)
      nodes[j] = vec3(d.x, d.y, core_terrain.getTerrainHeight(tmp1))

    const key = `[${className}] ${funcName}`
    this.perfStartTimes.set(key, performance.now())
  }

      }
      this.perfMetrics.set(key, metrics)
    }

    elemBlurs.set(el, { blurUpdateWrapper, processBlurVal, observe, unobserve })

  self.camNodeID = self.camNodeID or self.refNodes.ref or 0
  nodePos:set(data.veh:getNodePositionXYZ(self.camNodeID))

  if self.idUp and self.idBack then
    ref:set(data.veh:getNodePositionXYZ(self.idRef or self.camNodeID))
    up:set(data.veh:getNodePositionXYZ(self.idUp))

    ref:set(data.veh:getNodePositionXYZ(self.idRef or self.camNodeID))
    up:set(data.veh:getNodePositionXYZ(self.idUp))
    back:set(data.veh:getNodePositionXYZ(self.idBack))

    up:set(data.veh:getNodePositionXYZ(self.idUp))
    back:set(data.veh:getNodePositionXYZ(self.idBack))
    dir:setSub2(ref, back); dir:normalize()

  else
    ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
    left:set(data.veh:getNodePositionXYZ(self.refNodes.left))

    ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
    left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
    back:set(data.veh:getNodePositionXYZ(self.refNodes.back))

    left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
    back:set(data.veh:getNodePositionXYZ(self.refNodes.back))
    dir:setSub2(ref, back); dir:normalize()

    camLeft:setSub2(ref, left); camLeft:normalize()
    camUp:set(-(push3(dir):cross(push3(camLeft)))); camUp:normalize()
  end

    qdir = rotateEuler(math.rad(180),0,math.atan2(rotatedUp:dot(camLeft), rotatedUp:dot(camUp)),qdir)
    data.res.pos:set(data.veh:getSpawnWorldOOBBRearPoint())
  else

  end
  lastPosition:set(position)
  return lastVel

local function getBBPoints(bbCenter, bbAxis0, bbAxis1, bbAxis2)
  p1:set(bbCenter) p1:setAdd(bbAxis0) p1:setAdd(bbAxis1) p1:setSub(bbAxis2)
  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setAdd(bbAxis1) p2:setAdd(bbAxis2)

  p1:set(bbCenter) p1:setAdd(bbAxis0) p1:setAdd(bbAxis1) p1:setSub(bbAxis2)
  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setAdd(bbAxis1) p2:setAdd(bbAxis2)
  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setAdd(bbAxis1) p3:setAdd(bbAxis2)

  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setAdd(bbAxis1) p2:setAdd(bbAxis2)
  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setAdd(bbAxis1) p3:setAdd(bbAxis2)
  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setAdd(bbAxis1) p4:setSub(bbAxis2)

  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setAdd(bbAxis1) p3:setAdd(bbAxis2)
  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setAdd(bbAxis1) p4:setSub(bbAxis2)
  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setSub(bbAxis1) p5:setSub(bbAxis2)

  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setAdd(bbAxis1) p4:setSub(bbAxis2)
  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setSub(bbAxis1) p5:setSub(bbAxis2)
  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setSub(bbAxis1) p6:setAdd(bbAxis2)

  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setSub(bbAxis1) p5:setSub(bbAxis2)
  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setSub(bbAxis1) p6:setAdd(bbAxis2)
  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setSub(bbAxis1) p7:setAdd(bbAxis2)

  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setSub(bbAxis1) p6:setAdd(bbAxis2)
  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setSub(bbAxis1) p7:setAdd(bbAxis2)
  p8:set(bbCenter) p8:setSub(bbAxis0) p8:setSub(bbAxis1) p8:setSub(bbAxis2)

  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setSub(bbAxis1) p7:setAdd(bbAxis2)
  p8:set(bbCenter) p8:setSub(bbAxis0) p8:setSub(bbAxis1) p8:setSub(bbAxis2)
  bbPoints[1] = p1; bbPoints[2] = p2; bbPoints[3] = p3; bbPoints[4] = p4;

    updateData.vehPos = updateData.vehPos or vec3()
    updateData.vehPos:set(veh:getPositionXYZ())
    updateData.vehPos2d = updateData.vehPos2d or vec3()

    updateData.vehPos2d = updateData.vehPos2d or vec3()
    updateData.vehPos2d:set(updateData.vehPos)
    updateData.vehPos2d.z = 0

    updateData.vehVelocity = updateData.vehVelocity or vec3()
    updateData.vehVelocity:set(veh:getVelocityXYZ())

    updateData.bbCenter = updateData.bbCenter or vec3()
    updateData.bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
    updateData.bbHalfAxis0 = updateData.bbHalfAxis0 or vec3()

    updateData.bbHalfAxis0 = updateData.bbHalfAxis0 or vec3()
    updateData.bbHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
    updateData.bbHalfAxis1 = updateData.bbHalfAxis1 or vec3()

    updateData.bbHalfAxis1 = updateData.bbHalfAxis1 or vec3()
    updateData.bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
    updateData.bbHalfAxis2 = updateData.bbHalfAxis2 or vec3()

    updateData.bbHalfAxis2 = updateData.bbHalfAxis2 or vec3()
    updateData.bbHalfAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))

  updateData.camPos = updateData.camPos or vec3()
  updateData.camPos:set(core_camera.getPositionXYZ())
  updateData.camRot = updateData.camRot or quat()

  updateData.camRot = updateData.camRot or quat()
  updateData.camRot:set(core_camera.getQuatXYZW())
  updateData.bigMapActive = freeroam_bigMapMode.bigMapActive()

  end
  lastCamPos:set(updateData.camPos)
  if veh then

  if veh then
    playerVelLast:set(be:getObjectVelocityXYZ(veh:getID()))
  end

            databaseHostElement = new WI.DatabaseHostTreeElement(database.host);
            this._databaseHostTreeElementMap.set(database.host, databaseHostElement);
            this._databaseRootTreeElement = this._addStorageChild(databaseHostElement, this._databaseRootTreeElement, WI.UIString("Databases"));

            indexedDatabaseHostElement = new WI.IndexedDatabaseHostTreeElement(indexedDatabase.host);
            this._indexedDatabaseHostTreeElementMap.set(indexedDatabase.host, indexedDatabaseHostElement);
            this._indexedDatabaseRootTreeElement = this._addStorageChild(indexedDatabaseHostElement, this._indexedDatabaseRootTreeElement, WI.UIString("Indexed Databases"));

            applicationCacheManifestElement = new WI.ApplicationCacheManifestTreeElement(manifest);
            this._applicationCacheURLTreeElementMap.set(manifestURL, applicationCacheManifestElement);
            this._applicationCacheRootTreeElement = this._addStorageChild(applicationCacheManifestElement, this._applicationCacheRootTreeElement, WI.UIString("Application Cache"));

        this._durationByTaskType.set(taskType, duration);
        return duration;

        this._callbacks.set(callId, callback);
        this._postMessage({callId, actionName, actionArguments});

        this._callbacks.set(callId, callback);
        this._postMessage({callId, objectId, methodName, methodArguments});

        let canvas = WI.Canvas.fromPayload(canvasPayload);
        this._canvasIdentifierMap.set(canvas.identifier, canvas);

        let program = new WI.ShaderProgram(programIdentifier, canvas);
        this._shaderProgramIdentifierMap.set(program.identifier, program);

      $scope.$on("hide_ui", function (event, visible) {
        let cmd = visible === undefined ? `extensions.ui_visibility.toggleCef()` : `extensions.ui_visibility.set(${visible})`
        console.error("The hide_ui function is deprecated and will stop working in the future. Please use " + cmd)

                        workerData.dataPoints.push({time, usage: 0});
                        workersDataMap.set(targetId, workerData);
                    }

            if (entry)
                map.set(key, entry + 1);
            else

            else
                map.set(key, 1);
        }

                    else
                        repeatingTimers.set(record.details, {record, count: 1});
                } else

 * @return     {Object}            An interface with methods to retrieve the `current()` UI scope (as a computed), and
 *                                 to `set()` the current scope
 */

    local obj = getObjectByID(vehId)
    camPos:set(core_camera.getPositionXYZ())
    vehPos:set(obj:getPositionXYZ())

    camPos:set(core_camera.getPositionXYZ())
    vehPos:set(obj:getPositionXYZ())

    if camPos:distance(vehPos) > deleteDistance then
      camDir:set(core_camera.getForwardXYZ())
      local camToVeh = vehPos - camPos

    -- Compute the Frenet frame which will be used to orient the decal.
    tmpTan:set(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z)
    tmpTan:normalize()

    layerBufN[ctr] = layerBufN[ctr] or vec3()
    layerBufN[ctr]:set(masterSpline.normals[i])  -- Store the discretized normal using get-or-create pattern.
    ctr = ctr + 1

      pFlip[i] = pFlip[i] or vec3()
      pFlip[i]:set(tempPoints[srcIdx])
      wFlip[i] = tempWidths[srcIdx]

      nFlip[i] = nFlip[i] or vec3()
      nFlip[i]:set(tempNormals[srcIdx])
    end

--   if vehicleData then
--     vehPos:set(vehicleData.pos)
--     vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)

--     vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)
--     vehVel:set(vehicleData.vel)
--   end

  if vehicleData then
    -- vehPos:set(vehicleData.pos)
    vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))

    -- vehPos:set(vehicleData.pos)
    vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
    vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)

    vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)
    vehVel:set(vehicleData.vel)
  end

  local x, y = p1.x, p1.y
  p1:set(x * c - y * s, x * s + y * c, 0.0)
  local p2 = vec3(0, boxYHalf + bevel - 0.2 + innerShift, 0)

  local x, y = p2.x, p2.y
  p2:set(x * c - y * s, x * s + y * c, 0.0)

      local x, y = p.x, p.y
      n.p:set(x * c - y * s + cen.x, x * s + y * c + cen.y, zOld)
    end

    if isFirstEval then
      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)

      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)

      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)
      cen = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

      local radius1, radius2 = nil, nil
      tmp1:set(i1.x, i1.y, 0)
      tmp2:set(i2.x, i2.y, 0)

      tmp1:set(i1.x, i1.y, 0)
      tmp2:set(i2.x, i2.y, 0)
      tmp3:set(i3.x, i3.y, 0)

      tmp2:set(i2.x, i2.y, 0)
      tmp3:set(i3.x, i3.y, 0)
      local cen1 = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

      if cen1 then radius1 = cen1:distance(tmp1) end
      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)

      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)

      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)
      local cen2 = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

  local pDisc, rDisc, oDisc, wDisc, hLDisc, hRDisc = {}, {}, {}, {}, {}, {}
  pStart_2D:set(p1.x, p1.y, 0.0)
  pMid_2D:set(p2.x, p2.y, 0.0)

  pStart_2D:set(p1.x, p1.y, 0.0)
  pMid_2D:set(p2.x, p2.y, 0.0)
  pEnd_2D:set(p3.x, p3.y, 0.0)

  pMid_2D:set(p2.x, p2.y, 0.0)
  pEnd_2D:set(p3.x, p3.y, 0.0)
  local v1 = pStart_2D - cen

    -- Compute the incircle.
    tmp1:set(pI.x, pI.y, 0.0)
    tmp2:set(pIm.x, pIm.y, 0.0)

    tmp1:set(pI.x, pI.y, 0.0)
    tmp2:set(pIm.x, pIm.y, 0.0)
    tmp3:set(pIp.x, pIp.y, 0.0)

    tmp2:set(pIm.x, pIm.y, 0.0)
    tmp3:set(pIp.x, pIp.y, 0.0)
    local iCen_2D, iRad = computeIncircle2D(tmp1, tmp2, tmp3)

    local tgt_3D = pIp - pIm
    tgt_2D:set(tgt_3D.x, tgt_3D.y, 0.0)
    tgt_2D:normalize()

    local pStart_3D = vec3(pDisc[lastIdx].x, pDisc[lastIdx].y, 0)
    pStart_2D:set(pStart_3D.x, pStart_3D.y, 0.0)
    local i1, i2, i3, i4 = pPrev, pStart_2D, vec3(u1_2D.x, u1_2D.y, 0), vec3(u2_2D.x, u2_2D.y, 0)

    local div1, div2 = map[i2], map[i3]
    tmp1:set(pDisc[div1].x, pDisc[div1].y, 0)
    tmp2:set(pDisc[div2].x, pDisc[div2].y, 0)

    tmp1:set(pDisc[div1].x, pDisc[div1].y, 0)
    tmp2:set(pDisc[div2].x, pDisc[div2].y, 0)
    local dAll = tmp1:distance(tmp2)

    for _ = 1, size do
      tmp3:set(pDisc[ctr].x, pDisc[ctr].y, 0)
      local d1 = tmp3:distance(tmp1)

      local p = road.nodes[i].p
      tmp1:set(p.x, p.y, 0)
      p.z = core_terrain.getTerrainHeight(tmp1)

        local p1, p2, p3 = nodes[i - 1].p, nodes[i].p, nodes[i + 1].p
        tmp1:set(p1.x, p1.y, 0)
        tmp2:set(p2.x, p2.y, 0)

        tmp1:set(p1.x, p1.y, 0)
        tmp2:set(p2.x, p2.y, 0)
        tmp3:set(p3.x, p3.y, 0)

        tmp2:set(p2.x, p2.y, 0)
        tmp3:set(p3.x, p3.y, 0)
        local cen = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

    nml:normalize()
    tmpLat:set(nml.y * tgt.z - nml.z * tgt.y, nml.z * tgt.x - nml.x * tgt.z, nml.x * tgt.y - nml.y * tgt.x)
    tmpLat:normalize()

      rdk[5] = nml                                                                                  -- [5] The road section unit normal vector (not quad local).
      rdk[6]:set(tmpLat.x, tmpLat.y, tmpLat.z)                                                      -- [6] The road section unit lateral vectors (not quad local).
      rdk[7] = (p1 + p2) * 0.5                                                                      -- [7] The lane midpoint (on top face).

      rdk[5] = nml                                                                                  -- [5] The road section unit normal vector (not quad local).
      rdk[6]:set(tmpLat.x, tmpLat.y, tmpLat.z)                                                      -- [6] The road section unit lateral vectors (not quad local).
      rdk[7] = (p1 + p2) * 0.5                                                                      -- [7] The lane midpoint (on top face).

        local l1, l2, l3, l4 = rDL[1], rDL[2], rDL[3], rDL[4]
        tmp1:set(l1.x, l1.y, 0)
        tmp2:set(l2.x, l2.y, 0)

        tmp1:set(l1.x, l1.y, 0)
        tmp2:set(l2.x, l2.y, 0)
        local gL = core_terrain.getTerrainHeight(tmp1)                                              -- Get the terrain height value under the left and right points.

        local gR = core_terrain.getTerrainHeight(tmp2)
        tmp1:set(0, 0, l4.z - gL)                                                                   -- The left and right vertical offset vectors, required to conform the road.
        tmp2:set(0, 0, l3.z - gR)

        tmp1:set(0, 0, l4.z - gL)                                                                   -- The left and right vertical offset vectors, required to conform the road.
        tmp2:set(0, 0, l3.z - gR)
        rDL[1], rDL[2], rDL[3], rDL[4] = l1 - tmp1, l2 - tmp2, l3 - tmp2, l4 - tmp1

            for (let property of result)
                properties.set(property.name, property);

      for i,p in ipairs(vertexLUT.vertices) do
        tmpVec3:set(
          p.position.x * point.orientation.nx +

      for i,p in ipairs(vertexLUT.normals) do
        tmpVec3:set(
          p.x * point.orientation.nx +

    obj:queueGameEngineLua('be:queueObjectLua('..tostring(obj:getId())..', "if recovery.getFreeCamActiveFlag() ~= nil then recovery.setFreeCamActiveFlag(" .. tostring(commands.isFreeCamera()) .. ") end") commands.setFreeCamera()')
    snapshotTimeSmoother:set(1)
    blendTime = 0

      if not nodeRenderPositionsUpToDate[beam.id1] then
        t1:set(relativeNodePositions[beam.id1])
        t1:setRotate(rot)

        nodeRenderPositionsUpToDate[beam.id1] = true
        nodeRenderPositions[beam.id1]:set(p1)
      end

      if not nodeRenderPositionsUpToDate[beam.id2] then
        t2:set(relativeNodePositions[beam.id2])
        t2:setRotate(rot)

        nodeRenderPositionsUpToDate[beam.id2] = true
        nodeRenderPositions[beam.id2]:set(p2)
      end

    if not isFreeCamActive then
      camPos:set((push3(oobb[1])+oobb[4])/2 + push3(upVector) * (oobb[2].z-oobb[1].z) * 1.3 + (push3(oobb[3])-oobb[1]) * 1.5 + push3(backVec))
      tempVec:setSub2(dirFront, camOffsetVec)

          const appendCount = statsProcessor.append.get(call.type) || 0
          statsProcessor.append.set(call.type, appendCount + 1)
        } else {

          const typeCount = statsProcessor.types.get(call.type) || 0
          statsProcessor.types.set(call.type, typeCount + 1)
        }

          const count = statsProcessor.uiApps.get(targetElement) || 0
          statsProcessor.uiApps.set(targetElement, count + 1)
        }

          const fileCount = statsProcessor.files.get(filePath) || 0
          statsProcessor.files.set(filePath, fileCount + 1)
        }

    const currentCount = chainStats.get(chain) || 0
    chainStats.set(chain, currentCount + 1)
  }

      overlayElement.appendChild(overlayDiv)
      overlayDivs.set(element, overlayDiv)
    } catch (e) {

  if not gameplay_city then return end
  camPos:set(core_camera.getPositionXYZ())
  local location = gameplay_city.getHighestPrioZone(camPos)

                styleDeclarations = [];
                declarationsForStyleSheet.set(style.ownerStyleSheet, styleDeclarations);
            }

                this._entries.set(key, value);
            }

    {
        this._entries.set(key, value);
        this.dispatchEventToListeners(WI.DOMStorageObject.Event.ItemAdded, {key, value});

    {
        this._entries.set(key, value);
        this.dispatchEventToListeners(WI.DOMStorageObject.Event.ItemUpdated, {key, oldValue, value});

      tmpRot.x, tmpRot.y, tmpRot.z, tmpRot.w = meshRot.x, meshRot.y, meshRot.z, meshRot.w
      actualBinormal:set(0, 1, 0) -- Start with Y-axis (binormal in mesh space).
      actualBinormal:setRotate(tmpRot, actualBinormal)

  origin:set(veh:getPosition())
  target:setFromTable(self.pinIn.target.value)

        origin:set(veh:getPosition())
        target:setFromTable(self.pinIn.target.value)

    if im.DragFloat3("##pos"..self.id,pos, 0.5) then
      self.position:set(pos[0], pos[1], pos[2])
      self.changed = true

    bbHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(vehId))
    bottomRear:setAdd(vec3(0,-bbHalfExtents.y,0))

    bottomRear:setAdd(vec3(0,0,-bbHalfExtents.z))
    bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))

    defaultCamPos:set(
    math.sin(math.rad(self.defaultRotation.x)) * math.cos(math.rad(self.defaultRotation.y))

  self.skipFovModifier = self.skipFovModifier or false
  self.smoothedPitchOffset:set(0)
  self.dynamicPitchQuat:setFromEuler(0, 0, 0)

  if self.target then
    ref:set(self.targetCenter)
    left:set(self.targetLeft)

    ref:set(self.targetCenter)
    left:set(self.targetLeft)
    back:set(self.targetBack)

    left:set(self.targetLeft)
    back:set(self.targetBack)
  else

    if self.refNodes then
      ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
      left:set(data.veh:getNodePositionXYZ(self.refNodes.left))

      ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
      left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
      back:set(data.veh:getNodePositionXYZ(self.refNodes.back))

      left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
      back:set(data.veh:getNodePositionXYZ(self.refNodes.back))
    end

  if data.teleported then
    self.smoothedPitchOffset:set(0)
    self.dynamicPitchQuat:setFromEuler(0, 0, 0)

  -- calculate the camera offset: rotate with the vehicle
  nx:set(push3(left) - ref)
  ny:set(push3(back) - ref)

  nx:set(push3(left) - ref)
  ny:set(push3(back) - ref)
  nz:set(push3(nx):cross(ny))

  ny:set(push3(back) - ref)
  nz:set(push3(nx):cross(ny))
  ny:set(push3(nx):cross(-push3(nz)))

  nz:set(push3(nx):cross(ny))
  ny:set(push3(nx):cross(-push3(nz)))
  nx:normalize()

    if not self.camOffset2 then self.camOffset2 = vec3() end
    self.camOffset2:set(push3(nx) * self.camBase.x + push3(ny) * self.camBase.y + push3(nz) * self.camBase.z)
    targetPos:set(push3(data.pos) + ref + self.camOffset2)

    self.camOffset2:set(push3(nx) * self.camBase.x + push3(ny) * self.camBase.y + push3(nz) * self.camBase.z)
    targetPos:set(push3(data.pos) + ref + self.camOffset2)
  end

  local pitchDif = 0.1*(MoveManager.pitchDown - MoveManager.pitchUp)
  dir:set(vecY)

    if self.lockCamera == true then
      camdir:set(push3(self.camLastTargetPos) - self.camLastPos2)
      if sign((push3(targetPos) - self.camLastTargetPos):dot(camdir)) < 0 then

        self.camLastRot.x = self.camLastRot.x + math.pi
        self.camLastPos2:set(push3(targetPos) + camdir)
        self.camLastPosPerp:set(push3(vecZ):cross(camdir):normalized() * (self.relaxation * -0.8) + targetPos)

        self.camLastPos2:set(push3(targetPos) + camdir)
        self.camLastPosPerp:set(push3(vecZ):cross(camdir):normalized() * (self.relaxation * -0.8) + targetPos)
      end

      else
        self.camRot:set(self.defaultRotation)
        self.camLastRot:set(math.rad(self.camRot.x), math.rad(self.camRot.y) * 1.5, 0)

        self.camRot:set(self.defaultRotation)
        self.camLastRot:set(math.rad(self.camRot.x), math.rad(self.camRot.y) * 1.5, 0)
      end

  if self.cameraResetted ~= 1 then
    lastCamPointVec:set(push3(targetPos) - self.camLastPos2)
    lastCamLastPerp:set(push3(self.camLastPosPerp) - targetPos)

    lastCamPointVec:set(push3(targetPos) - self.camLastPos2)
    lastCamLastPerp:set(push3(self.camLastPosPerp) - targetPos)
    if lastCamPointVec:length() < self.relaxation and lastCamLastPerp:length() > self.relaxation * 0.8 then

    if lastCamPointVec:length() < self.relaxation and lastCamLastPerp:length() > self.relaxation * 0.8 then
      moveDir:set(push3(targetPos) - self.camLastTargetPos); moveDir:normalize()
      if math.abs(push3(lastCamPointVec):normalized():dot(moveDir)) > math.abs(push3(lastCamLastPerp):normalized():dot(moveDir)) then

      if math.abs(push3(lastCamPointVec):normalized():dot(moveDir)) > math.abs(push3(lastCamLastPerp):normalized():dot(moveDir)) then
        self.camLastPos2:set(push3(lastCamPointVec):cross(lastCamLastPerp):cross(lastCamLastPerp):normalized() + targetPos)
        lastCamPointVec:set(push3(targetPos) - self.camLastPos2)

        self.camLastPos2:set(push3(lastCamPointVec):cross(lastCamLastPerp):cross(lastCamLastPerp):normalized() + targetPos)
        lastCamPointVec:set(push3(targetPos) - self.camLastPos2)
      end

    end
    dir:set(lastCamPointVec)
    dir:normalize()

    -- flatten the rotation plane when camera moves perpendicularly
    dirxy:set(dir.x, dir.y, 0)
    local dirxylen = dirxy:length()

    local coef = math.sqrt(math.max(0, 1 - dirxylen))
    dir:set(push3(dir) * math.max(0, 1 - coef) + push3(dirxy) * (coef / (dirxylen + 1e-30)))
    dir:normalize()

  lastCamPointVec:set(push3(self.camLastPos2) - targetPos)
  self.camLastPos2:set(push3(lastCamPointVec) * (self.relaxation / (lastCamPointVec:length() + 1e-30)) + targetPos)

  lastCamPointVec:set(push3(self.camLastPos2) - targetPos)
  self.camLastPos2:set(push3(lastCamPointVec) * (self.relaxation / (lastCamPointVec:length() + 1e-30)) + targetPos)

  rot:set(math.rad(self.camRot.x), math.rad(self.camRot.y), math.rad(self.camRot.z))

  if self.rearNodeID then
    rear:set(data.veh:getNodePositionXYZ(self.rearNodeID))
    rear:setAdd(data.pos)

    local vehId = data.veh:getID()
    bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
    bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))

    bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
    bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
    rear:set(bbCenter)

    bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
    rear:set(bbCenter)
    rear:setAdd(bbHalfAxis1)

  calculatedCamPos:set(
    math.sin(rotB.x) * math.cos(rotB.y)

  camPos:set(push3(calculatedCamPos) + targetPos + self.orbitOffset)
  updir:setCross(vecZ, dir)

  updir:setCross(vecZ, dir)
  self.camLastPosPerp:set(push3(updir) * (self.relaxation * -0.8 / (updir:length() + 1e-30)) + targetPos)

  self.camLastTargetPos2:set(self.camLastTargetPos)
  self.camLastTargetPos:set(targetPos)

  self.camLastTargetPos2:set(self.camLastTargetPos)
  self.camLastTargetPos:set(targetPos)
  self.camVel:set((push3(camPos) - self.camLastPos) / data.dt)

  self.camLastTargetPos:set(targetPos)
  self.camVel:set((push3(camPos) - self.camLastPos) / data.dt)
  self.camLastPos:set(camPos)

  self.camVel:set((push3(camPos) - self.camLastPos) / data.dt)
  self.camLastPos:set(camPos)
  self.camLastRot:set(rot)

  self.camLastPos:set(camPos)
  self.camLastRot:set(rot)
  self.camLastDist = dist

  resultPos:set(0, 0, lengthValue)
  resultPos:setScaled(self.maxDynamicOffset)

  resultRot:setMul2(self.dynamicPitchQuat, resultRot)
  data.res.pos:set(resultPos)
  data.res.rot:set(resultRot)

  data.res.pos:set(resultPos)
  data.res.rot:set(resultRot)
  data.res.fov = fov

  data.res.fov = fov
  data.res.targetPos:set(targetPos)
  self.collision:update(data)

    rootObservers = new Map()
    observers.set(root, rootObservers)
  }

  if (!rootObservers.has(key)) {
    rootObservers.set(key, createObserver(root, rootMargin))
  }

  mounted(el, { value }) {
    observed.set(el, {
      enabled: true,

    },
    set(newValue) {
      sendUpdatedSelection(newValue)

      tmpVec3:set(
        point.orientation.nx * cappedWidth +

      tmpVec3:set(
        point.orientation.nx * (cappedWidth+side) +

      tmpVec3:set(
        point.orientation.nx * (cappedWidth+side) +

      tmpVec3:set(
        point.orientation.nx * (cappedWidth) +

  plPos:set(gameplay_drift_drift.getVehPos())
  plVel:set(gameplay_drift_drift.getVehVel())

  plPos:set(gameplay_drift_drift.getVehPos())
  plVel:set(gameplay_drift_drift.getVehVel())

  simTimeAuthority.pause(false)
  simTimeAuthority.set(1)
end

  -- Get vehicle front center (set module-level vehPos, vehVel)
  vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
  vehVel:set(vehicleData.vel)

  vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
  vehVel:set(vehicleData.vel)

  if sp then
    self.pos:set(sp.pos)
    self.rot:set(sp.rot)

    self.pos:set(sp.pos)
    self.rot:set(sp.rot)
    self.startPosValid = true

  -- The plane normal is the y-axis (since plane is drawn in x-z) - reuse tmpPlaneNormal
  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)

  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)
  tmpPlaneNormal:normalize()

      -- pos = pos + vel * dt
      scaledVel:set(vel); scaledVel:setScaled(dt)
      pos:setAdd(scaledVel)

      local wall = scenetree.findObject("perimeterWall")
      fieldCenterPos:set(wall:getWorldBoxCenter())
      fieldRadius = wall:getWorldBox():getExtents().x * 0.5

      local reset = scenetree.findObject("ballReturn")
      ballResetPos:set(reset:getPosition())

    if drawRimBeamForces then
      tmpVectorSum:set(0, 0, 0)
      for _, rBeam in ipairs(data.rimBeamsNode1) do

      smoothZ = data.rimBeamsNode1SmootherZ:get(tmpVectorSum.z, dt)
      data.rimBeamsNode1VectorSum:set(smoothX, smoothY, smoothZ)

      tmpVectorSum:set(0, 0, 0)
      for _, rBeam in ipairs(data.rimBeamsNode2) do

      smoothZ = data.rimBeamsNode2SmootherZ:get(tmpVectorSum.z, dt)
      data.rimBeamsNode2VectorSum:set(smoothX, smoothY, smoothZ)
    end

    if drawSidewallBeamForces then
      tmpVectorSum:set(0, 0, 0)
      for _, sBeamData in ipairs(data.sidewallBeamsNode1) do

      smoothZ = data.sidewallBeamsNode1SmootherZ:get(tmpVectorSum.z, dt)
      data.sidewallBeamsNode1VectorSum:set(smoothX, smoothY, smoothZ)

      tmpVectorSum:set(0, 0, 0)
      for _, sBeamData in ipairs(data.sidewallBeamsNode2) do

      smoothZ = data.sidewallBeamsNode2SmootherZ:get(tmpVectorSum.z, dt)
      data.sidewallBeamsNode2VectorSum:set(smoothX, smoothY, smoothZ)
    end

    if drawSuspensionBeamForces then
      tmpVectorSum:set(0, 0, 0)
      for _, sBeam in ipairs(data.suspensionBeamsNode1) do

      smoothZ = data.suspensionBeamsNode1SmootherZ:get(tmpVectorSum.z, dt)
      data.suspensionBeamsNode1VectorSum:set(smoothX, smoothY, smoothZ)

      tmpVectorSum:set(0, 0, 0)
      for _, sBeam in ipairs(data.suspensionBeamsNode2) do

      smoothZ = data.suspensionBeamsNode2SmootherZ:get(tmpVectorSum.z, dt)
      data.suspensionBeamsNode2VectorSum:set(smoothX, smoothY, smoothZ)

    if drawTreadNodeForces then
      tmpVectorSum:set(0, 0, 0)
      for _, tNode in ipairs(data.treadNodes) do

      smoothZ = data.treadNodesSmootherZ:get(tmpVectorSum.z, dt)
      data.treadNodesVectorSum:set(smoothX, smoothY, smoothZ)
    end

  local playerPosition = vec3(0,0,0)
  playerPosition:set(core_camera.getPosition())

    M.decalPool[idx].pos = lerp(from.pos, to.pos, t)
    M.decalPool[idx].position:set(M.decalPool[idx].pos.x, M.decalPool[idx].pos.y, M.decalPool[idx].pos.z)
    local normal = (to.pos - from.pos):normalized()

    local normal = (to.pos - from.pos):normalized()
    M.decalPool[idx].forwardVec:set(normal.x, normal.y, normal.z)
    M.decalPool[idx].color.a = 0

  if veh then
    playerVehPos:set(veh:getPositionXYZ())
  else

  else
    playerVehPos:set(core_camera.getPosition())
  end

    lastGenerationPos = lastGenerationPos or vec3()
    lastGenerationPos:set(playerVehPos)
  end

      for k, p in pairs(recordings[vehId].path) do
        dbgPt:set(p.x, p.y, p.z)
        if (dbgPt - campos):squaredLength() < cutoffPointSq then -- 100 x 100 m

        end
        lastPt:set(dbgPt)
      end

      view.control.renderView.resolution = Point2I(availSize.x, availSize.y)
      tmpRect:set(0, 0, availSize.x, availSize.y)
      view.control.renderView.viewPort = tmpRect

    local resolutionFactor = 800 / freeroam_bigMapMode.getVerticalResolution()
    camQuat:set(core_camera.getQuatXYZW())
    camUp:setRotate(camQuat, upVector)

        iconInfo.color = bigMapModeColorI
        tmpVec:set(data.camPos)
        tmpVec:setAdd(iconPos or vecZero)

        local iconPosColumn = quatFromAxisAngle(camToClusterLeft, (resolutionFactor * -0.03 * core_camera.getFovRad())):__mul(camToUpperPoint * 1.1)
        tmpVec:set(data.camPos)
        tmpVec:setAdd(iconPosColumn or vecZero)

  -- setting up the smoothers
  self.bigMapMarkerAlphaSmoother:set(0)
end

function C:setFullAlphaInstant()
  self.bigMapMarkerAlphaSmoother:set(1)
end

local function set(v)
  obj:queueGameEngineLua('simTimeAuthority.set('..tostring(1/v)..')')

local function set(v)
  obj:queueGameEngineLua('simTimeAuthority.set('..tostring(1/v)..')')
end

  fogDensitySmoother:set(0)
  shadowLogWeightSmoother:set(0)

  fogDensitySmoother:set(0)
  shadowLogWeightSmoother:set(0)
  shadowDistanceSmoother:set(shadowDist)

  shadowLogWeightSmoother:set(0)
  shadowDistanceSmoother:set(shadowDist)
  setActive(true)

  core_environment.setFogDensity(previousFogDensity)
  ui_visibility.set(previousUiVisibility)
  setTime(previousTod)

  core_camera.setByName(0, not activateBigMap and previousCamMode or "bigMap", false, activateBigMap and {initialCamData = {pos = bigMapInitialCamPos, rot = bigMapCamRotation}})
  ui_visibility.set(previousUiVisibility)

  setActive(true)
  ui_visibility.set(false)
  core_paths.playPath(camPath, 0, initData)

  groundMarkerAlphaSmoother:set(0)
  fogDensitySmoother:set(previousFogDensity)

  groundMarkerAlphaSmoother:set(0)
  fogDensitySmoother:set(previousFogDensity)
  if previousShadowLogWeight then

  if previousShadowLogWeight then
    shadowLogWeightSmoother:set(previousShadowLogWeight)
  end

  if previousShadowDistance then
    shadowDistanceSmoother:set(previousShadowDistance or 0)
  end

  groundMarkerAlphaSmoother:set(1)
  fogDensitySmoother:set(0)

  groundMarkerAlphaSmoother:set(1)
  fogDensitySmoother:set(0)
  shadowLogWeightSmoother:set(0)

  fogDensitySmoother:set(0)
  shadowLogWeightSmoother:set(0)
  shadowDistanceSmoother:set(shadowDist)

  shadowLogWeightSmoother:set(0)
  shadowDistanceSmoother:set(shadowDist)
  uiPopupOpen = false

  vehPos:set(vEditor.vehicle:getPositionXYZ())
  local refNodeRot = vEditor.vehicle:getRefNodeRotation()

  local refNodeRot = vEditor.vehicle:getRefNodeRotation()
  rotInv:set(refNodeRot.x, refNodeRot.y, refNodeRot.z, refNodeRot.w)
  rotInv:inverse()

    end
    localVertPos:set(flexbodyObj:getDebugVertexPos(i))

          if renderNode then
            nodePos:set(flexNodePositions[nodeID])
            tempVec:setSub2(vertPos, nodePos)

  prevMinBounds:set(minBounds)
  prevMaxBounds:set(maxBounds)

  prevMinBounds:set(minBounds)
  prevMaxBounds:set(maxBounds)
  minBounds:set(huge,huge,huge)

  prevMaxBounds:set(maxBounds)
  minBounds:set(huge,huge,huge)
  maxBounds:set(-huge,-huge,-huge)

  minBounds:set(huge,huge,huge)
  maxBounds:set(-huge,-huge,-huge)

    for _, nodeID in ipairs(flexbody._group_nodes) do
      nodePos:set(flexNodePositions[nodeID])
      local nodeColor = nodesUsed[nodeID] and nodeUsedColor or nodeUnusedColor

    local node = vEditor.vdata.nodes[state.pickedNodesID[1]]
    nodePos:set(vEditor.vehicle:getNodeAbsPositionXYZ(state.pickedNodesID[1]))

            local node = vEditor.vdata.nodes[nodeID]
            nodePos:set(vEditor.vehicle:getNodeAbsPositionXYZ(nodeID))
            local nodeName = ""

    for _, nodeID in ipairs(flexbody._group_nodes) do
      nodePos:set(vEditor.vehicle:getNodeAbsPositionXYZ(nodeID))
      debugDrawer:drawSphere(nodePos, nodeRenderRadius, nodeUnusedColor)

      if currentPos and nextPos then
        dotPos:set(currentPos)
        local direction = (nextPos - currentPos):normalized()

  end
  state.crawlerData.dynamicData.prevVehPos:set(state.crawlerData.dynamicData.vehPos)

  state.crawlerData.dynamicData.vehPos:set(veh:getPositionXYZ())
  state.crawlerData.dynamicData.vehDirectionVector:set(veh:getDirectionVector())

  state.crawlerData.dynamicData.vehPos:set(veh:getPositionXYZ())
  state.crawlerData.dynamicData.vehDirectionVector:set(veh:getDirectionVector())
  state.crawlerData.dynamicData.vehDirectionVectorUp:set(veh:getDirectionVectorUp())

  state.crawlerData.dynamicData.vehDirectionVector:set(veh:getDirectionVector())
  state.crawlerData.dynamicData.vehDirectionVectorUp:set(veh:getDirectionVectorUp())
  state.crawlerData.dynamicData.vehRot:set(veh:getRotation())

  state.crawlerData.dynamicData.vehDirectionVectorUp:set(veh:getDirectionVectorUp())
  state.crawlerData.dynamicData.vehRot:set(veh:getRotation())
  state.crawlerData.dynamicData.vehVelocity:set(veh:getVelocity())

  state.crawlerData.dynamicData.vehRot:set(veh:getRotation())
  state.crawlerData.dynamicData.vehVelocity:set(veh:getVelocity())
  state.crawlerData.dynamicData.bbCenter:set(be:getObjectOOBBCenterXYZ(crawlerId))

  state.crawlerData.dynamicData.vehVelocity:set(veh:getVelocity())
  state.crawlerData.dynamicData.bbCenter:set(be:getObjectOOBBCenterXYZ(crawlerId))

  tmp1:set(veh:getDirectionVectorXYZ())
  tmp2:set(veh:getVelocityXYZ())

  tmp1:set(veh:getDirectionVectorXYZ())
  tmp2:set(veh:getVelocityXYZ())
  tmp1.z = 0

    local dataString = sbuffer.new()
    dataString:set(data, dataSize)

    data.position:set(x,y,self.pinIn.pos.value[3] or 0)
    data.forwardVec:set(cosX, sinY, 1)

    data.position:set(x,y,self.pinIn.pos.value[3] or 0)
    data.forwardVec:set(cosX, sinY, 1)
    data.texture = self.pinIn.decalPath.value or defaultDecalPath

    data.texture = self.pinIn.decalPath.value or defaultDecalPath
    data.scale:set(unpack(self.pinIn.decalScale.value or defaultDecalScale))

  local te = extensions.editor_terrainEditor.getTerrainEditor()
  tmp1:set(box.xMin, box.yMin, 0) te:worldToGridByPoint2I(tmp1, gMin, tb)
  tmp1:set(box.xMax, box.yMax, 0) te:worldToGridByPoint2I(tmp1, gMax, tb)

  tmp1:set(box.xMin, box.yMin, 0) te:worldToGridByPoint2I(tmp1, gMin, tb)
  tmp1:set(box.xMax, box.yMax, 0) te:worldToGridByPoint2I(tmp1, gMax, tb)
  local gMinX, gMinY, gMaxX, gMaxY = gMin.x, gMin.y, gMax.x, gMax.y

      tmpPoint2I.x, tmpPoint2I.y = x, spansY[i]
      posWS:set(te:gridToWorldByPoint2I(tmpPoint2I, tb))
      local idx = (y - gMinY) * width + (x - gMinX) + 1 -- 2D -> 1D index used for the mask.

  -- Update the grid after changes.
  tmp1:set(gMinX, gMinY, 0)
  tmp2:set(gMaxX, gMaxY, 0)

  tmp1:set(gMinX, gMinY, 0)
  tmp2:set(gMaxX, gMaxY, 0)
  tb:updateGridMaterials(tmp1, tmp2)

  for i = 1, #stateVals do
    tmp1:set(stateX[i], stateY[i], 0)
    tb:setMaterialIdxWs(tmp1, stateVals[i]) -- Restore the original material index (before painting).

  -- Update the grid after changes.
  tmp1:set(group.paintedDataBoxXMin, group.paintedDataBoxYMin, 0)
  tmp2:set(group.paintedDataBoxXMax, group.paintedDataBoxYMax, 0)

  tmp1:set(group.paintedDataBoxXMin, group.paintedDataBoxYMin, 0)
  tmp2:set(group.paintedDataBoxXMax, group.paintedDataBoxYMax, 0)
  tb:updateGridMaterials(tmp1, tmp2)

  tr:setOneDimensionalScale(oneDimScale)
  tr:set(pos, rot, scl)
  tr:enableEditing()

local function updateCameraPose()
  gView:set(0.0, -meshRad * auditionPlanarDistFac, auditionHeight + meshRad * auditionElevationFac)
  local gRot = quatFromDir(auditionVec - gView)

  local x, y, s, c = gView.x, gView.y, sin(ang), cos(ang)
  auditionCamPos:set(x * c - y * s, x * s + y * c, gView.z)
  local gRot = quatFromDir(auditionVec - auditionCamPos)

                sphericalDelta.set( 0, 0, 0 );

                panOffset.set( 0, 0, 0 );

        rotateStart.set( event.clientX, event.clientY );

        dollyStart.set( event.clientX, event.clientY );

        panStart.set( event.clientX, event.clientY );

        rotateEnd.set( event.clientX, event.clientY );

        dollyEnd.set( event.clientX, event.clientY );

        panEnd.set( event.clientX, event.clientY );

        rotateStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );

            dollyStart.set( 0, distance );

            panStart.set( x, y );

        rotateEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );

            dollyEnd.set( 0, distance );

            dollyDelta.set( 0, Math.pow( dollyEnd.y / dollyStart.y, scope.zoomSpeed ) );

            panEnd.set( x, y );

      pFlip[ctr] = pFlip[ctr] or vec3()
      pFlip[ctr]:set(pClipped[i])
      wFlip[ctr] = wClipped[i]

    im.BeginTooltip()
    dimRdr:set(0, 0, shapePreviewSize, shapePreviewSize)
    shapePreview:renderWorld(dimRdr)

    im.BeginTooltip()
    dimRdr:set(0, 0, matPreviewSize, matPreviewSize)
    matPreview:renderWorld(dimRdr)

      -- remember where we drove off
      data.offTrackData.offPos:set(data.frontPos)
      data.inPrevAiPathIdx = data.aiPathIdx

    if not data.offTrackData.lastFrameIsOnRoad and data.isOnRoad then
      data.offTrackData.onPos:set(data.frontPos)

          maxCutDepth = cutDepth
          data.offTrackData.debugStuff.maxCutDepthPos:set(pos)
        end

        totalDistDrivenOffTrack = totalDistDrivenOffTrack + pos:distance(prevPos)
        prevPos:set(pos)
      end

      if veh then
        vehBBCenter:set(be:getObjectOOBBCenterXYZ(id))
        vehBBHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(id))

        vehBBCenter:set(be:getObjectOOBBCenterXYZ(id))
        vehBBHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(id))
        vehVel:set(veh:getVelocityXYZ())

        vehBBHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(id))
        vehVel:set(veh:getVelocityXYZ())
        vehDir:set(veh:getDirectionVectorXYZ())

        vehVel:set(veh:getVelocityXYZ())
        vehDir:set(veh:getDirectionVectorXYZ())
        local dir = sign2(vehDir:dot(vehVel)) -- negative if driving in reverse

        vehDir:setScaled(vehBBHalfExtents.y * dir)
        data.frontPos:set(vehBBCenter)
        data.frontPos:setAdd(vehDir)

    -- advance corners
  vehPos:set(vehicle:getPositionXYZ())
  vehDir:set(vehicle:getDirectionVectorXYZ())

  vehPos:set(vehicle:getPositionXYZ())
  vehDir:set(vehicle:getDirectionVectorXYZ())
  vehDirUp:set(vehicle:getDirectionVectorUpXYZ())

  vehDir:set(vehicle:getDirectionVectorXYZ())
  vehDirUp:set(vehicle:getDirectionVectorUpXYZ())
  vehRot:setFromDir(vehDir, vehDirUp)

  for i, corner in ipairs(state.wheelOffsets) do
    state.previousCorners[i]:set(state.currentCorners[i])
    state.currentCorners[i]:setRotate(vehRot, corner)

        var nameMap = new Map;
        nameMap.set("DOMActivate", "DOM Activate");
        nameMap.set("DOMCharacterDataModified", "DOM Character Data Modified");

        nameMap.set("DOMActivate", "DOM Activate");
        nameMap.set("DOMCharacterDataModified", "DOM Character Data Modified");
        nameMap.set("DOMContentLoaded", "DOM Content Loaded");

        nameMap.set("DOMCharacterDataModified", "DOM Character Data Modified");
        nameMap.set("DOMContentLoaded", "DOM Content Loaded");
        nameMap.set("DOMFocusIn", "DOM Focus In");

        nameMap.set("DOMContentLoaded", "DOM Content Loaded");
        nameMap.set("DOMFocusIn", "DOM Focus In");
        nameMap.set("DOMFocusOut", "DOM Focus Out");

        nameMap.set("DOMFocusIn", "DOM Focus In");
        nameMap.set("DOMFocusOut", "DOM Focus Out");
        nameMap.set("DOMNodeInserted", "DOM Node Inserted");

        nameMap.set("DOMFocusOut", "DOM Focus Out");
        nameMap.set("DOMNodeInserted", "DOM Node Inserted");
        nameMap.set("DOMNodeInsertedIntoDocument", "DOM Node Inserted Into Document");

        nameMap.set("DOMNodeInserted", "DOM Node Inserted");
        nameMap.set("DOMNodeInsertedIntoDocument", "DOM Node Inserted Into Document");
        nameMap.set("DOMNodeRemoved", "DOM Node Removed");

        nameMap.set("DOMNodeInsertedIntoDocument", "DOM Node Inserted Into Document");
        nameMap.set("DOMNodeRemoved", "DOM Node Removed");
        nameMap.set("DOMNodeRemovedFromDocument", "DOM Node Removed From Document");

        nameMap.set("DOMNodeRemoved", "DOM Node Removed");
        nameMap.set("DOMNodeRemovedFromDocument", "DOM Node Removed From Document");
        nameMap.set("DOMSubtreeModified", "DOM Sub-Tree Modified");

        nameMap.set("DOMNodeRemovedFromDocument", "DOM Node Removed From Document");
        nameMap.set("DOMSubtreeModified", "DOM Sub-Tree Modified");
        nameMap.set("addsourcebuffer", "Add Source Buffer");

        nameMap.set("DOMSubtreeModified", "DOM Sub-Tree Modified");
        nameMap.set("addsourcebuffer", "Add Source Buffer");
        nameMap.set("addstream", "Add Stream");

        nameMap.set("addsourcebuffer", "Add Source Buffer");
        nameMap.set("addstream", "Add Stream");
        nameMap.set("addtrack", "Add Track");

        nameMap.set("addstream", "Add Stream");
        nameMap.set("addtrack", "Add Track");
        nameMap.set("animationend", "Animation End");

        nameMap.set("addtrack", "Add Track");
        nameMap.set("animationend", "Animation End");
        nameMap.set("animationiteration", "Animation Iteration");

        nameMap.set("animationend", "Animation End");
        nameMap.set("animationiteration", "Animation Iteration");
        nameMap.set("animationstart", "Animation Start");

        nameMap.set("animationiteration", "Animation Iteration");
        nameMap.set("animationstart", "Animation Start");
        nameMap.set("audioend", "Audio End");

        nameMap.set("animationstart", "Animation Start");
        nameMap.set("audioend", "Audio End");
        nameMap.set("audioprocess", "Audio Process");

        nameMap.set("audioend", "Audio End");
        nameMap.set("audioprocess", "Audio Process");
        nameMap.set("audiostart", "Audio Start");

        nameMap.set("audioprocess", "Audio Process");
        nameMap.set("audiostart", "Audio Start");
        nameMap.set("beforecopy", "Before Copy");

        nameMap.set("audiostart", "Audio Start");
        nameMap.set("beforecopy", "Before Copy");
        nameMap.set("beforecut", "Before Cut");

        nameMap.set("beforecopy", "Before Copy");
        nameMap.set("beforecut", "Before Cut");
        nameMap.set("beforeload", "Before Load");

        nameMap.set("beforecut", "Before Cut");
        nameMap.set("beforeload", "Before Load");
        nameMap.set("beforepaste", "Before Paste");

        nameMap.set("beforeload", "Before Load");
        nameMap.set("beforepaste", "Before Paste");
        nameMap.set("beforeunload", "Before Unload");

        nameMap.set("beforepaste", "Before Paste");
        nameMap.set("beforeunload", "Before Unload");
        nameMap.set("canplay", "Can Play");

        nameMap.set("beforeunload", "Before Unload");
        nameMap.set("canplay", "Can Play");
        nameMap.set("canplaythrough", "Can Play Through");

        nameMap.set("canplay", "Can Play");
        nameMap.set("canplaythrough", "Can Play Through");
        nameMap.set("chargingchange", "Charging Change");

        nameMap.set("canplaythrough", "Can Play Through");
        nameMap.set("chargingchange", "Charging Change");
        nameMap.set("chargingtimechange", "Charging Time Change");

        nameMap.set("chargingchange", "Charging Change");
        nameMap.set("chargingtimechange", "Charging Time Change");
        nameMap.set("compositionend", "Composition End");

        nameMap.set("chargingtimechange", "Charging Time Change");
        nameMap.set("compositionend", "Composition End");
        nameMap.set("compositionstart", "Composition Start");

        nameMap.set("compositionend", "Composition End");
        nameMap.set("compositionstart", "Composition Start");
        nameMap.set("compositionupdate", "Composition Update");

        nameMap.set("compositionstart", "Composition Start");
        nameMap.set("compositionupdate", "Composition Update");
        nameMap.set("contextmenu", "Context Menu");

        nameMap.set("compositionupdate", "Composition Update");
        nameMap.set("contextmenu", "Context Menu");
        nameMap.set("cuechange", "Cue Change");

        nameMap.set("contextmenu", "Context Menu");
        nameMap.set("cuechange", "Cue Change");
        nameMap.set("datachannel", "Data Channel");

        nameMap.set("cuechange", "Cue Change");
        nameMap.set("datachannel", "Data Channel");
        nameMap.set("dblclick", "Double Click");

        nameMap.set("datachannel", "Data Channel");
        nameMap.set("dblclick", "Double Click");
        nameMap.set("devicemotion", "Device Motion");

        nameMap.set("dblclick", "Double Click");
        nameMap.set("devicemotion", "Device Motion");
        nameMap.set("deviceorientation", "Device Orientation");

        nameMap.set("devicemotion", "Device Motion");
        nameMap.set("deviceorientation", "Device Orientation");
        nameMap.set("dischargingtimechange", "Discharging Time Change");

        nameMap.set("deviceorientation", "Device Orientation");
        nameMap.set("dischargingtimechange", "Discharging Time Change");
        nameMap.set("dragend", "Drag End");

        nameMap.set("dischargingtimechange", "Discharging Time Change");
        nameMap.set("dragend", "Drag End");
        nameMap.set("dragenter", "Drag Enter");

        nameMap.set("dragend", "Drag End");
        nameMap.set("dragenter", "Drag Enter");
        nameMap.set("dragleave", "Drag Leave");

        nameMap.set("dragenter", "Drag Enter");
        nameMap.set("dragleave", "Drag Leave");
        nameMap.set("dragover", "Drag Over");

        nameMap.set("dragleave", "Drag Leave");
        nameMap.set("dragover", "Drag Over");
        nameMap.set("dragstart", "Drag Start");

        nameMap.set("dragover", "Drag Over");
        nameMap.set("dragstart", "Drag Start");
        nameMap.set("durationchange", "Duration Change");

        nameMap.set("dragstart", "Drag Start");
        nameMap.set("durationchange", "Duration Change");
        nameMap.set("focusin", "Focus In");

        nameMap.set("durationchange", "Duration Change");
        nameMap.set("focusin", "Focus In");
        nameMap.set("focusout", "Focus Out");

        nameMap.set("focusin", "Focus In");
        nameMap.set("focusout", "Focus Out");
        nameMap.set("gesturechange", "Gesture Change");

        nameMap.set("focusout", "Focus Out");
        nameMap.set("gesturechange", "Gesture Change");
        nameMap.set("gestureend", "Gesture End");

        nameMap.set("gesturechange", "Gesture Change");
        nameMap.set("gestureend", "Gesture End");
        nameMap.set("gesturescrollend", "Gesture Scroll End");

        nameMap.set("gestureend", "Gesture End");
        nameMap.set("gesturescrollend", "Gesture Scroll End");
        nameMap.set("gesturescrollstart", "Gesture Scroll Start");

        nameMap.set("gesturescrollend", "Gesture Scroll End");
        nameMap.set("gesturescrollstart", "Gesture Scroll Start");
        nameMap.set("gesturescrollupdate", "Gesture Scroll Update");

        nameMap.set("gesturescrollstart", "Gesture Scroll Start");
        nameMap.set("gesturescrollupdate", "Gesture Scroll Update");
        nameMap.set("gesturestart", "Gesture Start");

        nameMap.set("gesturescrollupdate", "Gesture Scroll Update");
        nameMap.set("gesturestart", "Gesture Start");
        nameMap.set("gesturetap", "Gesture Tap");

        nameMap.set("gesturestart", "Gesture Start");
        nameMap.set("gesturetap", "Gesture Tap");
        nameMap.set("gesturetapdown", "Gesture Tap Down");

        nameMap.set("gesturetap", "Gesture Tap");
        nameMap.set("gesturetapdown", "Gesture Tap Down");
        nameMap.set("hashchange", "Hash Change");

        nameMap.set("gesturetapdown", "Gesture Tap Down");
        nameMap.set("hashchange", "Hash Change");
        nameMap.set("icecandidate", "ICE Candidate");

        nameMap.set("hashchange", "Hash Change");
        nameMap.set("icecandidate", "ICE Candidate");
        nameMap.set("iceconnectionstatechange", "ICE Connection State Change");

        nameMap.set("icecandidate", "ICE Candidate");
        nameMap.set("iceconnectionstatechange", "ICE Connection State Change");
        nameMap.set("keydown", "Key Down");

        nameMap.set("iceconnectionstatechange", "ICE Connection State Change");
        nameMap.set("keydown", "Key Down");
        nameMap.set("keypress", "Key Press");

        nameMap.set("keydown", "Key Down");
        nameMap.set("keypress", "Key Press");
        nameMap.set("keyup", "Key Up");

        nameMap.set("keypress", "Key Press");
        nameMap.set("keyup", "Key Up");
        nameMap.set("levelchange", "Level Change");

        nameMap.set("keyup", "Key Up");
        nameMap.set("levelchange", "Level Change");
        nameMap.set("loadeddata", "Loaded Data");

        nameMap.set("levelchange", "Level Change");
        nameMap.set("loadeddata", "Loaded Data");
        nameMap.set("loadedmetadata", "Loaded Metadata");

        nameMap.set("loadeddata", "Loaded Data");
        nameMap.set("loadedmetadata", "Loaded Metadata");
        nameMap.set("loadend", "Load End");

        nameMap.set("loadedmetadata", "Loaded Metadata");
        nameMap.set("loadend", "Load End");
        nameMap.set("loadingdone", "Loading Done");

        nameMap.set("loadend", "Load End");
        nameMap.set("loadingdone", "Loading Done");
        nameMap.set("loadstart", "Load Start");

        nameMap.set("loadingdone", "Loading Done");
        nameMap.set("loadstart", "Load Start");
        nameMap.set("mousedown", "Mouse Down");

        nameMap.set("loadstart", "Load Start");
        nameMap.set("mousedown", "Mouse Down");
        nameMap.set("mouseenter", "Mouse Enter");

        nameMap.set("mousedown", "Mouse Down");
        nameMap.set("mouseenter", "Mouse Enter");
        nameMap.set("mouseleave", "Mouse Leave");

        nameMap.set("mouseenter", "Mouse Enter");
        nameMap.set("mouseleave", "Mouse Leave");
        nameMap.set("mousemove", "Mouse Move");

        nameMap.set("mouseleave", "Mouse Leave");
        nameMap.set("mousemove", "Mouse Move");
        nameMap.set("mouseout", "Mouse Out");

        nameMap.set("mousemove", "Mouse Move");
        nameMap.set("mouseout", "Mouse Out");
        nameMap.set("mouseover", "Mouse Over");

        nameMap.set("mouseout", "Mouse Out");
        nameMap.set("mouseover", "Mouse Over");
        nameMap.set("mouseup", "Mouse Up");

        nameMap.set("mouseover", "Mouse Over");
        nameMap.set("mouseup", "Mouse Up");
        nameMap.set("mousewheel", "Mouse Wheel");

        nameMap.set("mouseup", "Mouse Up");
        nameMap.set("mousewheel", "Mouse Wheel");
        nameMap.set("negotiationneeded", "Negotiation Needed");

        nameMap.set("mousewheel", "Mouse Wheel");
        nameMap.set("negotiationneeded", "Negotiation Needed");
        nameMap.set("nomatch", "No Match");

        nameMap.set("negotiationneeded", "Negotiation Needed");
        nameMap.set("nomatch", "No Match");
        nameMap.set("noupdate", "No Update");

        nameMap.set("nomatch", "No Match");
        nameMap.set("noupdate", "No Update");
        nameMap.set("orientationchange", "Orientation Change");

        nameMap.set("noupdate", "No Update");
        nameMap.set("orientationchange", "Orientation Change");
        nameMap.set("overflowchanged", "Overflow Changed");

        nameMap.set("orientationchange", "Orientation Change");
        nameMap.set("overflowchanged", "Overflow Changed");
        nameMap.set("pagehide", "Page Hide");

        nameMap.set("overflowchanged", "Overflow Changed");
        nameMap.set("pagehide", "Page Hide");
        nameMap.set("pageshow", "Page Show");

        nameMap.set("pagehide", "Page Hide");
        nameMap.set("pageshow", "Page Show");
        nameMap.set("popstate", "Pop State");

        nameMap.set("pageshow", "Page Show");
        nameMap.set("popstate", "Pop State");
        nameMap.set("ratechange", "Rate Change");

        nameMap.set("popstate", "Pop State");
        nameMap.set("ratechange", "Rate Change");
        nameMap.set("readystatechange", "Ready State Change");

        nameMap.set("ratechange", "Rate Change");
        nameMap.set("readystatechange", "Ready State Change");
        nameMap.set("removesourcebuffer", "Remove Source Buffer");

        nameMap.set("readystatechange", "Ready State Change");
        nameMap.set("removesourcebuffer", "Remove Source Buffer");
        nameMap.set("removestream", "Remove Stream");

        nameMap.set("removesourcebuffer", "Remove Source Buffer");
        nameMap.set("removestream", "Remove Stream");
        nameMap.set("removetrack", "Remove Track");

        nameMap.set("removestream", "Remove Stream");
        nameMap.set("removetrack", "Remove Track");
        nameMap.set("resize", "Resize");

        nameMap.set("removetrack", "Remove Track");
        nameMap.set("resize", "Resize");
        nameMap.set("securitypolicyviolation", "Security Policy Violation");

        nameMap.set("resize", "Resize");
        nameMap.set("securitypolicyviolation", "Security Policy Violation");
        nameMap.set("selectionchange", "Selection Change");

        nameMap.set("securitypolicyviolation", "Security Policy Violation");
        nameMap.set("selectionchange", "Selection Change");
        nameMap.set("selectstart", "Select Start");

        nameMap.set("selectionchange", "Selection Change");
        nameMap.set("selectstart", "Select Start");
        nameMap.set("signalingstatechange", "Signaling State Change");

        nameMap.set("selectstart", "Select Start");
        nameMap.set("signalingstatechange", "Signaling State Change");
        nameMap.set("soundend", "Sound End");

        nameMap.set("signalingstatechange", "Signaling State Change");
        nameMap.set("soundend", "Sound End");
        nameMap.set("soundstart", "Sound Start");

        nameMap.set("soundend", "Sound End");
        nameMap.set("soundstart", "Sound Start");
        nameMap.set("sourceclose", "Source Close");

        nameMap.set("soundstart", "Sound Start");
        nameMap.set("sourceclose", "Source Close");
        nameMap.set("sourceended", "Source Ended");

        nameMap.set("sourceclose", "Source Close");
        nameMap.set("sourceended", "Source Ended");
        nameMap.set("sourceopen", "Source Open");

        nameMap.set("sourceended", "Source Ended");
        nameMap.set("sourceopen", "Source Open");
        nameMap.set("speechend", "Speech End");

        nameMap.set("sourceopen", "Source Open");
        nameMap.set("speechend", "Speech End");
        nameMap.set("speechstart", "Speech Start");

        nameMap.set("speechend", "Speech End");
        nameMap.set("speechstart", "Speech Start");
        nameMap.set("textInput", "Text Input");

        nameMap.set("speechstart", "Speech Start");
        nameMap.set("textInput", "Text Input");
        nameMap.set("timeupdate", "Time Update");

        nameMap.set("textInput", "Text Input");
        nameMap.set("timeupdate", "Time Update");
        nameMap.set("tonechange", "Tone Change");

        nameMap.set("timeupdate", "Time Update");
        nameMap.set("tonechange", "Tone Change");
        nameMap.set("touchcancel", "Touch Cancel");

        nameMap.set("tonechange", "Tone Change");
        nameMap.set("touchcancel", "Touch Cancel");
        nameMap.set("touchend", "Touch End");

        nameMap.set("touchcancel", "Touch Cancel");
        nameMap.set("touchend", "Touch End");
        nameMap.set("touchmove", "Touch Move");

        nameMap.set("touchend", "Touch End");
        nameMap.set("touchmove", "Touch Move");
        nameMap.set("touchstart", "Touch Start");

        nameMap.set("touchmove", "Touch Move");
        nameMap.set("touchstart", "Touch Start");
        nameMap.set("transitionend", "Transition End");

        nameMap.set("touchstart", "Touch Start");
        nameMap.set("transitionend", "Transition End");
        nameMap.set("updateend", "Update End");

        nameMap.set("transitionend", "Transition End");
        nameMap.set("updateend", "Update End");
        nameMap.set("updateready", "Update Ready");

        nameMap.set("updateend", "Update End");
        nameMap.set("updateready", "Update Ready");
        nameMap.set("updatestart", "Update Start");

        nameMap.set("updateready", "Update Ready");
        nameMap.set("updatestart", "Update Start");
        nameMap.set("upgradeneeded", "Upgrade Needed");

        nameMap.set("updatestart", "Update Start");
        nameMap.set("upgradeneeded", "Upgrade Needed");
        nameMap.set("versionchange", "Version Change");

        nameMap.set("upgradeneeded", "Upgrade Needed");
        nameMap.set("versionchange", "Version Change");
        nameMap.set("visibilitychange", "Visibility Change");

        nameMap.set("versionchange", "Version Change");
        nameMap.set("visibilitychange", "Visibility Change");
        nameMap.set("volumechange", "Volume Change");

        nameMap.set("visibilitychange", "Visibility Change");
        nameMap.set("volumechange", "Volume Change");
        nameMap.set("webglcontextcreationerror", "WebGL Context Creation Error");

        nameMap.set("volumechange", "Volume Change");
        nameMap.set("webglcontextcreationerror", "WebGL Context Creation Error");
        nameMap.set("webglcontextlost", "WebGL Context Lost");

        nameMap.set("webglcontextcreationerror", "WebGL Context Creation Error");
        nameMap.set("webglcontextlost", "WebGL Context Lost");
        nameMap.set("webglcontextrestored", "WebGL Context Restored");

        nameMap.set("webglcontextlost", "WebGL Context Lost");
        nameMap.set("webglcontextrestored", "WebGL Context Restored");
        nameMap.set("webkitAnimationEnd", "Animation End");

        nameMap.set("webglcontextrestored", "WebGL Context Restored");
        nameMap.set("webkitAnimationEnd", "Animation End");
        nameMap.set("webkitAnimationIteration", "Animation Iteration");

        nameMap.set("webkitAnimationEnd", "Animation End");
        nameMap.set("webkitAnimationIteration", "Animation Iteration");
        nameMap.set("webkitAnimationStart", "Animation Start");

        nameMap.set("webkitAnimationIteration", "Animation Iteration");
        nameMap.set("webkitAnimationStart", "Animation Start");
        nameMap.set("webkitBeforeTextInserted", "Before Text Inserted");

        nameMap.set("webkitAnimationStart", "Animation Start");
        nameMap.set("webkitBeforeTextInserted", "Before Text Inserted");
        nameMap.set("webkitEditableContentChanged", "Editable Content Changed");

        nameMap.set("webkitBeforeTextInserted", "Before Text Inserted");
        nameMap.set("webkitEditableContentChanged", "Editable Content Changed");
        nameMap.set("webkitTransitionEnd", "Transition End");

        nameMap.set("webkitEditableContentChanged", "Editable Content Changed");
        nameMap.set("webkitTransitionEnd", "Transition End");
        nameMap.set("webkitaddsourcebuffer", "Add Source Buffer");

        nameMap.set("webkitTransitionEnd", "Transition End");
        nameMap.set("webkitaddsourcebuffer", "Add Source Buffer");
        nameMap.set("webkitbeginfullscreen", "Begin Full-Screen");

        nameMap.set("webkitaddsourcebuffer", "Add Source Buffer");
        nameMap.set("webkitbeginfullscreen", "Begin Full-Screen");
        nameMap.set("webkitcurrentplaybacktargetiswirelesschanged", "Current Playback Target Is Wireless Changed");

        nameMap.set("webkitbeginfullscreen", "Begin Full-Screen");
        nameMap.set("webkitcurrentplaybacktargetiswirelesschanged", "Current Playback Target Is Wireless Changed");
        nameMap.set("webkitendfullscreen", "End Full-Screen");

        nameMap.set("webkitcurrentplaybacktargetiswirelesschanged", "Current Playback Target Is Wireless Changed");
        nameMap.set("webkitendfullscreen", "End Full-Screen");
        nameMap.set("webkitfullscreenchange", "Full-Screen Change");

        nameMap.set("webkitendfullscreen", "End Full-Screen");
        nameMap.set("webkitfullscreenchange", "Full-Screen Change");
        nameMap.set("webkitfullscreenerror", "Full-Screen Error");

        nameMap.set("webkitfullscreenchange", "Full-Screen Change");
        nameMap.set("webkitfullscreenerror", "Full-Screen Error");
        nameMap.set("webkitkeyadded", "Key Added");

        nameMap.set("webkitfullscreenerror", "Full-Screen Error");
        nameMap.set("webkitkeyadded", "Key Added");
        nameMap.set("webkitkeyerror", "Key Error");

        nameMap.set("webkitkeyadded", "Key Added");
        nameMap.set("webkitkeyerror", "Key Error");
        nameMap.set("webkitkeymessage", "Key Message");

        nameMap.set("webkitkeyerror", "Key Error");
        nameMap.set("webkitkeymessage", "Key Message");
        nameMap.set("webkitneedkey", "Need Key");

        nameMap.set("webkitkeymessage", "Key Message");
        nameMap.set("webkitneedkey", "Need Key");
        nameMap.set("webkitnetworkinfochange", "Network Info Change");

        nameMap.set("webkitneedkey", "Need Key");
        nameMap.set("webkitnetworkinfochange", "Network Info Change");
        nameMap.set("webkitplaybacktargetavailabilitychanged", "Playback Target Availability Changed");

        nameMap.set("webkitnetworkinfochange", "Network Info Change");
        nameMap.set("webkitplaybacktargetavailabilitychanged", "Playback Target Availability Changed");
        nameMap.set("webkitpointerlockchange", "Pointer Lock Change");

        nameMap.set("webkitplaybacktargetavailabilitychanged", "Playback Target Availability Changed");
        nameMap.set("webkitpointerlockchange", "Pointer Lock Change");
        nameMap.set("webkitpointerlockerror", "Pointer Lock Error");

        nameMap.set("webkitpointerlockchange", "Pointer Lock Change");
        nameMap.set("webkitpointerlockerror", "Pointer Lock Error");
        nameMap.set("webkitregionoversetchange", "Region Overset Change");

        nameMap.set("webkitpointerlockerror", "Pointer Lock Error");
        nameMap.set("webkitregionoversetchange", "Region Overset Change");
        nameMap.set("webkitremovesourcebuffer", "Remove Source Buffer");

        nameMap.set("webkitregionoversetchange", "Region Overset Change");
        nameMap.set("webkitremovesourcebuffer", "Remove Source Buffer");
        nameMap.set("webkitresourcetimingbufferfull", "Resource Timing Buffer Full");

        nameMap.set("webkitremovesourcebuffer", "Remove Source Buffer");
        nameMap.set("webkitresourcetimingbufferfull", "Resource Timing Buffer Full");
        nameMap.set("webkitsourceclose", "Source Close");

        nameMap.set("webkitresourcetimingbufferfull", "Resource Timing Buffer Full");
        nameMap.set("webkitsourceclose", "Source Close");
        nameMap.set("webkitsourceended", "Source Ended");

        nameMap.set("webkitsourceclose", "Source Close");
        nameMap.set("webkitsourceended", "Source Ended");
        nameMap.set("webkitsourceopen", "Source Open");

        nameMap.set("webkitsourceended", "Source Ended");
        nameMap.set("webkitsourceopen", "Source Open");
        nameMap.set("webkitspeechchange", "Speech Change");

        nameMap.set("webkitsourceopen", "Source Open");
        nameMap.set("webkitspeechchange", "Speech Change");
        nameMap.set("writeend", "Write End");

        nameMap.set("webkitspeechchange", "Speech Change");
        nameMap.set("writeend", "Write End");
        nameMap.set("writestart", "Write Start");

        nameMap.set("writeend", "Write End");
        nameMap.set("writestart", "Write Start");

            valueSet = new Set;
            this._map.set(key, valueSet);
        }

          var copied = new ArrayBuffer(source.byteLength);
          new Uint8Array(copied).set(new Uint8Array(source));
          return copied;

 * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
 * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
 * segments:

 *   // change the attribute
 *   attrs.$set('ngModel', 'new value');
 *

          }
          dst.$set(key, value, true, srcAttr[key]);
        }

                    } else {
                      attr.$set(name, newValue);
                    }

    scope.$watch(attr[normalized], function ngBooleanAttrWatchAction(value) {
      attr.$set(attrName, !!value);
    });

          if (match) {
            attr.$set("ngPattern", new RegExp(match[1], match[2]));
            return;

        scope.$watch(attr[ngAttr], function ngAttrAliasWatchAction(value) {
          attr.$set(ngAttr, value);
        });

            if (attrName === 'href') {
              attr.$set(name, null);
            }

          attr.$set(name, value);

        return function ngValueConstantLink(scope, elm, attr) {
          attr.$set('value', scope.$eval(attr.ngValue));
        };

          scope.$watch(attr.ngValue, function valueWatchAction(value) {
            attr.$set('value', value);
          });

  compile: function(element, attr) {
    attr.$set('ngCloak', undefined);
    element.removeClass('ng-cloak');

        unset(ctrl.$error, validationErrorKey, controller);
        set(ctrl.$$success, validationErrorKey, controller);
      } else {

      } else {
        set(ctrl.$error, validationErrorKey, controller);
        unset(ctrl.$$success, validationErrorKey, controller);

    }
    set(ctrl[name], value, controller);
  }

      optionScope.$watch(interpolateTextFn, function interpolateWatchAction(newVal, oldVal) {
        optionAttrs.$set('value', newVal);
        if (oldVal !== newVal) {

        if (!interpolateTextFn) {
          attr.$set('value', element.text());
        }

    scl = scale*4 * size * dpi
    f:set(fwd)
    f:setScaled(2*scl)

    side:set(fwd)
    side:setCross(side, localUp)

    side:normalize()
    tmp2:set(side)
    tmp2:setScaled(1*scl)

    tmp2:setScaled(1*scl)
    bl:set(pos)
    bl:setSub(tmp2)

    bl:setSub(tmp2)
    br:set(pos)
    br:setAdd(tmp2)

    -- Draw the circle
    tmp1:set(pos)
    ui_apps_minimap_utils.worldToMapXYZ(tmp1,tmp1)

    side:set(fwd)
    side:setCross(side, localUp)

    side:normalize()
    f:set(fwd)
    f:setScaled(1.5*scl)

    f:setAdd(pos)
    bc:set(fwd)
    bc:setScaled(-scl)

    tmp1:set(fwd)
    tmp1:setScaled(1.5*scl)

    tmp1:setScaled(1.5*scl)
    tmp2:set(side)
    tmp2:setScaled(1*scl)

    tmp2:setScaled(1*scl)
    bl:set(pos)
    bl:setSub(tmp1)

    bl:setSub(tmp2)
    br:set(pos)
    br:setSub(tmp1)

  if isWalking then
    pos:set(gameplay_walk.getPosXYZ())
    rot:set(gameplay_walk.getRotXYZW())

    pos:set(gameplay_walk.getPosXYZ())
    rot:set(gameplay_walk.getRotXYZW())
    fwd:setRotate(rot, localFwd)

    if not vehicleData then return end
    pos:set(vehicleData.pos)
    fwd:set(vehicleData.dirVec.x,vehicleData.dirVec.y,0)

    pos:set(vehicleData.pos)
    fwd:set(vehicleData.dirVec.x,vehicleData.dirVec.y,0)
    fwd:normalize()

    --drawVehicle(camPos, cameraLook, clrOrange, 1, true, layers.VEHICLE_PLAYER)
    tmp1:set(cameraLook)

    tmp1:setScaled(scale * 10 * dpi)
    tmp2:set(adjustedCamPos)
    tmp2:setAdd(tmp1)

    tmp1:setScaled(1.25)
    tmp3:set(adjustedCamPos)
    tmp3:setSub(tmp1)

    tmp3:setSub(tmp1)
    tmp1:set(adjustedCamPos)
    ui_apps_minimap_utils.worldToMapXYZ(tmp1,tmp1)

  -- nightmare to fix dtSim not being in sync with the map data
  lastPos2:set(lastPos)
  lastPos:set(pos)

  lastPos2:set(lastPos)
  lastPos:set(pos)
  lastDtSim, lastVel = dtSim, vel

      pos:set(otherVeh:getPositionXYZ())
      fwd:set(otherVeh:getDirectionVectorXYZ())

      pos:set(otherVeh:getPositionXYZ())
      fwd:set(otherVeh:getDirectionVectorXYZ())
      fwd.z = 0

            let requestIdentifier = this._nextRequestIdentifier++;
            this._requestAnimationFrameCallbacks.set(requestIdentifier, callback);
            if (this._requestAnimationFrameTimer)

  twt.targetSpeed = 0
  twt.speedSmoother:set(0)
  twt.steerSmoother:set(0)

  twt.speedSmoother:set(0)
  twt.steerSmoother:set(0)
end

    outDeviation = sign(outDeviation) * min(1, abs(outDeviation))
    egoDeviationSmoother:set(outDeviation)
    egoDeviationSmoother:getUncapped(0, dt)

  else
    egoDeviationSmoother:set(0)
  end

    twt.dirTable[1]:setScaled2(ego.rightVec, -1)
    twt.dirTable[2]:set(ego.dirVec)
    twt.dirTable[3]:set(ego.rightVec)

    twt.dirTable[2]:set(ego.dirVec)
    twt.dirTable[3]:set(ego.rightVec)
    twt.dirTable[4]:setScaled2(ego.dirVec, -1)

    plan[i].vec:setSub2(plan[i-1].pos, plan[i].pos); plan[i].vec.z = 0
    plan[i].dirVec:set(plan[i].vec)
    plan[i].dirVec:normalize()

      if #newNode.outEdgeLanes == #laneConfig then -- TODO: this might not be correct
        dirVec:set(0, 0, 0)
      end

  local newNode = getNewNode()
  newNode.posOrig:set(getPathNodePosition(route, nextPathIdx))
  newNode.pos:set(newNode.posOrig)

  newNode.posOrig:set(getPathNodePosition(route, nextPathIdx))
  newNode.pos:set(newNode.posOrig)
  newNode.vec:set(0, 0, 0)

  newNode.pos:set(newNode.posOrig)
  newNode.vec:set(0, 0, 0)
  newNode.dirVec:set(0, 0, 0)

  newNode.vec:set(0, 0, 0)
  newNode.dirVec:set(0, 0, 0)
  newNode.turnDir:set(0, 0, 0)

  newNode.dirVec:set(0, 0, 0)
  newNode.turnDir:set(0, 0, 0)
  newNode.biNormal:setScaled2(mapmgr.surfaceNormalBelow(mapData.positions[newNodeId], mapData.radius[newNodeId] * 0.5), -1)

  newNode.biNormal:setScaled2(mapmgr.surfaceNormalBelow(mapData.positions[newNodeId], mapData.radius[newNodeId] * 0.5), -1)
  newNode.normal:set(0, 0, 0)
  newNode.radiusOrig = getPathNodeRadius(path, nextPathIdx)

  else
    plan[planCount].normal:set((push3(plan[planCount].posOrig) - newNode.posOrig):cross(plan[planCount].biNormal):normalized())
  end

    newNode.inEdgeNormal:set((push3(plan[planCount].pos) - newNode.pos):cross(newNode.biNormal):normalized())

  newNode.pos:set(newNode.lateralXnorm * push3(newNode.normal) + newNode.posOrig)

  newNode.vec:setSub2(lastPlanPos, newNode.pos); newNode.vec.z = 0
  newNode.dirVec:set(newNode.vec); newNode.dirVec:normalize()

      n.vec:setSub2(n_1.pos, n.pos); n.vec.z = 0
      n.dirVec:set(n.vec); n.dirVec:normalize()
      n_1.turnDir:setSub2(n_1.dirVec, n.dirVec); n_1.turnDir:normalize()

      if newPlan[i] then
        newPlan[i].pos:set(tabentry.pos)
        newPlan[i].normal:set(tabentry.normal)

        newPlan[i].pos:set(tabentry.pos)
        newPlan[i].normal:set(tabentry.normal)
        newPlan[i].posOrig:set(tabentry.posOrig)

        newPlan[i].normal:set(tabentry.normal)
        newPlan[i].posOrig:set(tabentry.posOrig)
        newPlan[i].biNormal:set(tabentry.biNormal)

        newPlan[i].posOrig:set(tabentry.posOrig)
        newPlan[i].biNormal:set(tabentry.biNormal)
        newPlan[i].dirVec:set(tabentry.dirVec)

        newPlan[i].biNormal:set(tabentry.biNormal)
        newPlan[i].dirVec:set(tabentry.dirVec)
        newPlan[i].vec:set(tabentry.vec)

        newPlan[i].dirVec:set(tabentry.dirVec)
        newPlan[i].vec:set(tabentry.vec)
      else

      newNode.vec:setSub2(n1.pos, newNode.pos); newNode.vec.z = 0
      newNode.dirVec:set(newNode.vec); newNode.dirVec:normalize()

      local _, t2 = closestLinePoints(newNode.pos, newNode.pos + newNode.normal, n1.posOrig, n2.posOrig)
      newNode.posOrig:set(t2 * (push3(n2.posOrig) - n1.posOrig) + n1.posOrig)
      local edgeNormal = (push3(n1.posOrig) - n2.posOrig):cross(newNode.biNormal):normalized():copy()

      n2.vec:set(newNode.vec)
      n2.dirVec:set(newNode.dirVec)

      n2.vec:set(newNode.vec)
      n2.dirVec:set(newNode.dirVec)

        planL[planL.planCount].lateralXnorm = planL[planL.planCount].lateralXnorm + (planL.offset or 0)
        planL[planL.planCount].pos:set(planL[planL.planCount].lateralXnorm * push3(planL[planL.planCount].normal) + planL[planL.planCount].posOrig)
        planL[planL.planCount].vec:setSub2(planL[planL.planCount-1].pos, planL[planL.planCount].pos); planL[planL.planCount].vec.z = 0

        planR[planR.planCount].lateralXnorm = planR[planR.planCount].lateralXnorm + (planR.offset or 0)
        planR[planR.planCount].pos:set(planR[planR.planCount].lateralXnorm * push3(planR[planR.planCount].normal) + planR[planR.planCount].posOrig)
        planR[planR.planCount].vec:setSub2(planR[planR.planCount-1].pos, planR[planR.planCount].pos); planR[planR.planCount].vec.z = 0

        plan[i].vec:setSub2(plan[i-1].pos, plan[i].pos); plan[i].vec.z = 0
        plan[i].dirVec:set(plan[i].vec)
        plan[i].dirVec:normalize()

      else
        forces[i]:set(0,0,0)
      end

    n.vec:setSub2(plan[i-1].pos, n.pos); n.vec.z = 0
    n.dirVec:set(n.vec); n.dirVec:normalize()

      if forces[i] then
        forces[i]:set(0, 0, 0)
      else

      if forces[i] then
        forces[i]:set(0, 0, 0)
      else

      if velocities[i] then
        velocities[i]:set(0, 0, 0)
      else

        plan[i].vec:setSub2(plan[i-1].pos, plan[i].pos); plan[i].vec.z = 0
        plan[i].dirVec:set(plan[i].vec)
        plan[i].dirVec:normalize()

    n.vec:setSub2(plan[i-1].pos, n.pos); n.vec.z = 0
    n.dirVec:set(n.vec); n.dirVec:normalize()

      v1z:set(plan[i-1].length, 0, n1.posOrig.z - plan[i-1].posOrig.z)
      v2z:set(n1.length, 0, n2.posOrig.z - n1.posOrig.z)

      v1z:set(plan[i-1].length, 0, n1.posOrig.z - plan[i-1].posOrig.z)
      v2z:set(n1.length, 0, n2.posOrig.z - n1.posOrig.z)
      v3z:set(n1.length + (n2.length or 0), 0, plan[min(plan.planCount, i + 2)].posOrig.z - n1.posOrig.z)

      v2z:set(n1.length, 0, n2.posOrig.z - n1.posOrig.z)
      v3z:set(n1.length + (n2.length or 0), 0, plan[min(plan.planCount, i + 2)].posOrig.z - n1.posOrig.z)

            prevNode = nil
            nDir:set(ego.dirVec)
          end

  ego.pos:set(obj:getFrontPosition())
  ego.pos.z = max(ego.pos.z - 1, obj:getSurfaceHeightBelow(ego.pos))

  ego.pos.z = max(ego.pos.z - 1, obj:getSurfaceHeightBelow(ego.pos))
  ego.prevDirVec:set(ego.dirVec)
  ego.dirVec:set(obj:getDirectionVectorXYZ())

  ego.prevDirVec:set(ego.dirVec)
  ego.dirVec:set(obj:getDirectionVectorXYZ())
  ego.upVec:set(obj:getDirectionVectorUpXYZ())

  ego.dirVec:set(obj:getDirectionVectorXYZ())
  ego.upVec:set(obj:getDirectionVectorUpXYZ())
  ego.rightVec:setCross(ego.dirVec, ego.upVec); ego.rightVec:normalize()

  ego.rightVec:setCross(ego.dirVec, ego.upVec); ego.rightVec:normalize()
  ego.vel:set(obj:getSmoothRefVelocityXYZ())
  ego.speed = ego.vel:length()

            -- acc_check: check if overtake respects grip limit
            d:set(-0.1 * push3(mainPlan[mainPlan.targetSeg].normal) + rearEgoPos2TargetPos) -- (targetPos + dispLim) - (ego.pos - ego.length * ego.dirVec)
            local dSqLengthInv = 1/(d:squaredLength() + 1e-30)

            -- acc_check: check if overtake respects grip limit
            d:set(0.1 * push3(mainPlan[mainPlan.targetSeg].normal) + rearEgoPos2TargetPos) -- (targetPos + dispLim) - (ego.pos - ego.length * ego.dirVec)
            local dSqLengthInv = 1/(d:squaredLength() + 1e-30)

          -- actuall speed
          tmpVec1:set(0, 0, prevEntry[2] * 0.2)
          tmpVec2:set(0, 0, v[2] * 0.2)

          tmpVec1:set(0, 0, prevEntry[2] * 0.2)
          tmpVec2:set(0, 0, v[2] * 0.2)
          debugDrawer:drawCylinder(prevEntry[1] + tmpVec1, v[1] + tmpVec2, 0.02, yellow)

          -- target speed
          tmpVec1:set(0, 0, prevEntry[3] * 0.2)
          tmpVec2:set(0, 0, v[3] * 0.2)

          tmpVec1:set(0, 0, prevEntry[3] * 0.2)
          tmpVec2:set(0, 0, v[3] * 0.2)
          debugDrawer:drawCylinder(prevEntry[1] + tmpVec1, v[1] + tmpVec2, 0.02, blue)

        tmpVec1:set(0, 0, v[3] * 0.2)
        debugDrawer:drawCylinder(v[1], v[1] + tmpVec1, 0.01, blue)

        if focusPos:squaredDistance(v[1]) < visDebug.labelRenderDistance * visDebug.labelRenderDistance then
          tmpVec1:set(0, 0, v[2] * 0.2)
          debugDrawer:drawText(v[1] + tmpVec1 + zOffSet, yellow, strFormat("%2.0f", v[2]*3.6).." kph")

          tmpVec1:set(0, 0, v[3] * 0.2)
          debugDrawer:drawText(v[1] + tmpVec1 + zOffSet, blue, strFormat("%2.0f", v[3]*3.6).." kph")

          local speed = (n.speed >= 0 and n.speed) or prevSpeed
          tmpVec:set(0, 0, speed * 0.2)
          local p1 = n.pos + tmpVec

            local legalSpeed = (n.legalSpeed >= 0 and n.legalSpeed) or prevLegalSpeed
            tmpVec:set(0, 0, legalSpeed * 0.2)
            local p1_ = n.pos + tmpVec

      M.updateGFX = updateGFX
      targetSpeedDifSmoother:set(0)
      targetSpeedSmoother:set(ego.speed)

      targetSpeedDifSmoother:set(0)
      targetSpeedSmoother:set(ego.speed)

  throttleSmoother:set(0)
  smoothTcs:set(1)

  throttleSmoother:set(0)
  smoothTcs:set(1)

      for i = 2, #script do
        scriptPosi:set(script[i].x, script[i].y, 0)
        if p1z0:squaredDistance(scriptPosi) > 0.2 * 0.2 then

      aggression = smoother.aggressionKey:get(max(aggression, sportModeAdjust), dt)
      smoother.aggressionAxis:set(aggression) --keep the other smoother in sync
    else

      aggression = smoother.aggressionAxis:get(max(aggression, sportModeAdjust), dt)
      smoother.aggressionKey:set(aggression) --keep the other smoother in sync
    end

  smoother.aggressionAxis:set(smoothedValues.drivingAggression)
  smoother.aggressionKey:set(smoothedValues.drivingAggression)

  smoother.aggressionAxis:set(smoothedValues.drivingAggression)
  smoother.aggressionKey:set(smoothedValues.drivingAggression)

  smoother.aggressionAxis:set(smoothedValues.drivingAggression)
  smoother.aggressionKey:set(smoothedValues.drivingAggression)

  smoother.aggressionAxis:set(smoothedValues.drivingAggression)
  smoother.aggressionKey:set(smoothedValues.drivingAggression)

        }
        this.columns.set(columnIdentifier, column);

            headerCellElement.classList.add(column["aligned"]);
        this._headerTableCellElements.set(columnIdentifier, headerCellElement);
        var referenceElement = this._headerTableRowElement.children[insertionIndex];

  local resetMetadata = true
  startEndPosTable.pos:set(pos)
  -- gcprobe()

  local tYMin, tYMax = centerY - yHalf, centerY + yHalf
  tmp1:set(tXMin, tYMin, 0)
  tmp2:set(tXMax, tYMax, 0)

  tmp1:set(tXMin, tYMin, 0)
  tmp2:set(tXMax, tYMax, 0)
  te:worldToGridByPoint2I(tmp1, gMin, tb)

                    level++;
                levelMap.set(treeElement, level);
            }

  simTimeAuthority.set(0.5)
  setActive(false)

  simTimeAuthority.set(1)
  if tp then

    {
        this._scriptIdMap.set(script.id, script);

                scripts = [];
                this._scriptContentIdentifierMap.set(script.contentIdentifier, scripts);
            }

    local p1, p2 = polygon[i], polygon[i + 1]
    tmp1:set(p1.x, p1.y, p1.z)
    tmp2:set(p2.x, p2.y, p2.z)

    tmp1:set(p1.x, p1.y, p1.z)
    tmp2:set(p2.x, p2.y, p2.z)
    for j = 1, lineSegGran do

    for j = 1, lineSegGran do
      tmp3:set(lerp(tmp1, tmp2, (j - 1) * lineSegGranInv)) -- Interpolate to increase line clarity on scene
      tmp4:set(lerp(tmp1, tmp2, j * lineSegGranInv))

      tmp3:set(lerp(tmp1, tmp2, (j - 1) * lineSegGranInv)) -- Interpolate to increase line clarity on scene
      tmp4:set(lerp(tmp1, tmp2, j * lineSegGranInv))
      tmp3.z = core_terrain.getTerrainHeight(tmp3) + lineRaiseHeight

    local p1, p2 = polygon[1], polygon[numNodes]
    tmp1:set(p1.x, p1.y, p1.z + lineRaiseHeight)
    tmp2:set(p2.x, p2.y, p2.z + lineRaiseHeight)

    tmp1:set(p1.x, p1.y, p1.z + lineRaiseHeight)
    tmp2:set(p2.x, p2.y, p2.z + lineRaiseHeight)
    render.drawSplineLineDull(tmp1, tmp2)

 * @return     {Object}            An interface with methods to retrieve the `current()` UI scope (as a computed), and
 *                                 to `set()` the current scope
 */

            this._mainFrameTreeElement = new WI.FolderTreeElement(mainFrame.securityOrigin, mainFrame);
            this._originTreeElementMap.set(mainFrame.securityOrigin, this._mainFrameTreeElement);
            break;

                    frameTreeElement = new WI.FolderTreeElement(origin, origin === resource.parentFrame.securityOrigin ? resource.parentFrame : null);
                    this._originTreeElementMap.set(origin, frameTreeElement);

        let targetTreeElement = new WI.WorkerTreeElement(target);
        this._workerTargetTreeElementMap.set(target, targetTreeElement);

  local xyOffset = obj:getObjectBox():getCenter():z0()
  xyOffset:set(xyOffset:componentMul(obj:getScale()))

    for i = 0, edgeCount - 2 do
      pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
      pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))

      pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
      pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))
      totalDist = totalDist + pos1:distance(pos2)

  if not params.useNormal then
    dirVecUp:set(vecUp)
  end

  for i = 0, edgeCount - 2 do
    pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
    pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))

    pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
    pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))
    local dist = math.max(1e-12, pos2:distance(pos1))

        local n = params.randomPosOffset
        posOffset:set(getRandom(n, params.useGauss), getRandom(n, params.useGauss), params.useRandomPosZ and getRandom(n, params.useGauss) or 0)
      end

        local useXY = params.useRandomRotXY
        rotOffset:set(quatFromEuler(useXY and getRandom(n, params.useGauss) or 0, useXY and getRandom(n, params.useGauss) or 0, getRandom(n, params.useGauss)))
      end

            pos.z = z
            dirVecUp:set(core_terrain.getTerrainSmoothNormal(pos))
          end

          pos.z = be:getSurfaceHeightBelow(pos + vecUp)
          dirVecUp:set(map.surfaceNormal(pos, 1))
        end

      pos.z = pos.z + posOffset.z -- adjust after snapping
      dirVec:set((pos2 - pos1):normalized() * dirForwards)

      if params.useCross then
        dirVec:set(dirVec:cross(dirVecUp) * dirSide)
      end

      camPos:set(sobj:getPosition())
      local vel = ((camPosPrev or camPos) - camPos) / dtSim

      local vel = ((camPosPrev or camPos) - camPos) / dtSim
      camPosPrev:set(camPos)

  adjustedPoint:set(intX * (math.sqrt(3) / 2) * trackPosition.unitX + intY * 0.5 * trackPosition.unitY)
  adjustedPoint.z = originalZ

    panningLocal = panningSpeedFactor * panningLocal
    self.camVel:set(panningLocal:toBase(sideVector, -forwardVector, upVector)) -- speed coords to world coords
  end

  local carPos, carVel = self.carPos, self.carVel -- just for convenience
  carPos:set(data.pos)
  carVel:set(data.vel)

  carPos:set(data.pos)
  carVel:set(data.vel)
  local nx, ny, nz = getNxyz(self.refNodes, data.veh)

  if core_camera.objectTeleported(carPos, self.lastCarPos, self.lastCarVel, data.dt) then self:carTeleported() end -- car *appears* to have teleported since the last time this camera was used
  self.lastCarPos:set(carPos)
  self.lastCarVel:set(carVel)

  self.lastCarPos:set(carPos)
  self.lastCarVel:set(carVel)

  self.camPos = self.camPos + self.camVel * data.dt
  self.lastCamPos:set(self.camPos)

  -- fill output table, and pass it through all remaining filters
  data.res.pos:set(self.camPos)
  self.predictor:update(data)

        local vehPos = veh:getPosition()
        skipEventPos:set(nextEvent.pos[1], nextEvent.pos[2], nextEvent.pos[3])
        local distanceSq = vehPos:squaredDistance(skipEventPos)

    local tagPos = vec3()
    tagPos:set(self.selectedPacenoteWaypoint.pos)
    tagPos.z = tagPos.z + 4

  if veh then
    vehVelocity:set(veh:getVelocityXYZ())
    local vehicleSpeed = vehVelocity:len()

local function getBBPoints(bbCenter, bbAxis0, bbAxis1, bbAxis2)
  p1:set(bbCenter) p1:setAdd(bbAxis0) p1:setAdd(bbAxis1) p1:setSub(bbAxis2)
  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setAdd(bbAxis1) p2:setAdd(bbAxis2)

  p1:set(bbCenter) p1:setAdd(bbAxis0) p1:setAdd(bbAxis1) p1:setSub(bbAxis2)
  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setAdd(bbAxis1) p2:setAdd(bbAxis2)
  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setAdd(bbAxis1) p3:setAdd(bbAxis2)

  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setAdd(bbAxis1) p2:setAdd(bbAxis2)
  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setAdd(bbAxis1) p3:setAdd(bbAxis2)
  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setAdd(bbAxis1) p4:setSub(bbAxis2)

  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setAdd(bbAxis1) p3:setAdd(bbAxis2)
  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setAdd(bbAxis1) p4:setSub(bbAxis2)
  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setSub(bbAxis1) p5:setSub(bbAxis2)

  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setAdd(bbAxis1) p4:setSub(bbAxis2)
  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setSub(bbAxis1) p5:setSub(bbAxis2)
  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setSub(bbAxis1) p6:setAdd(bbAxis2)

  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setSub(bbAxis1) p5:setSub(bbAxis2)
  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setSub(bbAxis1) p6:setAdd(bbAxis2)
  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setSub(bbAxis1) p7:setAdd(bbAxis2)

  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setSub(bbAxis1) p6:setAdd(bbAxis2)
  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setSub(bbAxis1) p7:setAdd(bbAxis2)
  p8:set(bbCenter) p8:setSub(bbAxis0) p8:setSub(bbAxis1) p8:setSub(bbAxis2)

  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setSub(bbAxis1) p7:setAdd(bbAxis2)
  p8:set(bbCenter) p8:setSub(bbAxis0) p8:setSub(bbAxis1) p8:setSub(bbAxis2)
  bbPoints[1] = p1; bbPoints[2] = p2; bbPoints[3] = p3; bbPoints[4] = p4;

    local unicycle = getPlayerUnicycle()
    vehPos:set(unicycle:getPositionXYZ())
    local closestHit = 2

      if not vehicleBlacklist[vehId] and veh.playerUsable ~= false and veh:getActive() and veh:getJBeamFilename() ~= "unicycle" then
        otherBBCenter:set(be:getObjectOOBBCenterXYZ(vehId))
        otherBBAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))

        otherBBCenter:set(be:getObjectOOBBCenterXYZ(vehId))
        otherBBAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
        otherBBAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))

        otherBBAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
        otherBBAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
        otherBBAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))

        otherBBAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
        otherBBAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))

    for i, corner in ipairs(vehWpData.wheelOffsets) do
      vehWpData.previousCorners[i]:set(vehWpData.currentCorners[i])
      vehWpData.currentCorners[i]:set(vPos + vRot*corner)

      vehWpData.previousCorners[i]:set(vehWpData.currentCorners[i])
      vehWpData.currentCorners[i]:set(vPos + vRot*corner)
    end

  if data.isFreeCam then
    tmpCorner:set(data.camPos)
    tmpCorner:setSub(self.pos)

  else
    tmpCorner:set(data.playerPosition)
    tmpCorner:setSub(self.pos)

    -- camera-oriented vectors
    tmpX:set(1,0,0)
    tmpX:setRotate(data.camRot)

    tmpX:setRotate(data.camRot)
    tmpY:set(0,1,0)
    tmpY:setRotate(data.camRot)

    tmpY:setRotate(data.camRot)
    tmpZ:set(0,0,1)
    tmpZ:setRotate(data.camRot)

    local fovRadians = core_camera.getFovRad()
    tmpNormal:set(tmpZ)
    tmpNormal:setScaled(math.tan(fovRadians/2))

    -- icon position with added height
    self.iconPos:set(self.pos)
    self.iconPos:setAddXYZ(0,0,iconHeight)

    tmpVec:set(self.iconPos)
    tmpVec:setSub(data.camPos)

    -- iconPos with inverse screenspace offset
    self.iconOff:set(self.iconPos)
    tmpVec:set(self.pos)

    self.iconOff:set(self.iconPos)
    tmpVec:set(self.pos)
    tmpVec:setAddXYZ(0,0,iconHeight)

    tmpVec:set(data.camPos)
    tmpVec:setSub(self.iconPos)

  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(0)

  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(0)

  self.camLastPosRel:set(data.res.pos)

  end
  self.camLastPosAbs:set(data.res.pos)
  self.firstTime = true

  self.camLastQDir:set(data.res.rot)
  self.camLastFOV = data.res.fov

    {
        this._detailNavigationItemMap.set(identifier, new WI.RadioButtonNavigationItem(identifier, toolTip));
    }

  -- vpos:set(v:getPositionXYZ())
  vup:set(v:getDirectionVectorUpXYZ())

  -- vpos:set(v:getPositionXYZ())
  vup:set(v:getDirectionVectorUpXYZ())
  vdir:set(v:getDirectionVectorXYZ())

  vup:set(v:getDirectionVectorUpXYZ())
  vdir:set(v:getDirectionVectorXYZ())
  velocity:set(v:getVelocityXYZ())

  vdir:set(v:getDirectionVectorXYZ())
  velocity:set(v:getVelocityXYZ())
  vright:setCross(vdir, vup)

        // camera border width is 9 px on each side
        offset.set(minX + 9, minY + 9)
        size.set(maxX - minX - 18, maxY - minY - 18)

        offset.set(minX + 9, minY + 9)
        size.set(maxX - minX - 18, maxY - minY - 18)
      }

  local midX, midY = (xMin + xMax) * 0.5, (yMin + yMax) * 0.5
  tmp1:set(midX, midY, 0.0)
  tmp2:set(xMax, yMax, 0.0)

  tmp1:set(midX, midY, 0.0)
  tmp2:set(xMax, yMax, 0.0)

    local smJer = smootherJer:getUncapped(jer, dtSim)
    if smJer > 2 then smootherJer:set(2) smJer = 2 end
    local smoothness = max(abs(smAcc) + smJer)

  oobbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
  local x, y, z = be:getObjectOOBBHalfExtentsXYZ(vehId);

  local pos = vec3(editor.getAxisGizmoTransform():inverse():getColumn(3))
  deltaPos:set(-(pos - axisArrows.startPos))

  dragging = false
  deltaPos:set(0,0,0)
end

  ui_visibility.set(false)
  gameplay_markerInteraction.setMarkersVisibleTemporary(false)

  gameplay_markerInteraction.setMarkersVisibleTemporary(true)
  ui_visibility.set(true)

      }
      this.profiles.set(listenerId, profile)
    }

        }
        this.uiAppProfiles.set(uiApp.name, uiAppProfile)
      }

function LuaVec3:set(x, y, z)
  if rawequal(y, nil) then

function LuaVec3:setTrianglePointFromUV(a, b, c, u, v)
  self:set(push3(a) * u + push3(b) * v + push3(c) * (1-u-v))
end

  local tx,ty,tz = (push3(q):cross(push3(x,y,z)) * 2):xyz()
  self:set(push3(x,y,z) - push3(tx,ty,tz) * q.w + push3(q):cross(push3(tx,ty,tz)))
end

  local qv = newLuaVec3xyz((push3(q):cross(self) * 2):xyz())
  qv:set(push3(self) - push3(qv) * q.w + push3(q):cross(qv))
  return qv

function LuaQuat:set(x, y, z, w)
  if rawequal(y, nil) then

    local qv = newLuaVec3xyz((push3(a):cross(b) * 2):xyz())
    qv:set(push3(b) - push3(qv)*a.w + push3(a):cross(qv))
    return qv

function LuaQuat:setFromDir(dir, up)
  if not up then tmpv1:set(0, 0, 1) else tmpv1:set(up) end
  tmpv2:set(dir) -- tmpv2 is dirNorm

function LuaQuat:setFromDir(dir, up)
  if not up then tmpv1:set(0, 0, 1) else tmpv1:set(up) end
  tmpv2:set(dir) -- tmpv2 is dirNorm

  if not up then tmpv1:set(0, 0, 1) else tmpv1:set(up) end
  tmpv2:set(dir) -- tmpv2 is dirNorm
  tmpv2:normalize()

  if abs(tmpv2:dot(tmpv1)) > 0.9999 then
    tmpv2:set((push3(tmpv2) + tmpv2:perpendicularN() * 1e-5):normalized())
  end

    if y > 0 and y < baba then return t end -- body
    oa:set(y <= 0 and oa or rpos - cposb) -- caps
    b = rdir:dot(oa)

        function listenForChange(setting) {
            initialValues.set(setting, setting.value);
            setting.addEventListener(WI.Setting.Event.Changed, () => {

  tempFwd:set(vecY:rotated(rot)) -- expected to be parallel to the road
  tempUp:set(map.surfaceNormal(pos, 1))

  tempFwd:set(vecY:rotated(rot)) -- expected to be parallel to the road
  tempUp:set(map.surfaceNormal(pos, 1))
  tempRight:setCross(tempFwd, tempUp)

    if veh then
      tempPos:set(veh:getInitialNodePosition(veh:getRefNodeId())) -- position offset of vehicle

      newQuat:setMul2(newQuat, quatFromAxisAngle(tempUp, math.rad(angle * dir)))
      tempFwd2:set(tempPos:rotated(newQuat)) -- actual direction vector for vehicle
      local x, y, z = -tempFwd2.x, -tempFwd2.y, tempPos.z

    -- Exit early if too far from camera
    vehPos:set(be:getObjectPositionXYZ(data.subjectID))
    camPos:set(core_camera.getPositionXYZ())

    vehPos:set(be:getObjectPositionXYZ(data.subjectID))
    camPos:set(core_camera.getPositionXYZ())
    if vehPos:distance(camPos) > camDistanceLimit then return end

    vehVelocity:set(be:getObjectVelocityXYZ(data.subjectID))
    local vehSpeed = vehVelocity:length()

          if abs(dot) > 0.9 then
            localXAxis:set(0, 1, 0) -- Nail is too close to X-axis, use Y-axis instead.
            dot = nailVector:dot(localXAxis)

    local rigidAttachForward, rigidAttachUp = sourceRigidAttachment.forward, sourceRigidAttachment.up
    placedPosWS:set(rigidAttachPos)
    placedForwardVec:set(rigidAttachForward)

    placedPosWS:set(rigidAttachPos)
    placedForwardVec:set(rigidAttachForward)
    placedUpVec:set(rigidAttachUp)

    placedForwardVec:set(rigidAttachForward)
    placedUpVec:set(rigidAttachUp)
    forwardRot:setRotationFromTo(bridgeAttachForward, placedForwardVec) -- Align the forward vectors.

    -- [This needs to be maintained across meshes, so that the behaviour would be the same as if it was not corrected.]
    sourceRigidAttachment.attachPos:set(newBridgeWorldPos)
    if sourceRigidAttachment.head then

    if sourceRigidAttachment.head then
      sourceRigidAttachment.head:set(newBridgeWorldPos + (sourceRigidAttachment.head - rigidAttachPos))
    end

    if sourceRigidAttachment.aux then
      sourceRigidAttachment.aux:set(newBridgeWorldPos + (sourceRigidAttachment.aux - rigidAttachPos))
    end

    local bridgeTargetAttachment = bridge.attachments[2]
    placedPosWS:set(targetRigidAttachment.attachPos)
    placedForwardVec:set(targetRigidAttachment.forward)

    placedPosWS:set(targetRigidAttachment.attachPos)
    placedForwardVec:set(targetRigidAttachment.forward)
    placedUpVec:set(targetRigidAttachment.up)

    placedForwardVec:set(targetRigidAttachment.forward)
    placedUpVec:set(targetRigidAttachment.up)
    forwardRot:setRotationFromTo(bridgeTargetAttachment.forward, placedForwardVec) -- Align the forward vectors.

    local newRigidLocalPos = posWS + attachAnchorPostRotateMS
    targetRigidAttachment.attachPos:set(newRigidLocalPos)
    if targetRigidAttachment.head then

    if targetRigidAttachment.head then
      targetRigidAttachment.head:set(newRigidLocalPos + (targetRigidAttachment.head - targetRigidAttachment.attachPos))
    end

    if targetRigidAttachment.aux then
      targetRigidAttachment.aux:set(newRigidLocalPos + (targetRigidAttachment.aux - targetRigidAttachment.attachPos))
    end

        if (filterBarButton.activated) {
            this._filterFunctionsMap.set(filterBarButton.identifier, filterBarButton.filterFunction);
            this._handleFilterChanged();

        if (filterBarButton.activated)
            this._filterFunctionsMap.set(filterBarButton.identifier, filterBarButton.filterFunction);
        else

  -- Use the actual minimap center coordinates, not the buffer offsets
  centerLocal:set(width/2, height/2, 0)

  -- Apply the same transformation as worldToMapXYZ but for direction vectors
  directionLocal:set(worldYDirection)
  directionLocal:setScaled(1/scale)  -- Scale like in worldToMapXYZ

  local targetDistance = math.max(width, height) * 2  -- Use a large enough distance to ensure we hit the boundary
  intersectionLocal:set(centerLocal.x + directionLocal.x * targetDistance, centerLocal.y + directionLocal.y * targetDistance, 0)

  -- Left vertical line of "N"
  leftTop:set(centerX - letterSize * 0.3, centerY + letterSize * 0.4, 0)
  leftBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)

  leftTop:set(centerX - letterSize * 0.3, centerY + letterSize * 0.4, 0)
  leftBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)

  -- Right vertical line of "N"
  rightTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  rightBottom:set(centerX + letterSize * 0.3, centerY - letterSize * 0.4, 0)

  rightTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  rightBottom:set(centerX + letterSize * 0.3, centerY - letterSize * 0.4, 0)

  -- Diagonal line of "N"
  diagonalTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  diagonalBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)

  diagonalTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  diagonalBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)
  local lineWidth = 1

  -- camera setup
  camPos:set(core_camera.getPositionXYZ())
  cameraLook:set(core_camera.getForwardXYZ())

  camPos:set(core_camera.getPositionXYZ())
  cameraLook:set(core_camera.getForwardXYZ())
  --cameraLook:setRotate(core_camera.getQuat())

  end
  camRotInverse:set(camRot)
  camRotInverse:inverse()

    local lookaheadValue = debugSettingsData.lookaheadValue[debugSettings.lookaheadValue].value
    lookWithoutZ:set(cameraLook.x, cameraLook.y, 0)
    lookWithoutZ:normalize()

            this.element.appendChild(tabItemElement);
            this._tabElementsByTabClass.set(tabClass, tabItemElement);
        }

      if self.pinIn[p].value ~= nil then
        self.mgr.modules.button:set(id, p, self.pinIn[p].value)
      end

    }
    data.set(
      data.id,

    data.posObserver = observePosition(el, data.observe)
    elms.set(el, data)
    // run

-- sets some field for the timer, using the variables.
function C:set(id, field, val) self.variables:change(id..field, val) end

function C:setMode(id, mode)
  self.variables:set(id.."mode", mode)
  if not self.timers[id].isPaused then

    local elapsedTime = self:getElapsedTime(id)
    self.variables:set(id.."start", self:getGlobalTime(mode) - elapsedTime)
  end

            if (currentHeader)
                this._headerMap.set(section.style, currentHeader);

    local p1 = divPoints[2]
    posOut:set(p0)
    tmpForward:setSub2(p1, p0)

    tmpForward:normalize()
    forwardOut:set(tmpForward)
    upOut:set(normals[1])

    forwardOut:set(tmpForward)
    upOut:set(normals[1])
    return true

    local pCur = divPoints[numDivPoints]
    posOut:set(pCur)
    tmpForward:setSub2(pCur, pPrev)

    tmpForward:normalize()
    forwardOut:set(tmpForward)
    upOut:set(normals[numDivPoints])

    forwardOut:set(tmpForward)
    upOut:set(normals[numDivPoints])
    return true

  tmpForward:normalize()
  forwardOut:set(tmpForward)

  tmpVec2:normalize()
  upOut:set(tmpVec2)

    forwardRot:setRotationFromTo(vec3(0, 1, 0), tmpForward)
    tmpVec1:set(0, 0, 1)
    tmpVec1:setRotate(forwardRot, tmpVec1)

      -- Determine inner side for this join from the turn direction in XY.
      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(tmpForward.x, tmpForward.y, 0)

      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(tmpForward.x, tmpForward.y, 0)
      local crossZ = tmpVec1.x * tmpVec2.y - tmpVec1.y * tmpVec2.x

    rectForwardArray[placementIdx] = rectForwardArray[placementIdx] or vec3()
    rectForwardArray[placementIdx]:set(tmpForward)
    rectRightArray[placementIdx] = rectRightArray[placementIdx] or vec3()

    rectRightArray[placementIdx] = rectRightArray[placementIdx] or vec3()
    rectRightArray[placementIdx]:set(tmpRight)
    rectUpArray[placementIdx] = rectUpArray[placementIdx] or vec3()

    rectUpArray[placementIdx] = rectUpArray[placementIdx] or vec3()
    rectUpArray[placementIdx]:set(tmpUp)
    prevForward = prevForward or vec3()

    prevForward = prevForward or vec3()
    prevForward:set(tmpForward)
    prevUp = prevUp or vec3()

    prevUp = prevUp or vec3()
    prevUp:set(tmpUp)

    rotationArray[placementIdx]:set(finalRot)
    meshPathArray[placementIdx] = rectMeshPath

      -- Compute turn angle in XY.
      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(fNext.x, fNext.y, 0)

      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(fNext.x, fNext.y, 0)
      local dot = tmpVec1.x * tmpVec2.x + tmpVec1.y * tmpVec2.y

          -- Build orthonormal frame: X = baseDir (outer edge), Y = outward, Z = X × Y.
          tmpForward:set(baseVec)
          tmpForward:normalize() -- baseDir

            -- Fallback: use rect right as outward direction.
            tmpVec1:set(rPrev)
          end

          -- In mesh space, the base edge is at +pizzaHalfHeight along local Y; after scaling, that distance is pizzaHalfHeight * scaleY.
          tmpVec1:set(0, 1, 0)                 -- local +Y (tip -> base)
          tmpVec1:setRotate(finalRot, tmpVec1) -- to world space

          rotationArray[placementIdx]:set(finalRot)
          meshPathArray[placementIdx] = pizzaMeshPath

  if self.mission.startTrigger.type == 'coordinates' then
    transformHelper:set(vec3(self.mission.startTrigger.pos), quat(self.mission.startTrigger.rot or {0,0,0,1}), self.mission.startTrigger.radius)
  end

          if stType == 'coordinates' then
            transformHelper:set(vec3(self.mission.startTrigger.pos), nil, self.mission.startTrigger.radius)
          end

    wCenter:set(0,0,0)
    local wCount = veh:getWheelCount() - 1

        local axisNodes = veh:getWheelAxisNodes(i)
        wPos:set(veh:getNodePosition(axisNodes[1]))
        wCenter:setAdd(wPos)

            for (let alias of property.aliases)
                WI.CSSKeywordCompletions.PropertyNameForAlias.set(alias, property.name);
        }

        if (property.longhands)
            WI.CSSKeywordCompletions.LonghandNamesForShorthandProperty.set(property.name, property.longhands);
    }

    "content": [
        "list-item", "close-quote", "no-close-quote", "no-open-quote", "open-quote", "attr()", "counter()", "counters()", "url()", "linear-gradient()", "radial-gradient()", "repeating-linear-gradient()", "repeating-radial-gradient()", "-webkit-canvas()", "cross-fade()", "image-set()"
    ],

    "list-style-image": [
        "none", "url()", "linear-gradient()", "radial-gradient()", "repeating-linear-gradient()", "repeating-radial-gradient()", "-webkit-canvas()", "cross-fade()", "image-set()"
    ],

        "-webkit-grab", "-webkit-grabbing", "-webkit-zoom-in", "-webkit-zoom-out",
        "url()", "image-set()"
    ],

    "background": [
        "none", "url()", "linear-gradient()", "radial-gradient()", "repeating-linear-gradient()", "repeating-radial-gradient()", "-webkit-canvas()", "cross-fade()", "image-set()",
        "repeat", "repeat-x", "repeat-y", "no-repeat", "space", "round",

    "background-image": [
        "none", "url()", "linear-gradient()", "radial-gradient()", "repeating-linear-gradient()", "repeating-radial-gradient()", "-webkit-canvas()", "cross-fade()", "image-set()"
    ],

    "border-image": [
        "repeat", "stretch", "url()", "linear-gradient()", "radial-gradient()", "repeating-linear-gradient()", "repeating-radial-gradient()", "-webkit-canvas()", "cross-fade()", "image-set()"
    ],

    --print(self.oldSet)
    self.smoother:set(self.oldSet)
  end

      if shouldLog then log('D', 'graphic',"Sanitizing display mode - "..tostring(current)..": Failed. Patching to display mode 'Window'") end
      o.GraphicDisplayModes.set('Window')
    end

      if shouldLog then log('D', 'graphic',"Sanitizing display resolution - "..tostring(current)..": Failed. Patching to "..newMode) end
      o.GraphicDisplayResolutions.set(newMode)
    end,

      if shouldLog then log('D', 'graphic',"Sanitizing refresh rate - "..tostring(current)..": Failed. Patching to "..tostring(modes.keys[1]).." hertz") end
      o.GraphicDisplayRefreshRates.set(modes.keys[1])
    end

      if shouldLog then log('D', 'graphic',"Sanitizing display - "..tostring(current)..": Failed. Patching to display '"..tostring(modes.keys[1]).."'") end
      o.GraphicDisplayDriver.adapter = o.GraphicDisplayDriver.set(modes.keys[1])
    end

      for k,v in pairs(levelData) do
        o[k].set(v)
      end

        -- log('I','','                              Setting quality to Custom')
        o.GraphicOverallQuality.set(0) -- custom
        return

    if graphicsOptions.WindowPlacement and type(graphicsOptions.WindowPlacement.set) == 'function' then
      graphicsOptions.WindowPlacement.set(newState.WindowPlacement)
      -- Window placement needs to save immediately due to things like pressing Ctrl + L which

    if graphicsOptions.GraphicDisplayDriver and type(graphicsOptions.GraphicDisplayDriver.set) == 'function' then
      graphicsOptions.GraphicDisplayDriver.set(newState.GraphicDisplayDriver)
      graphicsOptions.GraphicDisplayResolutions.SelectHighestForDisplay(newState.GraphicDisplayDriver)

    if graphicsOptions.GraphicDisplayModes and type(graphicsOptions.GraphicDisplayModes.set) == 'function' then
      graphicsOptions.GraphicDisplayModes.set(newState.GraphicDisplayModes)
      shouldLogSanitizeMessage = true

    if graphicsOptions.GraphicDisplayResolutions and type(graphicsOptions.GraphicDisplayResolutions.set) == 'function' then
      graphicsOptions.GraphicDisplayResolutions.set(newState.GraphicDisplayResolutions)
      shouldLogSanitizeMessage = true

    if graphicsOptions.GraphicDisplayRefreshRates and type(graphicsOptions.GraphicDisplayRefreshRates.set) == 'function' then
      graphicsOptions.GraphicDisplayRefreshRates.set(newState.GraphicDisplayRefreshRates)
    end

  -- if videoMem > 1000 then
  --   graphicsOptions.GraphicMeshQuality.set("High")
  --   graphicsOptions.GraphicTextureQuality.set("High")

  --   graphicsOptions.GraphicMeshQuality.set("High")
  --   graphicsOptions.GraphicTextureQuality.set("High")
  --   graphicsOptions.GraphicLightingQuality.set("High")

  --   graphicsOptions.GraphicTextureQuality.set("High")
  --   graphicsOptions.GraphicLightingQuality.set("High")
  --   graphicsOptions.GraphicShaderQuality.set("High")

  --   graphicsOptions.GraphicLightingQuality.set("High")
  --   graphicsOptions.GraphicShaderQuality.set("High")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyHighPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyHighPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(3)
  -- elseif videoMem >= 500 then

  -- elseif videoMem >= 500 then
  --   graphicsOptions.GraphicMeshQuality.set("Normal")
  --   graphicsOptions.GraphicTextureQuality.set("Normal")

  --   graphicsOptions.GraphicMeshQuality.set("Normal")
  --   graphicsOptions.GraphicTextureQuality.set("Normal")
  --   graphicsOptions.GraphicLightingQuality.set("Normal")

  --   graphicsOptions.GraphicTextureQuality.set("Normal")
  --   graphicsOptions.GraphicLightingQuality.set("Normal")
  --   graphicsOptions.GraphicShaderQuality.set("Normal")

  --   graphicsOptions.GraphicLightingQuality.set("Normal")
  --   graphicsOptions.GraphicShaderQuality.set("Normal")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyNormalPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyNormalPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(2)
  -- elseif videoMem > 250 then

  -- elseif videoMem > 250 then
  --   graphicsOptions.GraphicMeshQuality.set("Low")
  --   graphicsOptions.GraphicTextureQuality.set("Low")

  --   graphicsOptions.GraphicMeshQuality.set("Low")
  --   graphicsOptions.GraphicTextureQuality.set("Low")
  --   graphicsOptions.GraphicLightingQuality.set("Low")

  --   graphicsOptions.GraphicTextureQuality.set("Low")
  --   graphicsOptions.GraphicLightingQuality.set("Low")
  --   graphicsOptions.GraphicShaderQuality.set("Low")

  --   graphicsOptions.GraphicLightingQuality.set("Low")
  --   graphicsOptions.GraphicShaderQuality.set("Low")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(1)
  -- else

  -- else
  --   graphicsOptions.GraphicMeshQuality.set("Lowest")
  --   graphicsOptions.GraphicTextureQuality.set("Lowest")

  --   graphicsOptions.GraphicMeshQuality.set("Lowest")
  --   graphicsOptions.GraphicTextureQuality.set("Lowest")
  --   graphicsOptions.GraphicLightingQuality.set("Lowest")

  --   graphicsOptions.GraphicTextureQuality.set("Lowest")
  --   graphicsOptions.GraphicLightingQuality.set("Lowest")
  --   graphicsOptions.GraphicShaderQuality.set("Lowest")

  --   graphicsOptions.GraphicLightingQuality.set("Lowest")
  --   graphicsOptions.GraphicShaderQuality.set("Lowest")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowestPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowestPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(0)
  -- end

  self:set()

-- sets the position, rotation and scale of the helper. nil parameters are ignored,
-- so you can only set the rotation with :set(nil, quat(...), nil) for example
function C:set(pos, rot, scl)

-- so you can only set the rotation with :set(nil, quat(...), nil) for example
function C:set(pos, rot, scl)
  if self.oneDimensionalScale then

    local rot = quatFromDir(fwd, mouseInfo._downNormal):normalized()
    self:set(mouseInfo._downPos,
        self._temp.moved and self.allowRotate and rot,

          if self._temp then
            self:set(self._temp.pos, self._temp.rot, self._temp.scl)
            self._temp = nil

function C:helperPositionToCamera()
  self:set(core_camera.getPosition())
end

function C:helperPositionInFrontOfToCamera()
  self:set(vec3(core_camera.getQuat() * vec3(0, 15, 0)) + core_camera.getPosition())
end

  if not core_terrain.getTerrain() then return end
  self:set(vec3(self.pos.x, self.pos.y, core_terrain.getTerrainHeight(self.pos) or self.pos.z))
end

function C:helperRotationToCamera()
  self:set(nil , core_camera.getQuat())
end

  local fwd = (self.rot * vec3(0,1,0)):projectToOriginPlane(terrainNormal)
  self:set(nil, quatFromDir(fwd, terrainNormal))
end

function C:helperRotateWithCamera()
  self:set(nil, core_camera.getQuat())
end

  editor.clearObjectSelection()
  self:set()
end

        this._markerElementMap.set(marker, markerElement);

function C:set(itemPath, value)
  local str = split(itemPath, ".")

            -- set the value again, if set by user or default
            self:set(path, val.value)
          else

          local item = self:findItem(path)
          self:set(path, self:itemValueFromString(item, itemValue.value))
        end

      for _, item in pairs(subCat.items) do
        self:set(item.path, deepcopy(item.defaultValue))
      end

  local item = self:findItem(itemPath)
  self:set(item.path, deepcopy(item.defaultValue))
  return true

    for (let tabClass of productionTabClasses)
        WI._knownTabClassesByType.set(tabClass.Type, tabClass);

                WI._overridenDeviceSettings.set(setting, value);
                callback(true);

    {
        this._resourceDataMap.set(resource, {});
    }

    if veh then
      self.centerPos:set(veh:getSpawnWorldOOBB():getCenter())
    end

  self.offset:set(math.sin(aRad), math.cos(aRad), 0)

  self.camPos:set(self.centerPos)
  self.camPos:setAdd(self.offset * radius)

      local pos = obj:getNodePosition(i)
      tempVec:set(pos)
      tempVec:setAdd(bigOffset)

        local node = v.data.nodes[i]
        tempVec2:set(obj:getNodePositionRelativeXYZ(node.cid))
        tempVec2:setAdd(initRefNodePos)

    initRenderNodeTexts(partsSelected, showWheels)
    tempVec:set(obj:getPositionXYZ())
    for groupID, entries in pairs(groupIDToEntries) do

      end
      beamPositions[i]:set(tempVec)
      tempVec:setSub(vehPos)

  elseif modeID == 12 then
    tempVec:set(0,0,0)
    local j = 0

  elseif modeID == 13 then
    tempVec:set(0,0,0)
    local j = 0

        local oobb = veh:getSpawnWorldOOBB()
        self.zOffset:set(veh:getDirectionVectorUp() * oobb:getHalfExtents().z) -- vertical midpoint of vehicle
        for i, v in ipairs(self.bbPoints) do

        for i, v in ipairs(self.bbPoints) do
          self.points[i]:set(oobb:getPoint(v) + self.zOffset)
        end

        end
        self.points[1]:set(veh:getPosition())
      end

  self.userFov = 0 -- fov delta chosen by the user (numpad 9/3), for greater/smaller zoom
  self.fovSmoother:set(self.baseFov)
  self.steps = { -- the format is {meters of distance, fov angle}

    self.mustReset = false
    self.fovSmoother:set(newFov)
    return newFov

      simTimeBefore = simTimeAuthority.get()
      simTimeAuthority.set(slowMoFactor)
    end

  if simTimeBefore then
    simTimeAuthority.set(simTimeBefore)
  end

  guihooks.trigger('RadialTemporaryHide', true)
  simTimeAuthority.set(1)
  core_sounds.setAudioBlur(0)

  guihooks.trigger('RadialTemporaryHide', false)
  simTimeAuthority.set(slowMoFactor)
  core_sounds.setAudioBlur(1)

        this._cachedTargetsList = null;
        this._targets.set(target.identifier, target);

        // Add the target without dispatching an event.
        this._targets.set(target.identifier, target);
    }

  local pn = pathData.pathnodes:create()
  pn.pos:set(cpPos)
  pn.radius = cpRadius

        vecA:set(pn.pos)
        vecA.z = vecA.z + pn.radius + 0.25

        vecA.z = vecA.z + pn.radius + 0.25
        vecB:set(vecA)
        vecB.z = vecB.z + 1000

        if pn.normal then
          vecA:set(pn.pos)
          vecB:setScaled2(pn.normal, pn.radius)

  eulerYXZ.y = -eulerYXZ.y
  self.rot:set(eulerYXZ)
end

  local dtFactor = data.dt * 200
  inputVec:set(
    MoveManager.yawRelative / dtFactor + (MoveManager.yawRight - MoveManager.yawLeft) * 0.07,

  if self.newtonRotation then
    acc:set(0,0,0)
    if inputVec:squaredLength() > 0 then

    forceVec:setScaled2(acc, data.dt) -- Acceleration
    forceVec:set(push3(forceVec) - push3(self.angularVelocity) * math.min(self.angularDrag * data.dt, 1)) -- Drag
    self.angularVelocity:setAdd(forceVec)

  self.rot:set(push3(self.rot) + push3(self.angularVelocity) * data.dt) -- Rotate
  self.rot.y = clamp(self.rot.y, -1.5706, 1.5706)

  qdir:set(0,0,0,1)
  setRotateEuler(self.rot.x, -self.rot.y, 0, qdir, qdirLook)

  -- Translation
  acc:set(0,0,0)
  inputVec:set(

  acc:set(0,0,0)
  inputVec:set(
    MoveManager.right - MoveManager.left + MoveManager.absXAxis,

    forceVec:setScaled2(acc, data.dt) -- Acceleration
    forceVec:set(push3(forceVec) - push3(self.velocity) * math.min(self.translationDrag * data.dt, 1)) -- Drag
    self.velocity:setAdd(forceVec)

  tempVec:setRotate(qdir, self.velocity)
  self.pos:set(push3(self.pos) + push3(tempVec) * data.dt) -- Move

  data.res.rot = qdir
  data.res.pos:set(self.pos)

 *
 * The missing pieces here are that we do not have a transition set (within the CSS code nor within the `$animateCss` options) and the duration of the animation is
 * going to be detected from what the keyframe styles on the CSS class are. In this event, `$animateCss` will automatically create an inline transition

      local sp = data.self.path.startPositions:create(nil, data.spid or nil)
      sp:set(data.pos, quatFromDir(data.normal):normalized())
      sp.name = node.name .. " Recovery " .. (reverse and "Reverse" or "Forward")

  fwd:set((b - a):normalized())
  for i = 0, self.pinIn.amount.value or defaultAmount do

    data.texture = self.pinIn.decalPath.value or defaultDecalPath
    data.scale:set(unpack(self.pinIn.decalScale.value or defaultDecalScale))

    local level = segment[1]
    p1:set(segment[2], segment[3], 0)
    p2:set(segment[4], segment[5], 0)

    p1:set(segment[2], segment[3], 0)
    p2:set(segment[4], segment[5], 0)
    worldToMapXYZ(p1, p1)

        this._items.set(id, {label, value, color, checkbox, checked});
        this._total += value;

local function init(jbeamData)
  avgConsumptionSmoother:set(avgConsumptionDefaultValue)
end

  -- Compute the closest points on the segments.
  outP1:set(a0X + s * ux, a0Y + s * uy, a0Z + s * uz)
  outP2:set(b0X + t * vx, b0Y + t * vy, b0Z + t * vz)

  outP1:set(a0X + s * ux, a0Y + s * uy, a0Z + s * uz)
  outP2:set(b0X + t * vx, b0Y + t * vy, b0Z + t * vz)

  -- Project the mouse position onto the {z = 0} plane.
  mousePos2D:set(mousePos.x, mousePos.y, 0.0)

    local p0, p1 = points[j], points[j + 1]
    tmp1:set(p0.x, p0.y, 0.0)
    tmp2:set(p1.x, p1.y, 0.0)

    tmp1:set(p0.x, p0.y, 0.0)
    tmp2:set(p1.x, p1.y, 0.0)
    if mousePos2D:squaredDistanceToLineSegment(tmp1, tmp2) < intermediateTolSq then

  local dzdy = (tb:getHeightGrid(gx, gy + 1) - tb:getHeightGrid(gx, gy - 1)) * 0.5
  out:set(-dzdx, -dzdy, 1)
  out:normalize()

  local cosA, sinA = cos(angle), sin(angle)
  vec:set(vX * cosA - vY * sinA, vX * sinA + vY * cosA, v.z)
end

  tmp0:setAdd(tmp1)
  tmp2:set(v.x * c, v.y * c, v.z * c)
  tmp0:setAdd(tmp2)

  local abLen, bcLen = ab:length(), bc:length()
  abNorm:set(ab)
  abNorm:normalize()

  abNorm:normalize()
  bcNorm:set(bc)
  bcNorm:normalize()

    local p1X, p1Y = p1.x, p1.y
    out:set(p1X + xnorm * (p2.x - p1X), p1Y + xnorm * (p2.y - p1Y), 0)
    return out

local function angleBetweenVecs(a, b)
  tmp0:set(a)
  tmp0:normalize()

  tmp0:normalize()
  tmp1:set(b)
  tmp1:normalize()

local function angleBetweenVecs2D(a, b)
  tmp0:set(a.x, a.y, 0)
  tmp0:normalize()

  tmp0:normalize()
  tmp1:set(b.x, b.y, 0)
  tmp1:normalize()

    local p1, p2 = divPoints[iMinusOne], divPoints[i]
    tmpTangent:set(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z)
    local segLen = tmpTangent:length()

    local p1, p2 = divPoints[iMinusOne], divPoints[i]
    tmpTangent:set(p2.x - p1.x, p2.y - p1.y, p2.z - p1.z)
    local segLen = tmpTangent:length()

local function computeRandomJitterQuat(spline, tgt, rightVec, nmlVec, outQuat)
  outQuat:set(0, 0, 0, 1) -- Initialize to identity quaternion.
  local jitterForward, jitterRight, jitterUp = spline.jitterForward, spline.jitterRight, spline.jitterUp

local function computeRandomJitterQuatFromFreedomAxes(spline, freedomAxes, outQuat)
  outQuat:set(0, 0, 0, 1) -- Initialize to identity.
  local jitterAmount = (spline.jitterForward + spline.jitterRight + spline.jitterUp) / 3.0

    local bin, halfWidth = binormals[divIdx], widths[i] * 0.5
    tmp0:set(bin.x * halfWidth, bin.y * halfWidth, bin.z * halfWidth)
    local node = nodes[i]

    util.vertRaycast(nodes[i])
    tmp1:set(nodes[i].x, nodes[i].y, nodes[i].z + vals[i] * barScale)
    barPoints[i] = barPoints[i] or vec3()

    barPoints[i] = barPoints[i] or vec3()
    barPoints[i]:set(tmp1)
  end

    util.vertRaycast(node)
    tmp1:set(node.x, node.y, node.z + vals[i] * barScale)
    barPoints[i] = barPoints[i] or vec3()

    barPoints[i] = barPoints[i] or vec3()
    barPoints[i]:set(tmp1)
  end

      local x1, x2 = intersections[i], intersections[i + 1]
      tmp1:set(x1, yWorld, 0)
      te:worldToGridByPoint2I(tmp1, tmpPoint2I, tb)

      local xStart = tmpPoint2I.x
      tmp1:set(x2, yWorld, 0)
      te:worldToGridByPoint2I(tmp1, tmpPoint2I, tb)

  local p3X, p3Y, p3Z = p3.x, p3.y, p3.z
  outVec:set(
    (p1X - p0X) * m1c_d1 + (p0X - p2X) * m1c_d1d2 + (p1X - p3X) * m2c_d2d3 + (p3X - p2X) * m2c_d3 + t_1sq_2t1 * p1X + c21_tt_2t3 * p2X,

  local camPos = core_camera.getPosition()
  pLast:set(huge, huge, huge)
  local points = spline.nodes

    for k = 0, defaultMinNumDivisions do
      pThis:set(catmullRomCentripetalFast(p0, p1, p2, p3, k * splineGranInv, 0.5))
      if squaredSegSegDist(pThis, pLast, camPos, mousePos, tmp1, tmp2) < intermediateTolSq then

      end
      pLast:set(pThis)
    end

      tmp1:normalize()
      binormals[i]:set(tmp1)
      tmp2:setCross(binormals[i], tangents[i])

      tmp2:normalize()
      normals[i]:set(tmp2)
    end

      tmp1:normalize()
      binormals[i]:set(tmp1)
      tmp2:setCross(binormals[i], tangents[i])

      tmp2:normalize()
      normals[i]:set(tmp2)
    end

    local w0, w1, w2, w3 = widths[i1], widths[i2], widths[i3], widths[i4]
    tmp0:set(p0.x, p0.y, w0)
    tmp1:set(p1.x, p1.y, w1)

    tmp0:set(p0.x, p0.y, w0)
    tmp1:set(p1.x, p1.y, w1)
    tmp2:set(p2.x, p2.y, w2)

    tmp1:set(p1.x, p1.y, w1)
    tmp2:set(p2.x, p2.y, w2)
    tmp3:set(p3.x, p3.y, w3)

    tmp2:set(p2.x, p2.y, w2)
    tmp3:set(p3.x, p3.y, w3)
    local segmentLength = p1:distance(p2)

    local w0, w1, w2, w3 = widths[i1], widths[i2], widths[i3], widths[i4]
    tmp0:set(p0.x, p0.y, w0)
    tmp1:set(p1.x, p1.y, w1)

    tmp0:set(p0.x, p0.y, w0)
    tmp1:set(p1.x, p1.y, w1)
    tmp2:set(p2.x, p2.y, w2)

    tmp1:set(p1.x, p1.y, w1)
    tmp2:set(p2.x, p2.y, w2)
    tmp3:set(p3.x, p3.y, w3)

    tmp2:set(p2.x, p2.y, w2)
    tmp3:set(p3.x, p3.y, w3)
    local numDivisions = max(minNumDivisionsFinal, floor(p1:distance(p2) / maxDivisionSpacing + 0.5))

  tmp2:setSub2(p1, p2)
  tmpTangent:set(tmp2)
  tmpTangent:normalize()

      spline.divPoints[ctr] = spline.divPoints[ctr] or vec3()
      spline.divPoints[ctr]:set(nodePos)

      spline.normals[ctr] = spline.normals[ctr] or vec3(0, 0, 1)
      spline.normals[ctr]:set(map.surfaceNormal(nodePos, 1.0))

  view.control.renderView.resolution = Point2I(availSize.x, availSize.y)
  tmpRect:set(0, 0, availSize.x, availSize.y)
  view.control.renderView.viewPort = tmpRect

    local a, b, c, d = vec3(), vec3(), vec3(), vec3()
    a:set(v.pos) a.z = a.z+self.fenceDown
    b:set(v.pos) b.z = b.z+self.fenceHeight

    a:set(v.pos) a.z = a.z+self.fenceDown
    b:set(v.pos) b.z = b.z+self.fenceHeight
    c:set(self.vertices[v.next].pos) c.z = c.z+self.fenceHeight

    b:set(v.pos) b.z = b.z+self.fenceHeight
    c:set(self.vertices[v.next].pos) c.z = c.z+self.fenceHeight
    d:set(self.vertices[v.next].pos) d.z = d.z+self.fenceDown

    c:set(self.vertices[v.next].pos) c.z = c.z+self.fenceHeight
    d:set(self.vertices[v.next].pos) d.z = d.z+self.fenceDown
    if self.usePlanes then

    a:set(from) a.z = a.z+down
    b:set(from) b.z = b.z+up

    a:set(from) a.z = a.z+down
    b:set(from) b.z = b.z+up
    c:set(to) c.z = c.z+up

    b:set(from) b.z = b.z+up
    c:set(to) c.z = c.z+up
    d:set(to) d.z = d.z+down

    c:set(to) c.z = c.z+up
    d:set(to) d.z = d.z+down
    if usePlanes then

    local rot = {self.pinIn.x.value or 0, self.pinIn.y.value or 0, self.pinIn.z.value or 0, self.pinIn.w.value or 0}
    quatOut:set(rot[1], rot[2], rot[3], rot[4])
    self.pinOut.value.value = {quatOut.x, quatOut.y, quatOut.z, quatOut.w}

      proxy.wp = nil
      proxy.nudgeForwardSmoother:set(0)
      proxy.nudgeForwardSmootherTarget = 0

      proxy.nudgeForwardSmootherTarget = 0
      proxy.nearFarScaleSmoother:set(0)
      proxy.nearFarScaleSmootherTarget = 0

      proxy.nearFarScaleSmootherTarget = 0
      proxy.alphaSmoother:set(0)
      proxy.alphaSmootherTarget = 0

              setSmootherTargets(id, distToVehicle)
              arrowProxies[id].nudgeForwardSmoother:set(arrowProxies[id].nudgeForwardSmootherTarget)
              arrowProxies[id].nearFarScaleSmoother:set(arrowProxies[id].nearFarScaleSmootherTarget)

              arrowProxies[id].nudgeForwardSmoother:set(arrowProxies[id].nudgeForwardSmootherTarget)
              arrowProxies[id].nearFarScaleSmoother:set(arrowProxies[id].nearFarScaleSmootherTarget)
              arrowProxies[id].alphaSmoother:set(0)

              arrowProxies[id].nearFarScaleSmoother:set(arrowProxies[id].nearFarScaleSmootherTarget)
              arrowProxies[id].alphaSmoother:set(0)
            else

    if arrow then
      actualPos:set(proxy.pos.x, proxy.pos.y, proxy.pos.z)
      fwd:setRotate(proxy.rot, yVec)

      local scaleVal = proxy.nearFarScaleSmoother:get(proxy.nearFarScaleSmootherTarget, dt) * alphaValue
      scale:set(scaleVal, scaleVal, scaleVal)
      arrow:setScale(scale)

  rgbaBuffer:reset()
  rgbaBuffer:set(data, ffi.sizeof(data))
  if not bitmap:fromBuffer(rgbaBuffer) then

        let recordingTreeElement = new WI.GeneralTreeElement(WI.TimelineTabContentView.StopwatchIconStyleClass, recording.displayName, null, recording);
        this._recordingTreeElementMap.set(recording, recordingTreeElement);
        this._recordingsTreeOutline.appendChild(recordingTreeElement);

  if iconInfo and not isInArea then
    tmpVec:set(iconInfo.worldPosition)
    tmpVec:setSub(data.camPos)

      tmpVec:set(0,0,iconHeight)
      tmpVec:setAdd(self.pos)

      -- Set position
      tmpVec:set(0,0,iconHeight)
      tmpVec:setAdd(self.pos)

    self.iconDataById = {}
    tmpVec:set(0,0,iconHeightBottom)
    tmpVec:setAdd(self.pos)

  -- setting up the smoothers
  self.decalAlphaSmoother:set(0)
  self.ringAlphaSmoother:set(0)

  self.decalAlphaSmoother:set(0)
  self.ringAlphaSmoother:set(0)
  self.iconAlphaSmoother:set(0)

  self.ringAlphaSmoother:set(0)
  self.iconAlphaSmoother:set(0)
  self.iconPositionSmoother:set(iconHeightBottom)

  self.iconAlphaSmoother:set(0)
  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(1)

  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(1)
  self.bigMapSmoother:set(0)

  self.cruisingSmoother:set(1)
  self.bigMapSmoother:set(0)

function C:drawOnMinimap(td, dpi)
  a:set(self.pos)
  ui_apps_minimap_utils.worldToMapXYZ(a, a)

  a.y = a.y + offsetForTriangle[1].y*radius*dpi
  b:set(self.pos)
  ui_apps_minimap_utils.worldToMapXYZ(b, b)

  b.y = b.y + offsetForTriangle[2].y*radius*dpi
  c:set(self.pos)
  ui_apps_minimap_utils.worldToMapXYZ(c, c)

  local pos = self:getPosition()
  posCache:set(pos)
  self.lastRecalculateVehiclePos = posCache

  log('D', logTag,"-setter tests")
  obj:set('shadowDistance', 123)
  obj.shadowDistance = 123

  elem.transform:setOneDimensionalScale(elem.oneDimScale)
  elem.transform:set(elem.defaultPos, elem.defaultRot, elem.defaultScl)
  elem.fieldNamePos = elem.fieldName .. 'Pos'

local function boolSetContainer(e, ctd) if ctd[e.fieldName] == nil then e.ptr[0] = e.defaultValue else e.ptr[0] = ctd[e.fieldName] end end
local function transformSetContainer(e, ctd) e.transform:set(vec3(ctd[e.fieldNamePos] or e.defaultPos), quat(ctd[e.fieldNameRot] or e.defaultRot), e.oneDimScale and (ctd[e.fieldNameScl] or e.defaultScl) or (vec3(ctd[e.fieldNameScl] or e.defaultScl))) end
local function modelConfigSetContainer(e, ctd) e.mc.model = ctd[e.fieldNameModel] or e.defaultModel e.mc.config = ctd[e.fieldNameConfig] or e.defaultConfig e.mc.configPath = ctd[e.fieldNameConfigPath] or e.defaultConfigPath ui_flowgraph_editor.vehicleSelectorRefresh(e.mc) end

local function leaderboardSetContainer(e, ctd) e.best[0] = ctd[e.fieldNameBest] or e.defaultBest e.medium[0] = ctd[e.fieldNameMedium] or e.defaultMedium e.worst[0] = ctd[e.fieldNameWorst] or e.defaultWorst e.count[0] = ctd[e.fieldNameCount] or e.defaultCount end
local function simpleLapConfigSetContainer(e, ctd) e.lapConfig:set(ctd[e.fieldName] or deepcopy(e.defaultPos)) end
local function elementIdSetContainer(e, ctd) e.value = ctd.value or e.defaultValue end

  if editor.uiIconImageButton(editor.icons.undo, imVec24x24) then
    e.transform:set(vec3(e.defaultPos), quat(e.defaultRot), e.oneDimScale and (e.defaultScl) or (vec3(e.defaultScl)))
    ctd[e.fieldNamePos] = e.hasPos and (e.transform.pos:toTable())

    if self.pinIn.pos.value then
      pos:set(self.pinIn.pos.value)
    else

    else
      pos:set(core_camera.getPositionXYZ())
    end

  -- Calculate the plane normal (y-axis since plane is drawn in x-z)
  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)

  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)
  tmpPlaneNormal:normalize()

  -- Calculate closest point on plane
  tmpClosestPoint:set(tmpPlaneNormal)
  tmpClosestPoint:setScaled(-signedDistance)

        let node = new WI.LayerTreeDataGridNode(layer);
        this._dataGridNodesByLayerId.set(layer.layerId, node);

        this._resourceRecordMap.set(record.resource, record);

function C:set(id, field, val) self.variables:change(id..field, val) self.buttonsChanged = true end

local function set(data, startCmd)
  if not data then return end

end
function C:set(name, value)
  if not self.values[name] then

    end
    lastPos:set(pos)

        local sy1, sy2 = floor(yy), ceil(yy)
        tmp0:set(sx1, sy1, 0)
        tmp1:set(sx1, sy1, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx1, sy1, 0)
        tmp1:set(sx1, sy1, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

        tmp0:set(sx1, sy2, 0)
        tmp1:set(sx1, sy2, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx1, sy2, 0)
        tmp1:set(sx1, sy2, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

        tmp0:set(sx2, sy1, 0)
        tmp1:set(sx2, sy1, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx2, sy1, 0)
        tmp1:set(sx2, sy1, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

        tmp0:set(sx2, sy2, 0)
        tmp1:set(sx2, sy2, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx2, sy2, 0)
        tmp1:set(sx2, sy2, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

        if self.pinIn[p .. '_' ..i].value ~= nil then
          self.mgr.modules.button:set(id, p, self.pinIn[p .. '_' ..i].value)
        end

  simTimeAuthority.set(1) -- make sure bullettime is reset
  inputActionFilter.clear(0) -- revert filtered bindings

  --reset bullet time
  simTimeAuthority.set(1)

  extensions.hook('onEndScenario', countDownTime)
  if simTimeAuthority.get() > 1/8 then simTimeAuthority.set(1/8) end -- use slowmotion during end screen
end

    scenario.endScreenController = function()
      if simTimeAuthority.get() > 1/8 then simTimeAuthority.set(1/8) end -- use slowmotion during end screen
      -- This must be the last thing triggered, allows all other systems to process scenario state POST

    scenario.endScreenController = function()
      if simTimeAuthority.get() > 1/8 then simTimeAuthority.set(1/8) end -- use slowmotion during end screen
      -- This must be the last thing triggered, allows all other systems to process scenario state POST

    racer._wheelDistances[k] = racer._wheelDistances[k] or vec3()
    racer._wheelDistances[k]:set(wheel.pos)
    racer._wheelDistances[k]:setSub(stagePos)

  racer.vehPos:set(racer.vehObj:getPositionXYZ())
  racer.vehDirectionVector:set(racer.vehObj:getDirectionVectorXYZ())

  racer.vehPos:set(racer.vehObj:getPositionXYZ())
  racer.vehDirectionVector:set(racer.vehObj:getDirectionVectorXYZ())
  racer.vehDirectionVectorUp:set(racer.vehObj:getDirectionVectorUpXYZ())

  racer.vehDirectionVector:set(racer.vehObj:getDirectionVectorXYZ())
  racer.vehDirectionVectorUp:set(racer.vehObj:getDirectionVectorUpXYZ())
  racer.vehRot = quatFromDir(racer.vehDirectionVector, racer.vehDirectionVectorUp)

  racer.vehVelocity:set(racer.vehObj:getVelocityXYZ())
  racer.prevSpeed = racer.vehSpeed or 0

    end
    racer.wheelsCenter[k].pos:set(0, 0, 0)
    for _, wheel in ipairs(offset) do

    if vehInfo.loanType == "work" then
      vehPos:set(be:getObjectPositionXYZ(vehId))
      playerPos:set(be:getObjectPositionXYZ(be:getPlayerVehicleID(0)))

      vehPos:set(be:getObjectPositionXYZ(vehId))
      playerPos:set(be:getObjectPositionXYZ(be:getPlayerVehicleID(0)))

    local vehId = career_modules_inventory.getMapInventoryIdToVehId()[inventoryId]
    vehPos:set(be:getObjectPositionXYZ(vehId))
    playerPos:set(be:getObjectPositionXYZ(be:getPlayerVehicleID(0)))

    vehPos:set(be:getObjectPositionXYZ(vehId))
    playerPos:set(be:getObjectPositionXYZ(be:getPlayerVehicleID(0)))

    for i, object in ipairs(editor.selection.forestItem) do
      rotMtx:set(deltaEulerRotation, centerPoint)
      local objTrans = copyMat(originalTransforms[i])

  local oneWayTorque = device.oneWayTorqueSmoother:get(clamp(device.oneWayViscousCoef * device.outputAV1, -device.oneWayViscousTorque, device.oneWayViscousTorque))
  device.oneWayTorqueSmoother:set(device.outputAV1 * reverseGearRatioCoef < 0 and oneWayTorque or 0)
  oneWayTorque = device.oneWayTorqueSmoother:value() * reverseGearRatioCoef

        const wrappedHandler = interceptor.wrapHandler(handler, handlerId)
        wrappedHandlers.set(handler, wrappedHandler)
        if (interceptor.coordinator.debug) console.log(`Intercepted Vue stream listener: ${handlerId} (tracked: ${interceptor.trackedVueListeners})`)

          const wrappedHandler = interceptor.wrapHandler(handler, handlerId)
          interceptor.wrappedHandlers.set(handler, wrappedHandler)
          interceptor.coordinator.uiApps?.triggerRetroactiveSetup()

      // Store the UI app association for this listener
      this.coordinator.listenerUIApps.set(handlerId, uiApp)
      if (this.coordinator.debug) console.log(`Registered listener ${handlerId} from UI app "${uiApp.name}"`)

  meshRot.x, meshRot.y, meshRot.z, meshRot.w = rot.x, rot.y, rot.z, rot.w
  meshXAxis:set(1, 0, 0)
  meshXAxis:setRotate(meshRot, meshXAxis)

    splines[dragSplineIdx].isDirty = true
    lastDragMousePos:set(mousePos) -- Update last position for next frame.
  end

  local mouseRawY = im.GetMousePos().y
  mouseVel2D:set(mousePos.x - mouseLast.x, mousePos.y - mouseLast.y, 0.0)
  local isShiftDown, isAltDown, isCtrlDown = im.IsKeyDown(shiftKeyIdx), im.IsKeyDown(altKeyIdx), im.IsKeyDown(ctrlKeyIdx)

  local mousePos = util.mouseOnMapPos() -- The current mouse position on the map (3D).
  mouseVel2D:set(mousePos.x - mouseLast.x, mousePos.y - mouseLast.y, 0.0) -- The 2D mouse velocity (XY).
  if mouseVel2D:squaredLength() > isMouseMoveTolSq then

A100:"#82b1ff",A200:"#448aff",A400:"#2979ff",A700:"#2962ff",contrastDefaultColor:"light",contrastDarkColors:"100 200 300 400 A100",contrastStrongLightColors:"500 600 700 A200 A400 A700"},"light-blue":{50:"#e1f5fe",100:"#b3e5fc",200:"#81d4fa",300:"#4fc3f7",400:"#29b6f6",500:"#03a9f4",600:"#039be5",700:"#0288d1",800:"#0277bd",900:"#01579b",A100:"#80d8ff",A200:"#40c4ff",A400:"#00b0ff",A700:"#0091ea",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900 A700",contrastStrongLightColors:"500 600 700 800 A700"},cyan:{50:"#e0f7fa",100:"#b2ebf2",200:"#80deea",300:"#4dd0e1",400:"#26c6da",500:"#00bcd4",600:"#00acc1",700:"#0097a7",800:"#00838f",900:"#006064",A100:"#84ffff",A200:"#18ffff",A400:"#00e5ff",A700:"#00b8d4",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900",contrastStrongLightColors:"500 600 700 800"},teal:{50:"#e0f2f1",100:"#b2dfdb",200:"#80cbc4",300:"#4db6ac",400:"#26a69a",500:"#009688",600:"#00897b",700:"#00796b",800:"#00695c",900:"#004d40",A100:"#a7ffeb",A200:"#64ffda",A400:"#1de9b6",A700:"#00bfa5",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900",contrastStrongLightColors:"500 600 700"},green:{50:"#e8f5e9",100:"#c8e6c9",200:"#a5d6a7",300:"#81c784",400:"#66bb6a",500:"#4caf50",600:"#43a047",700:"#388e3c",800:"#2e7d32",900:"#1b5e20",A100:"#b9f6ca",A200:"#69f0ae",A400:"#00e676",A700:"#00c853",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900",contrastStrongLightColors:"500 600 700"},"light-green":{50:"#f1f8e9",100:"#dcedc8",200:"#c5e1a5",300:"#aed581",400:"#9ccc65",500:"#8bc34a",600:"#7cb342",700:"#689f38",800:"#558b2f",900:"#33691e",A100:"#ccff90",A200:"#b2ff59",A400:"#76ff03",A700:"#64dd17",contrastDefaultColor:"dark",contrastLightColors:"800 900",contrastStrongLightColors:"800 900"},lime:{50:"#f9fbe7",100:"#f0f4c3",200:"#e6ee9c",300:"#dce775",400:"#d4e157",500:"#cddc39",600:"#c0ca33",700:"#afb42b",800:"#9e9d24",900:"#827717",A100:"#f4ff81",A200:"#eeff41",A400:"#c6ff00",A700:"#aeea00",contrastDefaultColor:"dark",contrastLightColors:"900",contrastStrongLightColors:"900"},yellow:{50:"#fffde7",100:"#fff9c4",200:"#fff59d",300:"#fff176",400:"#ffee58",500:"#ffeb3b",600:"#fdd835",700:"#fbc02d",800:"#f9a825",900:"#f57f17",A100:"#ffff8d",A200:"#ffff00",A400:"#ffea00",A700:"#ffd600",contrastDefaultColor:"dark"},amber:{50:"#fff8e1",100:"#ffecb3",200:"#ffe082",300:"#ffd54f",400:"#ffca28",500:"#ffc107",600:"#ffb300",700:"#ffa000",800:"#ff8f00",900:"#ff6f00",A100:"#ffe57f",A200:"#ffd740",A400:"#ffc400",A700:"#ffab00",contrastDefaultColor:"dark"},orange:{50:"#fff3e0",100:"#ffe0b2",200:"#ffcc80",300:"#ffb74d",400:"#ffa726",500:"#ff9800",600:"#fb8c00",700:"#f57c00",800:"#ef6c00",900:"#e65100",A100:"#ffd180",A200:"#ffab40",A400:"#ff9100",A700:"#ff6d00",contrastDefaultColor:"dark",contrastLightColors:"800 900",contrastStrongLightColors:"800 900"},"deep-orange":{50:"#fbe9e7",100:"#ffccbc",200:"#ffab91",300:"#ff8a65",400:"#ff7043",500:"#ff5722",600:"#f4511e",700:"#e64a19",800:"#d84315",900:"#bf360c",A100:"#ff9e80",A200:"#ff6e40",A400:"#ff3d00",A700:"#dd2c00",contrastDefaultColor:"light",contrastDarkColors:"50 100 200 300 400 A100 A200",contrastStrongLightColors:"500 600 700 800 900 A400 A700"},brown:{50:"#efebe9",100:"#d7ccc8",200:"#bcaaa4",300:"#a1887f",400:"#8d6e63",500:"#795548",600:"#6d4c41",700:"#5d4037",800:"#4e342e",900:"#3e2723",A100:"#d7ccc8",A200:"#bcaaa4",A400:"#8d6e63",A700:"#5d4037",contrastDefaultColor:"light",contrastDarkColors:"50 100 200",contrastStrongLightColors:"300 400"},grey:{50:"#fafafa",100:"#f5f5f5",200:"#eeeeee",300:"#e0e0e0",400:"#bdbdbd",500:"#9e9e9e",600:"#757575",700:"#616161",800:"#424242",900:"#212121",1000:"#000000",A100:"#ffffff",A200:"#eeeeee",A400:"#bdbdbd",A700:"#616161",contrastDefaultColor:"dark",contrastLightColors:"600 700 800 900"},"blue-grey":{50:"#eceff1",100:"#cfd8dc",200:"#b0bec5",300:"#90a4ae",400:"#78909c",500:"#607d8b",600:"#546e7a",700:"#455a64",800:"#37474f",900:"#263238",A100:"#cfd8dc",A200:"#b0bec5",A400:"#78909c",A700:"#455a64",contrastDefaultColor:"light",contrastDarkColors:"50 100 200 300",contrastStrongLightColors:"400 500"}})}(),function(){function e(e){function o(e,t){return t=t||{},m[e]=a(e,t),g}function r(e,n){return a(e,t.extend({},m[e]||{},n))}function a(e,t){var n=C.filter(function(e){return!t[e]});if(n.length)throw new Error("Missing colors %1 in palette %2!".replace("%1",n.join(", ")).replace("%2",e));return t}function d(e,n){if(s[e])return s[e];n=n||"default";var o="string"==typeof n?s[n]:n,r=new c(e);return o&&t.forEach(o.colors,function(e,n){r.colors[n]={name:e.name,hues:t.extend({},e.hues)}}),s[e]=r,r}function c(e){function n(e){if(e=0===arguments.length?!0:!!e,e!==o.isDark){o.isDark=e,o.foregroundPalette=o.isDark?f:p,o.foregroundShadow=o.isDark?h:b;var n=o.isDark?T:A,r=o.isDark?A:T;return t.forEach(n,function(e,t){var n=o.colors[t],i=r[t];if(n)for(var a in n.hues)n.hues[a]===i[a]&&(n.hues[a]=e[a])}),o}}var o=this;o.name=e,o.colors={},o.dark=n,n(!1),M.forEach(function(e){var n=(o.isDark?T:A)[e];o[e+"Palette"]=function(r,i){var a=o.colors[e]={name:r,hues:t.extend({},n,i)};return Object.keys(a.hues).forEach(function(e){if(!n[e])throw new Error("Invalid hue name '%1' in theme %2's %3 color %4. Available hue names: %4".replace("%1",e).replace("%2",o.name).replace("%3",r).replace("%4",Object.keys(n).join(", ")))}),Object.keys(a.hues).map(function(e){return a.hues[e]}).forEach(function(t){if(-1==C.indexOf(t))throw new Error("Invalid hue value '%1' in theme %2's %3 color %4. Available hue values: %5".replace("%1",t).replace("%2",o.name).replace("%3",e).replace("%4",r).replace("%5",C.join(", ")))}),o},o[e+"Color"]=function(){var t=Array.prototype.slice.call(arguments);return console.warn("$mdThemingProviderTheme."+e+"Color() has been deprecated. Use $mdThemingProviderTheme."+e+"Palette() instead."),o[e+"Palette"].apply(o,t)}})}function u(e,o){function r(e){return e===n||""===e?!0:i.THEMES[e]!==n}function i(t,o){o===n&&(o=t,t=n),t===n&&(t=e),i.inherit(o,o)}return i.inherit=function(n,i){function a(e){r(e)||o.warn("Attempted to use unregistered theme '"+e+"'. Register it with $mdThemingProvider.theme().");var t=n.data("$mdThemeName");t&&n.removeClass("md-"+t+"-theme"),n.addClass("md-"+e+"-theme"),n.data("$mdThemeName",e),d&&n.data("$mdThemeController",d)}var d=i.controller("mdTheme"),c=n.attr("md-theme-watch");if((v||t.isDefined(c))&&"false"!=c){var l=e.$watch(function(){return d&&d.$mdTheme||E},a);n.on("$destroy",l)}else{var m=d&&d.$mdTheme||E;a(m)}},i.THEMES=t.extend({},s),i.defaultTheme=function(){return E},i.registered=r,i}m={},s={};var g,E="default",v=!1;return t.extend(m,e),u.$inject=["$rootScope","$log"],g={definePalette:o,extendPalette:r,theme:d,setDefaultTheme:function(e){E=e},alwaysWatchTheme:function(e){v=e},$get:u,_LIGHT_DEFAULT_HUES:A,_DARK_DEFAULT_HUES:T,_PALETTES:m,_THEMES:s,_parseRules:i,_rgba:l}}function o(e,t,n){return{priority:100,link:{pre:function(o,r,i){var a={$setTheme:function(t){e.registered(t)||n.warn("attempted to use unregistered theme '"+t+"'"),a.$mdTheme=t}};r.data("$mdThemeController",a),a.$setTheme(t(i.mdTheme)(o)),i.$observe("mdTheme",a.$setTheme)}}}}function r(e){return e}function i(e,n,o){d(e,n),o=o.replace(/THEME_NAME/g,e.name);var r=[],i=e.colors[n],a=new RegExp(".md-"+e.name+"-theme","g"),c=new RegExp("('|\")?{{\\s*("+n+")-(color|contrast)-?(\\d\\.?\\d*)?\\s*}}(\"|')?","g"),s=/'?"?\{\{\s*([a-zA-Z]+)-(A?\d+|hue\-[0-3]|shadow)-?(\d\.?\d*)?\s*\}\}'?"?/g,u=m[i.name];return o=o.replace(s,function(t,n,o,r){return"foreground"===n?"shadow"==o?e.foregroundShadow:e.foregroundPalette[o]||e.foregroundPalette[1]:(0===o.indexOf("hue")&&(o=e.colors[n].hues[o]),l((m[e.colors[n].name][o]||"").value,r))}),t.forEach(i.hues,function(t,n){var i=o.replace(c,function(e,n,o,r,i){return l(u[t]["color"===r?"value":"contrast"],i)});"default"!==n&&(i=i.replace(a,".md-"+e.name+"-theme.md-"+n)),"default"==e.name&&(i=i.replace(/\.md-default-theme/g,"")),r.push(i)}),r}function a(e){function n(e){var n=e.contrastDefaultColor,o=e.contrastLightColors||[],r=e.contrastStrongLightColors||[],i=e.contrastDarkColors||[];"string"==typeof o&&(o=o.split(" ")),"string"==typeof r&&(r=r.split(" ")),"string"==typeof i&&(i=i.split(" ")),delete e.contrastDefaultColor,delete e.contrastLightColors,delete e.contrastStrongLightColors,delete e.contrastDarkColors,t.forEach(e,function(a,d){function l(){return"light"===n?i.indexOf(d)>-1?g:r.indexOf(d)>-1?v:E:o.indexOf(d)>-1?r.indexOf(d)>-1?v:E:g}if(!t.isObject(a)){var m=c(a);if(!m)throw new Error("Color %1, in palette %2's hue %3, is invalid. Hex or rgb(a) color expected.".replace("%1",a).replace("%2",e.name).replace("%3",d));e[d]={value:m,contrast:l()}}})}var o=document.getElementsByTagName("head")[0],r=o?o.firstElementChild:null,a=e.has("$MD_THEME_CSS")?e.get("$MD_THEME_CSS"):"";if(r&&0!==a.length){t.forEach(m,n);var d={},l=a.split(/\}(?!(\}|'|"|;))/).filter(function(e){return e&&e.length}).map(function(e){return e.trim()+"}"}),p=new RegExp("md-("+M.join("|")+")","g");M.forEach(function(e){d[e]=""}),l.forEach(function(e){for(var t,n=(e.match(p),0);t=M[n];n++)if(e.indexOf(".md-"+t)>-1)return d[t]+=e;for(n=0;t=M[n];n++)if(e.indexOf(t)>-1)return d[t]+=e;return d[$]+=e}),t.forEach(s,function(e){u[e.name]||(M.forEach(function(t){for(var n=i(e,t,d[t]);n.length;){var a=document.createElement("style");a.setAttribute("type","text/css"),a.appendChild(document.createTextNode(n.shift())),o.insertBefore(a,r)}}),e.colors.primary.name==e.colors.accent.name&&console.warn("$mdThemingProvider: Using the same palette for primary and accent. This violates the material design spec."),u[e.name]=!0)})}}function d(e,t){if(!m[(e.colors[t]||{}).name])throw new Error("You supplied an invalid color palette for theme %1's %2 palette. Available palettes: %3".replace("%1",e.name).replace("%2",t).replace("%3",Object.keys(m).join(", ")))}function c(e){if(t.isArray(e)&&3==e.length)return e;if(/^rgb/.test(e))return e.replace(/(^\s*rgba?\(|\)\s*$)/g,"").split(",").map(function(e,t){return 3==t?parseFloat(e,10):parseInt(e,10)});if("#"==e.charAt(0)&&(e=e.substring(1)),/^([a-fA-F0-9]{3}){1,2}$/g.test(e)){var n=e.length/3,o=e.substr(0,n),r=e.substr(n,n),i=e.substr(2*n);return 1===n&&(o+=o,r+=r,i+=i),[parseInt(o,16),parseInt(r,16),parseInt(i,16)]}}function l(e,n){return e?(4==e.length&&(e=t.copy(e),n?e.pop():n=e.pop()),n&&("number"==typeof n||"string"==typeof n&&n.length)?"rgba("+e.join(",")+","+n+")":"rgb("+e.join(",")+")"):"rgb('0,0,0')"}t.module("material.core.theming",["material.core.theming.palette"]).directive("mdTheme",o).directive("mdThemable",r).provider("$mdTheming",e).run(a);var m,s,u={},p={name:"dark",1:"rgba(0,0,0,0.87)",2:"rgba(0,0,0,0.54)",3:"rgba(0,0,0,0.26)",4:"rgba(0,0,0,0.12)"},f={name:"light",1:"rgba(255,255,255,1.0)",2:"rgba(255,255,255,0.7)",3:"rgba(255,255,255,0.3)",4:"rgba(255,255,255,0.12)"},h="1px 1px 0px rgba(0,0,0,0.4), -1px -1px 0px rgba(0,0,0,0.4)",b="",g=c("rgba(0,0,0,0.87)"),E=c("rgba(255,255,255,0.87"),v=c("rgb(255,255,255)"),M=["primary","accent","warn","background"],$="primary",A={accent:{"default":"A200","hue-1":"A100","hue-2":"A400","hue-3":"A700"},background:{"default":"A100","hue-1":"300","hue-2":"800","hue-3":"900"}},T={background:{"default":"800","hue-1":"300","hue-2":"600","hue-3":"900"}};M.forEach(function(e){var t={"default":"500","hue-1":"300","hue-2":"800","hue-3":"A100"};A[e]||(A[e]=t),T[e]||(T[e]=t)});var C=["50","100","200","300","400","500","600","700","800","900","A100","A200","A400","A700"];e.$inject=["$mdColorPalette"],o.$inject=["$mdTheming","$interpolate","$log"],r.$inject=["$mdTheming"],a.$inject=["$injector"]}(),function(){t.module("material.components.autocomplete",["material.core","material.components.icon"])}(),function(){function e(){return{restrict:"E"}}function n(e){function n(e,n,i,a,d,c,l){function m(o,r,l){r=i.extractElementByName(r,"md-bottom-sheet"),p=i.createBackdrop(o,"md-bottom-sheet-backdrop md-opaque"),p.on("click",function(){i.nextTick(d.cancel,!0)}),a.inherit(p,l.parent),e.enter(p,l.parent,null);var m=new u(r,l.parent);return l.bottomSheet=m,l.targetEvent&&t.element(l.targetEvent.target).blur(),a.inherit(m.element,l.parent),l.disableParentScroll&&(l.lastOverflow=l.parent.css("overflow"),l.parent.css("overflow","hidden")),e.enter(m.element,l.parent).then(function(){var e=t.element(r[0].querySelector("button")||r[0].querySelector("a")||r[0].querySelector("[ng-click]"));e.focus(),l.escapeToClose&&(l.rootElementKeyupCallback=function(e){e.keyCode===n.KEY_CODE.ESCAPE&&i.nextTick(d.cancel,!0)},c.on("keyup",l.rootElementKeyupCallback))})}function s(n,o,r){var i=r.bottomSheet;return e.leave(p),e.leave(i.element).then(function(){r.disableParentScroll&&(r.parent.css("overflow",r.lastOverflow),delete r.lastOverflow),i.cleanup(),r.targetEvent&&t.element(r.targetEvent.target).focus()})}function u(e,t){function a(t){e.css(n.CSS.TRANSITION_DURATION,"0ms")}function c(t){var o=t.pointer.distanceY;5>o&&(o=Math.max(-r,o/2)),e.css(n.CSS.TRANSFORM,"translate3d(0,"+(r+o)+"px,0)")}function m(t){if(t.pointer.distanceY>0&&(t.pointer.distanceY>20||Math.abs(t.pointer.velocityY)>o)){var r=e.prop("offsetHeight")-t.pointer.distanceY,a=Math.min(r/t.pointer.velocityY*.75,500);e.css(n.CSS.TRANSITION_DURATION,a+"ms"),i.nextTick(d.cancel,!0)}else e.css(n.CSS.TRANSITION_DURATION,""),e.css(n.CSS.TRANSFORM,"")}var s=l.register(t,"drag",{horizontal:!1});return t.on("$md.dragstart",a).on("$md.drag",c).on("$md.dragend",m),{element:e,cleanup:function(){s(),t.off("$md.dragstart",a).off("$md.drag",c).off("$md.dragend",m)}}}var p;return{themable:!0,targetEvent:null,onShow:m,onRemove:s,escapeToClose:!0,disableParentScroll:!0}}var o=.5,r=80;return n.$inject=["$animate","$mdConstant","$mdUtil","$mdTheming","$mdBottomSheet","$rootElement","$mdGesture"],e("$mdBottomSheet").setDefaults({methods:["disableParentScroll","escapeToClose","targetEvent"],options:n})}t.module("material.components.bottomSheet",["material.core","material.components.backdrop"]).directive("mdBottomSheet",e).provider("$mdBottomSheet",n),n.$inject=["$$interimElementProvider"]}(),function(){t.module("material.components.backdrop",["material.core"]).directive("mdBackdrop",["$mdTheming","$animate","$rootElement","$window","$log","$$rAF","$document",function(e,t,n,o,r,i,a){function d(d,l,m){var s=o.getComputedStyle(a[0].body);if("fixed"==s.position){var u=parseInt(s.height,10)+Math.abs(parseInt(s.top,10));l.css({height:u+"px"})}t.pin&&t.pin(l,n),i(function(){var t=l.parent()[0];if(t){var n=o.getComputedStyle(t);"static"==n.position&&r.warn(c)}e.inherit(l,l.parent())})}var c=" may not work properly in a scrolled, static-positioned parent container.";return{restrict:"E",link:d}}])}(),function(){function e(e){return{restrict:"E",link:function(t,n,o){e(n)}}}t.module("material.components.card",["material.core"]).directive("mdCard",e),e.$inject=["$mdTheming"]}(),function(){function e(e,n,o,r,i,a,d){function c(n,c){return c.type="checkbox",c.tabindex=c.tabindex||"0",n.attr("role",c.type),function(n,c,m,s){function u(e,t,o){m[e]&&n.$watch(m[e],function(e){o[e]&&c.attr(t,o[e])})}function p(e){var t=e.which||e.keyCode;(t===r.KEY_CODE.SPACE||t===r.KEY_CODE.ENTER)&&(e.preventDefault(),c.hasClass("md-focused")||c.addClass("md-focused"),f(e))}function f(e){c[0].hasAttribute("disabled")||n.$apply(function(){var t=m.ngChecked?m.checked:!s.$viewValue;s.$setViewValue(t,e&&e.type),s.$render()})}function h(){s.$viewValue?c.addClass(l):c.removeClass(l)}s=s||a.fakeNgModel(),i(c),m.ngChecked&&n.$watch(n.$eval.bind(n,m.ngChecked),s.$setViewValue.bind(s)),u("ngDisabled","tabindex",{"true":"-1","false":m.tabindex}),o.expectWithText(c,"aria-label"),e.link.pre(n,{on:t.noop,0:{}},m,[s]),n.mouseActive=!1,c.on("click",f).on("keypress",p).on("mousedown",function(){n.mouseActive=!0,d(function(){n.mouseActive=!1},100)}).on("focus",function(){n.mouseActive===!1&&c.addClass("md-focused")}).on("blur",function(){c.removeClass("md-focused")}),s.$render=h}}e=e[0];var l="md-checked";return{restrict:"E",transclude:!0,require:"?ngModel",priority:210,template:'
',compile:c}}t.module("material.components.checkbox",["material.core"]).directive("mdCheckbox",e),e.$inject=["inputDirective","$mdInkRipple","$mdAria","$mdConstant","$mdTheming","$mdUtil","$timeout"]}(),function(){function e(e){function t(e,t){this.$scope=e,this.$element=t}return{restrict:"E",controller:["$scope","$element",t],link:function(t,o,r){o[0];e(o),t.$broadcast("$mdContentLoaded",o),n(o[0])}}}function n(e){t.element(e).on("$md.pressdown",function(t){"t"===t.pointer.type&&(t.$materialScrollFixed||(t.$materialScrollFixed=!0,0===e.scrollTop?e.scrollTop=1:e.scrollHeight===e.scrollTop+e.offsetHeight&&(e.scrollTop-=1)))})}t.module("material.components.content",["material.core"]).directive("mdContent",e),e.$inject=["$mdTheming"]}(),function(){function e(e,n,o,r){function i(e){return t.isDefined(e.href)||t.isDefined(e.ngHref)||t.isDefined(e.ngLink)||t.isDefined(e.uiSref)}function a(e,t){return i(t)?'':''}function d(a,d,c){var l=d[0];n(d),e.attach(a,d);var m=l.textContent.trim();m||o.expect(d,"aria-label"),i(c)&&t.isDefined(c.ngDisabled)&&a.$watch(c.ngDisabled,function(e){d.attr("tabindex",e?-1:0)}),d.on("click",function(e){c.disabled===!0&&(e.preventDefault(),e.stopImmediatePropagation())}),a.mouseActive=!1,d.on("mousedown",function(){a.mouseActive=!0,r(function(){a.mouseActive=!1},100)}).on("focus",function(){a.mouseActive===!1&&d.addClass("md-focused")}).on("blur",function(){d.removeClass("md-focused")})}return{restrict:"EA",replace:!0,transclude:!0,template:a,link:d}}t.module("material.components.button",["material.core"]).directive("mdButton",e),e.$inject=["$mdButtonInkRipple","$mdTheming","$mdAria","$timeout"]}(),function(){function e(e){return{restrict:"E",link:e}}t.module("material.components.divider",["material.core"]).directive("mdDivider",e),e.$inject=["$mdTheming"]}(),function(){t.module("material.components.chips",["material.core","material.components.autocomplete"])}(),function(){function e(e,n){return{restrict:"E",link:function(o,r,i){n(r),e(function(){function e(){r.toggleClass("md-content-overflow",o.scrollHeight>o.clientHeight)}var n,o=r[0].querySelector("md-dialog-content");o&&(n=o.getElementsByTagName("img"),e(),t.element(n).on("load",e))})}}}function n(e){function n(e,t){return{template:['',' ','   
{{ dialog.title }}
',"   
{{ dialog.content }}
"," ",' 
','   ',"     {{ dialog.cancel }}","   ",'   ',"     {{ dialog.ok }}","   "," 
",""].join("").replace(/\s\s+/g,""),controller:function(){this.hide=function(){e.hide(!0)},this.abort=function(){e.cancel()}},controllerAs:"dialog",bindToController:!0,theme:t.defaultTheme()}}function o(e,n,o,r,i,a,d,c){function l(e,n,r){function i(){function e(){var e=n[0].querySelector(".dialog-close");if(!e){var o=n[0].querySelectorAll(".md-actions button");e=o[o.length-1]}return t.element(e)}if(r.focusOnOpen){var o="alert"===r.$type?n.find("md-dialog-content"):e();o.focus()}}return n=o.extractElementByName(n,"md-dialog"),t.element(a[0].body).addClass("md-dialog-is-showing"),s(n,r),f(n.find("md-dialog"),r),p(e,n,r),g(n,r).then(function(){u(n,r),h(n,r),i()})}function m(e,n,o){return o.deactivateListeners(),o.unlockScreenReader(),o.hideBackdrop(),E(n,o)["finally"](function(){t.element(a[0].body).removeClass("md-dialog-is-showing"),n.remove(),o.origin.focus()})}function s(e,n){var r={element:null,bounds:null,focus:t.noop};n.origin=t.extend({},r,n.origin||{});var i=t.element((n.targetEvent||{}).target);i&&i.length&&(n.origin.element=i,n.origin.bounds=i[0].getBoundingClientRect(),n.origin.focus=function(){i.focus()}),n.parent=t.element(n.parent||c),n.disableParentScroll&&(n.restoreScroll=o.disableScrollAround(e,n.parent))}function u(t,n){var i=[],a=function(){var t="alert"==n.$type?e.hide:e.cancel;o.nextTick(t,!0)};if(n.escapeToClose){var d=n.parent,c=function(e){e.keyCode===r.KEY_CODE.ESCAPE&&(e.stopPropagation(),e.preventDefault(),a())};t.on("keyup",c),d.on("keyup",c),i.push(function(){t.off("keyup",c),d.off("keyup",c)})}if(n.clickOutsideToClose){var d=t,l=function(e){e.target===d[0]&&(e.stopPropagation(),e.preventDefault(),a())};d.on("click",l),i.push(function(){d.off("click",l)})}n.deactivateListeners=function(){i.forEach(function(e){e()}),n.deactivateListeners=null}}function p(e,t,n){n.hasBackdrop&&(n.backdrop=o.createBackdrop(e,"md-dialog-backdrop md-opaque"),i.enter(n.backdrop,n.parent)),n.hideBackdrop=function(){n.backdrop&&i.leave(n.backdrop),n.disableParentScroll&&n.restoreScroll(),n.hideBackdrop=null}}function f(e,t){var r="alert"===t.$type?"alertdialog":"dialog",i=e.find("md-dialog-content"),a=e.attr("id")||"dialog_"+o.nextUid();e.attr({role:r,tabIndex:"-1"}),0===i.length&&(i=e),i.attr("id",a),e.attr("aria-describedby",a),t.ariaLabel?n.expect(e,"aria-label",t.ariaLabel):n.expectAsync(e,"aria-label",function(){var e=i.text().split(/\s+/);return e.length>3&&(e=e.slice(0,3).concat("...")),e.join(" ")})}function h(e,t){function n(e){for(;e.parentNode;){if(e===document.body)return;for(var t=e.parentNode.children,r=0;r'+e+"