Changes the Gamepad focus from one overlay to one of its neighbors. Returns VROverlayError_NoNeighbor if there is no
        neighbor in that direction
182529
def moveGamepadFocusToNeighbor(self, eDirection, ulFrom):
        

        fn = self.function_table.moveGamepadFocusToNeighbor
        result = fn(eDirection, ulFrom)
        return result
1326884
def assign_vertex_attrib_location(self, vbo, location):
        """"""
        with vbo:
            if self.n_verts:
                assert vbo.data.shape[0] == self.n_verts
            else:
                self.n_verts = vbo.data.shape[0]

            # vbo.buffer_data()
            gl.glVertexAttribPointer(location, vbo.data.shape[1], gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
            gl.glEnableVertexAttribArray(location)
880303
def direction_to_nearest_place(feature, parent):
    
    _ = feature, parent  # NOQA

    layer = exposure_summary_layer()
    if not layer:
        return None

    index = layer.fields().lookupField(
        direction_field['field_name'])
    if index < 0:
        return None

    feature = next(layer.getFeatures())
    return feature[index]
1029941
function () {
    var controller = this.controller;
    var data = this.data;
    var object3D = this.el.object3D;
    var pose;
    var vrDisplay = this.system.vrDisplay;
    var standingMatrix;

    if (!controller) { return; }

    // Compose pose from Gamepad.
    pose = controller.pose;

    if (pose.position) {
      object3D.position.fromArray(pose.position);
    } else {
      // Controller not 6DOF, apply arm model.
      if (data.armModel) { this.applyArmModel(object3D.position); }
    }

    if (pose.orientation) {
      object3D.quaternion.fromArray(pose.orientation);
    }

    // Apply transforms, if 6DOF and in VR.
    if (vrDisplay && pose.position) {
      standingMatrix = this.el.sceneEl.renderer.vr.getStandingMatrix();
      object3D.matrix.compose(object3D.position, object3D.quaternion, object3D.scale);
      object3D.matrix.multiplyMatrices(standingMatrix, object3D.matrix);
      object3D.matrix.decompose(object3D.position, object3D.quaternion, object3D.scale);
    }

    object3D.rotateX(this.data.orientationOffset.x * THREE.Math.DEG2RAD);
    object3D.rotateY(this.data.orientationOffset.y * THREE.Math.DEG2RAD);
    object3D.rotateZ(this.data.orientationOffset.z * THREE.Math.DEG2RAD);
  }
375920
function mouseActionLocal(angleXY) {
    rotator.yaw = -angleXY[0];
    rotator.pitch = angleXY[1];
    rotator.updateRotMtx();
}
1213313
def setOverlayName(self, ulOverlayHandle, pchName):
        """"""

        fn = self.function_table.setOverlayName
        result = fn(ulOverlayHandle, pchName)
        return result
1012817
def setOverlayAutoCurveDistanceRangeInMeters(self, ulOverlayHandle, fMinDistanceInMeters, fMaxDistanceInMeters):
        

        fn = self.function_table.setOverlayAutoCurveDistanceRangeInMeters
        result = fn(ulOverlayHandle, fMinDistanceInMeters, fMaxDistanceInMeters)
        return result
322683
function (recognizer) {
            // Obtain the event location.
            var x = recognizer.clientX,
                y = recognizer.clientY;

            // Perform the pick. Must first convert from window coordinates to canvas coordinates, which are
            // relative to the upper left corner of the canvas rather than the upper left corner of the page.
            var pickList = wwd.pick(wwd.canvasCoordinates(x, y));

            // If only one thing is picked and it is the terrain, tell the WorldWindow to go to the picked location.
            if (pickList.objects.length === 1 && pickList.objects[0].isTerrain) {
                var position = pickList.objects[0].position;
                wwd.goTo(new WorldWind.Location(position.latitude, position.longitude));
            }
        }
84873
def getOverlayInputMethod(self, ulOverlayHandle):
        """"""

        fn = self.function_table.getOverlayInputMethod
        peInputMethod = VROverlayInputMethod()
        result = fn(ulOverlayHandle, byref(peInputMethod))
        return result, peInputMethod
380001
def setOverlayDualAnalogTransform(self, ulOverlay, eWhich, fRadius):
        """"""

        fn = self.function_table.setOverlayDualAnalogTransform
        pvCenter = HmdVector2_t()
        result = fn(ulOverlay, eWhich, byref(pvCenter), fRadius)
        return result, pvCenter
1041932
function() {

        // remove the HUD from the game world
        me.game.world.removeChild(this.HUD);

        // remove the joypad if initially added
        if (this.virtualJoypad && me.game.world.hasChild(this.virtualJoypad)) {
            me.game.world.removeChild(this.virtualJoypad);
        }

        // stop some music
        me.audio.stopTrack("dst-gameforest");
    }
1050567
def getOverlayFlag(self, ulOverlayHandle, eOverlayFlag):
        """"""

        fn = self.function_table.getOverlayFlag
        pbEnabled = openvr_bool()
        result = fn(ulOverlayHandle, eOverlayFlag, byref(pbEnabled))
        return result, pbEnabled
567328
def edit_distance(x, y):
    

    ret = layers_distance(x.layers, y.layers)
    ret += Constant.KERNEL_LAMBDA * skip_connections_distance(
        x.skip_connections, y.skip_connections
    )
    return ret
238812
private void updateSliderState(int touchX, int touchY) {
        int distanceX = touchX - mCircleCenterX;
        int distanceY = mCircleCenterY - touchY;
        //noinspection SuspiciousNameCombination
        double c = Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2));
        mAngle = Math.acos(distanceX / c);
        if (distanceY < 0) {
            mAngle = -mAngle;
        }

        if (mListener != null) {
            // notify slider moved listener of the new position which should be in [0..1] range
            mListener.onSliderMoved((mAngle - mStartAngle) / (2 * Math.PI));
        }
    }
1203702
function (gamepadId) {
    var gamepad = gamepadSupport.gamepads[gamepadId];

    // Update all the buttons (and their corresponding labels) on screen.
    window.tester.updateButton(gamepad.buttons[0], gamepadId, 'button-1');
    window.tester.updateButton(gamepad.buttons[1], gamepadId, 'button-2');
    window.tester.updateButton(gamepad.buttons[2], gamepadId, 'button-3');
    window.tester.updateButton(gamepad.buttons[3], gamepadId, 'button-4');

    window.tester.updateButton(gamepad.buttons[4], gamepadId,
        'button-left-shoulder-top');
    window.tester.updateButton(gamepad.buttons[6], gamepadId,
        'button-left-shoulder-bottom');
    window.tester.updateButton(gamepad.buttons[5], gamepadId,
        'button-right-shoulder-top');
    window.tester.updateButton(gamepad.buttons[7], gamepadId,
        'button-right-shoulder-bottom');

    window.tester.updateButton(gamepad.buttons[8], gamepadId, 'button-select');
    window.tester.updateButton(gamepad.buttons[9], gamepadId, 'button-start');

    window.tester.updateButton(gamepad.buttons[10], gamepadId, 'stick-1');
    window.tester.updateButton(gamepad.buttons[11], gamepadId, 'stick-2');

    window.tester.updateButton(gamepad.buttons[12], gamepadId, 'button-dpad-top');
    window.tester.updateButton(gamepad.buttons[13], gamepadId, 'button-dpad-bottom');
    window.tester.updateButton(gamepad.buttons[14], gamepadId, 'button-dpad-left');
    window.tester.updateButton(gamepad.buttons[15], gamepadId, 'button-dpad-right');

    // Update all the analogue sticks.
    window.tester.updateAxis(gamepad.axes[0], gamepadId,
        'stick-1-axis-x', 'stick-1', true);
    window.tester.updateAxis(gamepad.axes[1], gamepadId,
        'stick-1-axis-y', 'stick-1', false);
    window.tester.updateAxis(gamepad.axes[2], gamepadId,
        'stick-2-axis-x', 'stick-2', true);
    window.tester.updateAxis(gamepad.axes[3], gamepadId,
        'stick-2-axis-y', 'stick-2', false);

    // Update extraneous buttons.
    var extraButtonId = gamepadSupport.TYPICAL_BUTTON_COUNT;
    while (typeof gamepad.buttons[extraButtonId] !== 'undefined') {
      window.tester.updateButton(gamepad.buttons[extraButtonId], gamepadId,
          'extra-button-' + extraButtonId);

      extraButtonId++;
    }

    // Update extraneous axes.
    var extraAxisId = gamepadSupport.TYPICAL_AXIS_COUNT;
    while (typeof gamepad.axes[extraAxisId] !== 'undefined') {
      window.tester.updateAxis(gamepad.axes[extraAxisId], gamepadId,
          'extra-axis-' + extraAxisId);

      extraAxisId++;
    }

  }
537995
def mouseMove(self, x, y):
        
        log.debug('mouseMove %d,%d', x, y)
        self.x, self.y = x, y
        self.pointerEvent(x, y, self.buttons)
        return self
98453
def mouseMoveEvent(self, event):
        
        # ignore events when the scene is in view mode
        scene = self.scene()
        if scene and (scene.inViewMode() or scene.isConnecting()):
            event.ignore()
            return

        # call the base method
        super(XNodeConnection, self).mouseMoveEvent(event)