Lot of doc

controllers/list/views/index.jade

@@ -4,7 +4,6 @@ block title
     title #{title} - Test
 
 block extrajs
-    script(src='/static/js/List.min.js')
     script(src='/static/js/ListTest.min.js')
 
 block content

js/Makefile

@@ -6,13 +6,14 @@ else
 	CLOSURE=../utils/simple-compiler/compiler.sh
 endif
 
-all: L3D L3DP Socket Three Stats Bouncing Multisphere StreamingSimulator PrototypeReplay PrototypeInteractive Tutorial
+all: L3D L3DP Socket Three Stats Bouncing Multisphere StreamingSimulator PrototypeReplay PrototypeInteractive Tutorial TestList
 
 L3D:
 	$(CLOSURE) $(OPT) \
 		--js l3d/src/l3d.js \
 		--js l3d/src/math/Tools.js \
 		--js l3d/src/math/Hermite.js \
+		--js l3d/src/utils/List.js \
 		--js l3d/src/utils/CameraSelecter.js \
 		--js l3d/src/utils/Logger.js \
 		--js l3d/src/utils/Objects.js \
@@ -33,6 +34,13 @@ L3D:
 		--js l3d/src/scenes/initScene.js \
 		--js_output_file ../static/js/l3d.min.js
 
+TestList:
+	$(CLOSURE) $(OPT) \
+		--js l3d/src/l3d.js \
+		--js l3d/src/utils/List.js \
+		--js l3d/src/utils/ListTest.js \
+		--js_output_file ../static/js/ListTest.min.js
+
 L3DP:
 	$(CLOSURE) $(OPT) \
 		--js l3d/apps/prototype/ButtonManager.js \

js/l3d/apps/prototype/interactive/main.js

@@ -142,13 +142,6 @@ function init() {
 function initListeners() {
     window.addEventListener('resize', onWindowResize, false);
 
-    // Transmit click event to camera selecter
-    document.addEventListener('mousedown', function(event) {
-        if (event.which == 1)
-            cameraSelecter.clickPointer(event);
-        }, false
-    );
-
     // Transmit click event to camera selecter
     container.addEventListener('mousedown', function(event) {
         if (event.which == 1)

js/l3d/src/canvases/MousePointer.js

@@ -1,19 +1,89 @@
+/**
+ * Contains a canvas to place over the renderer for FPS-style pointer
+ * It's based on a javascript 2d-canvas : you'll need to render it manually.
+ *
+ * @example
+ * var container = documeng.getElementById('container');
+ * var renderer = new THREE.WebGLRenderer();
+ * renderer.setSize(width, height);
+ *
+ * var pointerCamera = new L3D.PointerCamera(50, width/height, near, fat, renderer, container);
+ * var mousePointer = new L3D.MousePointer(pointerCamera);
+ * mousePointer.domElement.width = width;
+ * mousePointer.domElement.height = height;
+ *
+ * container.appendChild(mousePointer.domElement);
+ * container.appendChild(renderer.domElement);
+ *
+ * mousePointer.render(L3D.MousePointer.BLACK);
+ * @memberof L3D
+ * @constructor
+ */
 L3D.MousePointer = function(camera) {
 
+    /**
+     * @type {elemnt}
+     * @description The document element to add on top of the renderer
+     */
     this.domElement = document.createElement('canvas');
+
     this.domElement.style.position = 'absolute';
     this.domElement.style.cssFloat = 'top-left';
+
+    /**
+     * @type {CanvasRenderingContext2D}
+     * @description The context of the canvas
+     */
     this.ctx = this.domElement.getContext('2d');
+
+    /**
+     * @type {Number}
+     * @description The size of the gun sight
+     */
     this.size = 10;
-    this.drawn = false;
+
     camera.mousePointer = this;
+
+    /**
+     * @type {Number}
+     * @description a L3D.MousePointer style. The current style of the mouse pointer
+     */
     this.style = L3D.MousePointer.NONE;
+
 };
 
+/**
+ * @memberof L3D.MousePointer
+ * @type {Number}
+ * @static
+ * @description Empty style : the canvas is fully transparent
+ */
 L3D.MousePointer.NONE = 0;
+
+/**
+ * @memberof L3D.MousePointer
+ * @type {Number}
+ * @static
+ * @description Black style : the canvas contains only a white cross in the middle of the screen
+ */
 L3D.MousePointer.BLACK = 1;
+
+/**
+ * @memberof L3D.MousePointer
+ * @type {Number}
+ * @static
+ * @description Red style : the canvas contains only a white and red cross in the midlle
+ * (used for hovering stuff)
+ */
 L3D.MousePointer.RED = 2;
 
+/**
+ * @memberof L3D.MousePointer
+ * @static
+ * @description Converts a style to a color
+ * @param {Number} style a L3D.MousePointer style (NONE, BLACK, or RED)
+ * @returns {string} null if input is NONE, a hex color string else
+ */
 L3D.MousePointer.toColor = function(style) {
 
     switch (style) {
@@ -29,9 +99,28 @@ L3D.MousePointer.toColor = function(style) {
 
 };
 
-L3D.MousePointer.prototype.render = function(style) {
+/**
+ * Re-renders the canvas
+ * For performance reasons, the rendering is done only if the style changed.
+ * @param {Number} style the L3D.MousePointer style you want to render
+ * @param {Boolean} force force the re-rendering (even if the style did not change)
+ *
+ */
+L3D.MousePointer.prototype.render = function(style, force) {
 
-    if (this.style !== style) {
+    if (style === undefined) {
+
+        style = L3D.MousePointer.NONE;
+
+    }
+
+    if (force === undefined) {
+
+        force = false;
+
+    }
+
+    if (this.style !== style || force) {
 
         if (style === L3D.MousePointer.NONE) {
 
@@ -75,8 +164,18 @@ L3D.MousePointer.prototype.render = function(style) {
 
 };
 
-L3D.MousePointer.prototype.clear = function() {
+/**
+ * Clears the canvas
+ * @param {Boolean} force force the clearing (even if the style did not change)
+ */
+L3D.MousePointer.prototype.clear = function(force) {
 
-    this.render(L3D.MousePointer.NONE);
+    if (force === undefined) {
+
+        force = false;
+
+    }
+
+    this.render(L3D.MousePointer.NONE, force);
 
 };

js/l3d/src/canvases/Previewer.js

@@ -2,16 +2,72 @@ Math.clamp = Math.clamp || function(number, min, max) {
     return Math.max(Math.min(number, max), min);
 };
 
+/**
+ * @memberof L3D
+ * @constructor
+ * @param {THREE.Renderer} renderer the renderer to use
+ * @param {THREE.Scene} scene the scene to render
+ * @description Displays a small preview of a camera
+ */
 L3D.Previewer = function(renderer, scene) {
+    /**
+     * @type {element}
+     * @description The document element to add on top of the renderer
+     */
     this.domElement = document.createElement('canvas');
+
+    /**
+     * @type {CanvasRenderingContext2D}
+     * @description The context of domElement
+     */
     this.ctx = this.domElement.getContext('2d');
+
+    /**
+     * @type {THREE.Renderer}
+     * @description The renderer to use
+     */
     this.renderer = renderer;
-    this.fixed = false;
+
+    /**
+     * @type {THREE.Scene}
+     * @description The scene to render
+     */
     this.scene = scene;
+
+    /**
+     * @type {Boolean}
+     * @description true if the preview should be stuck at the bottom left of the container,
+     * false if it should appear near the mouse
+     */
+    this.fixed = false;
+
+    /**
+     * @private
+     * @type {Boolean}
+     * @description true if the rendering as already been done
+     */
     this.drawn = false;
+
+    /**
+     * @private
+     * @type {Boolean}
+     * @description true if the rendering was done before
+     */
     this.drawnBefore = false;
 };
 
+/**
+ * Renders the preview
+ * @param {Object} pref an object containing :
+ * <ul>
+ *  <li><code>go</code> : a boolean if the rendering should be done</li>
+ *  <li><code>x</code> : the x coordinate of the mouse</li>
+ *  <li><code>y</code> : the y coordinate of the mouse</li>
+ *  <li><code>camera</code> : the camera to use for the preview</li>
+ * </ul>
+ * @param {Number} container_width width of the container
+ * @param {Number} container_height height of the container
+ */
 L3D.Previewer.prototype.render = function(prev, container_width, container_height) {
     var width, height, left, bottom;
 
@@ -79,6 +135,9 @@ L3D.Previewer.prototype.render = function(prev, container_width, container_heigh
 
 };
 
+/**
+ * Clears the borders of the preview
+ */
 L3D.Previewer.prototype.clear = function() {
     if (this.clearNeeded) {
         this.domElement.width = this.domElement.width;
@@ -86,10 +145,19 @@ L3D.Previewer.prototype.clear = function() {
     }
 };
 
+/**
+ * Setter for the fixed preview
+ * @param {Boolean} true if you want to fix the preview, false otherwise
+ */
 L3D.Previewer.prototype.fixedRecommendation = function(bool) {
     this.fixed = bool;
 };
 
+/**
+ * @private
+ * @description Update flags
+ * @param {Boolean} arg if the update drew something
+ */
 L3D.Previewer.prototype.update = function(arg) {
     this.drawnBefore = this.drawn;
     this.drawn = arg;

js/l3d/src/canvases/StartCanvas.js

@@ -1,15 +1,37 @@
+/**
+ * @memberof L3D
+ * @constructor
+ * @description Displays a translucid canvas over the renderer to enable interaction to lock pointer
+ */
 L3D.StartCanvas = function(camera) {
 
+    /**
+     * @type {elemnt}
+     * @description The document element to add on top of the renderer
+     */
     this.domElement = document.createElement('canvas');
     this.domElement.style.position = 'absolute';
     this.domElement.style.cssFloat = 'top-left';
+
+    /**
+     * @type {CanvasRenderingContext2D}
+     * @description The context of the canvas
+     */
     this.ctx = this.domElement.getContext('2d');
+
+    /**
+     * @type {Boolean}
+     * @description true if the canvas is displayed
+     */
     this.shown = false;
 
     camera.startCanvas = this;
 
 };
 
+/**
+ * Shows the canvas with a string in the middle of it
+ */
 L3D.StartCanvas.prototype.render = function() {
 
     if (!this.shown) {
@@ -30,6 +52,9 @@ L3D.StartCanvas.prototype.render = function() {
 
 };
 
+/**
+ * Hide canvas
+ */
 L3D.StartCanvas.prototype.clear = function() {
 
     if (this.shown) {

js/l3d/src/l3d.js

@@ -2,3 +2,11 @@
  * @namespace
  */
 var L3D = {};
+
+if (typeof module !== 'undefined' && module.exports) {
+
+    var THREE = require('three');
+
+    module.exports = L3D;
+}
+

js/l3d/src/math/Hermite.js

@@ -1,10 +1,42 @@
+/**
+ * @memberof L3D
+ * @namespace
+ * @description Contains eveything linked to hermite polynoms
+ */
 L3D.Hermite = {};
 
+/**
+ * @memberof L3D.Hermite
+ * @constructor
+ * @description creates a hermite polynom
+ * @param t {Number[]|THREE.Vector3[]} time indices of the interpolation
+ * @param f {Number[]|THREE.Vector3[]} values of the polynom at each time
+ * @param fp {Number[]|THREE.Vector3[]} values of the derivative of the polynom at each time
+ */
 L3D.Hermite.Polynom = function(t, f, fp) {
+
+    /**
+     * @type {Number[]|THREE.Vector3[]}
+     * @description time indices of the interpolation
+     */
     this.times = t;
+
+    /**
+     * @type {Number[]|THREE.Vector3[]}
+     * @description values of the polynom at each time
+     */
     this.evals = f;
+
+    /**
+     * @type {Number[]|THREE.Vector3[]}
+     * @description values of the derivatives of the polynom at each time
+     */
     this.primes = fp;
 
+    /**
+     * @type {L3D.Hermite.BaseFunction[]}
+     * @description array of the base functions to evaluate the poylnom
+     */
     this.baseFunctions = [];
 
     for (var i in this.times) {
@@ -12,6 +44,14 @@ L3D.Hermite.Polynom = function(t, f, fp) {
     }
 
     // Let's do something at least a little reusable
+    /**
+     * @type {Object}
+     * @description an object containing
+     * <ul>
+     *  <li><code>whatType</code> : a string being <code>THREE.Vector3</code> or <code>number</code></li>
+     *  <li><code>tools</code> : an object containg sum and mul, functions of the correct type</li>
+     * </ul>
+     */
     this.tools = {};
     if (f[0] instanceof THREE.Vector3) {
         this.tools.whatType = 'THREE.Vector3';
@@ -24,6 +64,11 @@ L3D.Hermite.Polynom = function(t, f, fp) {
     }
 };
 
+/**
+ * Evaluates the polynom at a certain time
+ * @param t {Number} time at which you want to evaluate the polynom
+ * @return {Number|THREE.Vector3} the evaluation of the polynom at the given time
+ */
 L3D.Hermite.Polynom.prototype.eval = function(t) {
     var ret;
 
@@ -67,6 +112,11 @@ L3D.Hermite.Polynom.prototype.eval = function(t) {
     return ret;
 };
 
+/**
+ * Evaluates the derivate of the polynom at a certain time
+ * @param t {Number} time at which you want to evaluate the derivative of the polynom
+ * @return {Number|THREE.Vector3} the evaluation of the derivative of the polynom at the given time
+ */
 L3D.Hermite.Polynom.prototype.prime = function(t) {
     var ret;
 
@@ -141,11 +191,32 @@ L3D.Hermite.Polynom.prototype.prime = function(t) {
     return ret;
 };
 
+/**
+ * @memberof L3D.Hermite
+ * @constructor
+ * @description Represents a base function for evaluation of hermite polynoms
+ * @param index {Number} the index of the base function
+ * @param times {Number[]} the times for polynom interpolation
+ */
 L3D.Hermite.BaseFunction = function(index, times) {
+    /**
+    * @type {Number}
+    * @description the index of the base function
+    */
     this.index = index;
+
+    /**
+     * @type {Number[]}
+     * @description the times for polynom interpolation
+     */
     this.times = times;
 };
 
+/**
+ * Returns the evaluation of the base function
+ * @param t {Number} time at which you want to evaluate the base function
+ * @returns {Number} the evaluation of the base function at the given time
+ */
 L3D.Hermite.BaseFunction.prototype.eval = function(t) {
     var ret = 1;
 
@@ -158,6 +229,11 @@ L3D.Hermite.BaseFunction.prototype.eval = function(t) {
     return ret * ret;
 };
 
+/**
+ * Returns the evaluation of the derivative of the base function
+ * @param t {Number} time at which you want to evaluate the derivative of the base function
+ * @returns {Number} the evaluation of the derivative of the base function at the given time
+ */
 L3D.Hermite.BaseFunction.prototype.prime = function(t) {
     var ret = 0;
 
@@ -170,16 +246,40 @@ L3D.Hermite.BaseFunction.prototype.prime = function(t) {
     return this.eval(t) * ret;
 };
 
+/**
+ * @memberof L3D.Hermite
+ * @namespace
+ */
 L3D.Hermite.special = {};
 
-// This polynom interpolates with two coords and one derivative
+/**
-// t = [0,1]
+ * @memberof L3D.Hermite.special
+ * @description Represents a simple hermite polynom where the times are [0, 1], and where
+ * the position is known at 0, 1 and where the derivative is only known at 1
+ * @constructor
+ * @param P0 {Number|THREE.Vector3} polynom at instant 0
+ * @param P1 {Number|THREE.Vector3} polynom at instant 1
+ * @param PP1 {Number|THREE.Vector3} derivative of the polynom at instant 1
+ */
 L3D.Hermite.special.Polynom = function(P0, P1, PP1) {
+    /**
+     * @type {Object}
+     * @description an object containing
+     * <ul>
+     *  <li><code>whatType</code> : a string being <code>THREE.Vector3</code> or <code>number</code></li>
+     *  <li><code>tools</code> : an object containg sum and mul, functions of the correct type</li>
+     * </ul>
+     */
     this.tools = {};
     if (P0 instanceof THREE.Vector3) {
         this.tools.sum = L3D.Tools.sum;
         this.tools.mul = L3D.Tools.mul;
         this.tools.diff = L3D.Tools.diff;
+
+        /**
+         * @type {Number|THREE.Vector3}
+         * @description b of ax²+bx+c
+         */
         this.c = P0.clone();
     } else {
         this.tools.sum = function(a,b) { return a+b; };
@@ -188,14 +288,33 @@ L3D.Hermite.special.Polynom = function(P0, P1, PP1) {
         this.c = P0;
     }
 
+    /**
+     * @type {Number}
+     * @description a of ax²+bx+c
+     */
     this.a = this.tools.sum(PP1, this.tools.diff(P0, P1));
+
+    /**
+     * @type {Number}
+     * @description b of ax²+bx+c
+     */
     this.b = this.tools.diff(this.tools.mul(this.tools.diff(P1,P0), 2), PP1);
 };
 
+/**
+ * Returns the evaluation of the polynom
+ * @param t {Number} time at which you want to evaluate the polynom
+ * @returns {Number|THREE.Vector3} the evaluation of the polynom at the given time
+ */
 L3D.Hermite.special.Polynom.prototype.eval = function(t) {
     return this.tools.sum(this.tools.mul(this.a, t*t), this.tools.sum(this.tools.mul(this.b, t), this.c));
 };
 
+/**
+ * Returns the evaluation of the derivative of the polynom
+ * @param t {Number} time at which you want to evaluate the derivative of the polynom
+ * @returns {Number|THREE.Vector3} the evaluation of the derivative of the polynom at the given time
+ */
 L3D.Hermite.special.Polynom.prototype.prime = function(t) {
     return this.tools.sum(this.tools.mul(this.a,2*t), this.b);
 };

js/l3d/src/math/Tools.js

@@ -1,17 +1,52 @@
+/**
+ * @namespace
+ * @memberof L3D
+ * @description Contains various functions for manipulating THREE.Vector3
+ * Note that all these functions also work objects {x: x, y: y, z: z}, even if
+ * they're not THREE.Vector3
+ */
 L3D.Tools = {};
 
+/**
+ * @memberof L3D.Tools
+ * @description Computes the sum of two vectors
+ * @param v1 {Vector} first vector of the sum
+ * @param v2 {Vector} second vector of the sum
+ * @returns {THREE.Vector3} v1 + v2
+ */
 L3D.Tools.sum = function(v1, v2) {
     return new THREE.Vector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 };
 
+/**
+ * @memberof L3D.Tools
+ * @description Computes the difference between two vectors
+ * @param v1 {Vector} first vector of the difference
+ * @param v2 {Vector} second vector of the difference
+ * @returns {THREE.Vector3} v1 - v2
+ */
 L3D.Tools.diff = function(v1, v2) {
     return new THREE.Vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
 };
 
+/**
+ * @memberof L3D.Tools
+ * @description Computes the dot product of two vectors
+ * @param v1 {Vector} first vector of the dot product
+ * @param v2 {Vector} second vector of the dot product
+ * @returns {THREE.Vector3} v1 * v2
+ */
 L3D.Tools.dot = function(v1, v2) {
     return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
 };
 
+/**
+ * @memberof L3D.Tools
+ * @description Computes the cross product of two vectors
+ * @param v1 {Vector} first vector of the cross product
+ * @param v2 {Vector} second vector of the cross product
+ * @returns {THREE.Vector3} v1 ^ v2
+ */
 L3D.Tools.cross = function(v1, v2) {
     return new THREE.Vector3(
          v1.y * v2.z - v1.z * v2.y,
@@ -20,18 +55,33 @@ L3D.Tools.cross = function(v1, v2) {
     );
 };
 
+/**
+ * @memberof L3D.Tools
+ * @description Computes the product of a vector and a number
+ * @param v1 {Vector} vector of the product
+ * @param lambda {Number} number of the product
+ * @returns {THREE.Vector3} v1 * lambda
+ */
 L3D.Tools.mul = function(v1, lambda) {
     return new THREE.Vector3(v1.x * lambda, v1.y * lambda, v1.z * lambda);
 };
 
-L3D.Tools.equals = function(v1, v2) {
+/**
-    return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z;
+ * @memberof L3D.Tools
-};
+ * @description Computes the square norm of a vector
-
+ * @param v {Vector} vector you want to compute the norm of
+ * @returns {Number} ||v||²
+ */
 L3D.Tools.norm2 = function(v) {
     return v.x * v.x + v.y * v.y + v.z * v.z;
 };
 
+/**
+ * @memberof L3D.Tools
+ * @description Computes the norm of a vector
+ * @param v {Vector} vector you want to compute the norm of
+ * @returns {Number} ||v||
+ */
 L3D.Tools.norm = function(v) {
     return Math.sqrt(L3D.Tools.norm2(v));
 };

js/l3d/src/recommendations/ArrowRecommendation.js

@@ -1,6 +1,8 @@
-// Initialization
+/**
-
+ * @description Represents a reccomendation displayed as an arrow
-// class camera extends THREE.PerspectiveCamera
+ * @constructor
+ * @extends L3D.BaseRecommendation
+ */
 L3D.ArrowRecommendation = function(arg1, arg2, arg3, arg4, position, target) {
     L3D.BaseRecommendation.apply(this, arguments);
 };

js/l3d/src/recommendations/BaseRecommendation.js

@@ -1,6 +1,10 @@
-// Initialization
+/**
-
+ * @memberof L3D
-// class camera extends THREE.PerspectiveCamera
+ * @description The base class for recommendation
+ * @constructor
+ * @extends THREE.PerspectiveCamera
+ * @abstract
+ */
 L3D.BaseRecommendation = function(arg1, arg2, arg3, arg4, position, target) {
     THREE.PerspectiveCamera.apply(this, arguments);
 
@@ -41,6 +45,9 @@ L3D.BaseRecommendation = function(arg1, arg2, arg3, arg4, position, target) {
 L3D.BaseRecommendation.prototype = Object.create(THREE.PerspectiveCamera.prototype);
 L3D.BaseRecommendation.prototype.constructor = L3D.BaseRecommendation;
 
+/**
+ * Changes the color of the meshes like a HTML link
+ */
 L3D.BaseRecommendation.prototype.check = function() {
     this.object3D.traverse(function(obj) {
         if (obj instanceof THREE.Mesh)
@@ -48,6 +55,9 @@ L3D.BaseRecommendation.prototype.check = function() {
     });
 };
 
+/**
+ * Initialize the extremity of the arrow
+ */
 L3D.BaseRecommendation.prototype.initExtremity = function() {
     var geometry = new THREE.Geometry();
 
@@ -92,6 +102,9 @@ L3D.BaseRecommendation.prototype.initExtremity = function() {
     return this.mesh;
 };
 
+/**
+ * Updates the extremity of the arrow
+ */
 L3D.BaseRecommendation.prototype.updateExtremity = function() {
     var direction = this.target.clone();
     direction.sub(this.position);
@@ -118,12 +131,22 @@ L3D.BaseRecommendation.prototype.updateExtremity = function() {
 
 };
 
+/**
+ * Changes the size of the element
+ * @param size {Number} new size
+ * @deprecated this function doesn't work since there are lots of things to
+ * keep in mind (length of the arrow, width, size of the body, size of the
+ * extremity...)
+ */
 L3D.BaseRecommendation.prototype.setSize = function(size) {
     this.size = size;
     this.updateExtremity();
 };
 
-// Update function
+/**
+ * Updates the arrow. The arrow is moving according to the position of the camera
+ * @param {Object} a camera containing two THREE.Vector3 (position, and target)
+ */
 L3D.BaseRecommendation.prototype.update = function(mainCamera) {
     // Compute distance between center of camera and position
     dist = L3D.Tools.norm2(L3D.Tools.diff(mainCamera.position, this.center));
@@ -156,6 +179,10 @@ L3D.BaseRecommendation.prototype.update = function(mainCamera) {
     this.regenerateArrow(mainCamera);
 };
 
+/**
+ * Regenerates the arrow according to the position of the camera
+ * @param {Object} a camera containing two THREE.Vector3 (position, and target)
+ */
 L3D.BaseRecommendation.prototype.regenerateArrow = function(mainCamera) {
     var i;
     var vertices = [];
@@ -266,20 +293,34 @@ L3D.BaseRecommendation.prototype.regenerateArrow = function(mainCamera) {
 
 };
 
-// Look function
+/**
+ * Look at function. Just like OpenGL gluLookAt (from position to target)
+ */
 L3D.BaseRecommendation.prototype.look = function() {
     this.lookAt(this.target);
 };
 
+/**
+ * Add the camera and its mesh representation to the scene
+ * @param scene {THREE.Scene} scene to add the camera to
+ */
 L3D.BaseRecommendation.prototype.addToScene = function(scene) {
     scene.add(this);
     scene.add(this.object3D);
 };
 
+/**
+ * Apply a callback to all objects representing the camera
+ * @param callback {function} callback to call on each mesh
+ */
 L3D.BaseRecommendation.prototype.traverse = function(callback) {
     this.object3D.traverse(callback);
 };
 
+/**
+ * Checks if an object is contained in the representation of the camera
+ * @param object {THREE.Object3D} Object that could belong the camera
+ */
 L3D.BaseRecommendation.prototype.containsObject = function(object) {
     return object.parent === this.object3D;
 };

js/l3d/src/recommendations/ReverseRecommendation.js

@@ -1,3 +1,9 @@
+/**
+ * @constructor
+ * @memberof L3D
+ * @description Different representation of 3D recommendation (kind of a weird one)
+ * @extends L3D.BaseRecommendation
+ */
 L3D.ReverseRecommendation = function(arg1, arg2, arg3, arg4, position, target) {
     L3D.BaseRecommendation.apply(this, arguments);
 };

js/l3d/src/recommendations/ViewportRecommendation.js

@@ -1,6 +1,9 @@
-// Initialization
+/**
-
+ * @memberof L3D
-// class camera extends THREE.PerspectiveCamera
+ * @extends L3D.BaseRecommendation
+ * @description Reprensents a recommendation as a viewport (3D representation of a camera)
+ * @constructor
+ */
 L3D.ViewportRecommendation = function(arg1, arg2, arg3, arg4, position, target) {
     THREE.PerspectiveCamera.apply(this, arguments);
 

js/l3d/src/utils/CameraSelecter.js

@@ -116,8 +116,6 @@ L3D.CameraSelecter.prototype.update = function(event, y) {
 L3D.CameraSelecter.prototype.click = function(event) {
     var e;
 
-    if (this.cameras.mainCamera().pointerLocked === false) {
-
     var newCamera = this.pointedCamera();
 
     if (newCamera !== undefined && !(newCamera instanceof Coin)) {
@@ -140,35 +138,4 @@ L3D.CameraSelecter.prototype.click = function(event) {
 
     }
 
-    }
-
-};
-
-L3D.CameraSelecter.prototype.clickPointer = function(event) {
-    var e;
-
-    if (this.cameras.mainCamera().pointerLocked) {
-
-        var newCamera = this.pointedCamera();
-
-        if (newCamera !== undefined && !(newCamera instanceof Coin)) {
-
-            e = new L3D.BD.Event.ArrowClicked();
-            e.arrow_id = this.cameras.cameras.indexOf(newCamera);
-            e.send();
-
-            newCamera.check();
-            this.cameras.mainCamera().moveHermite(newCamera);
-            buttonManager.updateElements();
-
-        } else if (newCamera instanceof Coin) {
-
-            // Coin found, notify server
-            e = new L3D.BD.Event.CoinClicked();
-            e.coin_id = this.coins.indexOf(newCamera);
-            e.send();
-            newCamera.get();
-
-        }
-    }
 };

js/l3d/src/utils/List.js

@@ -1,21 +1,55 @@
+/**
+ * @namespace
+ * @memberof L3D
+ */
 L3D.utils = (function() {
 
 var utils = {};
 
-// Defines a double linked-list class
+/**
-utils.List = function() {
+ * @constructor
+ * @description Linked list in javascript
+ * @memberof L3D.utils
+ */
+var List = function() {
+
+    /**
+     * @private
+     * @type {Number}
+     * @description number of elements in the list
+     */
     this._size = 0;
+
+    /**
+     * @private
+     * @type {Object}
+     * @description first chain element of the list
+     */
     this._begin = null;
+
+    /**
+     * @private
+     * @type {Object}
+     * @description last chain element of the list
+     */
     this._end = null;
 };
 
-// Returns the number of element of a list
+/**
-utils.List.prototype.size = function() {
+ * Size of the list
+ * Complexity O(1)
+ * @returns {Number} the number of elements in the list
+ */
+List.prototype.size = function() {
     return this._size;
 };
 
-// Pushes an element to the end of a class
+/**
-utils.List.prototype.push = function(element) {
+ * Push an element at the end of the list
+ * Complexity O(1)
+ * @param element {Object} object to push at the end of the list
+ */
+List.prototype.push = function(element) {
     if (this._size === 0) {
         this._begin = { data : element, next: null, prev: null };
         this._end = this._begin;
@@ -28,8 +62,11 @@ utils.List.prototype.push = function(element) {
     }
 };
 
-// Sort the list
+/**
-utils.List.prototype.sort = function(comparator) {
+ * Sorts the list by creating an array, sorting it, and recopying it to the list
+ * Complexity O(size() * log (size()))
+ */
+List.prototype.sort = function(comparator) {
 
     if (comparator === undefined) {
         comparator = priv.defaultComparator;
@@ -52,15 +89,23 @@ utils.List.prototype.sort = function(comparator) {
     }
 };
 
-// Remove last element and returns it
+/**
-utils.List.prototype.pop = function() {
+ * Removes and returns the last element of the list
+ * Complexity O(1)
+ * @returns {Object} the last element of the list
+ */
+List.prototype.pop = function() {
     var tmp = this._end;
     this._end = null;
     return tmp.data;
 };
 
-// Apply a function to each element of the list
+/**
-utils.List.prototype.forEach = function(callback) {
+ * Apply a call back to each element of the list
+ * Complexity O(size())
+ * @param callback {function} callback to call on all elements of the list
+ */
+List.prototype.forEach = function(callback) {
     var chain = this._begin;
 
     while (chain !== null) {
@@ -69,8 +114,12 @@ utils.List.prototype.forEach = function(callback) {
     }
 };
 
-// Apply a function to each element of the list (starting from the end)
+/**
-utils.List.prototype.forEachInverse = function(callback) {
+ * Apply a call back to each element of the list in reverse order
+ * Complexity O(size())
+ * @param callback {function} callback to call on all elements of the list in reverse order
+ */
+List.prototype.forEachInverse = function(callback) {
     var chain = this._end;
 
     while (chain !== null) {
@@ -79,8 +128,13 @@ utils.List.prototype.forEachInverse = function(callback) {
     }
 };
 
-// Get ith element of the list
+/**
-utils.List.prototype.at = function(ith) {
+ * Get the ith element of the list
+ * Complexity O(ith)
+ * @param ith {Number} index of the element to get
+ * @returns {Object} the ith element if it exists, null otherwise
+ */
+List.prototype.at = function(ith) {
     if (ith < 0 || ith >= this.size()) {
         return null;
     }
@@ -93,16 +147,23 @@ utils.List.prototype.at = function(ith) {
     return chain.data;
 };
 
-// Clear the list
+/**
-utils.List.prototype.clear = function() {
+ * Empty the list
+ */
+List.prototype.clear = function() {
     this._begin = null;
     this._end = null;
     this._size = 0;
 };
 
-// Insert an element at the right place in the list
+/**
-// Precondition : list must be sorted
+ * Insert an element at the right place in a sorted list
-utils.List.prototype.insertSorted = function(elt, comparator) {
+ * Precondition : the list must be sorted
+ * Complexity : O(i) where i is the number of elements lower than elt
+ * @param elt {Object} element to add
+ * @param comparator {function} classic js comparator
+ */
+List.prototype.insertSorted = function(elt, comparator) {
     var newElement;
 
     if (comparator === undefined) {
@@ -146,8 +207,13 @@ utils.List.prototype.insertSorted = function(elt, comparator) {
     }
 };
 
-// Check if a list is sorted of not
+/**
-utils.List.prototype.isSorted = function(comparator) {
+ * Checks if a list is sorted
+ * Complexity : O(size()) if the list is sorted, O(i) where i is the first non-sorted element in the list
+ * @param comparator {function} classic js comparator
+ * @returns {Boolean} true if the list is sorted, false otherwise
+ */
+List.prototype.isSorted = function(comparator) {
     var chain = this._begin;
 
     if (comparator === undefined) {
@@ -164,61 +230,107 @@ utils.List.prototype.isSorted = function(comparator) {
     return true;
 };
 
-// Gives an iterator to the begin of the list
+/**
-utils.List.prototype.begin = function() {
+ * Returns an iterator to the begin of the list
-    return new utils.List.Iterator(this._begin, 0);
+ * @returns {Iterator} an interator to the first element
+ */
+List.prototype.begin = function() {
+    return new Iterator(this._begin, 0);
 };
 
-// Gives an iterator to the end of the list
+/**
-utils.List.prototype.end = function() {
+ * Returns an iterator to the end of the list
-    return new utils.List.Iterator(this._end, this.size() - 1);
+ * @returns {Iterator} an interator to the first element
+ */
+List.prototype.end = function() {
+    return new Iterator(this._end, this.size() - 1);
 };
 
-// Class iterator
+/**
-utils.List.Iterator = function(chain, counter) {
+ * @constructor
+ * @description Reprensents an iterator to an element of a list
+ * @param chain {Object} chain element of a list
+ * @param counter {Number} index of the current element
+ * @memberof L3D.utils
+ */
+var Iterator = function(chain, counter) {
     this._chain = chain;
     this._counter = counter;
 };
 
-// Go to the next element
+/**
-utils.List.Iterator.prototype.next = function() {
+ * Go to the next element
+ * @method
+ */
+Iterator.prototype.next = function() {
     this._chain = this._chain.next;
     this._counter ++;
 };
 
-// Go to the previous element
+/**
-utils.List.Iterator.prototype.prev = function() {
+ * Go to the previous element
+ * @method
+ */
+Iterator.prototype.prev = function() {
     this._chain = this._chain.prev;
     this._counter --;
 };
 
-// Return the current element
+/**
-utils.List.Iterator.prototype.get = function() {
+ * Returns the current element
+ * @method
+ * @returns {Object} current element
+ */
+Iterator.prototype.get = function() {
     return this._chain.data;
 };
 
-// Check if there is another element next
+/**
-utils.List.Iterator.prototype.hasNext = function() {
+ * Checks if there is a element after the current element
+ * @method
+ * @returns {Boolean} true if the element exists, false otherwise
+ */
+Iterator.prototype.hasNext = function() {
     return this._chain.next !== null;
 };
 
-// Check if there is another element before
+/**
-utils.List.Iterator.prototype.hasPrev = function() {
+ * Checks if there is a element before the current element
+ * @method
+ * @returns {Boolean} true if the element exists, false otherwise
+ */
+Iterator.prototype.hasPrev = function() {
     return this._chain.prev !== null;
 };
 
-// Compares to another iterator of the same list
+/**
-utils.List.Iterator.prototype.lowerThan = function(it2) {
+ * Compares two iterators of the same list
-    return utils.distance(this, it2) > 0;
+ * @param it2 {Iterator} second iterator of the comparison
+ * @returns {Boolean} result of this < it2
+ */
+Iterator.prototype.lowerThan = function(it2) {
+    return distance(this, it2) > 0;
 };
 
-// Compares to another iterator of the same list
+/**
-utils.List.Iterator.prototype.greaterThan = function(it2) {
+ * Compares two iterators of the same list
-    return utils.distance(this, it2) < 0;
+ * @method
+ * @param it2 {Iterator} second iterator of the comparison
+ * @returns {Boolean} result of this > it2
+ */
+Iterator.prototype.greaterThan = function(it2) {
+    return distance(this, it2) < 0;
 };
 
-// Returns the distance between two iterators of the same list
+/**
-utils.distance = function(it1, it2) {
+ * Compute the distance between two iterators
+ * @method
+ * @private
+ * @param it1 {Iterator} first iterator of the computation
+ * @param it2 {Iterator} second iterator of the computation
+ * @returns {Number} distance between it1 and it2
+ */
+var distance = function(it1, it2) {
     return it2._counter - it1._counter;
 };
 
@@ -232,11 +344,11 @@ priv.defaultComparator = function(a,b) {
     return 0;
 };
 
-// Support for NodeJs
+utils.List = List;
-if (typeof module !== 'undefined' && module.exports) {
+utils.Iterator = Iterator;
-    module.exports = utils;
+
-} else {
 return utils;
-}
+
+console.log("Hello");
 
 })();