add aabb-collider component

public/defaults/proxy/vwf.example.com/aframe/aabb-collider-component.vwf.yaml

@@ -0,0 +1,10 @@
+# aabb-collider-component
+---
+extends: http://vwf.example.com/aframe/aentityComponent.vwf
+type: "component"
+properties:
+  collideNonVisible:
+  debug:
+  enabled:
+  objects:
+  interval:

public/defaults/proxy/vwf.example.com/aframe/aentity.js

@@ -83,6 +83,19 @@ this.clearIntersectEventMethod = function () {
 
 }
 
+this.hitstartEventMethod = function () {
+
+    //intersect method
+}
+
+
+this.hitendEventMethod = function () {
+
+    //clearIntersect method
+
+}
+
+
 this.setOwner = function (param) {
 
     var clients = this.find("doc('http://vwf.example.com/clients.vwf')")[0];

public/defaults/proxy/vwf.example.com/aframe/aentity.vwf.yaml

@@ -45,6 +45,7 @@ properties:
   edit:
   osc:
   ownedBy:
+  class:
 events:
   positionChanged:
   rotationChanged:
@@ -52,9 +53,13 @@ events:
   sendOSC:
   intersectEvent:
   clearIntersectEvent:
+  hitstartEvent:
+  hitendEvent:
 methods:
   intersectEventMethod:
   clearIntersectEventMethod:
+  hitstartEventMethod:
+  hitendEventMethod:
   sendOSC:
     parameters:
       - msg

public/defaults/proxy/vwf.example.com/aframe/app-aabb-collider-listener-component.vwf.yaml

@@ -0,0 +1,5 @@
+# raycaster listener
+---
+extends: http://vwf.example.com/aframe/aentityComponent.vwf
+type: "component"
+properties:

public/defaults/proxy/vwf.example.com/aframe/app-raycaster-listener-component.vwf.yaml

@@ -2,5 +2,4 @@
 ---
 extends: http://vwf.example.com/aframe/aentityComponent.vwf
 type: "component"
-properties:
-  class:
+properties:

public/defaults/proxy/vwf.example.com/aframe/avatar.js

@@ -127,6 +127,15 @@ this.createAvatarBody = function (nodeDef, modelSrc) {
                                         "properties":{
                                             "color": myColor
                                         }
+                                    },
+                                    "aabb-collider": {
+                                        "extends": "http://vwf.example.com/aframe/aabb-collider-component.vwf",
+                                        "type": "component",
+                                        "properties": {
+                                            debug: true,
+                                            interval: 10,
+                                            objects: ".aabb"
+                                        }
                                     }
                                 }
                                 

public/defaults/worlds/aframe2/index.vwf.yaml

@@ -76,7 +76,18 @@ children:
       depth: 2
       height: 1
       width: 1
+      class: "aabb"
+    methods:
+      hitstartEventMethod:
+        body: |
+          this.material.opacity = 0.7
+      hitendEventMethod:
+        body: |
+          this.material.opacity = 1.0
     children:
+      aabb-collider-listener:
+        extends: http://vwf.example.com/aframe/app-aabb-collider-listener-component.vwf
+        type: "component"
       material:
         extends: http://vwf.example.com/aframe/aMaterialComponent.vwf
         properties:

public/vwf.js

@@ -318,6 +318,10 @@ Copyright (c) 2014-2018 Nikolai Suslov and the Krestianstvo.org project contribu
                         deps: [ "vwf/model/aframe/aframe-master" ]
                     },
 
+                    "vwf/model/aframe/kframe/aframe-aabb-collider-component.min": {
+                        deps: [ "vwf/model/aframe/aframe-master" ]
+                    },
+
                     "vwf/model/aframe/addon/aframe-components": {
                         deps: [ "vwf/model/aframe/aframe-master",
                         "vwf/model/aframe/extras/aframe-extras.loaders",
@@ -325,7 +329,8 @@ Copyright (c) 2014-2018 Nikolai Suslov and the Krestianstvo.org project contribu
                         "vwf/model/aframe/addon/SkyShader",
                         "vwf/model/aframe/addon/BVHLoader",
                         "vwf/model/aframe/addon/TransformControls",
-                        "vwf/model/aframe/addon/THREE.MeshLine"
+                        "vwf/model/aframe/addon/THREE.MeshLine",
+                        "vwf/model/aframe/kframe/aframe-aabb-collider-component.min"
                     ]
                     },
                     "vwf/view/arjs/aframe-ar": {
@@ -365,7 +370,8 @@ Copyright (c) 2014-2018 Nikolai Suslov and the Krestianstvo.org project contribu
                     "vwf/model/aframe/extras/aframe-extras.controls.min",
                     "vwf/model/aframe/addon/BVHLoader",
                     "vwf/model/aframe/addon/TransformControls",
-                    "vwf/model/aframe/addon/THREE.MeshLine"
+                    "vwf/model/aframe/addon/THREE.MeshLine",
+                    "vwf/model/aframe/kframe/aframe-aabb-collider-component.min"
                        
                  ], 
                     active: false 
@@ -402,6 +408,8 @@ Copyright (c) 2014-2018 Nikolai Suslov and the Krestianstvo.org project contribu
                 { library: "vwf/model/aframe/addon/BVHLoader", active: false },
                 { library: "vwf/model/aframe/addon/TransformControls", active: false },
                 { library: "vwf/model/aframe/addon/THREE.MeshLine", active: false },
+                { library: "vwf/model/aframe/kframe/aframe-aabb-collider-component.min", active: false },
+                
                 
                 
                 

public/vwf/model/aframe.js

@@ -426,6 +426,9 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                             node.events.clickable = propertyValue;
                             break;
 
+                        case "class":
+                                aframeObject.setAttribute('class', propertyValue);
+                            break;
 
                         case "ownedBy":
                             aframeObject.setAttribute('ownedby', propertyValue);
@@ -963,6 +966,10 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                             value = node.events.clickable;
                             break;
 
+                        case "class":
+                            aframeObject.getAttribute('class');
+                        break;
+
                         // case "look-controls-enabled":
                         //     var look = aframeObject.getAttribute('look-controls-enabled');
                         //     if (look !== null && look !== undefined) {

public/vwf/model/aframe/addon/aframe-components.js

@@ -204,6 +204,34 @@ AFRAME.registerComponent('cursor-listener', {
     }
 });
 
+AFRAME.registerComponent('aabb-collider-listener', {
+
+    init: function () {
+
+        let self = this;
+        this.me = vwf_view.kernel.moniker();
+
+        this.el.addEventListener('hitstart', function (evt) {
+            //console.log('Hit start..' + evt);
+            let ownedby = evt.target.getAttribute('ownedby');
+            if (ownedby == self.me || (evt.target.id.includes(self.me))) { //if (evt.detail.el.id.includes(self.me)) {
+                vwf_view.kernel.fireEvent(evt.target.id, "hitstartEvent", [self.me]);
+            }
+        })
+
+        this.el.addEventListener('hitend', function (evt) {
+            //console.log('Hit end..' + evt);
+            let ownedby = evt.target.getAttribute('ownedby');
+            if (ownedby == self.me || (evt.target.id.includes(self.me))) { //if (evt.detail.el.id.includes(self.me)) {
+                vwf_view.kernel.fireEvent(evt.target.id, "hitendEvent", [self.me]);
+            }
+        })
+    }
+
+
+
+});
+
 AFRAME.registerComponent('raycaster-listener', {
     init: function () {
 

public/vwf/model/aframe/extras/aframe-extras.controls.js

@@ -1372,7 +1372,7 @@ module.exports = AFRAME.registerComponent('movement-controls', {
     speed: { default: 0.3, min: 0 },
     fly: { default: false },
     constrainToNavMesh: { default: false },
-    camera: { default: '[camera]', type: 'selector' }
+    camera: { default: '[movement-controls] [camera]', type: 'selector' }
   },
 
   /*******************************************************************

public/vwf/model/aframe/extras/aframe-extras.js

@@ -5744,7 +5744,7 @@ module.exports = AFRAME.registerComponent('movement-controls', {
     speed: { default: 0.3, min: 0 },
     fly: { default: false },
     constrainToNavMesh: { default: false },
-    camera: { default: '[camera]', type: 'selector' }
+    camera: { default: '[movement-controls] [camera]', type: 'selector' }
   },
 
   /*******************************************************************

public/vwf/model/aframe/kframe/aframe-aabb-collider-component.js

@@ -0,0 +1,303 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+	/* global AFRAME, THREE */
+
+	if (typeof AFRAME === 'undefined') {
+	  throw new Error('Component attempted to register before AFRAME was available.');
+	}
+
+	// Configuration for the MutationObserver used to refresh the whitelist.
+	// Listens for addition/removal of elements and attributes within the scene.
+	var OBSERVER_CONFIG = {
+	  childList: true,
+	  attributes: true,
+	  subtree: true
+	};
+
+	/**
+	 * Implement AABB collision detection for entities with a mesh.
+	 * https://en.wikipedia.org/wiki/Minimum_bounding_box#Axis-aligned_minimum_bounding_box
+	 *
+	 * @property {string} objects - Selector of entities to test for collision.
+	 */
+	AFRAME.registerComponent('aabb-collider', {
+	  schema: {
+	    collideNonVisible: {default: false},
+	    debug: {default: false},
+	    enabled: {default: true},
+	    interval: {default: 80},
+	    objects: {default: ''}
+	  },
+
+	  init: function () {
+	    this.centerDifferenceVec3 = new THREE.Vector3();
+	    this.clearedIntersectedEls = [];
+	    this.closestIntersectedEl = null;
+	    this.boundingBox = new THREE.Box3();
+	    this.boxCenter = new THREE.Vector3();
+	    this.boxHelper = new THREE.BoxHelper();
+	    this.boxMax = new THREE.Vector3();
+	    this.boxMin = new THREE.Vector3();
+	    this.hitClosestClearEventDetail = {};
+	    this.hitClosestEventDetail = {};
+	    this.intersectedEls = [];
+	    this.objectEls = [];
+	    this.newIntersectedEls = [];
+	    this.prevCheckTime = undefined;
+	    this.previousIntersectedEls = [];
+
+	    this.setDirty = this.setDirty.bind(this);
+	    this.observer = new MutationObserver(this.setDirty);
+	    this.dirty = true;
+
+	    this.hitStartEventDetail = {intersectedEls: this.newIntersectedEls};
+	  },
+
+	  play: function () {
+	    this.observer.observe(this.el.sceneEl, OBSERVER_CONFIG);
+	    this.el.sceneEl.addEventListener('object3dset', this.setDirty);
+	    this.el.sceneEl.addEventListener('object3dremove', this.setDirty);
+	  },
+
+	  remove: function () {
+	    this.observer.disconnect();
+	    this.el.sceneEl.removeEventListener('object3dset', this.setDirty);
+	    this.el.sceneEl.removeEventListener('object3dremove', this.setDirty);
+	  },
+
+	  tick: function (time) {
+	    var boxHelper;
+	    var boundingBox = this.boundingBox;
+	    var centerDifferenceVec3 = this.centerDifferenceVec3;
+	    var clearedIntersectedEls = this.clearedIntersectedEls;
+	    var closestCenterDifference;
+	    var newClosestEl;
+	    var intersectedEls = this.intersectedEls;
+	    var el = this.el;
+	    var i;
+	    var newIntersectedEls = this.newIntersectedEls;
+	    var objectEls = this.objectEls;
+	    var prevCheckTime = this.prevCheckTime;
+	    var previousIntersectedEls = this.previousIntersectedEls;
+	    var self = this;
+
+	    if (!this.data.enabled) { return; }
+
+	    // Only check for intersection if interval time has passed.
+	    if (prevCheckTime && (time - prevCheckTime < this.data.interval)) { return; }
+	    // Update check time.
+	    this.prevCheckTime = time;
+
+	    if (this.dirty) { this.refreshObjects(); }
+
+	    // Update the bounding box to account for rotations and position changes.
+	    boundingBox.setFromObject(el.object3D);
+	    this.boxMin.copy(boundingBox.min);
+	    this.boxMax.copy(boundingBox.max);
+	    boundingBox.getCenter(this.boxCenter);
+
+	    if (this.data.debug) {
+	      this.boxHelper.setFromObject(el.object3D);
+	      if (!this.boxHelper.parent) { el.sceneEl.object3D.add(this.boxHelper); }
+	    }
+
+	    copyArray(previousIntersectedEls, intersectedEls);
+
+	    // Populate intersectedEls array.
+	    intersectedEls.length = 0;
+	    for (i = 0; i < objectEls.length; i++) {
+	      if (objectEls[i] === this.el) { continue; }
+
+	      // Don't collide with non-visible if flag set.
+	      if (!this.data.collideNonVisible && !objectEls[i].getAttribute('visible')) {
+	        // Remove box helper if debug flag set and has box helper.
+	        if (this.data.debug) {
+	          boxHelper = objectEls[i].object3D.boxHelper;
+	          if (boxHelper) {
+	            el.sceneEl.object3D.remove(boxHelper);
+	            objectEls[i].object3D.boxHelper = null;
+	          }
+	        }
+	        continue;
+	      }
+
+	      // Check for interection.
+	      if (this.isIntersecting(objectEls[i])) { intersectedEls.push(objectEls[i]); }
+	    }
+
+	    // Get newly intersected entities.
+	    newIntersectedEls.length = 0;
+	    for (i = 0; i < intersectedEls.length; i++) {
+	      if (previousIntersectedEls.indexOf(intersectedEls[i]) === -1) {
+	        newIntersectedEls.push(intersectedEls[i]);
+	      }
+	    }
+
+	    // Emit cleared events on no longer intersected entities.
+	    clearedIntersectedEls.length = 0;
+	    for (i = 0; i < previousIntersectedEls.length; i++) {
+	      if (intersectedEls.indexOf(previousIntersectedEls[i]) !== -1) { continue; }
+	      if (!previousIntersectedEls[i].hasAttribute('aabb-collider')) {
+	        previousIntersectedEls[i].emit('hitend');
+	      }
+	      clearedIntersectedEls.push(previousIntersectedEls[i]);
+	    }
+
+	    // Emit events on intersected entities. Do this after the cleared events.
+	    for (i = 0; i < newIntersectedEls.length; i++) {
+	      if (newIntersectedEls[i] === this.el) { continue; }
+	      if (newIntersectedEls[i].hasAttribute('aabb-collider')) { continue; }
+	      newIntersectedEls[i].emit('hitstart');
+	    }
+
+	    // Calculate closest intersected entity based on centers.
+	    for (i = 0; i < intersectedEls.length; i++) {
+	      if (intersectedEls[i] === this.el) { continue; }
+	      centerDifferenceVec3
+	        .copy(intersectedEls[i].object3D.boundingBoxCenter)
+	        .sub(this.boxCenter);
+	      if (closestCenterDifference === undefined ||
+	          centerDifferenceVec3.length() < closestCenterDifference) {
+	        closestCenterDifference = centerDifferenceVec3.length();
+	        newClosestEl = intersectedEls[i];
+	      }
+	    }
+
+	    // Emit events for the new closest entity and the old closest entity.
+	    if (!intersectedEls.length && this.closestIntersectedEl) {
+	      // No intersected entities, clear any closest entity.
+	      this.hitClosestClearEventDetail.el = this.closestIntersectedEl;
+	      this.closestIntersectedEl.emit('hitclosestclear');
+	      this.closestIntersectedEl = null;
+	      el.emit('hitclosestclear', this.hitClosestClearEventDetail);
+	    } else if (newClosestEl !== this.closestIntersectedEl) {
+	      // Clear the previous closest entity.
+	      if (this.closestIntersectedEl) {
+	        this.hitClosestClearEventDetail.el = this.closestIntersectedEl;
+	        this.closestIntersectedEl.emit('hitclosestclear', this.hitClosestClearEventDetail);
+	      }
+	      if (newClosestEl) {
+	        // Emit for the new closest entity.
+	        newClosestEl.emit('hitclosest');
+	        this.closestIntersectedEl = newClosestEl;
+	        this.hitClosestEventDetail.el = newClosestEl;
+	        el.emit('hitclosest', this.hitClosestEventDetail);
+	      }
+	    }
+
+	    if (clearedIntersectedEls.length) {
+	      el.emit('hitend');
+	    }
+
+	    if (newIntersectedEls.length) {
+	      el.emit('hitstart', this.hitStartEventDetail);
+	    }
+	  },
+
+	  /**
+	   * AABB collision detection.
+	   * 3D version of https://www.youtube.com/watch?v=ghqD3e37R7E
+	   */
+	  isIntersecting: (function () {
+	    var boundingBox = new THREE.Box3();
+
+	    return function (el) {
+	      var isIntersecting;
+	      var boxHelper;
+	      var boxMin;
+	      var boxMax;
+
+	      boundingBox.setFromObject(el.object3D);
+
+	      if (this.data.debug) {
+	        if (!el.object3D.boxHelper) {
+	          el.object3D.boxHelper = new THREE.BoxHelper(
+	            el.object3D, new THREE.Color(Math.random(), Math.random(), Math.random()));
+	          el.sceneEl.object3D.add(el.object3D.boxHelper);
+	        }
+	        el.object3D.boxHelper.setFromObject(el.object3D);
+	      }
+
+	      boxMin = boundingBox.min;
+	      boxMax = boundingBox.max;
+	      el.object3D.boundingBoxCenter = el.object3D.boundingBoxCenter || new THREE.Vector3();
+	      boundingBox.getCenter(el.object3D.boundingBoxCenter);
+	      return (this.boxMin.x <= boxMax.x && this.boxMax.x >= boxMin.x) &&
+	             (this.boxMin.y <= boxMax.y && this.boxMax.y >= boxMin.y) &&
+	             (this.boxMin.z <= boxMax.z && this.boxMax.z >= boxMin.z);
+	    };
+	  })(),
+
+	  /**
+	   * Mark the object list as dirty, to be refreshed before next raycast.
+	   */
+	  setDirty: function () {
+	    this.dirty = true;
+	  },
+
+	  /**
+	   * Update list of objects to test for intersection.
+	   */
+	  refreshObjects: function () {
+	    var data = this.data;
+	    // If objects not defined, intersect with everything.
+	    this.objectEls = data.objects
+	      ? this.el.sceneEl.querySelectorAll(data.objects)
+	      : this.el.sceneEl.children;
+	    this.dirty = false;
+	  }
+	});
+
+	function copyArray (dest, source) {
+	  var i;
+	  dest.length = 0;
+	  for (i = 0; i < source.length; i++) { dest[i] = source[i]; }
+	}
+
+
+/***/ })
+/******/ ]);

public/vwf/model/aframeComponent.js

@@ -118,6 +118,9 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                     'A-SOUND': [
                         "autoplay", "distanceModel", "loop", "maxDistance", "on", "poolSize", "refDistance",
                         "rolloffFactor", "src", "volume"
+                    ],
+                    'aabb-collider':[
+                        "collideNonVisible", "debug",  "enabled", "objects", "interval"
                     ]
 
             }
@@ -315,28 +318,23 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                 }
 
 
-                if (value === undefined && isARayCasterListenerDefinition(node.prototypes)) {
-                    if (aframeObject.el.getAttribute(aframeObject.compName)) {
-
-                        value = propertyValue;
-                        let parentNodeAF = aframeObject.el;
-
+                // if (value === undefined && isARayCasterListenerDefinition(node.prototypes)) {
+                //     if (aframeObject.el.getAttribute(aframeObject.compName)) {
 
-                        switch (propertyName) {
+                //         value = propertyValue;
+                //         let parentNodeAF = aframeObject.el;
 
-                            case "class":
-                                parentNodeAF.setAttribute('class', propertyValue);
-                                break;
 
+                //         switch (propertyName) {
 
-                            default:
-                                value = undefined;
-                                break;
-                        }
+                //             default:
+                //                 value = undefined;
+                //                 break;
+                //         }
 
 
-                    }
-                }
+                //     }
+                // }
 
                 if (value === undefined && isAShadowDefinition(node.prototypes)) {
                     if (aframeObject.el.getAttribute(aframeObject.compName)) {
@@ -393,6 +391,20 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                     }
                 }
 
+                if (value === undefined && isAAabbColliderDefinition(node.prototypes)) {
+                    if (aframeObject.el.getAttribute(aframeObject.compName)) {
+
+                        value = propertyValue;
+                        let parentNodeAF = aframeObject.el;
+                        //let defs = ['color', 'transparent', 'opacity', 'side'];
+
+                        self.aframeComponentDef['aabb-collider'].forEach(element => {
+                            element == propertyName ? parentNodeAF.setAttribute('aabb-collider', element, propertyValue) :
+                                value = undefined;
+                        })
+                    }
+                }
+
                 if (value === undefined && isAFogDefinition(node.prototypes)) {
                     if (aframeObject.el.getAttribute(aframeObject.compName)) {
 
@@ -674,25 +686,18 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                 }
 
 
-                if (value === undefined && isARayCasterListenerDefinition(node.prototypes)) {
+                // if (value === undefined && isARayCasterListenerDefinition(node.prototypes)) {
                     
+                //         value = propertyValue;
+                //         let parentNodeAF = aframeObject.el;
 
-                        value = propertyValue;
-                        let parentNodeAF = aframeObject.el;
-
+                //         switch (propertyName) {
 
-                        switch (propertyName) {
-
-                            case "class":
-                                parentNodeAF.getAttribute('class');
-                                break;
-
-
-                            default:
-                                value = undefined;
-                                break;
-                        }
-                }
+                //             default:
+                //                 value = undefined;
+                //                 break;
+                //         }
+                // }
 
 
                 if (value === undefined && isAFogDefinition(node.prototypes)) {
@@ -841,6 +846,20 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
                     })
                 }
 
+                if (value === undefined && isAAabbColliderDefinition(node.prototypes)) {
+                    value = propertyValue;
+
+                    // let parentNodeAF = self.state.nodes[node.parentID].aframeObj;
+                    let parentNodeAF = aframeObject.el;
+
+                    self.aframeComponentDef['aabb-collider'].forEach(element => {
+                        if (element == propertyName) {
+                            value = parentNodeAF.getAttribute('aabb-collider').element;
+                        }
+
+                    })
+                }
+
                 if (value === undefined && isALinePathDefinition(node.prototypes)) {
                     value = propertyValue;
 
@@ -1067,6 +1086,18 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
         return found;
     }
 
+    function isAAabbColliderDefinition(prototypes) {
+        var found = false;
+        if (prototypes) {
+            for (var i = 0; i < prototypes.length && !found; i++) {
+                found = (prototypes[i] == "http://vwf.example.com/aframe/aabb-collider-component.vwf");
+            }
+        }
+        return found;
+    }
+
+    
+
     function isARayCasterDefinition(prototypes) {
         var found = false;
         if (prototypes) {
@@ -1087,7 +1118,15 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
         return found;
     }
 
-   
+    function isAAabbColliderListenerDefinition(prototypes) {
+        var found = false;
+        if (prototypes) {
+            for (var i = 0; i < prototypes.length && !found; i++) {
+                found = (prototypes[i] ==  "http://vwf.example.com/aframe/app-aabb-collider-listener-component.vwf");
+            }
+        }
+        return found;
+    }
 
     function isALineDefinition(prototypes) {
         var found = false;
@@ -1197,6 +1236,14 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
 
         }
 
+        if (self.state.isComponentClass(protos, "http://vwf.example.com/aframe/aabb-collider-component.vwf")) {
+
+            // aframeObj.el.setAttribute(node.type, {});
+            aframeObj.compName = "aabb-collider";
+            aframeObj.el.setAttribute(aframeObj.compName, {});
+
+        }
+
         if (self.state.isComponentClass(protos, "http://vwf.example.com/aframe/viewOffsetCamera-component.vwf")) {
 
             // aframeObj.el.setAttribute(node.type, {});
@@ -1304,6 +1351,15 @@ define(["module", "vwf/model", "vwf/utility"], function (module, model, utility)
 
         }
 
+        if (self.state.isComponentClass(protos, "http://vwf.example.com/aframe/app-aabb-collider-listener-component.vwf")) {
+
+
+            // aframeObj.el.setAttribute(node.type, {});
+            aframeObj.compName = "aabb-collider-listener";
+            aframeObj.el.setAttribute(aframeObj.compName, {});
+
+        }
+
         if (self.state.isComponentClass(protos, "http://vwf.example.com/aframe/app-cursor-listener-component.vwf")) {
 
 

public/vwf/view/aframe.js

@@ -474,25 +474,11 @@ define(["module", "vwf/view"], function (module, view) {
 
             }
 
+            let intersectEvents = ['hitstart', 'hitend', 'intersect', 'clearIntersect'];
 
-            if (eventName == "intersectEvent") {
-
-                var clientThatSatProperty = self.kernel.client();
-                var me = self.kernel.moniker();
-
-                // If the transform property was initially updated by this view....
-                if (clientThatSatProperty == me) {
-
-                    if (me == eventParameters[0]) {
-                        vwf_view.kernel.callMethod(nodeID, "intersectEventMethod", [])
-                    }
-                }
-
-            }
-
-
-            if (eventName == "clearIntersectEvent") {
-
+            let hitEvent = intersectEvents.filter(el=> el == eventName.slice(0,-5))[0]; //slice Event word
+            if (hitEvent)
+            {
                 var clientThatSatProperty = self.kernel.client();
                 var me = self.kernel.moniker();
 
@@ -500,11 +486,13 @@ define(["module", "vwf/view"], function (module, view) {
                 if (clientThatSatProperty == me) {
 
                     if (me == eventParameters[0]) {
-                        vwf_view.kernel.callMethod(nodeID, "clearIntersectEventMethod", [])
+                        let methodName = eventName +'Method';
+                        vwf_view.kernel.callMethod(nodeID, methodName, [])
                     }
                 }
 
             }
+    
 
             if (eventName == "clickEvent") {