Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-25 00:03:16 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of https://github.com/highfidelity/hifi into mute_signal

Browse source
This commit is contained in:
Atlante45 2014-11-17 09:56:55 -08:00
commit 0507edf90f
69 changed files with 2091 additions and 408 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
assignment-client/src/octree/OctreeServer.cpp
View file

@ -1020,7 +1020,7 @@ void OctreeServer::readConfiguration() {
bool noPersist;
readOptionBool(QString("NoPersist"), settingsSectionObject, noPersist);
_wantPersist = !noPersist;
qDebug("wantPersist=%s", debug::valueOf(_wantPersist));
qDebug() << "wantPersist=" << _wantPersist;
if (_wantPersist) {
QString persistFilename;
@ -1029,6 +1029,26 @@ void OctreeServer::readConfiguration() {
}
strcpy(_persistFilename, qPrintable(persistFilename));
qDebug("persistFilename=%s", _persistFilename);
_persistInterval = OctreePersistThread::DEFAULT_PERSIST_INTERVAL;
readOptionInt(QString("persistInterval"), settingsSectionObject, _persistInterval);
qDebug() << "persistInterval=" << _persistInterval;
bool noBackup;
readOptionBool(QString("NoBackup"), settingsSectionObject, noBackup);
_wantBackup = !noBackup;
qDebug() << "wantBackup=" << _wantBackup;
if (_wantBackup) {
_backupExtensionFormat = OctreePersistThread::DEFAULT_BACKUP_EXTENSION_FORMAT;
readOptionString(QString("backupExtensionFormat"), settingsSectionObject, _backupExtensionFormat);
qDebug() << "backupExtensionFormat=" << _backupExtensionFormat;
_backupInterval = OctreePersistThread::DEFAULT_BACKUP_INTERVAL;
readOptionInt(QString("backupInterval"), settingsSectionObject, _backupInterval);
qDebug() << "backupInterval=" << _backupInterval;
}
} else {
qDebug("persistFilename= DISABLED");
}
@ -1112,7 +1132,8 @@ void OctreeServer::run() {
if (_wantPersist) {
// now set up PersistThread
_persistThread = new OctreePersistThread(_tree, _persistFilename);
_persistThread = new OctreePersistThread(_tree, _persistFilename, _persistInterval,
_wantBackup, _backupInterval, _backupExtensionFormat);
if (_persistThread) {
_persistThread->initialize(true);
}
@ -1197,6 +1218,9 @@ void OctreeServer::aboutToFinish() {
qDebug() << qPrintable(_safeServerName) << "server about to finish while node still connected node:" << *node;
forceNodeShutdown(node);
}
if (_persistThread) {
_persistThread->aboutToFinish();
}
qDebug() << qPrintable(_safeServerName) << "server ENDING about to finish...";
}

5
assignment-client/src/octree/OctreeServer.h
View file

@ -167,6 +167,11 @@ protected:
JurisdictionSender* _jurisdictionSender;
OctreeInboundPacketProcessor* _octreeInboundPacketProcessor;
OctreePersistThread* _persistThread;
int _persistInterval;
bool _wantBackup;
QString _backupExtensionFormat;
int _backupInterval;
static OctreeServer* _instance;

93
domain-server/resources/describe-settings.json
View file

@ -276,6 +276,52 @@
"label": "Entity Server Settings",
"assignment-types": [6],
"settings": [
{
"name": "persistFilename",
"label": "Persistant Filename",
"help": "the filename for your entities",
"placeholder": "resources/models.svo",
"default": "resources/models.svo",
"advanced": true
},
{
"name": "persistInterval",
"label": "Persist Interval",
"help": "Interval between persist checks in msecs.",
"placeholder": "30000",
"default": "30000",
"advanced": true
},
{
"name": "NoPersist",
"type": "checkbox",
"help": "Don't persist your entities to a file.",
"default": false,
"advanced": true
},
{
"name": "backupExtensionFormat",
"label": "Backup File Extension Format:",
"help": "Format used to create the extension for the backup of your persisted entities.",
"placeholder": ".backup.%Y-%m-%d.%H:%M:%S.%z",
"default": ".backup.%Y-%m-%d.%H:%M:%S.%z",
"advanced": true
},
{
"name": "backupInterval",
"label": "Backup Interval",
"help": "Interval between backup checks in msecs.",
"placeholder": "1800000",
"default": "1800000",
"advanced": true
},
{
"name": "NoBackup",
"type": "checkbox",
"help": "Don't regularly backup your persisted entities to a backup file.",
"default": false,
"advanced": true
},
{
"name": "statusHost",
"label": "Status Hostname",
@ -330,7 +376,52 @@
"label": "Voxel Server Settings",
"assignment-types": [3],
"settings": [
{
"name": "persistFilename",
"label": "Persistant Filename",
"help": "the filename for your voxels",
"placeholder": "resources/voxels.svo",
"default": "resources/voxels.svo",
"advanced": true
},
{
"name": "persistInterval",
"label": "Persist Interval",
"help": "Interval between persist checks in msecs.",
"placeholder": "30000",
"default": "30000",
"advanced": true
},
{
"name": "NoPersist",
"type": "checkbox",
"help": "Don't persist your voxels to a file.",
"default": false,
"advanced": true
},
{
"name": "backupExtensionFormat",
"label": "Backup File Extension Format:",
"help": "Format used to create the extension for the backup of your persisted voxels.",
"placeholder": ".backup.%Y-%m-%d.%H:%M:%S.%z",
"default": ".backup.%Y-%m-%d.%H:%M:%S.%z",
"advanced": true
},
{
"name": "backupInterval",
"label": "Backup Interval",
"help": "Interval between backup checks in msecs.",
"placeholder": "1800000",
"default": "1800000",
"advanced": true
},
{
"name": "NoBackup",
"type": "checkbox",
"help": "Don't regularly backup your persisted voxels to a backup file.",
"default": false,
"advanced": true
},
{
"name": "statusHost",
"label": "Status Hostname",

8
examples/cleanupChessboards.js Normal file
View file

@ -0,0 +1,8 @@
var entities = Entities.findEntities(MyAvatar.position, 10000);
var URL = "https://s3.amazonaws.com/hifi-public/models/props/chess/";
for(var i in entities) {
if (Entities.getEntityProperties(entities[i]).modelURL.slice(0, URL.length) === URL) {
Entities.deleteEntity(entities[i]);
}
}

294
examples/clonedOverlaysExample.js Normal file
View file

@ -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);
});

34
examples/editModels.js
View file

@ -48,6 +48,9 @@ var RIGHT = 1;
var SPAWN_DISTANCE = 1;
var DEFAULT_DIMENSION = 0.20;
var DEFAULT_TEXT_DIMENSION_X = 1.0;
var DEFAULT_TEXT_DIMENSION_Y = 1.0;
var DEFAULT_TEXT_DIMENSION_Z = 0.01;
var modelURLs = [
HIFI_PUBLIC_BUCKET + "models/entities/2-Terrain:%20Alder.fbx",
@ -1122,6 +1125,7 @@ var toolBar = (function () {
newModelButton,
newCubeButton,
newSphereButton,
newTextButton,
browseModelsButton,
loadURLMenuItem,
loadFileMenuItem,
@ -1208,7 +1212,16 @@ var toolBar = (function () {
alpha: 0.9,
visible: true
});
newTextButton = toolBar.addTool({
//imageURL: toolIconUrl + "add-text.svg",
imageURL: "https://s3-us-west-1.amazonaws.com/highfidelity-public/images/tools/add-text.svg", // temporarily
subImage: { x: 0, y: Tool.IMAGE_WIDTH, width: Tool.IMAGE_WIDTH, height: Tool.IMAGE_HEIGHT },
width: toolWidth,
height: toolHeight,
alpha: 0.9,
visible: true
});
}
function toggleNewModelButton(active) {
@ -1372,6 +1385,25 @@ var toolBar = (function () {
}
if (newTextButton === toolBar.clicked(clickedOverlay)) {
var position = Vec3.sum(MyAvatar.position, Vec3.multiply(Quat.getFront(MyAvatar.orientation), SPAWN_DISTANCE));
if (position.x > 0 && position.y > 0 && position.z > 0) {
Entities.addEntity({
type: "Text",
position: position,
dimensions: { x: DEFAULT_TEXT_DIMENSION_X, y: DEFAULT_TEXT_DIMENSION_Y, z: DEFAULT_TEXT_DIMENSION_Z },
backgroundColor: { red: 0, green: 0, blue: 0 },
textColor: { red: 255, green: 255, blue: 255 },
text: "some text",
lineHight: "0.1"
});
} else {
print("Can't create box: Text would be out of bounds.");
}
return true;
}
return false;
};

201
examples/entityScripts/chessPiece.js Normal file
View file

@ -0,0 +1,201 @@
(function(){
this.FIRST_TILE = null; // Global position of the first tile (1a)
this.TILE_SIZE = null; // Size of one tile
this.wantDebug = false;
this.active = false;
this.entityID = null;
this.properties = null;
this.boardID = null;
this.boardUserData = null;
this.sound = null;
this.startingTile = null;
this.pieces = new Array();
// All callbacks start by updating the properties
this.updateProperties = function(entityID) {
// Piece ID
if (this.entityID === null || !this.entityID.isKnownID) {
this.entityID = Entities.identifyEntity(entityID);
}
// Piece Properties
this.properties = Entities.getEntityProperties(this.entityID);
// Board ID
if (this.boardID === null) {
// Read user data string and update boardID
var userData = JSON.parse(this.properties.userData);
var boardID = Entities.identifyEntity(userData.boardID);
if (boardID.isKnownID) {
this.boardID = boardID;
} else {
return;
}
}
// Board User Data
this.updateUserData();
}
// Get an entity's user data
this.getEntityUserData = function(entityID) {
var properties = Entities.getEntityProperties(entityID);
if (properties && properties.userData){
return JSON.parse(properties.userData);
} else {
print("No user data found.");
return null;
}
}
// Updates user data related objects
this.updateUserData = function() {
// Get board's user data
if (this.boardID !== null && this.boardID.isKnownID) {
this.boardUserData = this.getEntityUserData(this.boardID);
if (!(this.boardUserData &&
this.boardUserData.firstTile &&
this.boardUserData.tileSize)) {
print("Incomplete boardUserData " + this.boardID.id);
} else {
this.FIRST_TILE = this.boardUserData.firstTile;
this.TILE_SIZE = this.boardUserData.tileSize;
this.active = true;
}
} else {
print("Missing boardID:" + JSON.stringify(this.boardID));
}
}
// Returns whether pos is inside the grid or not
this.isOutsideGrid = function(pos) {
return !(pos.i >= 0 && pos.j >= 0 && pos.i < 8 && pos.j < 8);
}
// Returns the tile coordinate
this.getIndexPosition = function(position) {
var halfTile = this.TILE_SIZE / 2.0;
var corner = Vec3.sum(this.FIRST_TILE, { x: -halfTile, y: 0.0, z: -halfTile });
var relative = Vec3.subtract(position, corner);
return {
i: Math.floor(relative.x / this.TILE_SIZE),
j: Math.floor(relative.z / this.TILE_SIZE)
}
}
// Returns the world position
this.getAbsolutePosition = function(pos, halfHeight) {
var relative = {
x: pos.i * this.TILE_SIZE,
y: halfHeight,
z: pos.j * this.TILE_SIZE
}
return Vec3.sum(this.FIRST_TILE, relative);
}
// Pr, Vr are respectively the Ray's Point of origin and Vector director
// Pp, Np are respectively the Plane's Point of origin and Normal vector
this.rayPlaneIntersection = function(Pr, Vr, Pp, Np) {
var d = -Vec3.dot(Pp, Np);
var t = -(Vec3.dot(Pr, Np) + d) / Vec3.dot(Vr, Np);
return Vec3.sum(Pr, Vec3.multiply(t, Vr));
}
// Download sound if needed
this.maybeDownloadSound = function() {
if (this.sound === null) {
this.sound = SoundCache.getSound("http://public.highfidelity.io/sounds/Footsteps/FootstepW3Left-12db.wav");
}
}
// Play drop sound
this.playSound = function() {
if (this.sound && this.sound.downloaded) {
Audio.playSound(this.sound, { position: this.properties.position });
}
}
// updates the piece position based on mouse input
this.updatePosition = function(mouseEvent) {
var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
var upVector = { x: 0, y: 1, z: 0 };
var intersection = this.rayPlaneIntersection(pickRay.origin, pickRay.direction,
this.properties.position, upVector);
// if piece outside grid then send it back to the starting tile
if (this.isOutsideGrid(this.getIndexPosition(intersection))) {
intersection = this.getAbsolutePosition(this.startingTile, this.properties.dimensions.y / 2.0);
}
Entities.editEntity(this.entityID, { position: intersection });
}
// Snap piece to the center of the tile it is on
this.snapToGrid = function() {
var pos = this.getIndexPosition(this.properties.position);
var finalPos = this.getAbsolutePosition((this.isOutsideGrid(pos)) ? this.startingTile : pos,
this.properties.dimensions.y / 2.0);
Entities.editEntity(this.entityID, { position: finalPos });
}
this.moveDeadPiece = function() {
var myPos = this.getIndexPosition(this.properties.position);
var others = Entities.findEntities(this.properties.position, this.properties.dimensions.y);
for (var i = 0; i < others.length; i++) {
var piece = others[i];
if (piece.id != this.entityID.id) {
var properties = Entities.getEntityProperties(piece);
var isWhite = properties.modelURL.search("White") !== -1;
var type = (properties.modelURL.search("King") !== -1) ? 4 :
(properties.modelURL.search("Queen") !== -1) ? 3 :
(properties.modelURL.search("Rook") !== -1) ? 2 :
(properties.modelURL.search("Knight") !== -1) ? 1 :
(properties.modelURL.search("Bishop") !== -1) ? 0 :
(properties.modelURL.search("Pawn") !== -1) ? -1 : -2;
var piecePos = this.getIndexPosition(properties.position);
if (myPos.i === piecePos.i && myPos.j === piecePos.j && type !== -2) {
var position = this.getAbsolutePosition((isWhite) ? { i: type, j: -1 } : { i: 7 - type, j: 8 },
properties.dimensions.y / 2.0);
Entities.editEntity(piece, {
position: position
});
break;
}
}
}
}
this.grab = function(mouseEvent) {
if (this.active) {
this.startingTile = this.getIndexPosition(this.properties.position);
this.updatePosition(mouseEvent);
}
}
this.move = function(mouseEvent) {
if (this.active) {
this.updatePosition(mouseEvent);
}
}
this.release = function(mouseEvent) {
if (this.active) {
this.updatePosition(mouseEvent);
this.snapToGrid();
this.moveDeadPiece();
this.playSound();
}
}
this.preload = function(entityID) {
this.updateProperties(entityID); // All callbacks start by updating the properties
this.maybeDownloadSound();
}
this.clickDownOnEntity = function(entityID, mouseEvent) {
this.preload(entityID); // TODO : remove
this.updateProperties(entityID); // All callbacks start by updating the properties
this.grab(mouseEvent);
};
this.holdingClickOnEntity = function(entityID, mouseEvent) {
this.updateProperties(entityID); // All callbacks start by updating the properties
this.move(mouseEvent);
};
this.clickReleaseOnEntity = function(entityID, mouseEvent) {
this.updateProperties(entityID); // All callbacks start by updating the properties
this.release(mouseEvent);
};
})

80
examples/html/entityProperties.html
View file

@ -134,6 +134,17 @@
var elModelAnimationURL = document.getElementById("property-model-animation-url");
var elModelAnimationPlaying = document.getElementById("property-model-animation-playing");
var elModelAnimationFPS = document.getElementById("property-model-animation-fps");
var elModelAnimationFrame = document.getElementById("property-model-animation-frame");
var elTextSection = document.getElementById("text-section");
var elTextText = document.getElementById("property-text-text");
var elTextLineHeight = document.getElementById("property-text-line-height");
var elTextTextColorRed = document.getElementById("property-text-text-color-red");
var elTextTextColorGreen = document.getElementById("property-text-text-color-green");
var elTextTextColorBlue = document.getElementById("property-text-text-color-blue");
var elTextBackgroundColorRed = document.getElementById("property-text-background-color-red");
var elTextBackgroundColorGreen = document.getElementById("property-text-background-color-green");
var elTextBackgroundColorBlue = document.getElementById("property-text-background-color-blue");
if (window.EventBridge !== undefined) {
EventBridge.scriptEventReceived.connect(function(data) {
@ -201,13 +212,27 @@
elModelSection.style.display = 'none';
} else {
elModelSection.style.display = 'block';
elModelURL.value = properties.modelURL;
elModelAnimationURL.value = properties.animationURL;
elModelAnimationPlaying.checked = properties.animationPlaying;
elModelAnimationFPS.value = properties.animationFPS;
}
if (properties.type != "Text") {
elTextSection.style.display = 'none';
} else {
elTextSection.style.display = 'block';
elTextText.value = properties.text;
elTextLineHeight.value = properties.lineHeight;
elTextTextColorRed.value = properties.textColor.red;
elTextTextColorGreen.value = properties.textColor.green;
elTextTextColorBlue.value = properties.textColor.blue;
elTextBackgroundColorRed.value = properties.backgroundColor.red;
elTextBackgroundColorGreen.value = properties.backgroundColor.green;
elTextBackgroundColorBlue.value = properties.backgroundColor.blue;
}
if (properties.type != "Light") {
elLightSection.style.display = 'none';
} else {
@ -320,6 +345,22 @@
elModelAnimationPlaying.addEventListener('change', createEmitCheckedPropertyUpdateFunction('animationIsPlaying'));
elModelAnimationFPS.addEventListener('change', createEmitNumberPropertyUpdateFunction('animationFPS'));
elModelAnimationFrame.addEventListener('change', createEmitNumberPropertyUpdateFunction('animationFrameIndex'));
elTextText.addEventListener('change', createEmitTextPropertyUpdateFunction('text'));
elTextLineHeight.addEventListener('change', createEmitNumberPropertyUpdateFunction('lineHeight'));
var textTextColorChangeFunction = createEmitColorPropertyUpdateFunction(
'textColor', elTextTextColorRed, elTextTextColorGreen, elTextTextColorBlue);
elTextTextColorRed.addEventListener('change', textTextColorChangeFunction);
elTextTextColorGreen.addEventListener('change', textTextColorChangeFunction);
elTextTextColorBlue.addEventListener('change', textTextColorChangeFunction);
var textBackgroundColorChangeFunction = createEmitColorPropertyUpdateFunction(
'backgroundColor', elTextBackgroundColorRed, elTextBackgroundColorGreen, elTextBackgroundColorBlue);
elTextBackgroundColorRed.addEventListener('change', textBackgroundColorChangeFunction);
elTextBackgroundColorGreen.addEventListener('change', textBackgroundColorChangeFunction);
elTextBackgroundColorBlue.addEventListener('change', textBackgroundColorChangeFunction);
}
</script>
</head>
@ -490,6 +531,43 @@
<input class="coord" type='number' id="property-model-animation-fps"></input>
</span>
</div>
<div class="property-section">
<label>Animation Frame</label>
<span>
<input class="coord" type='number' id="property-model-animation-frame"></input>
</span>
</div>
</div>
<div id="text-section" class="multi-property-section">
<div class="property-section">
<label>Text</label>
<span>
<input type="text" id="property-text-text"></input>
</span>
</div>
<div class="property-section">
<label>Line Height</label>
<span>
<input class="coord" type='number' id="property-text-line-height"></input>
</span>
</div>
<div class="property-section">
<label>Text Color</label>
<span>
Red <input class="coord" type='number' id="property-text-text-color-red"></input>
Green <input class="coord" type='number' id="property-text-text-color-green"></input>
Blue <input class="coord" type='number' id="property-text-text-color-blue"></input>
</span>
</div>
<div class="property-section">
<label>Background Color</label>
<span>
Red <input class="coord" type='number' id="property-text-background-color-red"></input>
Green <input class="coord" type='number' id="property-text-background-color-green"></input>
Blue <input class="coord" type='number' id="property-text-background-color-blue"></input>
</span>
</div>
</div>

57
examples/libraries/entityPropertyDialogBox.js
View file

@ -41,15 +41,15 @@ EntityPropertyDialogBox = (function () {
array.push({ label: "Entity Type:" + properties.type, type: "header" });
index++;
array.push({ label: "Locked:", value: properties.locked });
array.push({ label: "Locked:", type: "checkbox", value: properties.locked });
index++;
if (properties.type == "Model") {
array.push({ label: "Model URL:", value: properties.modelURL });
index++;
array.push({ label: "Animation URL:", value: properties.animationURL });
index++;
array.push({ label: "Animation is playing:", value: properties.animationIsPlaying });
array.push({ label: "Animation is playing:", type: "checkbox", value: properties.animationIsPlaying });
previousAnimationIsPlaying = properties.animationIsPlaying;
index++;
array.push({ label: "Animation FPS:", value: properties.animationFPS });
@ -65,6 +65,30 @@ EntityPropertyDialogBox = (function () {
array.push({ label: "Original Textures:\n" + properties.originalTextures, type: "header" });
index++;
}
if (properties.type == "Text") {
array.push({ label: "Text:", value: properties.text });
index++;
array.push({ label: "Line Height:", value: properties.lineHeight });
index++;
array.push({ label: "Text Color:", type: "header" });
index++;
array.push({ label: "Red:", value: properties.textColor.red });
index++;
array.push({ label: "Green:", value: properties.textColor.green });
index++;
array.push({ label: "Blue:", value: properties.textColor.blue });
index++;
array.push({ label: "Background Color:", type: "header" });
index++;
array.push({ label: "Red:", value: properties.backgroundColor.red });
index++;
array.push({ label: "Green:", value: properties.backgroundColor.green });
index++;
array.push({ label: "Blue:", value: properties.backgroundColor.blue });
index++;
}
array.push({ label: "Position:", type: "header" });
index++;
array.push({ label: "X:", value: properties.position.x.toFixed(decimals) });
@ -140,20 +164,20 @@ EntityPropertyDialogBox = (function () {
index++;
array.push({ label: "Mass:", value: properties.mass.toFixed(decimals) });
index++;
array.push({ label: "Ignore for Collisions:", value: properties.ignoreForCollisions });
array.push({ label: "Ignore for Collisions:", type: "checkbox", value: properties.ignoreForCollisions });
index++;
array.push({ label: "Collisions Will Move:", value: properties.collisionsWillMove });
array.push({ label: "Collisions Will Move:", type: "checkbox", value: properties.collisionsWillMove });
index++;
array.push({ label: "Lifetime:", value: properties.lifetime.toFixed(decimals) });
index++;
array.push({ label: "Visible:", value: properties.visible });
array.push({ label: "Visible:", type: "checkbox", value: properties.visible });
index++;
array.push({ label: "Script:", value: properties.script });
index++;
if (properties.type == "Box" || properties.type == "Sphere") {
array.push({ label: "Color:", type: "header" });
index++;
@ -225,7 +249,7 @@ EntityPropertyDialogBox = (function () {
var rescaledX = peekX * peekRescale / 100.0;
var rescaledY = peekY * peekRescale / 100.0;
var rescaledZ = peekZ * peekRescale / 100.0;
Window.reloadNonBlockingForm([
{ value: rescaledX.toFixed(decimals), oldIndex: dimensionX },
{ value: rescaledY.toFixed(decimals), oldIndex: dimensionY },
@ -271,6 +295,22 @@ EntityPropertyDialogBox = (function () {
properties.textures = array[index++].value;
index++; // skip textureNames label
}
if (properties.type == "Text") {
properties.text = array[index++].value;
properties.lineHeight = array[index++].value;
index++; // skip header
properties.textColor.red = array[index++].value;
properties.textColor.green = array[index++].value;
properties.textColor.blue = array[index++].value;
index++; // skip header
properties.backgroundColor.red = array[index++].value;
properties.backgroundColor.green = array[index++].value;
properties.backgroundColor.blue = array[index++].value;
}
index++; // skip header
properties.position.x = array[index++].value;
properties.position.y = array[index++].value;
@ -354,4 +394,3 @@ EntityPropertyDialogBox = (function () {
return that;
}());

36
examples/newEditEntities.js
View file

@ -54,6 +54,9 @@ var wantEntityGlow = false;
var SPAWN_DISTANCE = 1;
var DEFAULT_DIMENSION = 0.20;
var DEFAULT_TEXT_DIMENSION_X = 1.0;
var DEFAULT_TEXT_DIMENSION_Y = 1.0;
var DEFAULT_TEXT_DIMENSION_Z = 0.01;
var MENU_INSPECT_TOOL_ENABLED = "Inspect Tool";
var MENU_EASE_ON_FOCUS = "Ease Orientation on Focus";
@ -84,6 +87,7 @@ var toolBar = (function () {
newCubeButton,
newSphereButton,
newLightButton,
newTextButton,
browseModelsButton,
loadURLMenuItem,
loadFileMenuItem,
@ -180,6 +184,16 @@ var toolBar = (function () {
visible: true
});
newTextButton = toolBar.addTool({
//imageURL: toolIconUrl + "add-text.svg",
imageURL: "https://s3-us-west-1.amazonaws.com/highfidelity-public/images/tools/add-text.svg", // temporarily
subImage: { x: 0, y: Tool.IMAGE_WIDTH, width: Tool.IMAGE_WIDTH, height: Tool.IMAGE_HEIGHT },
width: toolWidth,
height: toolHeight,
alpha: 0.9,
visible: true
});
}
function toggleNewModelButton(active) {
@ -357,7 +371,7 @@ var toolBar = (function () {
var position = Vec3.sum(MyAvatar.position, Vec3.multiply(Quat.getFront(MyAvatar.orientation), SPAWN_DISTANCE));
if (position.x > 0 && position.y > 0 && position.z > 0) {
Entities.addEntity({
Entities.addEntity({
type: "Light",
position: position,
dimensions: { x: DEFAULT_DIMENSION, y: DEFAULT_DIMENSION, z: DEFAULT_DIMENSION },
@ -378,6 +392,24 @@ var toolBar = (function () {
return true;
}
if (newTextButton === toolBar.clicked(clickedOverlay)) {
var position = Vec3.sum(MyAvatar.position, Vec3.multiply(Quat.getFront(MyAvatar.orientation), SPAWN_DISTANCE));
if (position.x > 0 && position.y > 0 && position.z > 0) {
Entities.addEntity({
type: "Text",
position: position,
dimensions: { x: DEFAULT_TEXT_DIMENSION_X, y: DEFAULT_TEXT_DIMENSION_Y, z: DEFAULT_TEXT_DIMENSION_Z },
backgroundColor: { red: 0, green: 0, blue: 0 },
textColor: { red: 255, green: 255, blue: 255 },
text: "some text",
lineHight: "0.1"
});
} else {
print("Can't create box: Text would be out of bounds.");
}
return true;
}
return false;
@ -710,7 +742,7 @@ function handeMenuEvent(menuItem) {
var selectedModel = form[0].value;
if (form[1].value == "Properties") {
editModelID = selectedModel;
showPropertiesForm(editModelID);
entityPropertyDialogBox.openDialog(editModelID);
} else if (form[1].value == "Delete") {
Entities.deleteEntity(selectedModel);
} else if (form[1].value == "Teleport") {

262
examples/playChess.js Normal file
View file

@ -0,0 +1,262 @@
//
// playChess.js
// examples
//
// Created by Clement Brisset on 11/08/2014
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
var gamePosition = { x: 1.0, y: 1.0, z: 1.0 };
var gameSize = 1.0;
// Script namespace
var extraDebug = extraDebug || true;
var ChessGame = ChessGame || {
BOARD: {
modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Board.fbx",
dimensions: { x: 773.191, y: 20.010, z: 773.191 },
rotation: Quat.fromPitchYawRollDegrees(0, 90, 0),
numTiles: 10.0
},
KING: 0, QUEEN: 1, BISHOP: 2, KNIGHT: 3, ROOK: 4, PAWN: 5,
board: null,
pieces: new Array()
};
ChessGame.getPieceInfo = function(type, isWhite) {
var info = {
modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/",
dimensions: { x: 1.0, y: 1.0, z: 1.0 },
rotation: Quat.fromPitchYawRollDegrees(0, 0, 0)
}
switch(type) {
case ChessGame.KING:
info.modelURL += "King";
info.dimensions = { x: 110.496, y: 306.713, z: 110.496 };
info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
break;
case ChessGame.QUEEN:
info.modelURL += "Queen";
info.dimensions = { x: 110.496, y: 257.459, z: 110.496 };
break;
case ChessGame.BISHOP:
info.modelURL += "Bishop";
info.dimensions = { x: 102.002, y: 213.941, z: 102.002 };
info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
break;
case ChessGame.KNIGHT:
info.modelURL += "Knight";
info.dimensions = { x: 95.602, y: 186.939, z: 95.602 };
info.rotation = Quat.fromPitchYawRollDegrees(0, 180, 0);
break;
case ChessGame.ROOK:
info.modelURL += "Rook";
info.dimensions = { x: 101.024, y: 167.523, z: 101.024 };
break;
case ChessGame.PAWN:
info.modelURL += "Pawn";
info.dimensions = { x: 93.317, y: 138.747, z: 93.317 };
break;
}
info.modelURL += ((isWhite) ? "_White" : "_Black") + ".fbx"
return info;
}
// Board class
ChessGame.Board = (function(position, scale) {
this.dimensions = Vec3.multiply(1.0 / ChessGame.BOARD.dimensions.x, ChessGame.BOARD.dimensions); // 1 by 1
this.dimensions = Vec3.multiply(scale, this.dimensions); // scale by scale
this.position = position
this.tileSize = scale / ChessGame.BOARD.numTiles;
this.userDataObject = {
firstTile: this.tilePosition(1, 1),
tileSize: this.tileSize,
whitesDeadPieces: this.tilePosition(0,0),
blacksDeadPieces: this.tilePosition(9,9)
}
this.entityProperties = {
type: "Model",
modelURL: ChessGame.BOARD.modelURL,
position: this.position,
dimensions: this.dimensions,
userData: this.buildUserDataString()
}
this.entity = null;
});
// Returns the top center point of tile i,j
ChessGame.Board.prototype.tilePosition = function(i, j) {
if (!(this.position || this.dimensions || this.tileSize || ChessGame.BOARD.numTiles)) {
print("ChessGame.Board.prototype.tilePosition(): Called before proper initialisation, bailing.");
return null;
}
return {
x: this.position.x + (i - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize,
y: this.position.y + this.dimensions.y / 2.0,
z: this.position.z + (j - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize
};
}
// Checks the color of the tile
ChessGame.Board.prototype.isWhite = function(i, j) {
return (i + j) % 2 != 0;
}
// Build the user data string
ChessGame.Board.prototype.buildUserDataString = function() {
return JSON.stringify(this.userDataObject);
}
// Updates the user data stored by the board
ChessGame.Board.prototype.updateUserData = function() {
var userDataString = this.buildUserDataString();
this.entityProperties.userData = userDataString;
Entities.editEntity(this.entity, { userData: userDataString });
}
// Spawns the board using entities
ChessGame.Board.prototype.spawn = function() {
if (extraDebug) {
print("Spawning board...");
}
this.entity = Entities.addEntity(this.entityProperties);
print("Board spawned");
}
// Cleans up the entities of the board
ChessGame.Board.prototype.cleanup = function() {
if (extraDebug) {
print("Cleaning up board...");
}
Entities.deleteEntity(this.entity);
print("Board cleaned up");
}
// Piece class
ChessGame.Piece = (function(position, dimensions, url, rotation) {
this.dimensions = dimensions;
this.position = position;
this.position.y += this.dimensions.y / 2.0;
this.entityProperties = {
type: "Model",
position: this.position,
rotation: rotation,
dimensions: this.dimensions,
modelURL: url,
/**/
script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js",
/*/
script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js",
/**/
userData: this.buildUserDataString()
}
this.entity = null;
});
// Build the user data string
ChessGame.Piece.prototype.buildUserDataString = function() {
if (!(ChessGame.board !== null || ChessGame.board.entity.isKnownID)) {
print("ChessGame.Piece.prototype.buildUserDataString(): Called before proper initialization, bailing.");
return null;
}
var userDataObject = {
boardID: ChessGame.board.entity,
};
return JSON.stringify(userDataObject);
}
// Spawns the piece
ChessGame.Piece.prototype.spawn = function() {
this.entity = Entities.addEntity(this.entityProperties);
}
// Cleans up the piece
ChessGame.Piece.prototype.cleanup = function() {
Entities.deleteEntity(this.entity);
}
ChessGame.makePiece = function(piece, i, j, isWhite) {
var info = ChessGame.getPieceInfo(piece, isWhite);
var url = info.modelURL;
var size = Vec3.multiply(0.5 * (1.0 / ChessGame.BOARD.dimensions.x), info.dimensions);
var rotation = (isWhite) ? info.rotation
: Quat.multiply(Quat.fromPitchYawRollDegrees(0, 180, 0),
info.rotation);
var position = ChessGame.board.tilePosition(i, j);
var piece = new ChessGame.Piece(position, size, url, rotation);
piece.spawn();
ChessGame.pieces.push(piece);
return piece;
}
ChessGame.scriptStarting = function() {
print("playChess.js started");
gamePosition = Vec3.sum(MyAvatar.position,
Vec3.multiplyQbyV(MyAvatar.orientation,
{ x: 0, y: 0, z: -1 }));
// Setup board
ChessGame.board = new ChessGame.Board(gamePosition, gameSize);
ChessGame.board.spawn();
}
ChessGame.update = function() {
ChessGame.board.entity = Entities.identifyEntity(ChessGame.board.entity);
if (ChessGame.board.entity.isKnownID && ChessGame.pieces.length == 0) {
// Setup white pieces
var isWhite = true;
var row = 1;
// King
ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
// Queen
ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
// Bishop
ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
// Knight
ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
// Rook
ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
for(var j = 1; j <= 8; j++) {
ChessGame.makePiece(ChessGame.PAWN, row + 1, j, isWhite);
}
// Setup black pieces
isWhite = false;
row = 8;
// King
ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
// Queen
ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
// Bishop
ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
// Knight
ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
// Rook
ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
for(var j = 1; j <= 8; j++) {
ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
}
Script.update.disconnect(ChessGame.update);
}
}
ChessGame.scriptEnding = function() {
// Cleaning up board
ChessGame.board.cleanup();
// Cleaning up pieces
for(var i in ChessGame.pieces) {
ChessGame.pieces[i].cleanup();
}
print("playChess.js finished");
}
Script.scriptEnding.connect(ChessGame.scriptEnding);
Script.update.connect(ChessGame.update);
ChessGame.scriptStarting();

2
interface/src/Application.cpp
View file

@ -1555,6 +1555,8 @@ void Application::checkBandwidthMeterClick() {
// ... to be called upon button release
if (Menu::getInstance()->isOptionChecked(MenuOption::Bandwidth) &&
Menu::getInstance()->isOptionChecked(MenuOption::Stats) &&
Menu::getInstance()->isOptionChecked(MenuOption::UserInterface) &&
glm::compMax(glm::abs(glm::ivec2(_mouseX - _mouseDragStartedX, _mouseY - _mouseDragStartedY)))
<= BANDWIDTH_METER_CLICK_MAX_DRAG_LENGTH
&& _bandwidthMeter.isWithinArea(_mouseX, _mouseY, _glWidget->width(), _glWidget->height())) {

12
interface/src/entities/EntityTreeRenderer.cpp
View file

@ -34,6 +34,7 @@
#include "RenderableLightEntityItem.h"
#include "RenderableModelEntityItem.h"
#include "RenderableSphereEntityItem.h"
#include "RenderableTextEntityItem.h"
QThread* EntityTreeRenderer::getMainThread() {
@ -50,6 +51,7 @@ EntityTreeRenderer::EntityTreeRenderer(bool wantScripts) :
REGISTER_ENTITY_TYPE_WITH_FACTORY(Box, RenderableBoxEntityItem::factory)
REGISTER_ENTITY_TYPE_WITH_FACTORY(Sphere, RenderableSphereEntityItem::factory)
REGISTER_ENTITY_TYPE_WITH_FACTORY(Light, RenderableLightEntityItem::factory)
REGISTER_ENTITY_TYPE_WITH_FACTORY(Text, RenderableTextEntityItem::factory)
_currentHoverOverEntityID = EntityItemID::createInvalidEntityID(); // makes it the unknown ID
_currentClickingOnEntityID = EntityItemID::createInvalidEntityID(); // makes it the unknown ID
@ -163,10 +165,12 @@ QScriptValue EntityTreeRenderer::loadEntityScript(EntityItem* entity) {
QString scriptContents = loadScriptContents(entity->getScript());
if (QScriptEngine::checkSyntax(scriptContents).state() != QScriptSyntaxCheckResult::Valid) {
QScriptSyntaxCheckResult syntaxCheck = QScriptEngine::checkSyntax(scriptContents);
if (syntaxCheck.state() != QScriptSyntaxCheckResult::Valid) {
qDebug() << "EntityTreeRenderer::loadEntityScript() entity:" << entityID;
qDebug() << " INVALID SYNTAX";
qDebug() << " SCRIPT:" << scriptContents;
qDebug() << " " << syntaxCheck.errorMessage() << ":"
<< syntaxCheck.errorLineNumber() << syntaxCheck.errorColumnNumber();
qDebug() << " SCRIPT:" << entity->getScript();
return QScriptValue(); // invalid script
}
@ -175,7 +179,7 @@ QScriptValue EntityTreeRenderer::loadEntityScript(EntityItem* entity) {
if (!entityScriptConstructor.isFunction()) {
qDebug() << "EntityTreeRenderer::loadEntityScript() entity:" << entityID;
qDebug() << " NOT CONSTRUCTOR";
qDebug() << " SCRIPT:" << scriptContents;
qDebug() << " SCRIPT:" << entity->getScript();
return QScriptValue(); // invalid script
}

3
interface/src/entities/EntityTreeRenderer.h
View file

@ -56,7 +56,8 @@ public:
void processEraseMessage(const QByteArray& dataByteArray, const SharedNodePointer& sourceNode);
virtual void init();
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO);
virtual const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem);
virtual const Model* getModelForEntityItem(const EntityItem* entityItem);

110
interface/src/entities/RenderableTextEntityItem.cpp Normal file
View file

@ -0,0 +1,110 @@
//
// RenderableTextEntityItem.cpp
// interface/src
//
// Created by Brad Hefta-Gaub on 8/6/14.
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include <glm/gtx/quaternion.hpp>
#include "InterfaceConfig.h"
#include <TextEntityItem.h>
#include <PerfStat.h>
#include "Menu.h"
#include "EntityTreeRenderer.h"
#include "RenderableTextEntityItem.h"
const int FIXED_FONT_POINT_SIZE = 40;
const float LINE_SCALE_RATIO = 1.2f;
EntityItem* RenderableTextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableTextEntityItem(entityID, properties);
}
void RenderableTextEntityItem::render(RenderArgs* args) {
PerformanceTimer perfTimer("RenderableTextEntityItem::render");
assert(getType() == EntityTypes::Text);
glm::vec3 position = getPositionInMeters();
glm::vec3 dimensions = getDimensions() * (float)TREE_SCALE;
glm::vec3 halfDimensions = dimensions / 2.0f;
glm::quat rotation = getRotation();
float leftMargin = 0.1f;
float rightMargin = 0.1f;
float topMargin = 0.1f;
float bottomMargin = 0.1f;
//qDebug() << "RenderableTextEntityItem::render() id:" << getEntityItemID() << "text:" << getText();
glPushMatrix();
{
glTranslatef(position.x, position.y, position.z);
glm::vec3 axis = glm::axis(rotation);
glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
const float MAX_COLOR = 255.0f;
xColor backgroundColor = getBackgroundColorX();
float alpha = 1.0f; //getBackgroundAlpha();
glColor4f(backgroundColor.red / MAX_COLOR, backgroundColor.green / MAX_COLOR, backgroundColor.blue / MAX_COLOR, alpha);
const float SLIGHTLY_BEHIND = -0.005f;
glBegin(GL_QUADS);
glVertex3f(-halfDimensions.x, -halfDimensions.y, SLIGHTLY_BEHIND);
glVertex3f(halfDimensions.x, -halfDimensions.y, SLIGHTLY_BEHIND);
glVertex3f(halfDimensions.x, halfDimensions.y, SLIGHTLY_BEHIND);
glVertex3f(-halfDimensions.x, halfDimensions.y, SLIGHTLY_BEHIND);
glEnd();
const int FIXED_FONT_SCALING_RATIO = FIXED_FONT_POINT_SIZE * 40.0f; // this is a ratio determined through experimentation
// Same font properties as textWidth()
TextRenderer* textRenderer = TextRenderer::getInstance(SANS_FONT_FAMILY, FIXED_FONT_POINT_SIZE);
float maxHeight = (float)textRenderer->calculateHeight("Xy") * LINE_SCALE_RATIO;
float scaleFactor = (maxHeight / FIXED_FONT_SCALING_RATIO) * _lineHeight;
glTranslatef(-(halfDimensions.x - leftMargin), halfDimensions.y - topMargin, 0.0f);
glm::vec2 clipMinimum(0.0f, 0.0f);
glm::vec2 clipDimensions((dimensions.x - (leftMargin + rightMargin)) / scaleFactor,
(dimensions.y - (topMargin + bottomMargin)) / scaleFactor);
glScalef(scaleFactor, -scaleFactor, 1.0);
enableClipPlane(GL_CLIP_PLANE0, -1.0f, 0.0f, 0.0f, clipMinimum.x + clipDimensions.x);
enableClipPlane(GL_CLIP_PLANE1, 1.0f, 0.0f, 0.0f, -clipMinimum.x);
enableClipPlane(GL_CLIP_PLANE2, 0.0f, -1.0f, 0.0f, clipMinimum.y + clipDimensions.y);
enableClipPlane(GL_CLIP_PLANE3, 0.0f, 1.0f, 0.0f, -clipMinimum.y);
xColor textColor = getTextColorX();
glColor3f(textColor.red / MAX_COLOR, textColor.green / MAX_COLOR, textColor.blue / MAX_COLOR);
QStringList lines = _text.split("\n");
int lineOffset = maxHeight;
float textAlpha = 1.0f; // getTextAlpha()
foreach(QString thisLine, lines) {
textRenderer->draw(0, lineOffset, qPrintable(thisLine), textAlpha);
lineOffset += maxHeight;
}
glDisable(GL_CLIP_PLANE0);
glDisable(GL_CLIP_PLANE1);
glDisable(GL_CLIP_PLANE2);
glDisable(GL_CLIP_PLANE3);
}
glPopMatrix();
}
void RenderableTextEntityItem::enableClipPlane(GLenum plane, float x, float y, float z, float w) {
GLdouble coefficients[] = { x, y, z, w };
glClipPlane(plane, coefficients);
glEnable(plane);
}

44
interface/src/entities/RenderableTextEntityItem.h Normal file
View file

@ -0,0 +1,44 @@
//
// RenderableTextEntityItem.h
// interface/src/entities
//
// Created by Brad Hefta-Gaub on 8/6/14.
// Copyright 2014 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_RenderableTextEntityItem_h
#define hifi_RenderableTextEntityItem_h
#include <glm/glm.hpp>
#include <stdint.h>
#include <EntityTree.h>
#include <Octree.h>
#include <OctreePacketData.h>
#include <OctreeRenderer.h>
#include <PacketHeaders.h>
#include <SharedUtil.h>
#include <ViewFrustum.h>
#include <TextEntityItem.h>
class RenderableTextEntityItem : public TextEntityItem {
public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties);
RenderableTextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
TextEntityItem(entityItemID, properties)
{ }
virtual void render(RenderArgs* args);
private:
void enableClipPlane(GLenum plane, float x, float y, float z, float w);
};
#endif // hifi_RenderableTextEntityItem_h

26
interface/src/scripting/WindowScriptingInterface.cpp
View file

@ -252,6 +252,7 @@ QScriptValue WindowScriptingInterface::doPeekNonBlockingFormResult(QScriptValue
int e = -1;
int d = -1;
int c = -1;
int h = -1;
for (int i = 0; i < _form.property("length").toInt32(); ++i) {
QScriptValue item = _form.property(i);
QScriptValue value = item.property("value");
@ -275,6 +276,11 @@ QScriptValue WindowScriptingInterface::doPeekNonBlockingFormResult(QScriptValue
array.engine()->undefinedValue()
);
_form.setProperty(i, item);
} else if (item.property("type").toString() == "checkbox") {
h++;
value = _checks.at(h)->checkState() == Qt::Checked;
item.setProperty("value", value);
_form.setProperty(i, item);
} else {
e += 1;
bool ok = true;
@ -309,6 +315,7 @@ QScriptValue WindowScriptingInterface::doGetNonBlockingFormResult(QScriptValue a
int e = -1;
int d = -1;
int c = -1;
int h = -1;
for (int i = 0; i < _form.property("length").toInt32(); ++i) {
QScriptValue item = _form.property(i);
QScriptValue value = item.property("value");
@ -332,6 +339,11 @@ QScriptValue WindowScriptingInterface::doGetNonBlockingFormResult(QScriptValue a
array.engine()->undefinedValue()
);
_form.setProperty(i, item);
} else if (item.property("type").toString() == "checkbox") {
h++;
value = _checks.at(h)->checkState() == Qt::Checked;
item.setProperty("value", value);
_form.setProperty(i, item);
} else {
e += 1;
bool ok = true;
@ -362,6 +374,7 @@ QScriptValue WindowScriptingInterface::doGetNonBlockingFormResult(QScriptValue a
_edits.clear();
_directories.clear();
_combos.clear();
_checks.clear();
array = _form;
return (_formResult == QDialog::Accepted);
@ -387,6 +400,7 @@ QScriptValue WindowScriptingInterface::showForm(const QString& title, QScriptVal
int e = -1;
int d = -1;
int c = -1;
int h = -1;
for (int i = 0; i < form.property("length").toInt32(); ++i) {
QScriptValue item = form.property(i);
QScriptValue value = item.property("value");
@ -410,6 +424,11 @@ QScriptValue WindowScriptingInterface::showForm(const QString& title, QScriptVal
form.engine()->undefinedValue()
);
form.setProperty(i, item);
} else if (item.property("type").toString() == "checkbox") {
h++;
value = _checks.at(h)->checkState() == Qt::Checked;
item.setProperty("value", value);
form.setProperty(i, item);
} else {
e += 1;
bool ok = true;
@ -436,6 +455,7 @@ QScriptValue WindowScriptingInterface::showForm(const QString& title, QScriptVal
delete editDialog;
_combos.clear();
_checks.clear();
_edits.clear();
_directories.clear();
return (result == QDialog::Accepted);
@ -522,6 +542,12 @@ QDialog* WindowScriptingInterface::createForm(const QString& title, QScriptValue
}
_combos.push_back(combo);
formLayout->addRow(new QLabel(item.property("label").toString()), combo);
} else if (item.property("type").toString() == "checkbox") {
QCheckBox* check = new QCheckBox();
check->setTristate(false);
check->setCheckState(item.property("value").toString() == "true" ? Qt::Checked : Qt::Unchecked);
_checks.push_back(check);
formLayout->addRow(new QLabel(item.property("label").toString()), check);
} else {
QLineEdit* edit = new QLineEdit(item.property("value").toString());
edit->setMinimumWidth(200);

1
interface/src/scripting/WindowScriptingInterface.h
View file

@ -90,6 +90,7 @@ private:
bool _nonBlockingFormActive;
int _formResult;
QVector<QComboBox*> _combos;
QVector<QCheckBox*> _checks;
QVector<QLineEdit*> _edits;
QVector<QPushButton*> _directories;
};

15
interface/src/ui/overlays/Base3DOverlay.cpp
View file

@ -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();
}

2
interface/src/ui/overlays/Base3DOverlay.h
View file

@ -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

16
interface/src/ui/overlays/BillboardOverlay.cpp
View file

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

5
interface/src/ui/overlays/BillboardOverlay.h
View file

@ -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();

25
interface/src/ui/overlays/Circle3DOverlay.cpp
View file

@ -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);
}

3
interface/src/ui/overlays/Circle3DOverlay.h
View file

@ -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;

9
interface/src/ui/overlays/Cube3DOverlay.cpp
View file

@ -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);
}

3
interface/src/ui/overlays/Cube3DOverlay.h
View file

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

11
interface/src/ui/overlays/Grid3DOverlay.cpp
View file

@ -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);
}

3
interface/src/ui/overlays/Grid3DOverlay.h
View file

@ -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;

15
interface/src/ui/overlays/ImageOverlay.cpp
View file

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

3
interface/src/ui/overlays/ImageOverlay.h
View file

@ -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...

10
interface/src/ui/overlays/Line3DOverlay.cpp
View file

@ -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);
}

3
interface/src/ui/overlays/Line3DOverlay.h
View file

@ -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;
};

11
interface/src/ui/overlays/LocalModelsOverlay.cpp
View file

@ -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);
}

3
interface/src/ui/overlays/LocalModelsOverlay.h
View file

@ -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;
};

10
interface/src/ui/overlays/LocalVoxelsOverlay.cpp
View file

@ -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());

2
interface/src/ui/overlays/LocalVoxelsOverlay.h
View file

@ -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

20
interface/src/ui/overlays/ModelOverlay.cpp
View file

@ -22,6 +22,22 @@ ModelOverlay::ModelOverlay()
_isLoaded = false;
}
ModelOverlay::ModelOverlay(const ModelOverlay* modelOverlay) :
Base3DOverlay(modelOverlay),
_model(),
_modelTextures(QVariantMap()),
_url(modelOverlay->_url),
_rotation(modelOverlay->_rotation),
_scale(modelOverlay->_scale),
_updateModel(false)
{
_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);
}

7
interface/src/ui/overlays/ModelOverlay.h
View file

@ -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;

22
interface/src/ui/overlays/Overlay.cpp
View file

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

2
interface/src/ui/overlays/Overlay.h
View file

@ -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:

6
interface/src/ui/overlays/Overlay2D.cpp
View file

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

3
interface/src/ui/overlays/Overlay2D.h
View file

@ -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);

24
interface/src/ui/overlays/Overlays.cpp
View file

@ -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 {

6
interface/src/ui/overlays/Overlays.h
View file

@ -51,7 +51,8 @@ public:
~Overlays();
void init(QGLWidget* parent);
void update(float deltatime);
void render3D(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
void render3D(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO);
void render2D();
public slots:
@ -61,6 +62,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);

6
interface/src/ui/overlays/Planar3DOverlay.cpp
View file

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

1
interface/src/ui/overlays/Planar3DOverlay.h
View file

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

14
interface/src/ui/overlays/Rectangle3DOverlay.cpp
View file

@ -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);
}

3
interface/src/ui/overlays/Rectangle3DOverlay.h
View file

@ -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;
};

9
interface/src/ui/overlays/Sphere3DOverlay.cpp
View file

@ -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);
}

3
interface/src/ui/overlays/Sphere3DOverlay.h
View file

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

19
interface/src/ui/overlays/Text3DOverlay.cpp
View file

@ -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));
}

3
interface/src/ui/overlays/Text3DOverlay.h
View file

@ -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);

15
interface/src/ui/overlays/TextOverlay.cpp
View file

@ -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);

3
interface/src/ui/overlays/TextOverlay.h
View file

@ -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;

6
interface/src/ui/overlays/Volume3DOverlay.cpp
View file

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

1
interface/src/ui/overlays/Volume3DOverlay.h
View file

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

222
libraries/entities/src/EntityItemProperties.cpp
View file

@ -20,93 +20,60 @@
#include "EntityItem.h"
#include "EntityItemProperties.h"
#include "ModelEntityItem.h"
#include "TextEntityItem.h"
EntityItemProperties::EntityItemProperties() :
CONSTRUCT_PROPERTY(visible, EntityItem::DEFAULT_VISIBLE),
CONSTRUCT_PROPERTY(position, 0),
CONSTRUCT_PROPERTY(dimensions, EntityItem::DEFAULT_DIMENSIONS),
CONSTRUCT_PROPERTY(rotation, EntityItem::DEFAULT_ROTATION),
CONSTRUCT_PROPERTY(mass, EntityItem::DEFAULT_MASS),
CONSTRUCT_PROPERTY(velocity, EntityItem::DEFAULT_VELOCITY),
CONSTRUCT_PROPERTY(gravity, EntityItem::DEFAULT_GRAVITY),
CONSTRUCT_PROPERTY(damping, EntityItem::DEFAULT_DAMPING),
CONSTRUCT_PROPERTY(lifetime, EntityItem::DEFAULT_LIFETIME),
CONSTRUCT_PROPERTY(script, EntityItem::DEFAULT_SCRIPT),
CONSTRUCT_PROPERTY(color, ),
CONSTRUCT_PROPERTY(modelURL, ""),
CONSTRUCT_PROPERTY(animationURL, ""),
CONSTRUCT_PROPERTY(animationFPS, ModelEntityItem::DEFAULT_ANIMATION_FPS),
CONSTRUCT_PROPERTY(animationFrameIndex, ModelEntityItem::DEFAULT_ANIMATION_FRAME_INDEX),
CONSTRUCT_PROPERTY(animationIsPlaying, ModelEntityItem::DEFAULT_ANIMATION_IS_PLAYING),
CONSTRUCT_PROPERTY(registrationPoint, EntityItem::DEFAULT_REGISTRATION_POINT),
CONSTRUCT_PROPERTY(angularVelocity, EntityItem::DEFAULT_ANGULAR_VELOCITY),
CONSTRUCT_PROPERTY(angularDamping, EntityItem::DEFAULT_ANGULAR_DAMPING),
CONSTRUCT_PROPERTY(ignoreForCollisions, EntityItem::DEFAULT_IGNORE_FOR_COLLISIONS),
CONSTRUCT_PROPERTY(collisionsWillMove, EntityItem::DEFAULT_COLLISIONS_WILL_MOVE),
CONSTRUCT_PROPERTY(isSpotlight, false),
CONSTRUCT_PROPERTY(diffuseColor, ),
CONSTRUCT_PROPERTY(ambientColor, ),
CONSTRUCT_PROPERTY(specularColor, ),
CONSTRUCT_PROPERTY(constantAttenuation, 1.0f),
CONSTRUCT_PROPERTY(linearAttenuation, 0.0f),
CONSTRUCT_PROPERTY(quadraticAttenuation, 0.0f),
CONSTRUCT_PROPERTY(exponent, 0.0f),
CONSTRUCT_PROPERTY(cutoff, PI),
CONSTRUCT_PROPERTY(locked, false),
CONSTRUCT_PROPERTY(textures, ""),
CONSTRUCT_PROPERTY(animationSettings, ""),
CONSTRUCT_PROPERTY(userData, EntityItem::DEFAULT_USER_DATA),
CONSTRUCT_PROPERTY(text, TextEntityItem::DEFAULT_TEXT),
CONSTRUCT_PROPERTY(lineHeight, TextEntityItem::DEFAULT_LINE_HEIGHT),
CONSTRUCT_PROPERTY(textColor, TextEntityItem::DEFAULT_TEXT_COLOR),
CONSTRUCT_PROPERTY(backgroundColor, TextEntityItem::DEFAULT_BACKGROUND_COLOR),
_id(UNKNOWN_ENTITY_ID),
_idSet(false),
_lastEdited(0), // ????
_lastEdited(0),
_created(UNKNOWN_CREATED_TIME),
_type(EntityTypes::Unknown),
_position(0),
_dimensions(EntityItem::DEFAULT_DIMENSIONS),
_rotation(EntityItem::DEFAULT_ROTATION),
_mass(EntityItem::DEFAULT_MASS),
_velocity(EntityItem::DEFAULT_VELOCITY),
_gravity(EntityItem::DEFAULT_GRAVITY),
_damping(EntityItem::DEFAULT_DAMPING),
_lifetime(EntityItem::DEFAULT_LIFETIME),
_userData(EntityItem::DEFAULT_USER_DATA),
_script(EntityItem::DEFAULT_SCRIPT),
_registrationPoint(EntityItem::DEFAULT_REGISTRATION_POINT),
_angularVelocity(EntityItem::DEFAULT_ANGULAR_VELOCITY),
_angularDamping(EntityItem::DEFAULT_ANGULAR_DAMPING),
_visible(EntityItem::DEFAULT_VISIBLE),
_ignoreForCollisions(EntityItem::DEFAULT_IGNORE_FOR_COLLISIONS),
_collisionsWillMove(EntityItem::DEFAULT_COLLISIONS_WILL_MOVE),
_positionChanged(false),
_dimensionsChanged(false),
_rotationChanged(false),
_massChanged(false),
_velocityChanged(false),
_gravityChanged(false),
_dampingChanged(false),
_lifetimeChanged(false),
_userDataChanged(false),
_scriptChanged(false),
_registrationPointChanged(false),
_angularVelocityChanged(false),
_angularDampingChanged(false),
_visibleChanged(false),
_ignoreForCollisionsChanged(false),
_collisionsWillMoveChanged(false),
_color(),
_modelURL(""),
_animationURL(""),
_animationIsPlaying(ModelEntityItem::DEFAULT_ANIMATION_IS_PLAYING),
_animationFrameIndex(ModelEntityItem::DEFAULT_ANIMATION_FRAME_INDEX),
_animationFPS(ModelEntityItem::DEFAULT_ANIMATION_FPS),
_animationSettings(""),
_glowLevel(0.0f),
_localRenderAlpha(1.0f),
_isSpotlight(false),
_colorChanged(false),
_modelURLChanged(false),
_animationURLChanged(false),
_animationIsPlayingChanged(false),
_animationFrameIndexChanged(false),
_animationFPSChanged(false),
_animationSettingsChanged(false),
_glowLevelChanged(false),
_localRenderAlphaChanged(false),
_isSpotlightChanged(false),
_diffuseColor(),
_ambientColor(),
_specularColor(),
_constantAttenuation(1.0f),
_linearAttenuation(0.0f),
_quadraticAttenuation(0.0f),
_exponent(0.0f),
_cutoff(PI),
_locked(false),
_textures(""),
_diffuseColorChanged(false),
_ambientColorChanged(false),
_specularColorChanged(false),
_constantAttenuationChanged(false),
_linearAttenuationChanged(false),
_quadraticAttenuationChanged(false),
_exponentChanged(false),
_cutoffChanged(false),
_lockedChanged(false),
_texturesChanged(false),
_defaultSettings(true),
_naturalDimensions(1.0f, 1.0f, 1.0f)
@ -226,6 +193,10 @@ EntityPropertyFlags EntityItemProperties::getChangedProperties() const {
CHECK_PROPERTY_CHANGE(PROP_LOCKED, locked);
CHECK_PROPERTY_CHANGE(PROP_TEXTURES, textures);
CHECK_PROPERTY_CHANGE(PROP_USER_DATA, userData);
CHECK_PROPERTY_CHANGE(PROP_TEXT, text);
CHECK_PROPERTY_CHANGE(PROP_LINE_HEIGHT, lineHeight);
CHECK_PROPERTY_CHANGE(PROP_TEXT_COLOR, textColor);
CHECK_PROPERTY_CHANGE(PROP_BACKGROUND_COLOR, backgroundColor);
return changedProperties;
}
@ -280,6 +251,10 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine) cons
COPY_PROPERTY_TO_QSCRIPTVALUE(locked);
COPY_PROPERTY_TO_QSCRIPTVALUE(textures);
COPY_PROPERTY_TO_QSCRIPTVALUE(userData);
COPY_PROPERTY_TO_QSCRIPTVALUE(text);
COPY_PROPERTY_TO_QSCRIPTVALUE(lineHeight);
COPY_PROPERTY_TO_QSCRIPTVALUE_COLOR_GETTER(textColor, getTextColor());
COPY_PROPERTY_TO_QSCRIPTVALUE_COLOR_GETTER(backgroundColor, getBackgroundColor());
// Sitting properties support
QScriptValue sittingPoints = engine->newObject();
@ -355,6 +330,10 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object) {
COPY_PROPERTY_FROM_QSCRIPTVALUE_BOOL(locked, setLocked);
COPY_PROPERTY_FROM_QSCRIPTVALUE_STRING(textures, setTextures);
COPY_PROPERTY_FROM_QSCRIPTVALUE_STRING(userData, setUserData);
COPY_PROPERTY_FROM_QSCRIPTVALUE_STRING(text, setText);
COPY_PROPERTY_FROM_QSCRIPTVALUE_FLOAT(lineHeight, setLineHeight);
COPY_PROPERTY_FROM_QSCRIPTVALUE_COLOR(textColor, setTextColor);
COPY_PROPERTY_FROM_QSCRIPTVALUE_COLOR(backgroundColor, setBackgroundColor);
_lastEdited = usecTimestampNow();
}
@ -494,30 +473,43 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem
APPEND_ENTITY_PROPERTY(PROP_LIFETIME, appendValue, properties.getLifetime());
APPEND_ENTITY_PROPERTY(PROP_SCRIPT, appendValue, properties.getScript());
APPEND_ENTITY_PROPERTY(PROP_COLOR, appendColor, properties.getColor());
APPEND_ENTITY_PROPERTY(PROP_MODEL_URL, appendValue, properties.getModelURL());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_URL, appendValue, properties.getAnimationURL());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_FPS, appendValue, properties.getAnimationFPS());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_FRAME_INDEX, appendValue, properties.getAnimationFrameIndex());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_PLAYING, appendValue, properties.getAnimationIsPlaying());
APPEND_ENTITY_PROPERTY(PROP_REGISTRATION_POINT, appendValue, properties.getRegistrationPoint());
APPEND_ENTITY_PROPERTY(PROP_ANGULAR_VELOCITY, appendValue, properties.getAngularVelocity());
APPEND_ENTITY_PROPERTY(PROP_ANGULAR_DAMPING, appendValue, properties.getAngularDamping());
APPEND_ENTITY_PROPERTY(PROP_VISIBLE, appendValue, properties.getVisible());
APPEND_ENTITY_PROPERTY(PROP_IGNORE_FOR_COLLISIONS, appendValue, properties.getIgnoreForCollisions());
APPEND_ENTITY_PROPERTY(PROP_COLLISIONS_WILL_MOVE, appendValue, properties.getCollisionsWillMove());
APPEND_ENTITY_PROPERTY(PROP_IS_SPOTLIGHT, appendValue, properties.getIsSpotlight());
APPEND_ENTITY_PROPERTY(PROP_DIFFUSE_COLOR, appendColor, properties.getDiffuseColor());
APPEND_ENTITY_PROPERTY(PROP_AMBIENT_COLOR, appendColor, properties.getAmbientColor());
APPEND_ENTITY_PROPERTY(PROP_SPECULAR_COLOR, appendColor, properties.getSpecularColor());
APPEND_ENTITY_PROPERTY(PROP_CONSTANT_ATTENUATION, appendValue, properties.getConstantAttenuation());
APPEND_ENTITY_PROPERTY(PROP_LINEAR_ATTENUATION, appendValue, properties.getLinearAttenuation());
APPEND_ENTITY_PROPERTY(PROP_QUADRATIC_ATTENUATION, appendValue, properties.getQuadraticAttenuation());
APPEND_ENTITY_PROPERTY(PROP_EXPONENT, appendValue, properties.getExponent());
APPEND_ENTITY_PROPERTY(PROP_CUTOFF, appendValue, properties.getCutoff());
APPEND_ENTITY_PROPERTY(PROP_LOCKED, appendValue, properties.getLocked());
APPEND_ENTITY_PROPERTY(PROP_TEXTURES, appendValue, properties.getTextures());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_SETTINGS, appendValue, properties.getAnimationSettings());
APPEND_ENTITY_PROPERTY(PROP_USER_DATA, appendValue, properties.getUserData());
if (properties.getType() == EntityTypes::Text) {
APPEND_ENTITY_PROPERTY(PROP_TEXT, appendValue, properties.getText());
APPEND_ENTITY_PROPERTY(PROP_LINE_HEIGHT, appendValue, properties.getLineHeight());
APPEND_ENTITY_PROPERTY(PROP_TEXT_COLOR, appendColor, properties.getTextColor());
APPEND_ENTITY_PROPERTY(PROP_BACKGROUND_COLOR, appendColor, properties.getBackgroundColor());
}
if (properties.getType() == EntityTypes::Model) {
APPEND_ENTITY_PROPERTY(PROP_MODEL_URL, appendValue, properties.getModelURL());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_URL, appendValue, properties.getAnimationURL());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_FPS, appendValue, properties.getAnimationFPS());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_FRAME_INDEX, appendValue, properties.getAnimationFrameIndex());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_PLAYING, appendValue, properties.getAnimationIsPlaying());
APPEND_ENTITY_PROPERTY(PROP_TEXTURES, appendValue, properties.getTextures());
APPEND_ENTITY_PROPERTY(PROP_ANIMATION_SETTINGS, appendValue, properties.getAnimationSettings());
}
if (properties.getType() == EntityTypes::Light) {
APPEND_ENTITY_PROPERTY(PROP_IS_SPOTLIGHT, appendValue, properties.getIsSpotlight());
APPEND_ENTITY_PROPERTY(PROP_DIFFUSE_COLOR, appendColor, properties.getDiffuseColor());
APPEND_ENTITY_PROPERTY(PROP_AMBIENT_COLOR, appendColor, properties.getAmbientColor());
APPEND_ENTITY_PROPERTY(PROP_SPECULAR_COLOR, appendColor, properties.getSpecularColor());
APPEND_ENTITY_PROPERTY(PROP_CONSTANT_ATTENUATION, appendValue, properties.getConstantAttenuation());
APPEND_ENTITY_PROPERTY(PROP_LINEAR_ATTENUATION, appendValue, properties.getLinearAttenuation());
APPEND_ENTITY_PROPERTY(PROP_QUADRATIC_ATTENUATION, appendValue, properties.getQuadraticAttenuation());
APPEND_ENTITY_PROPERTY(PROP_EXPONENT, appendValue, properties.getExponent());
APPEND_ENTITY_PROPERTY(PROP_CUTOFF, appendValue, properties.getCutoff());
}
}
if (propertyCount > 0) {
int endOfEntityItemData = packetData->getUncompressedByteOffset();
@ -705,30 +697,43 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LIFETIME, float, setLifetime);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_SCRIPT,setScript);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_COLOR, setColor);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_MODEL_URL, setModelURL);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_ANIMATION_URL, setAnimationURL);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANIMATION_FPS, float, setAnimationFPS);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANIMATION_FRAME_INDEX, float, setAnimationFrameIndex);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANIMATION_PLAYING, bool, setAnimationIsPlaying);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_REGISTRATION_POINT, glm::vec3, setRegistrationPoint);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_VELOCITY, glm::vec3, setAngularVelocity);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANGULAR_DAMPING, float, setAngularDamping);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_VISIBLE, bool, setVisible);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_IGNORE_FOR_COLLISIONS, bool, setIgnoreForCollisions);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_COLLISIONS_WILL_MOVE, bool, setCollisionsWillMove);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_IS_SPOTLIGHT, bool, setIsSpotlight);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_DIFFUSE_COLOR, setDiffuseColor);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_AMBIENT_COLOR, setAmbientColor);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_SPECULAR_COLOR, setSpecularColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CONSTANT_ATTENUATION, float, setConstantAttenuation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINEAR_ATTENUATION, float, setLinearAttenuation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_QUADRATIC_ATTENUATION, float, setQuadraticAttenuation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EXPONENT, float, setExponent);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CUTOFF, float, setCutoff);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LOCKED, bool, setLocked);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_TEXTURES, setTextures);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_ANIMATION_SETTINGS, setAnimationSettings);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_USER_DATA, setUserData);
if (properties.getType() == EntityTypes::Text) {
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_TEXT, setText);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINE_HEIGHT, float, setLineHeight);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_TEXT_COLOR, setTextColor);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_BACKGROUND_COLOR, setBackgroundColor);
}
if (properties.getType() == EntityTypes::Model) {
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_MODEL_URL, setModelURL);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_ANIMATION_URL, setAnimationURL);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANIMATION_FPS, float, setAnimationFPS);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANIMATION_FRAME_INDEX, float, setAnimationFrameIndex);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_ANIMATION_PLAYING, bool, setAnimationIsPlaying);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_TEXTURES, setTextures);
READ_ENTITY_PROPERTY_STRING_TO_PROPERTIES(PROP_ANIMATION_SETTINGS, setAnimationSettings);
}
if (properties.getType() == EntityTypes::Light) {
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_IS_SPOTLIGHT, bool, setIsSpotlight);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_DIFFUSE_COLOR, setDiffuseColor);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_AMBIENT_COLOR, setAmbientColor);
READ_ENTITY_PROPERTY_COLOR_TO_PROPERTIES(PROP_SPECULAR_COLOR, setSpecularColor);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CONSTANT_ATTENUATION, float, setConstantAttenuation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_LINEAR_ATTENUATION, float, setLinearAttenuation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_QUADRATIC_ATTENUATION, float, setQuadraticAttenuation);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_EXPONENT, float, setExponent);
READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_CUTOFF, float, setCutoff);
}
return valid;
}
@ -800,6 +805,11 @@ void EntityItemProperties::markAllChanged() {
_cutoffChanged = true;
_lockedChanged = true;
_texturesChanged = true;
_textChanged = true;
_lineHeightChanged = true;
_textColorChanged = true;
_backgroundColorChanged = true;
}
AACube EntityItemProperties::getMaximumAACubeInTreeUnits() const {

277
libraries/entities/src/EntityItemProperties.h
View file

@ -83,7 +83,14 @@ enum EntityPropertyList {
PROP_ANIMATION_SETTINGS,
PROP_USER_DATA,
PROP_LAST_ITEM = PROP_USER_DATA
PROP_LAST_ITEM = PROP_USER_DATA,
// These properties of TextEntity piggy back off of properties of ModelEntities, the type doesn't matter
// since the derived class knows how to interpret it's own properties and knows the types it expects
PROP_TEXT_COLOR = PROP_COLOR,
PROP_TEXT = PROP_MODEL_URL,
PROP_LINE_HEIGHT = PROP_ANIMATION_URL,
PROP_BACKGROUND_COLOR = PROP_ANIMATION_FPS,
};
typedef PropertyFlags<EntityPropertyList> EntityPropertyFlags;
@ -102,10 +109,14 @@ class EntityItemProperties {
friend class BoxEntityItem; // TODO: consider removing this friend relationship and use public methods
friend class SphereEntityItem; // TODO: consider removing this friend relationship and use public methods
friend class LightEntityItem; // TODO: consider removing this friend relationship and use public methods
friend class TextEntityItem; // TODO: consider removing this friend relationship and use public methods
public:
EntityItemProperties();
virtual ~EntityItemProperties();
EntityTypes::EntityType getType() const { return _type; }
void setType(EntityTypes::EntityType type) { _type = type; }
virtual QScriptValue copyToScriptValue(QScriptEngine* engine) const;
virtual void copyFromScriptValue(const QScriptValue& object);
@ -123,86 +134,63 @@ public:
AABox getAABoxInMeters() const;
void debugDump() const;
void setLastEdited(quint64 usecTime) { _lastEdited = usecTime; }
DEFINE_PROPERTY(PROP_VISIBLE, Visible, visible, bool);
DEFINE_PROPERTY_REF_WITH_SETTER(PROP_POSITION, Position, position, glm::vec3);
DEFINE_PROPERTY_REF(PROP_DIMENSIONS, Dimensions, dimensions, glm::vec3);
DEFINE_PROPERTY_REF(PROP_ROTATION, Rotation, rotation, glm::quat);
DEFINE_PROPERTY(PROP_MASS, Mass, mass, float);
DEFINE_PROPERTY_REF(PROP_VELOCITY, Velocity, velocity, glm::vec3);
DEFINE_PROPERTY_REF(PROP_GRAVITY, Gravity, gravity, glm::vec3);
DEFINE_PROPERTY(PROP_DAMPING, Damping, damping, float);
DEFINE_PROPERTY(PROP_LIFETIME, Lifetime, lifetime, float);
DEFINE_PROPERTY_REF(PROP_SCRIPT, Script, script, QString);
DEFINE_PROPERTY_REF(PROP_COLOR, Color, color, xColor);
DEFINE_PROPERTY_REF(PROP_MODEL_URL, ModelURL, modelURL, QString);
DEFINE_PROPERTY_REF(PROP_ANIMATION_URL, AnimationURL, animationURL, QString);
DEFINE_PROPERTY(PROP_ANIMATION_FPS, AnimationFPS, animationFPS, float);
DEFINE_PROPERTY(PROP_ANIMATION_FRAME_INDEX, AnimationFrameIndex, animationFrameIndex, float);
DEFINE_PROPERTY(PROP_ANIMATION_PLAYING, AnimationIsPlaying, animationIsPlaying, bool);
DEFINE_PROPERTY_REF(PROP_REGISTRATION_POINT, RegistrationPoint, registrationPoint, glm::vec3);
DEFINE_PROPERTY_REF(PROP_ANGULAR_VELOCITY, AngularVelocity, angularVelocity, glm::vec3);
DEFINE_PROPERTY(PROP_ANGULAR_DAMPING, AngularDamping, angularDamping, float);
DEFINE_PROPERTY(PROP_IGNORE_FOR_COLLISIONS, IgnoreForCollisions, ignoreForCollisions, bool);
DEFINE_PROPERTY(PROP_COLLISIONS_WILL_MOVE, CollisionsWillMove, collisionsWillMove, bool);
DEFINE_PROPERTY(PROP_IS_SPOTLIGHT, IsSpotlight, isSpotlight, bool);
DEFINE_PROPERTY_REF(PROP_DIFFUSE_COLOR, DiffuseColor, diffuseColor, xColor);
DEFINE_PROPERTY_REF(PROP_AMBIENT_COLOR, AmbientColor, ambientColor, xColor);
DEFINE_PROPERTY_REF(PROP_SPECULAR_COLOR, SpecularColor, specularColor, xColor);
DEFINE_PROPERTY(PROP_CONSTANT_ATTENUATION, ConstantAttenuation, constantAttenuation, float);
DEFINE_PROPERTY(PROP_LINEAR_ATTENUATION, LinearAttenuation, linearAttenuation, float);
DEFINE_PROPERTY(PROP_QUADRATIC_ATTENUATION, QuadraticAttenuation, quadraticAttenuation, float);
DEFINE_PROPERTY(PROP_EXPONENT, Exponent, exponent, float);
DEFINE_PROPERTY(PROP_CUTOFF, Cutoff, cutoff, float);
DEFINE_PROPERTY(PROP_LOCKED, Locked, locked, bool);
DEFINE_PROPERTY_REF(PROP_TEXTURES, Textures, textures, QString);
DEFINE_PROPERTY_REF_WITH_SETTER_AND_GETTER(PROP_ANIMATION_SETTINGS, AnimationSettings, animationSettings, QString);
DEFINE_PROPERTY_REF(PROP_USER_DATA, UserData, userData, QString);
DEFINE_PROPERTY_REF(PROP_TEXT, Text, text, QString);
DEFINE_PROPERTY(PROP_LINE_HEIGHT, LineHeight, lineHeight, float);
DEFINE_PROPERTY_REF(PROP_TEXT_COLOR, TextColor, textColor, xColor);
DEFINE_PROPERTY_REF(PROP_BACKGROUND_COLOR, BackgroundColor, backgroundColor, xColor);
// properties of all entities
EntityTypes::EntityType getType() const { return _type; }
void setType(EntityTypes::EntityType type) { _type = type; }
const glm::vec3& getPosition() const { return _position; }
/// set position in meter units, will be clamped to domain bounds
void setPosition(const glm::vec3& value) { _position = glm::clamp(value, 0.0f, (float)TREE_SCALE); _positionChanged = true; }
const glm::vec3& getDimensions() const { return _dimensions; }
void setDimensions(const glm::vec3& value) { _dimensions = value; _dimensionsChanged = true; }
public:
float getMaxDimension() const { return glm::max(_dimensions.x, _dimensions.y, _dimensions.z); }
const glm::quat& getRotation() const { return _rotation; }
void setRotation(const glm::quat& rotation) { _rotation = rotation; _rotationChanged = true; }
float getMass() const { return _mass; }
void setMass(float value) { _mass = value; _massChanged = true; }
/// velocity in meters (0.0-1.0) per second
const glm::vec3& getVelocity() const { return _velocity; }
/// velocity in meters (0.0-1.0) per second
void setVelocity(const glm::vec3& value) { _velocity = value; _velocityChanged = true; }
/// gravity in meters (0.0-TREE_SCALE) per second squared
const glm::vec3& getGravity() const { return _gravity; }
/// gravity in meters (0.0-TREE_SCALE) per second squared
void setGravity(const glm::vec3& value) { _gravity = value; _gravityChanged = true; }
float getDamping() const { return _damping; }
void setDamping(float value) { _damping = value; _dampingChanged = true; }
float getLifetime() const { return _lifetime; } /// get the lifetime in seconds for the entity
void setLifetime(float value) { _lifetime = value; _lifetimeChanged = true; } /// set the lifetime in seconds for the entity
const QString& getUserData() const { return _userData; }
void setUserData(const QString& value) { _userData = value; _userDataChanged = true; }
float getAge() const { return (float)(usecTimestampNow() - _created) / (float)USECS_PER_SECOND; }
quint64 getCreated() const { return _created; }
void setCreated(quint64 usecTime) { _created = usecTime; }
bool hasCreatedTime() const { return (_created != UNKNOWN_CREATED_TIME); }
// NOTE: how do we handle _defaultSettings???
bool containsBoundsProperties() const { return (_positionChanged || _dimensionsChanged); }
bool containsPositionChange() const { return _positionChanged; }
bool containsDimensionsChange() const { return _dimensionsChanged; }
// TODO: this need to be more generic. for now, we're going to have the properties class support these as
// named getter/setters, but we want to move them to generic types...
// properties we want to move to just models and particles
xColor getColor() const { return _color; }
const QString& getModelURL() const { return _modelURL; }
const QString& getAnimationURL() const { return _animationURL; }
float getAnimationFrameIndex() const { return _animationFrameIndex; }
bool getAnimationIsPlaying() const { return _animationIsPlaying; }
float getAnimationFPS() const { return _animationFPS; }
QString getAnimationSettings() const;
float getGlowLevel() const { return _glowLevel; }
float getLocalRenderAlpha() const { return _localRenderAlpha; }
const QString& getScript() const { return _script; }
// model related properties
void setColor(const xColor& value) { _color = value; _colorChanged = true; }
void setModelURL(const QString& url) { _modelURL = url; _modelURLChanged = true; }
void setAnimationURL(const QString& url) { _animationURL = url; _animationURLChanged = true; }
void setAnimationFrameIndex(float value) { _animationFrameIndex = value; _animationFrameIndexChanged = true; }
void setAnimationIsPlaying(bool value) { _animationIsPlaying = value; _animationIsPlayingChanged = true; }
void setAnimationFPS(float value) { _animationFPS = value; _animationFPSChanged = true; }
void setAnimationSettings(const QString& value);
void setGlowLevel(float value) { _glowLevel = value; _glowLevelChanged = true; }
void setLocalRenderAlpha(float value) { _localRenderAlpha = value; _localRenderAlphaChanged = true; }
void setScript(const QString& value) { _script = value; _scriptChanged = true; }
static bool encodeEntityEditPacket(PacketType command, EntityItemID id, const EntityItemProperties& properties,
unsigned char* bufferOut, int sizeIn, int& sizeOut);
@ -214,23 +202,6 @@ public:
static bool decodeEntityEditPacket(const unsigned char* data, int bytesToRead, int& processedBytes,
EntityItemID& entityID, EntityItemProperties& properties);
bool positionChanged() const { return _positionChanged; }
bool rotationChanged() const { return _rotationChanged; }
bool massChanged() const { return _massChanged; }
bool velocityChanged() const { return _velocityChanged; }
bool gravityChanged() const { return _gravityChanged; }
bool dampingChanged() const { return _dampingChanged; }
bool lifetimeChanged() const { return _lifetimeChanged; }
bool userDataChanged() const { return _userDataChanged; }
bool scriptChanged() const { return _scriptChanged; }
bool dimensionsChanged() const { return _dimensionsChanged; }
bool registrationPointChanged() const { return _registrationPointChanged; }
bool colorChanged() const { return _colorChanged; }
bool modelURLChanged() const { return _modelURLChanged; }
bool animationURLChanged() const { return _animationURLChanged; }
bool animationIsPlayingChanged() const { return _animationIsPlayingChanged; }
bool animationFrameIndexChanged() const { return _animationFrameIndexChanged; }
bool animationFPSChanged() const { return _animationFPSChanged; }
bool glowLevelChanged() const { return _glowLevelChanged; }
bool localRenderAlphaChanged() const { return _localRenderAlphaChanged; }
@ -238,161 +209,26 @@ public:
void markAllChanged();
void setSittingPoints(const QVector<SittingPoint>& sittingPoints);
const glm::vec3& getNaturalDimensions() const { return _naturalDimensions; }
void setNaturalDimensions(const glm::vec3& value) { _naturalDimensions = value; }
const glm::vec3& getRegistrationPoint() const { return _registrationPoint; }
void setRegistrationPoint(const glm::vec3& value) { _registrationPoint = value; _registrationPointChanged = true; }
const glm::vec3& getAngularVelocity() const { return _angularVelocity; }
void setAngularVelocity(const glm::vec3& value) { _angularVelocity = value; _angularVelocityChanged = true; }
float getAngularDamping() const { return _angularDamping; }
void setAngularDamping(float value) { _angularDamping = value; _angularDampingChanged = true; }
bool getVisible() const { return _visible; }
void setVisible(bool value) { _visible = value; _visibleChanged = true; }
bool getIgnoreForCollisions() const { return _ignoreForCollisions; }
void setIgnoreForCollisions(bool value) { _ignoreForCollisions = value; _ignoreForCollisionsChanged = true; }
bool getCollisionsWillMove() const { return _collisionsWillMove; }
void setCollisionsWillMove(bool value) { _collisionsWillMove = value; _collisionsWillMoveChanged = true; }
bool getIsSpotlight() const { return _isSpotlight; }
void setIsSpotlight(bool value) { _isSpotlight = value; _isSpotlightChanged = true; }
xColor getDiffuseColor() const { return _diffuseColor; }
xColor getAmbientColor() const { return _ambientColor; }
xColor getSpecularColor() const { return _specularColor; }
void setDiffuseColor(const xColor& value) { _diffuseColor = value; _diffuseColorChanged = true; }
void setAmbientColor(const xColor& value) { _ambientColor = value; _ambientColorChanged = true; }
void setSpecularColor(const xColor& value) { _specularColor = value; _specularColorChanged = true; }
bool diffuseColorChanged() const { return _colorChanged; }
bool ambientColorChanged() const { return _ambientColorChanged; }
bool specularColorChanged() const { return _specularColorChanged; }
float getConstantAttenuation() const { return _constantAttenuation; }
void setConstantAttenuation(float value) { _constantAttenuation = value; _constantAttenuationChanged = true; }
float getLinearAttenuation() const { return _linearAttenuation; }
void setLinearAttenuation(float value) { _linearAttenuation = value; _linearAttenuationChanged = true; }
float getQuadraticAttenuation() const { return _quadraticAttenuation; }
void setQuadraticAttenuation(float value) { _quadraticAttenuation = value; _quadraticAttenuationChanged = true; }
float getExponent() const { return _exponent; }
void setExponent(float value) { _exponent = value; _exponentChanged = true; }
float getCutoff() const { return _cutoff; }
void setCutoff(float value) { _cutoff = value; _cutoffChanged = true; }
bool getLocked() const { return _locked; }
void setLocked(bool value) { _locked = value; _lockedChanged = true; }
bool lockedChanged() const { return _lockedChanged; }
const QString& getTextures() const { return _textures; }
void setTextures(const QString& value) { _textures = value; _texturesChanged = true; }
const QStringList& getTextureNames() const { return _textureNames; }
void setTextureNames(const QStringList& value) { _textureNames = value; }
void setLastEdited(quint64 usecTime) { _lastEdited = usecTime; }
private:
QUuid _id;
bool _idSet;
quint64 _lastEdited;
quint64 _created;
EntityTypes::EntityType _type;
void setType(const QString& typeName) { _type = EntityTypes::getEntityTypeFromName(typeName); }
glm::vec3 _position;
glm::vec3 _dimensions;
glm::quat _rotation;
float _mass;
glm::vec3 _velocity;
glm::vec3 _gravity;
float _damping;
float _lifetime;
QString _userData;
QString _script;
glm::vec3 _registrationPoint;
glm::vec3 _angularVelocity;
float _angularDamping;
bool _visible;
bool _ignoreForCollisions;
bool _collisionsWillMove;
bool _positionChanged;
bool _dimensionsChanged;
bool _rotationChanged;
bool _massChanged;
bool _velocityChanged;
bool _gravityChanged;
bool _dampingChanged;
bool _lifetimeChanged;
bool _userDataChanged;
bool _scriptChanged;
bool _registrationPointChanged;
bool _angularVelocityChanged;
bool _angularDampingChanged;
bool _visibleChanged;
bool _ignoreForCollisionsChanged;
bool _collisionsWillMoveChanged;
// TODO: this need to be more generic. for now, we're going to have the properties class support these as
// named getter/setters, but we want to move them to generic types...
xColor _color;
QString _modelURL;
QString _animationURL;
bool _animationIsPlaying;
float _animationFrameIndex;
float _animationFPS;
QString _animationSettings;
float _glowLevel;
float _localRenderAlpha;
bool _isSpotlight;
bool _colorChanged;
bool _modelURLChanged;
bool _animationURLChanged;
bool _animationIsPlayingChanged;
bool _animationFrameIndexChanged;
bool _animationFPSChanged;
bool _animationSettingsChanged;
bool _glowLevelChanged;
bool _localRenderAlphaChanged;
bool _isSpotlightChanged;
xColor _diffuseColor;
xColor _ambientColor;
xColor _specularColor;
float _constantAttenuation;
float _linearAttenuation;
float _quadraticAttenuation;
float _exponent;
float _cutoff;
bool _locked;
QString _textures;
bool _diffuseColorChanged;
bool _ambientColorChanged;
bool _specularColorChanged;
bool _constantAttenuationChanged;
bool _linearAttenuationChanged;
bool _quadraticAttenuationChanged;
bool _exponentChanged;
bool _cutoffChanged;
bool _lockedChanged;
bool _texturesChanged;
bool _defaultSettings;
// NOTE: The following are pseudo client only properties. They are only used in clients which can access
@ -406,6 +242,11 @@ QScriptValue EntityItemPropertiesToScriptValue(QScriptEngine* engine, const Enti
void EntityItemPropertiesFromScriptValue(const QScriptValue &object, EntityItemProperties& properties);
// define these inline here so the macros work
inline void EntityItemProperties::setPosition(const glm::vec3& value)
{ _position = glm::clamp(value, 0.0f, (float)TREE_SCALE); _positionChanged = true; }
inline QDebug operator<<(QDebug debug, const EntityItemProperties& properties) {
debug << "EntityItemProperties[" << "\n"
<< " position:" << properties.getPosition() << "in meters" << "\n"

40
libraries/entities/src/EntityItemPropertiesMacros.h
View file

@ -260,6 +260,46 @@
} \
} \
}
#define CONSTRUCT_PROPERTY(n, V) \
_##n(V), \
_##n##Changed(false)
#define DEFINE_PROPERTY(P, N, n, T) \
public: \
T get##N() const { return _##n; } \
void set##N(T value) { _##n = value; _##n##Changed = true; } \
bool n##Changed() const { return _##n##Changed; } \
private: \
T _##n; \
bool _##n##Changed;
#define DEFINE_PROPERTY_REF(P, N, n, T) \
public: \
const T& get##N() const { return _##n; } \
void set##N(const T& value) { _##n = value; _##n##Changed = true; } \
bool n##Changed() const { return _##n##Changed; } \
private: \
T _##n; \
bool _##n##Changed;
#define DEFINE_PROPERTY_REF_WITH_SETTER(P, N, n, T) \
public: \
const T& get##N() const { return _##n; } \
void set##N(const T& value); \
bool n##Changed() const; \
private: \
T _##n; \
bool _##n##Changed;
#define DEFINE_PROPERTY_REF_WITH_SETTER_AND_GETTER(P, N, n, T) \
public: \
T get##N() const; \
void set##N(const T& value); \
bool n##Changed() const; \
private: \
T _##n; \
bool _##n##Changed;

13
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -93,7 +93,6 @@ EntityItemProperties EntityScriptingInterface::getEntityProperties(EntityItemID
EntityItemID EntityScriptingInterface::editEntity(EntityItemID entityID, const EntityItemProperties& properties) {
EntityItemID actualID = entityID;
// if the entity is unknown, attempt to look it up
if (!entityID.isKnownID) {
actualID = EntityItemID::getIDfromCreatorTokenID(entityID.creatorTokenID);
@ -113,6 +112,18 @@ EntityItemID EntityScriptingInterface::editEntity(EntityItemID entityID, const E
// if at this point, we know the id, send the update to the entity server
if (entityID.isKnownID) {
// make sure the properties has a type, so that the encode can know which properties to include
if (properties.getType() == EntityTypes::Unknown) {
EntityItem* entity = _entityTree->findEntityByEntityItemID(entityID);
if (entity) {
EntityItemProperties tempProperties = properties;
tempProperties.setType(entity->getType());
queueEntityMessage(PacketTypeEntityAddOrEdit, entityID, tempProperties);
return entityID;
}
}
// if the properties already includes the type, then use it as is
queueEntityMessage(PacketTypeEntityAddOrEdit, entityID, properties);
}

2
libraries/entities/src/EntityTree.cpp
View file

@ -1089,7 +1089,6 @@ bool DebugOperator::preRecursion(OctreeElement* element) {
}
void EntityTree::dumpTree() {
// First, look for the existing entity in the tree..
DebugOperator theOperator;
recurseTreeWithOperator(&theOperator);
}
@ -1107,7 +1106,6 @@ bool PruneOperator::postRecursion(OctreeElement* element) {
}
void EntityTree::pruneTree() {
// First, look for the existing entity in the tree..
PruneOperator theOperator;
recurseTreeWithOperator(&theOperator);
}

2
libraries/entities/src/EntityTypes.cpp
View file

@ -22,6 +22,7 @@
#include "LightEntityItem.h"
#include "ModelEntityItem.h"
#include "SphereEntityItem.h"
#include "TextEntityItem.h"
QMap<EntityTypes::EntityType, QString> EntityTypes::_typeToNameMap;
QMap<QString, EntityTypes::EntityType> EntityTypes::_nameToTypeMap;
@ -35,6 +36,7 @@ REGISTER_ENTITY_TYPE(Model)
REGISTER_ENTITY_TYPE(Box)
REGISTER_ENTITY_TYPE(Sphere)
REGISTER_ENTITY_TYPE(Light)
REGISTER_ENTITY_TYPE(Text)
const QString& EntityTypes::getEntityTypeName(EntityType entityType) {

3
libraries/entities/src/EntityTypes.h
View file

@ -34,7 +34,8 @@ public:
Box,
Sphere,
Light,
LAST = Light
Text,
LAST = Text
} EntityType;
static const QString& getEntityTypeName(EntityType entityType);

113
libraries/entities/src/TextEntityItem.cpp Normal file
View file

@ -0,0 +1,113 @@
//
// TextEntityItem.cpp
// libraries/entities/src
//
// Created by Brad Hefta-Gaub on 12/4/13.
// Copyright 2013 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include <QDebug>
#include <ByteCountCoding.h>
#include "EntityTree.h"
#include "EntityTreeElement.h"
#include "TextEntityItem.h"
const QString TextEntityItem::DEFAULT_TEXT("");
const float TextEntityItem::DEFAULT_LINE_HEIGHT = 0.1f;
const xColor TextEntityItem::DEFAULT_TEXT_COLOR = { 255, 255, 255 };
const xColor TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0};
EntityItem* TextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem* result = new TextEntityItem(entityID, properties);
return result;
}
TextEntityItem::TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
EntityItem(entityItemID)
{
_type = EntityTypes::Text;
_created = properties.getCreated();
setProperties(properties, true);
}
EntityItemProperties TextEntityItem::getProperties() const {
EntityItemProperties properties = EntityItem::getProperties(); // get the properties from our base class
COPY_ENTITY_PROPERTY_TO_PROPERTIES(text, getText);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(lineHeight, getLineHeight);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(textColor, getTextColorX);
COPY_ENTITY_PROPERTY_TO_PROPERTIES(backgroundColor, getBackgroundColorX);
return properties;
}
bool TextEntityItem::setProperties(const EntityItemProperties& properties, bool forceCopy) {
bool somethingChanged = false;
somethingChanged = EntityItem::setProperties(properties, forceCopy); // set the properties in our base class
SET_ENTITY_PROPERTY_FROM_PROPERTIES(text, setText);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(lineHeight, setLineHeight);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(textColor, setTextColor);
SET_ENTITY_PROPERTY_FROM_PROPERTIES(backgroundColor, setBackgroundColor);
if (somethingChanged) {
bool wantDebug = false;
if (wantDebug) {
uint64_t now = usecTimestampNow();
int elapsed = now - getLastEdited();
qDebug() << "TextEntityItem::setProperties() AFTER update... edited AGO=" << elapsed <<
"now=" << now << " getLastEdited()=" << getLastEdited();
}
setLastEdited(properties._lastEdited);
}
return somethingChanged;
}
int TextEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
ReadBitstreamToTreeParams& args,
EntityPropertyFlags& propertyFlags, bool overwriteLocalData) {
int bytesRead = 0;
const unsigned char* dataAt = data;
READ_ENTITY_PROPERTY_STRING(PROP_TEXT, setText);
READ_ENTITY_PROPERTY(PROP_LINE_HEIGHT, float, _lineHeight);
READ_ENTITY_PROPERTY_COLOR(PROP_TEXT_COLOR, _textColor);
READ_ENTITY_PROPERTY_COLOR(PROP_BACKGROUND_COLOR, _backgroundColor);
return bytesRead;
}
// TODO: eventually only include properties changed since the params.lastViewFrustumSent time
EntityPropertyFlags TextEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);
requestedProperties += PROP_TEXT;
requestedProperties += PROP_LINE_HEIGHT;
requestedProperties += PROP_TEXT_COLOR;
requestedProperties += PROP_BACKGROUND_COLOR;
return requestedProperties;
}
void TextEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount,
OctreeElement::AppendState& appendState) const {
bool successPropertyFits = true;
APPEND_ENTITY_PROPERTY(PROP_TEXT, appendValue, getText());
APPEND_ENTITY_PROPERTY(PROP_LINE_HEIGHT, appendValue, getLineHeight());
APPEND_ENTITY_PROPERTY(PROP_TEXT_COLOR, appendColor, getTextColor());
APPEND_ENTITY_PROPERTY(PROP_BACKGROUND_COLOR, appendColor, getBackgroundColor());
}

81
libraries/entities/src/TextEntityItem.h Normal file
View file

@ -0,0 +1,81 @@
//
// TextEntityItem.h
// libraries/entities/src
//
// Created by Brad Hefta-Gaub on 12/4/13.
// Copyright 2013 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_TextEntityItem_h
#define hifi_TextEntityItem_h
#include "EntityItem.h"
class TextEntityItem : public EntityItem {
public:
static EntityItem* factory(const EntityItemID& entityID, const EntityItemProperties& properties);
TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
ALLOW_INSTANTIATION // This class can be instantiated
// methods for getting/setting all properties of an entity
virtual EntityItemProperties getProperties() const;
virtual bool setProperties(const EntityItemProperties& properties, bool forceCopy = false);
// TODO: eventually only include properties changed since the params.lastViewFrustumSent time
virtual EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const;
virtual void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
EntityPropertyFlags& requestedProperties,
EntityPropertyFlags& propertyFlags,
EntityPropertyFlags& propertiesDidntFit,
int& propertyCount,
OctreeElement::AppendState& appendState) const;
virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
ReadBitstreamToTreeParams& args,
EntityPropertyFlags& propertyFlags, bool overwriteLocalData);
static const QString DEFAULT_TEXT;
void setText(const QString& value) { _text = value; }
const QString& getText() const { return _text; }
static const float DEFAULT_LINE_HEIGHT;
void setLineHeight(float value) { _lineHeight = value; }
float getLineHeight() const { return _lineHeight; }
static const xColor DEFAULT_TEXT_COLOR;
const rgbColor& getTextColor() const { return _textColor; }
xColor getTextColorX() const { xColor color = { _textColor[RED_INDEX], _textColor[GREEN_INDEX], _textColor[BLUE_INDEX] }; return color; }
void setTextColor(const rgbColor& value) { memcpy(_textColor, value, sizeof(_textColor)); }
void setTextColor(const xColor& value) {
_textColor[RED_INDEX] = value.red;
_textColor[GREEN_INDEX] = value.green;
_textColor[BLUE_INDEX] = value.blue;
}
static const xColor DEFAULT_BACKGROUND_COLOR;
const rgbColor& getBackgroundColor() const { return _backgroundColor; }
xColor getBackgroundColorX() const { xColor color = { _backgroundColor[RED_INDEX], _backgroundColor[GREEN_INDEX], _backgroundColor[BLUE_INDEX] }; return color; }
void setBackgroundColor(const rgbColor& value) { memcpy(_backgroundColor, value, sizeof(_backgroundColor)); }
void setBackgroundColor(const xColor& value) {
_backgroundColor[RED_INDEX] = value.red;
_backgroundColor[GREEN_INDEX] = value.green;
_backgroundColor[BLUE_INDEX] = value.blue;
}
protected:
QString _text;
float _lineHeight;
rgbColor _textColor;
rgbColor _backgroundColor;
};
#endif // hifi_TextEntityItem_h

3
libraries/octree/src/OctreeHeadlessViewer.h
View file

@ -33,7 +33,8 @@ public:
virtual void renderElement(OctreeElement* element, RenderArgs* args) { /* swallow these */ }
virtual void init();
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE) { /* swallow these */ }
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO) { /* swallow these */ }
void setJurisdictionListener(JurisdictionListener* jurisdictionListener) { _jurisdictionListener = jurisdictionListener; }

104
libraries/octree/src/OctreePersistThread.cpp
View file

@ -9,18 +9,31 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include <time.h>
#include <QDebug>
#include <PerfStat.h>
#include <SharedUtil.h>
#include "OctreePersistThread.h"
OctreePersistThread::OctreePersistThread(Octree* tree, const QString& filename, int persistInterval) :
const int OctreePersistThread::DEFAULT_PERSIST_INTERVAL = 1000 * 30; // every 30 seconds
const int OctreePersistThread::DEFAULT_BACKUP_INTERVAL = 1000 * 60 * 30; // every 30 minutes
const QString OctreePersistThread::DEFAULT_BACKUP_EXTENSION_FORMAT(".backup.%Y-%m-%d.%H:%M:%S.%z");
OctreePersistThread::OctreePersistThread(Octree* tree, const QString& filename, int persistInterval,
bool wantBackup, int backupInterval, const QString& backupExtensionFormat) :
_tree(tree),
_filename(filename),
_backupExtensionFormat(backupExtensionFormat),
_persistInterval(persistInterval),
_backupInterval(backupInterval),
_initialLoadComplete(false),
_loadTimeUSecs(0)
_loadTimeUSecs(0),
_lastCheck(0),
_lastBackup(0),
_wantBackup(wantBackup)
{
}
@ -51,16 +64,22 @@ bool OctreePersistThread::process() {
unsigned long leafNodeCount = OctreeElement::getLeafNodeCount();
qDebug("Nodes after loading scene %lu nodes %lu internal %lu leaves", nodeCount, internalNodeCount, leafNodeCount);
double usecPerGet = (double)OctreeElement::getGetChildAtIndexTime() / (double)OctreeElement::getGetChildAtIndexCalls();
qDebug() << "getChildAtIndexCalls=" << OctreeElement::getGetChildAtIndexCalls()
<< " getChildAtIndexTime=" << OctreeElement::getGetChildAtIndexTime() << " perGet=" << usecPerGet;
bool wantDebug = false;
if (wantDebug) {
double usecPerGet = (double)OctreeElement::getGetChildAtIndexTime()
/ (double)OctreeElement::getGetChildAtIndexCalls();
qDebug() << "getChildAtIndexCalls=" << OctreeElement::getGetChildAtIndexCalls()
<< " getChildAtIndexTime=" << OctreeElement::getGetChildAtIndexTime() << " perGet=" << usecPerGet;
double usecPerSet = (double)OctreeElement::getSetChildAtIndexTime() / (double)OctreeElement::getSetChildAtIndexCalls();
qDebug() << "setChildAtIndexCalls=" << OctreeElement::getSetChildAtIndexCalls()
<< " setChildAtIndexTime=" << OctreeElement::getSetChildAtIndexTime() << " perset=" << usecPerSet;
double usecPerSet = (double)OctreeElement::getSetChildAtIndexTime()
/ (double)OctreeElement::getSetChildAtIndexCalls();
qDebug() << "setChildAtIndexCalls=" << OctreeElement::getSetChildAtIndexCalls()
<< " setChildAtIndexTime=" << OctreeElement::getSetChildAtIndexTime() << " perSet=" << usecPerSet;
}
_initialLoadComplete = true;
_lastCheck = usecTimestampNow(); // we just loaded, no need to save again
_lastBackup = _lastCheck = usecTimestampNow(); // we just loaded, no need to save again
time(&_lastPersistTime);
emit loadCompleted();
}
@ -78,19 +97,62 @@ bool OctreePersistThread::process() {
quint64 intervalToCheck = _persistInterval * MSECS_TO_USECS;
if (sinceLastSave > intervalToCheck) {
// check the dirty bit and persist here...
_lastCheck = usecTimestampNow();
if (_tree->isDirty()) {
qDebug() << "pruning Octree before saving...";
_tree->pruneTree();
qDebug() << "DONE pruning Octree before saving...";
qDebug() << "saving Octree to file " << _filename << "...";
_tree->writeToSVOFile(_filename.toLocal8Bit().constData());
_tree->clearDirtyBit(); // tree is clean after saving
qDebug("DONE saving Octree to file...");
}
_lastCheck = now;
persist();
}
}
return isStillRunning(); // keep running till they terminate us
}
void OctreePersistThread::aboutToFinish() {
qDebug() << "Persist thread about to finish...";
persist();
qDebug() << "Persist thread done with about to finish...";
}
void OctreePersistThread::persist() {
if (_tree->isDirty()) {
_tree->lockForWrite();
{
qDebug() << "pruning Octree before saving...";
_tree->pruneTree();
qDebug() << "DONE pruning Octree before saving...";
}
_tree->unlock();
backup(); // handle backup if requested
qDebug() << "saving Octree to file " << _filename << "...";
_tree->writeToSVOFile(qPrintable(_filename));
time(&_lastPersistTime);
_tree->clearDirtyBit(); // tree is clean after saving
qDebug() << "DONE saving Octree to file...";
}
}
void OctreePersistThread::backup() {
if (_wantBackup) {
quint64 now = usecTimestampNow();
quint64 sinceLastBackup = now - _lastBackup;
quint64 MSECS_TO_USECS = 1000;
quint64 intervalToBackup = _backupInterval * MSECS_TO_USECS;
if (sinceLastBackup > intervalToBackup) {
struct tm* localTime = localtime(&_lastPersistTime);
char backupExtension[256];
strftime(backupExtension, sizeof(backupExtension), qPrintable(_backupExtensionFormat), localTime);
QString backupFileName = _filename + backupExtension;
qDebug() << "backing up persist file " << _filename << "to" << backupFileName << "...";
int result = rename(qPrintable(_filename), qPrintable(backupFileName));
if (result == 0) {
qDebug() << "DONE backing up persist file...";
} else {
qDebug() << "ERROR in backing up persist file...";
}
}
}
}

18
libraries/octree/src/OctreePersistThread.h
View file

@ -22,27 +22,41 @@
class OctreePersistThread : public GenericThread {
Q_OBJECT
public:
static const int DEFAULT_PERSIST_INTERVAL = 1000 * 30; // every 30 seconds
static const int DEFAULT_PERSIST_INTERVAL;
static const int DEFAULT_BACKUP_INTERVAL;
static const QString DEFAULT_BACKUP_EXTENSION_FORMAT;
OctreePersistThread(Octree* tree, const QString& filename, int persistInterval = DEFAULT_PERSIST_INTERVAL);
OctreePersistThread(Octree* tree, const QString& filename, int persistInterval = DEFAULT_PERSIST_INTERVAL,
bool wantBackup = false, int backupInterval = DEFAULT_BACKUP_INTERVAL,
const QString& backupExtensionFormat = DEFAULT_BACKUP_EXTENSION_FORMAT);
bool isInitialLoadComplete() const { return _initialLoadComplete; }
quint64 getLoadElapsedTime() const { return _loadTimeUSecs; }
void aboutToFinish(); /// call this to inform the persist thread that the owner is about to finish to support final persist
signals:
void loadCompleted();
protected:
/// Implements generic processing behavior for this thread.
virtual bool process();
void persist();
void backup();
private:
Octree* _tree;
QString _filename;
QString _backupExtensionFormat;
int _persistInterval;
int _backupInterval;
bool _initialLoadComplete;
quint64 _loadTimeUSecs;
quint64 _lastCheck;
quint64 _lastBackup;
bool _wantBackup;
time_t _lastPersistTime;
};
#endif // hifi_OctreePersistThread_h

3
libraries/octree/src/OctreeRenderer.h
View file

@ -52,7 +52,8 @@ public:
virtual void init();
/// render the content of the octree
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO);
ViewFrustum* getViewFrustum() const { return _viewFrustum; }
void setViewFrustum(ViewFrustum* viewFrustum) { _viewFrustum = viewFrustum; }