mirror of
https://github.com/JulianGro/overte.git
synced 2025-04-06 00:02:59 +02:00
459 lines
14 KiB
JavaScript
459 lines
14 KiB
JavaScript
//
|
|
// Created by Bradley Austin Davis on 2015/08/29
|
|
// Copyright 2015 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 UPDATE_INTERVAL = 0.1;
|
|
|
|
|
|
// A collection of balls and edges connecting them.
|
|
MagBalls = function() {
|
|
Graph.call(this);
|
|
this.MAX_ADJUST_ITERATIONS = 100;
|
|
this.REFRESH_WAIT_TICKS = 10;
|
|
this.MAX_VARIANCE = 0.25;
|
|
this.lastUpdateAge = 0;
|
|
this.stable = true;
|
|
this.adjustIterations = 0;
|
|
this.selectedNodes = {};
|
|
this.edgeObjects = {};
|
|
this.unstableEdges = {};
|
|
|
|
this.refresh();
|
|
|
|
var _this = this;
|
|
Script.scriptEnding.connect(function() {
|
|
_this.onCleanup();
|
|
});
|
|
|
|
Entities.addingEntity.connect(function(entityId) {
|
|
_this.onEntityAdded(entityId);
|
|
});
|
|
}
|
|
|
|
MagBalls.prototype = Object.create( Graph.prototype );
|
|
|
|
MagBalls.prototype.onUpdate = function(deltaTime) {
|
|
this.lastUpdateAge += deltaTime;
|
|
if (this.lastUpdateAge > UPDATE_INTERVAL) {
|
|
this.lastUpdateAge = 0;
|
|
if (this.refreshNeeded) {
|
|
if (++this.refreshNeeded > this.REFRESH_WAIT_TICKS) {
|
|
logDebug("Refreshing");
|
|
this.refresh();
|
|
this.refreshNeeded = 0;
|
|
}
|
|
}
|
|
if (!this.stable && !Object.keys(this.selectedNodes).length) {
|
|
this.adjustIterations += 1;
|
|
var adjusted = false;
|
|
var nodeAdjustResults = {};
|
|
var fixupEdges = {};
|
|
|
|
for(var edgeId in this.edges) {
|
|
if (!this.unstableEdges[edgeId]) {
|
|
continue;
|
|
}
|
|
// FIXME need to add some randomness to this so that objects don't hit a
|
|
// false equilibrium
|
|
// FIXME should this be done node-wise, to more easily account for the number of edge
|
|
// connections for a node?
|
|
adjusted |= this.edgeObjects[edgeId].adjust(nodeAdjustResults, this.adjustIterations);
|
|
}
|
|
|
|
for (var nodeId in nodeAdjustResults) {
|
|
var curPos = this.getNodePosition(nodeId);
|
|
var newPos = nodeAdjustResults[nodeId];
|
|
var distance = Vec3.distance(curPos, newPos);
|
|
for (var edgeId in this.nodes[nodeId]) {
|
|
fixupEdges[edgeId] = true;
|
|
}
|
|
// logDebug("Moving node Id " + nodeId + " " + (distance * 1000).toFixed(3) + " mm");
|
|
Entities.editEntity(nodeId, {
|
|
position: newPos,
|
|
// DEBUGGING, flashes moved balls
|
|
// color: COLORS.RED
|
|
});
|
|
}
|
|
|
|
// DEBUGGING, flashes moved balls
|
|
//Script.setTimeout(function(){
|
|
// for (var nodeId in nodeAdjustResults) {
|
|
// Entities.editEntity(nodeId, { color: BALL_COLOR });
|
|
// }
|
|
//}, ((UPDATE_INTERVAL * 1000) / 2));
|
|
|
|
for (var edgeId in fixupEdges) {
|
|
this.fixupEdge(edgeId);
|
|
}
|
|
|
|
|
|
if (!adjusted || this.adjustIterations > this.MAX_ADJUST_ITERATIONS) {
|
|
if (adjusted) {
|
|
logDebug("Could not stabilized after " + this.MAX_ADJUST_ITERATIONS + " abandoning");
|
|
}
|
|
this.adjustIterations = 0;
|
|
this.stable = true;
|
|
this.unstableEdges = {};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MagBalls.prototype.createNodeEntity = function(customProperies) {
|
|
var nodeId = Entities.addEntity(mergeObjects(BALL_PROTOTYPE, customProperies));
|
|
return nodeId;
|
|
}
|
|
|
|
MagBalls.prototype.createEdgeEntity = function(nodeIdA, nodeIdB) {
|
|
var apos = this.getNodePosition(nodeIdA);
|
|
var bpos = this.getNodePosition(nodeIdB);
|
|
var edgeId = Entities.addEntity(mergeObjects(EDGE_PROTOTYPE, {
|
|
position: apos,
|
|
linePoints: [ ZERO_VECTOR, Vec3.subtract(bpos, apos) ],
|
|
userData: JSON.stringify({
|
|
magBalls: {
|
|
start: nodeIdA,
|
|
end: nodeIdB,
|
|
length: BALL_DISTANCE
|
|
}
|
|
})
|
|
}));
|
|
this.edgeObjects[edgeId] = new EdgeSpring(edgeId, this);
|
|
return edgeId;
|
|
}
|
|
|
|
MagBalls.prototype.findPotentialEdges = function(nodeId) {
|
|
var variances = {};
|
|
for (var otherNodeId in this.nodes) {
|
|
// can't self connect
|
|
if (otherNodeId == nodeId) {
|
|
continue;
|
|
}
|
|
|
|
// can't doubly connect
|
|
if (this.areConnected(otherNodeId, nodeId)) {
|
|
continue;
|
|
}
|
|
|
|
// Check distance to attempt
|
|
var distance = this.getNodeDistance(nodeId, otherNodeId);
|
|
var variance = this.getVariance(distance);
|
|
if (Math.abs(variance) > this.MAX_VARIANCE) {
|
|
continue;
|
|
}
|
|
|
|
variances[otherNodeId] = variance;
|
|
}
|
|
return variances;
|
|
}
|
|
|
|
MagBalls.prototype.breakEdges = function(nodeId) {
|
|
//var unstableNodes = this.findShape(Object.keys.target);
|
|
//for (var node in unstableNodes) {
|
|
// this.unstableNodes[node] = true;
|
|
//}
|
|
Graph.prototype.breakEdges.call(this, nodeId);
|
|
}
|
|
|
|
MagBalls.prototype.createBall = function(position) {
|
|
var created = this.createNode({ position: position });
|
|
this.selectBall(created);
|
|
return created;
|
|
}
|
|
|
|
MagBalls.prototype.selectBall = function(selected) {
|
|
if (!selected) {
|
|
return;
|
|
}
|
|
// stop updating shapes while manipulating
|
|
this.stable = true;
|
|
this.selectedNodes[selected] = true;
|
|
this.breakEdges(selected);
|
|
}
|
|
|
|
|
|
MagBalls.prototype.releaseBall = function(releasedBall) {
|
|
delete this.selectedNodes[releasedBall];
|
|
logDebug("Released ball: " + releasedBall);
|
|
|
|
var releasePosition = this.getNodePosition(releasedBall);
|
|
this.stable = false;
|
|
|
|
|
|
// iterate through the other balls and ensure we don't intersect with
|
|
// any of them. If we do, just delete this ball and return.
|
|
// FIXME (play a pop sound)
|
|
for (var nodeId in this.nodes) {
|
|
if (nodeId == releasedBall) {
|
|
continue;
|
|
}
|
|
var distance = this.getNodeDistance(releasedBall, nodeId);
|
|
if (distance < BALL_SIZE) {
|
|
this.destroyNode(releasedBall);
|
|
return;
|
|
}
|
|
}
|
|
|
|
var targets = this.findPotentialEdges(releasedBall);
|
|
if (!targets || !Object.keys(targets).length) {
|
|
// this.destroyNode(releasedBall);
|
|
}
|
|
for (var otherBallId in targets) {
|
|
this.createEdge(otherBallId, releasedBall);
|
|
}
|
|
|
|
var unstableNodes = this.findShape(releasedBall);
|
|
for (var nodeId in unstableNodes) {
|
|
for (var edgeId in this.nodes[nodeId]) {
|
|
this.unstableEdges[edgeId] = true;
|
|
}
|
|
}
|
|
this.validate();
|
|
}
|
|
|
|
|
|
MagBalls.prototype.findShape = function(nodeId) {
|
|
var result = {};
|
|
var queue = [ nodeId ];
|
|
while (queue.length) {
|
|
var curNode = queue.shift();
|
|
if (result[curNode]) {
|
|
continue;
|
|
}
|
|
result[curNode] = true;
|
|
for (var otherNodeId in this.getConnectedNodes(curNode)) {
|
|
queue.push(otherNodeId);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
MagBalls.prototype.getVariance = function(distance) {
|
|
// FIXME different balls or edges might have different ideas of variance...
|
|
// let something else handle this
|
|
var offset = (BALL_DISTANCE - distance);
|
|
var variance = offset / BALL_DISTANCE
|
|
return variance;
|
|
}
|
|
|
|
// remove unconnected balls
|
|
MagBalls.prototype.clean = function() {
|
|
// do nothing unless there are at least 2 balls and one edge
|
|
if (Object.keys(this.nodes).length < 2 || !Object.keys(this.edges).length) {
|
|
return;
|
|
}
|
|
var disconnectedNodes = {};
|
|
for (var nodeId in this.nodes) {
|
|
if (!Object.keys(this.nodes[nodeId]).length) {
|
|
disconnectedNodes[nodeId] = true;
|
|
}
|
|
}
|
|
for (var nodeId in disconnectedNodes) {
|
|
this.destroyNode(nodeId);
|
|
}
|
|
}
|
|
|
|
// remove all balls
|
|
MagBalls.prototype.clear = function() {
|
|
if (DEBUG_MAGSTICKS) {
|
|
this.deleteAll();
|
|
var ids = Entities.findEntities(MyAvatar.position, 50);
|
|
var result = [];
|
|
ids.forEach(function(id) {
|
|
var properties = Entities.getEntityProperties(id);
|
|
if (properties.name == BALL_NAME || properties.name == EDGE_NAME) {
|
|
Entities.deleteEntity(id);
|
|
}
|
|
}, this);
|
|
}
|
|
}
|
|
|
|
MagBalls.prototype.destroyEdge = function(edgeId) {
|
|
Graph.prototype.destroyEdge.call(this, edgeId);
|
|
delete this.edgeObjects[edgeId];
|
|
}
|
|
|
|
MagBalls.prototype.destroyNode = function(nodeId) {
|
|
Graph.prototype.destroyNode.call(this, nodeId);
|
|
}
|
|
|
|
// Scan the entity tree and load all the objects in range
|
|
MagBalls.prototype.refresh = function() {
|
|
var ids = Entities.findEntities(MyAvatar.position, 50);
|
|
for (var i in ids) {
|
|
var id = ids[i];
|
|
var properties = Entities.getEntityProperties(id);
|
|
if (properties.name == BALL_NAME) {
|
|
this.nodes[id] = {};
|
|
}
|
|
}
|
|
|
|
var deleteEdges = [];
|
|
for (var i in ids) {
|
|
var id = ids[i];
|
|
var properties = Entities.getEntityProperties(id);
|
|
if (properties.name == EDGE_NAME) {
|
|
var edgeId = id;
|
|
this.edges[edgeId] = {};
|
|
var magBallData = getMagBallsData(id);
|
|
if (!magBallData.start || !magBallData.end) {
|
|
logWarn("Edge information is missing for " + id);
|
|
continue;
|
|
}
|
|
if (!this.nodes[magBallData.start] || !this.nodes[magBallData.end]) {
|
|
logWarn("Edge " + id + " refers to unknown nodes: " + JSON.stringify(magBallData));
|
|
Entities.editEntity(id, { color: COLORS.RED });
|
|
deleteEdges.push(id);
|
|
continue;
|
|
}
|
|
this.nodes[magBallData.start][edgeId] = true;
|
|
this.nodes[magBallData.end][edgeId] = true;
|
|
this.edges[edgeId][magBallData.start] = true;
|
|
this.edges[edgeId][magBallData.end] = true;
|
|
this.edgeObjects[id] = new EdgeSpring(id, this);
|
|
}
|
|
}
|
|
|
|
if (deleteEdges.length) {
|
|
Script.setTimeout(function() {
|
|
for (var i in deleteEdges) {
|
|
var edgeId = deleteEdges[i];
|
|
//logDebug("deleting invalid edge " + edgeId);
|
|
//Entities.deleteEntity(edgeId);
|
|
Entities.editEntity(edgeId, {
|
|
color: COLORS.RED
|
|
})
|
|
}
|
|
}, 1000);
|
|
}
|
|
|
|
var edgeCount = Object.keys(this.edges).length;
|
|
var nodeCount = Object.keys(this.nodes).length;
|
|
logDebug("Found " + nodeCount + " nodes and " + edgeCount + " edges ");
|
|
this.validate();
|
|
}
|
|
|
|
|
|
MagBalls.prototype.findEdgeParams = function(startBall, endBall) {
|
|
var startBallPos = this.getNodePosition(startBall);
|
|
var endBallPos = this.getNodePosition(endBall);
|
|
var vector = Vec3.subtract(endBallPos, startBallPos);
|
|
return {
|
|
position: startBallPos,
|
|
linePoints: [ ZERO_VECTOR, vector ]
|
|
};
|
|
}
|
|
|
|
MagBalls.prototype.fixupEdge = function(edgeId) {
|
|
var ballsInEdge = Object.keys(this.edges[edgeId]);
|
|
Entities.editEntity(edgeId, this.findEdgeParams(ballsInEdge[0], ballsInEdge[1]));
|
|
}
|
|
|
|
MagBalls.prototype.onEntityAdded = function(entityId) {
|
|
// We already have it
|
|
if (this.nodes[entityId] || this.edges[entityId]) {
|
|
return;
|
|
}
|
|
|
|
var properties = Entities.getEntityProperties(entityId);
|
|
if (properties.name == BALL_NAME || properties.name == EDGE_NAME) {
|
|
this.refreshNeeded = 1;
|
|
}
|
|
}
|
|
|
|
findMatchingNode = function(position, nodePositions) {
|
|
for (var nodeId in nodePositions) {
|
|
var nodePos = nodePositions[nodeId];
|
|
var distance = Vec3.distance(position, nodePos);
|
|
if (distance < 0.03) {
|
|
return nodeId;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
MagBalls.prototype.repair = function() {
|
|
// Find all the balls and record their positions
|
|
var nodePositions = {};
|
|
for (var nodeId in this.nodes) {
|
|
nodePositions[nodeId] = this.getNodePosition(nodeId);
|
|
}
|
|
|
|
// Now check all the edges to see if they're valid (point to balls)
|
|
// and ensure that the balls point back to them
|
|
var ballsToEdges = {};
|
|
|
|
// WARNING O(n^2) algorithm, every edge that is broken does
|
|
// an O(N) search against the nodes
|
|
for (var edgeId in this.edges) {
|
|
var properties = Entities.getEntityProperties(edgeId);
|
|
var startPos = properties.position;
|
|
var endPos = Vec3.sum(startPos, properties.linePoints[1]);
|
|
var magBallData = getMagBallsData(edgeId);
|
|
var update = false;
|
|
if (!magBallData.start) {
|
|
var startNode = findMatchingNode(startPos, nodePositions);
|
|
if (startNode) {
|
|
logDebug("Found start node " + startNode)
|
|
magBallData.start = startNode;
|
|
update = true;
|
|
}
|
|
}
|
|
if (!magBallData.end) {
|
|
var endNode = findMatchingNode(endPos, nodePositions);
|
|
if (endNode) {
|
|
logDebug("Found end node " + endNode)
|
|
magBallData.end = endNode;
|
|
update = true;
|
|
}
|
|
}
|
|
if (!magBallData.start || !magBallData.end) {
|
|
logDebug("Didn't find both ends");
|
|
this.destroyEdge(edgeId);
|
|
continue;
|
|
}
|
|
if (!ballsToEdges[magBallData.start]) {
|
|
ballsToEdges[magBallData.start] = [ edgeId ];
|
|
} else {
|
|
ballsToEdges[magBallData.start].push(edgeId);
|
|
}
|
|
if (!ballsToEdges[magBallData.end]) {
|
|
ballsToEdges[magBallData.end] = [ edgeId ];
|
|
} else {
|
|
ballsToEdges[magBallData.end].push(edgeId);
|
|
}
|
|
if (update) {
|
|
logDebug("Updating incomplete edge " + edgeId);
|
|
magBallData.length = BALL_DISTANCE;
|
|
setMagBallsData(edgeId, magBallData);
|
|
}
|
|
}
|
|
for (var nodeId in ballsToEdges) {
|
|
var magBallData = getMagBallsData(nodeId);
|
|
var edges = magBallData.edges || [];
|
|
var edgeHash = {};
|
|
for (var i in edges) {
|
|
edgeHash[edges[i]] = true;
|
|
}
|
|
var update = false;
|
|
for (var i in ballsToEdges[nodeId]) {
|
|
var edgeId = ballsToEdges[nodeId][i];
|
|
if (!edgeHash[edgeId]) {
|
|
update = true;
|
|
edgeHash[edgeId] = true;
|
|
edges.push(edgeId);
|
|
}
|
|
}
|
|
if (update) {
|
|
logDebug("Fixing node with missing edge data");
|
|
magBallData.edges = edges;
|
|
setMagBallsData(nodeId, magBallData);
|
|
}
|
|
}
|
|
}
|
|
|