diff --git a/controllers/list/views/index.jade b/controllers/list/views/index.jade index 99dd837..0ca66cf 100644 --- a/controllers/list/views/index.jade +++ b/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 diff --git a/js/Makefile b/js/Makefile index abf3591..b39a602 100644 --- a/js/Makefile +++ b/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 \ diff --git a/js/l3d/apps/prototype/interactive/main.js b/js/l3d/apps/prototype/interactive/main.js index e031d14..002b77a 100644 --- a/js/l3d/apps/prototype/interactive/main.js +++ b/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) diff --git a/js/l3d/src/canvases/MousePointer.js b/js/l3d/src/canvases/MousePointer.js index cb64426..148bdf9 100644 --- a/js/l3d/src/canvases/MousePointer.js +++ b/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); }; diff --git a/js/l3d/src/canvases/Previewer.js b/js/l3d/src/canvases/Previewer.js index 8464b29..96a9aaa 100644 --- a/js/l3d/src/canvases/Previewer.js +++ b/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 : + * + * @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; diff --git a/js/l3d/src/canvases/StartCanvas.js b/js/l3d/src/canvases/StartCanvas.js index 78d00f6..e301812 100644 --- a/js/l3d/src/canvases/StartCanvas.js +++ b/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) { diff --git a/js/l3d/src/l3d.js b/js/l3d/src/l3d.js index 4cf4ef0..24f245b 100644 --- a/js/l3d/src/l3d.js +++ b/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; +} + diff --git a/js/l3d/src/math/Hermite.js b/js/l3d/src/math/Hermite.js index f0e0c73..93d79c5 100644 --- a/js/l3d/src/math/Hermite.js +++ b/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 + * + */ 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 + * + */ 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); }; diff --git a/js/l3d/src/math/Tools.js b/js/l3d/src/math/Tools.js index 4fd5b5b..5cf29c6 100644 --- a/js/l3d/src/math/Tools.js +++ 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)); }; diff --git a/js/l3d/src/recommendations/ArrowRecommendation.js b/js/l3d/src/recommendations/ArrowRecommendation.js index 956245c..9170998 100644 --- a/js/l3d/src/recommendations/ArrowRecommendation.js +++ b/js/l3d/src/recommendations/ArrowRecommendation.js @@ -1,6 +1,8 @@ -// Initialization - -// class camera extends THREE.PerspectiveCamera +/** + * @description Represents a reccomendation displayed as an arrow + * @constructor + * @extends L3D.BaseRecommendation + */ L3D.ArrowRecommendation = function(arg1, arg2, arg3, arg4, position, target) { L3D.BaseRecommendation.apply(this, arguments); }; diff --git a/js/l3d/src/recommendations/BaseRecommendation.js b/js/l3d/src/recommendations/BaseRecommendation.js index f82a9cb..330b827 100644 --- a/js/l3d/src/recommendations/BaseRecommendation.js +++ b/js/l3d/src/recommendations/BaseRecommendation.js @@ -1,6 +1,10 @@ -// Initialization - -// class camera extends THREE.PerspectiveCamera +/** + * @memberof L3D + * @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; }; diff --git a/js/l3d/src/recommendations/ReverseRecommendation.js b/js/l3d/src/recommendations/ReverseRecommendation.js index c8c59cc..2c4c26a 100644 --- a/js/l3d/src/recommendations/ReverseRecommendation.js +++ b/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); }; diff --git a/js/l3d/src/recommendations/ViewportRecommendation.js b/js/l3d/src/recommendations/ViewportRecommendation.js index 000bc4e..5ff7d65 100644 --- a/js/l3d/src/recommendations/ViewportRecommendation.js +++ b/js/l3d/src/recommendations/ViewportRecommendation.js @@ -1,6 +1,9 @@ -// Initialization - -// class camera extends THREE.PerspectiveCamera +/** + * @memberof L3D + * @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); diff --git a/js/l3d/src/utils/CameraSelecter.js b/js/l3d/src/utils/CameraSelecter.js index d2f05ad..c44b88c 100644 --- a/js/l3d/src/utils/CameraSelecter.js +++ b/js/l3d/src/utils/CameraSelecter.js @@ -116,59 +116,26 @@ 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(); - var newCamera = this.pointedCamera(); + if (newCamera !== undefined && !(newCamera instanceof Coin)) { - if (newCamera !== undefined && !(newCamera instanceof Coin)) { + e = new L3D.BD.Event.ArrowClicked(); + e.arrow_id = this.cameras.cameras.indexOf(newCamera); + e.send(); - 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(); - newCamera.check(); - this.cameras.mainCamera().moveHermite(newCamera); - buttonManager.updateElements(); + } else if (newCamera instanceof Coin) { - } 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(); - - } + // Coin found, notify server + e = new L3D.BD.Event.CoinClicked(); + e.coin_id = this.coins.indexOf(newCamera); + e.send(); + newCamera.get(); } }; - -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(); - - } - } -}; diff --git a/js/l3d/src/utils/List.js b/js/l3d/src/utils/List.js index 754bf17..c1aef1c 100644 --- a/js/l3d/src/utils/List.js +++ b/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 -utils.List.prototype.insertSorted = function(elt, comparator) { +/** + * Insert an element at the right place in a sorted list + * 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() { - return new utils.List.Iterator(this._begin, 0); +/** + * Returns an iterator to the begin of the list + * @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() { - return new utils.List.Iterator(this._end, this.size() - 1); +/** + * Returns an iterator to the end of the list + * @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) { - return utils.distance(this, it2) > 0; +/** + * Compares two iterators of the same list + * @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) { - return utils.distance(this, it2) < 0; +/** + * Compares two iterators of the same list + * @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 -if (typeof module !== 'undefined' && module.exports) { - module.exports = utils; -} else { - return utils; -} +utils.List = List; +utils.Iterator = Iterator; + +return utils; + +console.log("Hello"); })();