Merge pull request #3794 from thoys/20176

CR for Job #20176 - Ability to clone Overlay in Javascript

examples/clonedOverlaysExample.js

@@ -0,0 +1,294 @@
+//
+//  clonedOverlaysExample.js
+//  examples
+//
+//  Created by Thijs Wenker on 11/13/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Demonstrates the use of the overlay cloning function.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+const NUM_OF_TREES = 40;
+const NUM_OF_SANTAS = 20;
+
+// Image source: https://openclipart.org/detail/447/christmas-tree-by-theresaknott (heavily edited by Maximillian Merlin)
+const CHRISTMAS_TREE_SPRITES_URL = "http://test.thoys.nl/hifi/images/santa/christmas-tree.svg";
+
+// Image source: http://opengameart.org/content/santa-claus (CC-BY 3.0)
+const SANTA_SPRITES_URL = "http://test.thoys.nl/hifi/images/santa/Santa.png";
+
+Array.prototype.contains = function(obj) {
+    var i = this.length;
+    while (i--) {
+        if (this[i] === obj) {
+            return true;
+        }
+    }
+    return false;
+};
+
+function getRandomPosAroundMyAvatar(radius, height_offset) {
+    if (height_offset == undefined) {
+        height_offset = 0;
+    }
+    return {x: MyAvatar.position.x + Math.floor(Math.random() * radius * 2) - radius, y: MyAvatar.position.y + height_offset, z: MyAvatar.position.z + Math.floor(Math.random() * radius * 2) - radius};
+}
+
+function OverlayPreloader(overlay_type, overlay_properties, loaded_callback) {
+    var _this = this;
+    this.loaded_callback = loaded_callback;
+    this.overlay = Overlays.addOverlay(overlay_type, overlay_properties);
+    this.timer = null;
+    this.timer = Script.setInterval(function() { 
+        if (Overlays.isLoaded(_this.overlay)) {
+            Script.clearInterval(_this.timer);
+            _this.loaded_callback();
+        }
+    }, 100);
+}
+
+function SpriteBillboard(sprite_properties, overlay) {
+    var _this = this;
+    
+    // set properties
+    this.overlay = overlay;
+    this.overlay_properties = {};
+    this.sprite_properties = sprite_properties;
+    this.edited_overlay_properties = [];
+    this.defaultFPS = 30;
+    this.currentSequence = "";
+    this.sequenceIndex = 0;
+    this.sequenceFPS = 0;
+    this.sequenceStepToNext = false;
+    this.sequenceTimer = null;
+    this.prevSequenceIndex = -1;
+    this.sequenceX = 0;
+    this.sequenceY = 0;
+    
+    this.spriteSize = {x: 0, y: 0, width: 32, height: 64};
+    
+    this.editedProperty = function(prop_name) {
+        if (!_this.edited_overlay_properties.contains(prop_name)) {
+            _this.edited_overlay_properties.push(prop_name);
+        }
+    };
+
+    // function definitions
+    this.getPosition = function() {
+        return _this.overlay_properties.position ?
+            _this.overlay_properties.position : {x: 0, y: 0, z: 0};
+    };
+
+    this.setPosition = function(newPosition) {
+        this.overlay_properties.position = newPosition;
+        this.editedProperty("position");
+        return _this;
+    };
+
+    this.setAlpha = function(alpha) {
+        this.overlay_properties.alpha = alpha;
+        this.editedProperty("alpha");
+        return _this;
+    }
+
+    this.setScale = function(scale) {
+        this.overlay_properties.scale = scale;
+        this.editedProperty("scale");
+        return _this;
+    }
+
+    this.setSpriteSize = function(spriteSize) {
+        this.overlay_properties.subImage = spriteSize;
+        this.editedProperty("subImage");
+        return _this;
+    };
+    
+    this.setSpriteXIndex = function(x_index) {
+        _this.sequenceX = x_index;
+        _this.overlay_properties.subImage.x = x_index * _this.overlay_properties.subImage.width;
+        _this.editedProperty("subImage");
+        return _this;
+    }
+    
+    this.setSpriteYIndex = function(y_index) {
+        _this.sequenceY = y_index;
+        _this.overlay_properties.subImage.y = y_index * _this.overlay_properties.subImage.height;
+        _this.editedProperty("subImage");
+        return _this;
+    }
+
+    this.editOverlay = function(properties) {
+        for (var key in properties) {
+            _this.overlay_properties[attrname] = properties[key];
+            _this.editedProperty(key);
+        }
+        return _this;
+    };
+
+    this.commitChanges = function() {
+        var changed_properties = {};
+        for (var i = 0; i < _this.edited_overlay_properties.length; i++) {
+             var key = _this.edited_overlay_properties[i];
+             changed_properties[key] = _this.overlay_properties[key];
+        }
+        if (Object.keys(changed_properties).length === 0) {
+            return;
+        }
+        Overlays.editOverlay(_this.overlay, changed_properties);
+        _this.edited_overlay_properties = [];
+    };
+
+    this._renderFrame = function() {
+        var currentSequence = _this.sprite_properties.sequences[_this.currentSequence];
+        var currentItem = currentSequence[_this.sequenceIndex];
+        var indexChanged = _this.sequenceIndex != _this.prevSequenceIndex;
+        var canMoveToNext = true;
+        _this.prevSequenceIndex = _this.sequenceIndex;
+        if (indexChanged) {
+            if (currentItem.loop != undefined) {
+                _this.loopSequence = currentItem.loop;
+            }
+            if (currentItem.fps !== undefined && currentItem.fps != _this.sequenceFPS) {
+                _this.startSequenceTimerFPS(currentItem.fps);
+            }
+            if (currentItem.step_to_next !== undefined) {
+                _this.sequenceStepToNext = currentItem.step_to_next;
+            }
+            if (currentItem.x !== undefined) {
+                _this.setSpriteXIndex(currentItem.x);
+            }
+            if (currentItem.y !== undefined) {
+                _this.setSpriteYIndex(currentItem.y);
+            }
+            
+            if (_this.sequenceStepToNext) {
+                canMoveToNext = false;
+            }
+        }
+        _this.prevSequenceIndex = _this.sequenceIndex;
+        var nextIndex = (_this.sequenceIndex + 1) % currentSequence.length;
+        var nextItem = currentSequence[nextIndex];
+        var nextX = nextItem.x != undefined ? nextItem.x : _this.sequenceX;
+        var nextY = nextItem.Y != undefined ? nextItem.Y : _this.sequenceY;
+        
+        if (_this.sequenceStepToNext && !indexChanged) {
+            var XMoveNext = true;
+            var YMoveNext = true;
+            if (Math.abs(nextX - _this.sequenceX) > 1) {
+                _this.setSpriteXIndex(_this.sequenceX + (nextX > _this.sequenceX ? 1 : -1));
+                XMoveNext = Math.abs(nextX - _this.sequenceX) == 1;
+            }
+            if (Math.abs(nextY - _this.sequenceY) > 1) {
+                _this.setSpriteYIndex(_this.sequenceY + (nextY > _this.sequenceY ? 1 : -1));
+                YMoveNext = Math.abs(nextY - _this.sequenceY) == 1;
+            }
+            canMoveToNext = XMoveNext && YMoveNext;
+        }
+        if (canMoveToNext) {
+            _this.sequenceIndex = nextIndex;
+        }
+        _this.commitChanges();
+        
+    };
+
+    this.clone = function() {
+        var clone = {};
+        clone.prototype = this.prototype;
+        for (property in this) {
+            clone[property] = this[property];
+        }
+        return clone;
+    };
+    
+    this.startSequenceTimerFPS = function(fps) {
+        _this.sequenceFPS = fps;
+        if (_this.sequenceTimer != null) {
+            Script.clearInterval(_this.sequenceTimer);
+        }
+        _this.sequenceTimer = Script.setInterval(_this._renderFrame, 1000 / fps);
+    }
+
+    this.start = function(sequenceName) {
+        this.currentSequence = sequenceName;
+        this.sequenceFPS = this.defaultFPS;
+        this.startSequenceTimerFPS(this.defaultFPS);
+    };
+
+    if (this.sprite_properties.url !== undefined) {
+        this.setURL(this.sprite_properties.url);
+    }
+
+    if (this.sprite_properties.sprite_size !== undefined) {
+        this.setSpriteSize(this.sprite_properties.sprite_size);
+    }
+
+    if (this.sprite_properties.scale !== undefined) {
+        this.setScale(this.sprite_properties.scale);
+    }
+
+    if (this.sprite_properties.alpha !== undefined) {
+        this.setAlpha(this.sprite_properties.alpha);
+    }
+
+    if (this.sprite_properties.position !== undefined) {
+        this.setPosition(this.sprite_properties.position);
+    }
+
+    _this.commitChanges();
+
+    if (this.sprite_properties.startup_sequence != undefined) {
+        this.start(this.sprite_properties.startup_sequence);
+    }
+    
+    Script.scriptEnding.connect(function () {
+        if (_this.sequenceTimer != null) {
+            Script.clearInterval(_this.sequenceTimer);
+        }
+        Overlays.deleteOverlay(_this.overlay);
+    });
+}
+
+var christmastree_loader = null;
+christmastree_loader = new OverlayPreloader("billboard", 
+    {url: CHRISTMAS_TREE_SPRITES_URL, alpha: 0}, function() {
+        for (var i = 0; i < NUM_OF_TREES; i++) {
+            var clonedOverlay = Overlays.cloneOverlay(christmastree_loader.overlay);
+            new SpriteBillboard({
+                position: getRandomPosAroundMyAvatar(20),
+                sprite_size: {x: 0, y: 0, width: 250.000, height: 357.626},
+                scale: 6,
+                alpha: 1,
+                sequences: {"idle": [{x: 0, y: 0, step_to_next: true, fps: 3}, {x: 3, step_to_next: false}]},
+                startup_sequence: "idle"
+            }, clonedOverlay);
+        }
+    }
+);
+
+var santa_loader = null;
+santa_loader = new OverlayPreloader("billboard", 
+    {url: SANTA_SPRITES_URL, alpha: 0}, function() {
+        for (var i = 0; i < NUM_OF_SANTAS; i++) {
+            var clonedOverlay = Overlays.cloneOverlay(santa_loader.overlay);
+            new SpriteBillboard({
+                position: getRandomPosAroundMyAvatar(18, -1),
+                sprite_size: {x: 0, y: 0, width: 64, height:  72},
+                scale: 4,
+                alpha: 1,
+                sequences: {
+                    "walk_left": [{x: 2, y: 0, step_to_next: true, fps: 4}, {x: 10, step_to_next: false}],
+                    "walk_right": [{x: 10, y: 1, step_to_next: true, fps: 4}, {x: 2, step_to_next: false}],
+                },
+                startup_sequence: (i % 2 == 0) ? "walk_left" : "walk_right"
+            }, clonedOverlay);
+        }
+    }
+);
+
+Script.scriptEnding.connect(function () {
+    Overlays.deleteOverlay(christmastree_loader.overlay);
+    Overlays.deleteOverlay(santa_loader.overlay);
+});

interface/src/ui/overlays/Base3DOverlay.cpp

@@ -31,6 +31,17 @@ Base3DOverlay::Base3DOverlay() :
 {
 }
 
+Base3DOverlay::Base3DOverlay(const Base3DOverlay* base3DOverlay) :
+    Overlay(base3DOverlay),
+    _position(base3DOverlay->_position),
+    _lineWidth(base3DOverlay->_lineWidth),
+    _rotation(base3DOverlay->_rotation),
+    _isSolid(base3DOverlay->_isSolid),
+    _isDashedLine(base3DOverlay->_isDashedLine),
+    _ignoreRayIntersection(base3DOverlay->_ignoreRayIntersection)
+{
+}
+
 Base3DOverlay::~Base3DOverlay() {
 }
 
@@ -178,8 +189,4 @@ void Base3DOverlay::drawDashedLine(const glm::vec3& start, const glm::vec3& end)
     glVertex3f(end.x, end.y, end.z);
 
     glEnd();
-
 }
-
-
-

interface/src/ui/overlays/Base3DOverlay.h

@@ -23,6 +23,7 @@ class Base3DOverlay : public Overlay {
     
 public:
     Base3DOverlay();
+    Base3DOverlay(const Base3DOverlay* base3DOverlay);
     ~Base3DOverlay();
 
     // getters
@@ -64,6 +65,5 @@ protected:
     bool _isDashedLine;
     bool _ignoreRayIntersection;
 };
-
  
 #endif // hifi_Base3DOverlay_h

interface/src/ui/overlays/BillboardOverlay.cpp

@@ -24,6 +24,17 @@ BillboardOverlay::BillboardOverlay() :
       _isLoaded = false;
 }
 
+BillboardOverlay::BillboardOverlay(const BillboardOverlay* billboardOverlay) :
+    Base3DOverlay(billboardOverlay),
+    _newTextureNeeded(true),
+    _scale(billboardOverlay->_scale),
+    _isFacingAvatar(billboardOverlay->_isFacingAvatar),
+    _fromImage(billboardOverlay->_fromImage),
+    _url(billboardOverlay->_url),
+    _billboard(billboardOverlay->_billboard)
+{
+}
+
 void BillboardOverlay::render(RenderArgs* args) {
     if (!_visible || !_isLoaded) {
         return;
@@ -215,3 +226,6 @@ bool BillboardOverlay::findRayIntersection(const glm::vec3& origin, const glm::v
     return false;
 }
 
+BillboardOverlay* BillboardOverlay::createClone() const {
+    return new BillboardOverlay(this);
+}

interface/src/ui/overlays/BillboardOverlay.h

@@ -22,7 +22,8 @@ class BillboardOverlay : public Base3DOverlay {
     Q_OBJECT
 public:
     BillboardOverlay();
-    
+    BillboardOverlay(const BillboardOverlay* billboardOverlay);
+
     virtual void render(RenderArgs* args);
 
     // setters
@@ -36,6 +37,8 @@ public:
 
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
     
+    virtual BillboardOverlay* createClone() const;
+
 private slots:
     void replyFinished();
 

interface/src/ui/overlays/Circle3DOverlay.cpp

@@ -33,6 +33,22 @@ Circle3DOverlay::Circle3DOverlay() :
     _minorTickMarksColor.red = _minorTickMarksColor.green = _minorTickMarksColor.blue = (unsigned char)0;
 }
 
+Circle3DOverlay::Circle3DOverlay(const Circle3DOverlay* circle3DOverlay) :
+    Planar3DOverlay(circle3DOverlay),
+    _startAt(circle3DOverlay->_startAt),
+    _endAt(circle3DOverlay->_endAt),
+    _outerRadius(circle3DOverlay->_outerRadius),
+    _innerRadius(circle3DOverlay->_innerRadius),
+    _hasTickMarks(circle3DOverlay->_hasTickMarks),
+    _majorTickMarksAngle(circle3DOverlay->_majorTickMarksAngle),
+    _minorTickMarksAngle(circle3DOverlay->_minorTickMarksAngle),
+    _majorTickMarksLength(circle3DOverlay->_majorTickMarksLength),
+    _minorTickMarksLength(circle3DOverlay->_minorTickMarksLength),
+    _majorTickMarksColor(circle3DOverlay->_majorTickMarksColor),
+    _minorTickMarksColor(circle3DOverlay->_minorTickMarksColor)
+{
+}
+
 Circle3DOverlay::~Circle3DOverlay() {
 }
 
@@ -358,9 +374,6 @@ bool Circle3DOverlay::findRayIntersection(const glm::vec3& origin,
     return intersects;
 }
 
-
-
-
-
-
-
+Circle3DOverlay* Circle3DOverlay::createClone() const {
+    return new Circle3DOverlay(this);
+}

interface/src/ui/overlays/Circle3DOverlay.h

@@ -18,6 +18,7 @@ class Circle3DOverlay : public Planar3DOverlay {
     
 public:
     Circle3DOverlay();
+    Circle3DOverlay(const Circle3DOverlay* circle3DOverlay);
     ~Circle3DOverlay();
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
@@ -48,6 +49,8 @@ public:
     void setMinorTickMarksColor(const xColor& value) { _minorTickMarksColor = value; }
 
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+
+    virtual Circle3DOverlay* createClone() const;
     
 protected:
     float _startAt;

interface/src/ui/overlays/Cube3DOverlay.cpp

@@ -22,6 +22,11 @@
 Cube3DOverlay::Cube3DOverlay() {
 }
 
+Cube3DOverlay::Cube3DOverlay(const Cube3DOverlay* cube3DOverlay) :
+    Volume3DOverlay(cube3DOverlay)
+{
+}
+
 Cube3DOverlay::~Cube3DOverlay() {
 }
 
@@ -102,3 +107,7 @@ void Cube3DOverlay::render(RenderArgs* args) {
         delete glower;
     }
 }
+
+Cube3DOverlay* Cube3DOverlay::createClone() const {
+    return new Cube3DOverlay(this);
+}

interface/src/ui/overlays/Cube3DOverlay.h

@@ -18,8 +18,11 @@ class Cube3DOverlay : public Volume3DOverlay {
     
 public:
     Cube3DOverlay();
+    Cube3DOverlay(const Cube3DOverlay* cube3DOverlay);
     ~Cube3DOverlay();
     virtual void render(RenderArgs* args);
+
+    virtual Cube3DOverlay* createClone() const;
 };
 
  

interface/src/ui/overlays/Grid3DOverlay.cpp

@@ -20,6 +20,13 @@ Grid3DOverlay::Grid3DOverlay() : Base3DOverlay(),
     _majorGridEvery(5) {
 }
 
+Grid3DOverlay::Grid3DOverlay(const Grid3DOverlay* grid3DOverlay) :
+    Base3DOverlay(grid3DOverlay),
+    _minorGridWidth(grid3DOverlay->_minorGridWidth),
+    _majorGridEvery(grid3DOverlay->_majorGridEvery)
+{
+}
+
 Grid3DOverlay::~Grid3DOverlay() {
 }
 
@@ -127,3 +134,7 @@ QScriptValue Grid3DOverlay::getProperty(const QString& property) {
 
     return Base3DOverlay::getProperty(property);
 }
+
+Grid3DOverlay* Grid3DOverlay::createClone() const {
+    return new Grid3DOverlay(this);
+}

interface/src/ui/overlays/Grid3DOverlay.h

@@ -29,12 +29,15 @@ class Grid3DOverlay : public Base3DOverlay {
 
 public:
     Grid3DOverlay();
+    Grid3DOverlay(const Grid3DOverlay* grid3DOverlay);
     ~Grid3DOverlay();
 
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
+    virtual Grid3DOverlay* createClone() const;
+
 private:
     float _minorGridWidth;
     int _majorGridEvery;

interface/src/ui/overlays/ImageOverlay.cpp

@@ -27,6 +27,17 @@ ImageOverlay::ImageOverlay() :
     _isLoaded = false;
 }
 
+ImageOverlay::ImageOverlay(const ImageOverlay* imageOverlay) :
+    Overlay2D(imageOverlay),
+    _textureID(0),
+    _textureBound(false),
+    _wantClipFromImage(false),
+    _renderImage(imageOverlay->_renderImage),
+    _imageURL(imageOverlay->_imageURL),
+    _textureImage(imageOverlay->_textureImage)
+{
+}
+
 ImageOverlay::~ImageOverlay() {
     if (_parent && _textureID) {
         // do we need to call this?
@@ -161,3 +172,6 @@ QScriptValue ImageOverlay::getProperty(const QString& property) {
 
     return Overlay2D::getProperty(property);
 }
+ImageOverlay* ImageOverlay::createClone() const {
+    return new ImageOverlay(this);
+}

interface/src/ui/overlays/ImageOverlay.h

@@ -33,6 +33,7 @@ class ImageOverlay : public Overlay2D {
     
 public:
     ImageOverlay();
+    ImageOverlay(const ImageOverlay* imageOverlay);
     ~ImageOverlay();
     virtual void render(RenderArgs* args);
 
@@ -46,6 +47,8 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
+    virtual ImageOverlay* createClone() const;
+
 private slots:
     void replyFinished(); // we actually want to hide this...
 

interface/src/ui/overlays/Line3DOverlay.cpp

@@ -18,6 +18,12 @@
 Line3DOverlay::Line3DOverlay() {
 }
 
+Line3DOverlay::Line3DOverlay(const Line3DOverlay* line3DOverlay) :
+    Base3DOverlay(line3DOverlay),
+    _end(line3DOverlay->_end)
+{
+}
+
 Line3DOverlay::~Line3DOverlay() {
 }
 
@@ -87,3 +93,7 @@ QScriptValue Line3DOverlay::getProperty(const QString& property) {
 
     return Base3DOverlay::getProperty(property);
 }
+
+Line3DOverlay* Line3DOverlay::createClone() const {
+    return new Line3DOverlay(this);
+}

interface/src/ui/overlays/Line3DOverlay.h

@@ -18,6 +18,7 @@ class Line3DOverlay : public Base3DOverlay {
     
 public:
     Line3DOverlay();
+    Line3DOverlay(const Line3DOverlay* line3DOverlay);
     ~Line3DOverlay();
     virtual void render(RenderArgs* args);
 
@@ -30,6 +31,8 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
+    virtual Line3DOverlay* createClone() const;
+
 protected:
     glm::vec3 _end;
 };

interface/src/ui/overlays/LocalModelsOverlay.cpp

@@ -18,6 +18,13 @@ LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer) :
     _entityTreeRenderer(entityTreeRenderer) {
 }
 
+LocalModelsOverlay::LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay) :
+    Volume3DOverlay(localModelsOverlay),
+    _entityTreeRenderer(localModelsOverlay->_entityTreeRenderer)
+{
+
+}
+
 LocalModelsOverlay::~LocalModelsOverlay() {
 }
 
@@ -48,3 +55,7 @@ void LocalModelsOverlay::render(RenderArgs* args) {
 
     }
 }
+
+LocalModelsOverlay* LocalModelsOverlay::createClone() const {
+    return new LocalModelsOverlay(this);
+}

interface/src/ui/overlays/LocalModelsOverlay.h

@@ -20,11 +20,14 @@ class LocalModelsOverlay : public Volume3DOverlay {
     Q_OBJECT
 public:
     LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer);
+    LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay);
     ~LocalModelsOverlay();
     
     virtual void update(float deltatime);
     virtual void render(RenderArgs* args);
 
+    virtual LocalModelsOverlay* createClone() const;
+
 private:
     EntityTreeRenderer* _entityTreeRenderer;
 };

interface/src/ui/overlays/LocalVoxelsOverlay.cpp

@@ -28,6 +28,12 @@ LocalVoxelsOverlay::LocalVoxelsOverlay() :
 {
 }
 
+LocalVoxelsOverlay::LocalVoxelsOverlay(const LocalVoxelsOverlay* localVoxelsOverlay) :
+    Volume3DOverlay(localVoxelsOverlay),
+    _voxelCount(localVoxelsOverlay->_voxelCount)
+{
+}
+
 LocalVoxelsOverlay::~LocalVoxelsOverlay() {
     _voxelSystem->changeTree(new VoxelTree());
     _voxelSystem.clear();
@@ -103,6 +109,10 @@ void LocalVoxelsOverlay::setProperties(const QScriptValue &properties) {
     }
 }
 
+LocalVoxelsOverlay* LocalVoxelsOverlay::createClone() const {
+    return new LocalVoxelsOverlay(this);
+}
+
 QScriptValue LocalVoxelsOverlay::getProperty(const QString& property) {
     if (property == "scale") {
         return vec3toScriptValue(_scriptEngine, getDimensions());

interface/src/ui/overlays/LocalVoxelsOverlay.h

@@ -32,6 +32,7 @@ class LocalVoxelsOverlay : public Volume3DOverlay {
     Q_OBJECT
 public:
     LocalVoxelsOverlay();
+    LocalVoxelsOverlay(const LocalVoxelsOverlay* localVoxelsOverlay);
     ~LocalVoxelsOverlay();
     
     virtual void update(float deltatime);
@@ -40,6 +41,7 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
+    virtual LocalVoxelsOverlay* createClone() const;
 private:
     static QMap<QString, WeakVoxelSystemPointer> _voxelSystemMap; // treeName/voxelSystem
     

interface/src/ui/overlays/ModelOverlay.cpp

@@ -22,6 +22,22 @@ ModelOverlay::ModelOverlay()
     _isLoaded = false;
 }
 
+ModelOverlay::ModelOverlay(const ModelOverlay* modelOverlay) :
+    Base3DOverlay(modelOverlay),
+    _model(),
+    _modelTextures(QVariantMap()),
+    _scale(modelOverlay->_scale),
+    _updateModel(false),
+    _url(modelOverlay->_url),
+    _rotation(modelOverlay->_rotation)
+{
+    _model.init();
+    if (_url.isValid()) {
+        _updateModel = true;
+        _isLoaded = false;
+    }
+}
+
 void ModelOverlay::update(float deltatime) {
     if (_updateModel) {
         _updateModel = false;
@@ -166,4 +182,6 @@ bool ModelOverlay::findRayIntersectionExtraInfo(const glm::vec3& origin, const g
     return _model.findRayIntersectionAgainstSubMeshes(origin, direction, distance, face, extraInfo);
 }
 
-
+ModelOverlay* ModelOverlay::createClone() const {
+    return new ModelOverlay(this);
+}

interface/src/ui/overlays/ModelOverlay.h

@@ -20,7 +20,8 @@ class ModelOverlay : public Base3DOverlay {
     Q_OBJECT
 public:
     ModelOverlay();
-    
+    ModelOverlay(const ModelOverlay* modelOverlay);
+
     virtual void update(float deltatime);
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
@@ -29,8 +30,10 @@ public:
     virtual bool findRayIntersectionExtraInfo(const glm::vec3& origin, const glm::vec3& direction, 
                                                     float& distance, BoxFace& face, QString& extraInfo) const;
 
+    virtual ModelOverlay* createClone() const;
+
 private:
-    
+
     Model _model;
     QVariantMap _modelTextures;
     

interface/src/ui/overlays/Overlay.cpp

@@ -39,12 +39,30 @@ Overlay::Overlay() :
 {
 }
 
+Overlay::Overlay(const Overlay* overlay) :
+    _parent(NULL),
+    _alpha(overlay->_alpha),
+    _lastPulseUpdate(usecTimestampNow()),
+    _alphaPulse(overlay->_alphaPulse),
+    _anchor(overlay->_anchor),
+    _color(overlay->_color),
+    _colorPulse(overlay->_colorPulse),
+    _glowLevel(overlay->_glowLevel),
+    _glowLevelPulse(overlay->_glowLevelPulse),
+    _pulseDirection(overlay->_pulseDirection),
+    _pulseMax(overlay->_pulseMax),
+    _pulseMin(overlay->_pulseMin),
+    _pulsePeriod(overlay->_pulsePeriod),
+    _visible(overlay->_visible),
+    _isLoaded(overlay->_isLoaded)
+{
+}
+
 void Overlay::init(QGLWidget* parent, QScriptEngine* scriptEngine) {
     _parent = parent;
     _scriptEngine = scriptEngine;
 }
 
-
 Overlay::~Overlay() {
 }
 

interface/src/ui/overlays/Overlay.h

@@ -36,6 +36,7 @@ public:
     };
     
     Overlay();
+    Overlay(const Overlay* overlay);
     ~Overlay();
     void init(QGLWidget* parent, QScriptEngine* scriptEngine);
     virtual void update(float deltatime) {}
@@ -78,6 +79,7 @@ public:
     void setAlphaPulse(float value) { _alphaPulse = value; }
 
     virtual void setProperties(const QScriptValue& properties);
+    virtual Overlay* createClone() const = 0;
     virtual QScriptValue getProperty(const QString& property);
 
 protected:

interface/src/ui/overlays/Overlay2D.cpp

@@ -22,6 +22,12 @@
 Overlay2D::Overlay2D() {
 }
 
+Overlay2D::Overlay2D(const Overlay2D* overlay2D) :
+    Overlay(overlay2D),
+    _bounds(overlay2D->_bounds)
+{
+}
+
 Overlay2D::~Overlay2D() {
 }
 

interface/src/ui/overlays/Overlay2D.h

@@ -28,6 +28,7 @@ class Overlay2D : public Overlay {
     
 public:
     Overlay2D();
+    Overlay2D(const Overlay2D* overlay2D);
     ~Overlay2D();
     
     virtual bool is3D() const { return false; }
@@ -43,7 +44,7 @@ public:
     void setX(int x) { _bounds.setX(x); }
     void setY(int y) { _bounds.setY(y);  }
     void setWidth(int width) { _bounds.setWidth(width); }
-    void setHeight(int height) {  _bounds.setHeight(height); }
+    void setHeight(int height) { _bounds.setHeight(height); }
     void setBounds(const QRect& bounds) { _bounds = bounds; }
 
     virtual void setProperties(const QScriptValue& properties);

interface/src/ui/overlays/Overlays.cpp

@@ -196,6 +196,16 @@ unsigned int Overlays::addOverlay(Overlay* overlay) {
     return thisID;
 }
 
+unsigned int Overlays::cloneOverlay(unsigned int id) {
+    Overlay* thisOverlay = NULL;
+    if (_overlays2D.contains(id)) {
+        thisOverlay = _overlays2D[id];
+    } else if (_overlays3D.contains(id)) {
+        thisOverlay = _overlays3D[id];
+    }
+    return addOverlay(thisOverlay->createClone());
+}
+
 bool Overlays::editOverlay(unsigned int id, const QScriptValue& properties) {
     Overlay* thisOverlay = NULL;
     QWriteLocker lock(&_lock);
@@ -397,15 +407,15 @@ void RayToOverlayIntersectionResultFromScriptValue(const QScriptValue& object, R
 
 bool Overlays::isLoaded(unsigned int id) {
     QReadLocker lock(&_lock);
-    Overlay* overlay = _overlays2D.value(id);
-    if (!overlay) {
-        _overlays3D.value(id);
-    }
-    if (!overlay) {
+    Overlay* thisOverlay = NULL;
+    if (_overlays2D.contains(id)) {
+        thisOverlay = _overlays2D[id];
+    } else if (_overlays3D.contains(id)) {
+        thisOverlay = _overlays3D[id];
+    } else {
         return false; // not found
     }
-
-    return overlay->isLoaded();
+    return thisOverlay->isLoaded();
 }
 
 float Overlays::textWidth(unsigned int id, const QString& text) const {

interface/src/ui/overlays/Overlays.h

@@ -61,6 +61,9 @@ public slots:
     /// adds an overlay that's already been created
     unsigned int addOverlay(Overlay* overlay);
 
+    /// clones an existing overlay
+    unsigned int cloneOverlay(unsigned int id);
+
     /// edits an overlay updating only the included properties, will return the identified OverlayID in case of
     /// successful edit, if the input id is for an unknown overlay this function will have no effect
     bool editOverlay(unsigned int id, const QScriptValue& properties);

interface/src/ui/overlays/Planar3DOverlay.cpp

@@ -26,6 +26,12 @@ Planar3DOverlay::Planar3DOverlay() :
 {
 }
 
+Planar3DOverlay::Planar3DOverlay(const Planar3DOverlay* planar3DOverlay) :
+    Base3DOverlay(planar3DOverlay),
+    _dimensions(planar3DOverlay->_dimensions)
+{
+}
+
 Planar3DOverlay::~Planar3DOverlay() {
 }
 

interface/src/ui/overlays/Planar3DOverlay.h

@@ -26,6 +26,7 @@ class Planar3DOverlay : public Base3DOverlay {
     
 public:
     Planar3DOverlay();
+    Planar3DOverlay(const Planar3DOverlay* planar3DOverlay);
     ~Planar3DOverlay();
 
     // getters

interface/src/ui/overlays/Rectangle3DOverlay.cpp

@@ -20,6 +20,11 @@
 Rectangle3DOverlay::Rectangle3DOverlay() {
 }
 
+Rectangle3DOverlay::Rectangle3DOverlay(const Rectangle3DOverlay* rectangle3DOverlay) :
+    Planar3DOverlay(rectangle3DOverlay)
+{
+}
+
 Rectangle3DOverlay::~Rectangle3DOverlay() {
 }
 
@@ -106,9 +111,6 @@ void Rectangle3DOverlay::setProperties(const QScriptValue &properties) {
     Planar3DOverlay::setProperties(properties);
 }
 
-
-
-
-
-
-
+Rectangle3DOverlay* Rectangle3DOverlay::createClone() const {
+    return new Rectangle3DOverlay(this);
+}

interface/src/ui/overlays/Rectangle3DOverlay.h

@@ -18,9 +18,12 @@ class Rectangle3DOverlay : public Planar3DOverlay {
     
 public:
     Rectangle3DOverlay();
+    Rectangle3DOverlay(const Rectangle3DOverlay* rectangle3DOverlay);
     ~Rectangle3DOverlay();
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
+
+    virtual Rectangle3DOverlay* createClone() const;
 };
 
  

interface/src/ui/overlays/Sphere3DOverlay.cpp

@@ -21,6 +21,11 @@
 Sphere3DOverlay::Sphere3DOverlay() {
 }
 
+Sphere3DOverlay::Sphere3DOverlay(const Sphere3DOverlay* Sphere3DOverlay) :
+    Volume3DOverlay(Sphere3DOverlay)
+{
+}
+
 Sphere3DOverlay::~Sphere3DOverlay() {
 }
 
@@ -70,3 +75,7 @@ void Sphere3DOverlay::render(RenderArgs* args) {
     }
 
 }
+
+Sphere3DOverlay* Sphere3DOverlay::createClone() const {
+    return new Sphere3DOverlay(this);
+}

interface/src/ui/overlays/Sphere3DOverlay.h

@@ -18,8 +18,11 @@ class Sphere3DOverlay : public Volume3DOverlay {
     
 public:
     Sphere3DOverlay();
+    Sphere3DOverlay(const Sphere3DOverlay* Sphere3DOverlay);
     ~Sphere3DOverlay();
     virtual void render(RenderArgs* args);
+
+    virtual Sphere3DOverlay* createClone() const;
 };
 
  

interface/src/ui/overlays/Text3DOverlay.cpp

@@ -31,6 +31,19 @@ Text3DOverlay::Text3DOverlay() :
 {
 }
 
+Text3DOverlay::Text3DOverlay(const Text3DOverlay* text3DOverlay) :
+    Planar3DOverlay(text3DOverlay),
+    _text(text3DOverlay->_text),
+    _backgroundColor(text3DOverlay->_backgroundColor),
+    _lineHeight(text3DOverlay->_lineHeight),
+    _leftMargin(text3DOverlay->_leftMargin),
+    _topMargin(text3DOverlay->_topMargin),
+    _rightMargin(text3DOverlay->_rightMargin),
+    _bottomMargin(text3DOverlay->_bottomMargin),
+    _isFacingAvatar(text3DOverlay->_isFacingAvatar)
+{
+}
+
 Text3DOverlay::~Text3DOverlay() {
 }
 
@@ -172,7 +185,6 @@ void Text3DOverlay::setProperties(const QScriptValue& properties) {
         setBottomMargin(properties.property("bottomMargin").toVariant().toFloat());
     }
 
-
     QScriptValue isFacingAvatarValue = properties.property("isFacingAvatar");
     if (isFacingAvatarValue.isValid()) {
         _isFacingAvatar = isFacingAvatarValue.toVariant().toBool();
@@ -208,6 +220,10 @@ QScriptValue Text3DOverlay::getProperty(const QString& property) {
     return Planar3DOverlay::getProperty(property);
 }
 
+Text3DOverlay* Text3DOverlay::createClone() const {
+    return new Text3DOverlay(this);;
+}
+
 float Text3DOverlay::textWidth(const QString& text) const {
     QFont font(SANS_FONT_FAMILY, FIXED_FONT_POINT_SIZE);  // Same font properties as render()
     QFontMetrics fontMetrics(font);
@@ -215,3 +231,4 @@ float Text3DOverlay::textWidth(const QString& text) const {
     return scaleFactor * (float)fontMetrics.width(qPrintable(text));
 }
 
+

interface/src/ui/overlays/Text3DOverlay.h

@@ -24,6 +24,7 @@ class Text3DOverlay : public Planar3DOverlay {
     
 public:
     Text3DOverlay();
+    Text3DOverlay(const Text3DOverlay* text3DOverlay);
     ~Text3DOverlay();
     virtual void render(RenderArgs* args);
 
@@ -51,6 +52,8 @@ public:
 
     float textWidth(const QString& text) const;  // Meters
 
+    virtual Text3DOverlay* createClone() const;
+
 private:
     void enableClipPlane(GLenum plane, float x, float y, float z, float w);
 

interface/src/ui/overlays/TextOverlay.cpp

@@ -25,6 +25,16 @@ TextOverlay::TextOverlay() :
 {
 }
 
+TextOverlay::TextOverlay(const TextOverlay* textOverlay) :
+    Overlay2D(textOverlay),
+    _text(textOverlay->_text),
+    _backgroundColor(textOverlay->_backgroundColor),
+    _leftMargin(textOverlay->_leftMargin),
+    _topMargin(textOverlay->_topMargin),
+    _fontSize(textOverlay->_fontSize)
+{
+}
+
 TextOverlay::~TextOverlay() {
 }
 
@@ -124,6 +134,10 @@ void TextOverlay::setProperties(const QScriptValue& properties) {
     }
 }
 
+TextOverlay* TextOverlay::createClone() const {
+    return new TextOverlay(this);
+}
+
 QScriptValue TextOverlay::getProperty(const QString& property) {
     if (property == "font") {
         QScriptValue font = _scriptEngine->newObject();
@@ -146,7 +160,6 @@ QScriptValue TextOverlay::getProperty(const QString& property) {
     return Overlay2D::getProperty(property);
 }
 
-
 float TextOverlay::textWidth(const QString& text) const {
     QFont font(SANS_FONT_FAMILY, _fontSize, DEFAULT_FONT_WEIGHT);  // Same font properties as render()
     QFontMetrics fontMetrics(font);

interface/src/ui/overlays/TextOverlay.h

@@ -37,6 +37,7 @@ class TextOverlay : public Overlay2D {
     
 public:
     TextOverlay();
+    TextOverlay(const TextOverlay* textOverlay);
     ~TextOverlay();
     virtual void render(RenderArgs* args);
 
@@ -53,12 +54,12 @@ public:
     void setFontSize(int fontSize) { _fontSize = fontSize; }
 
     virtual void setProperties(const QScriptValue& properties);
+    virtual TextOverlay* createClone() const;
     virtual QScriptValue getProperty(const QString& property);
 
     float textWidth(const QString& text) const;  // Pixels
 
 private:
-
     QString _text;
     xColor _backgroundColor;
     int _leftMargin;

interface/src/ui/overlays/Volume3DOverlay.cpp

@@ -28,6 +28,12 @@ Volume3DOverlay::Volume3DOverlay() :
 {
 }
 
+Volume3DOverlay::Volume3DOverlay(const Volume3DOverlay* volume3DOverlay) :
+    Base3DOverlay(volume3DOverlay),
+    _dimensions(volume3DOverlay->_dimensions)
+{
+}
+
 Volume3DOverlay::~Volume3DOverlay() {
 }
 

interface/src/ui/overlays/Volume3DOverlay.h

@@ -26,6 +26,7 @@ class Volume3DOverlay : public Base3DOverlay {
     
 public:
     Volume3DOverlay();
+    Volume3DOverlay(const Volume3DOverlay* volume3DOverlay);
     ~Volume3DOverlay();
 
     // getters