code: function (time) {
      var el = this.el;
      var data = this.data;
      var intersectedEls;
      var intersections;
      var prevCheckTime = this.prevCheckTime;
      var prevIntersectedEls;
  
      // Only check for intersection if interval time has passed.
      if (prevCheckTime && (time - prevCheckTime < data.interval)) { return; }
  
      // Store old previously intersected entities.
      prevIntersectedEls = this.intersectedEls.slice();
  
      // Raycast.
      this.updateOriginDirection();
      intersections = this.raycaster.intersectObjects(this.objects, data.recursive);
  
      // Only keep intersections against objects that have a reference to an entity.
      intersections = intersections.filter(function hasEl (intersection) {
        return !!intersection.object.el;
      });
  
      // Update intersectedEls.
      intersectedEls = this.intersectedEls = intersections.map(function getEl (intersection) {
        return intersection.object.el;
      });
  
      // Emit intersected on intersected entity per intersected entity.
      intersections.forEach(function emitEvents (intersection) {
        var intersectedEl = intersection.object.el;
        intersectedEl.addState('hovered');
        intersectedEl.emit('raycaster-intersected', {el: el, intersection: intersection});
      });
  
      // Emit all intersections at once on raycasting entity.
      if (intersections.length) {
        el.emit('raycaster-intersection', {
          els: intersectedEls,
          intersections: intersections
        });
      }
  
      // Emit intersection cleared on both entities per formerly intersected entity.
      prevIntersectedEls.forEach(function checkStillIntersected (intersectedEl) {
        if (intersectedEls.indexOf(intersectedEl) !== -1) { return; }
        intersectedEl.removeState('hovered');
        el.emit('raycaster-intersection-cleared', {el: intersectedEl});
        intersectedEl.emit('raycaster-intersected-cleared', {el: el});
      });
    }
docs: Check for intersections and cleared intersections on an interval.