Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-21 09:24:00 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge branch 'master' of ssh://github.com/highfidelity/hifi into cleanup

Browse source
This commit is contained in:
Andrew Meadows 2014-01-31 17:44:13 -08:00
commit a5aff81881
69 changed files with 1241 additions and 852 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
README.md
View file

@ -71,8 +71,15 @@ We have successfully built on OS X 10.8, Ubuntu and a few other modern Linux
distributions. A Windows build is planned for the future, but not currently in
development.
On a fresh Ubuntu 13.10 install, these are all the packages you need to grab and build the hifi project:
<pre>sudo apt-get install build-essential cmake git libcurl4-openssl-dev libqt5scripttools5 libqt5svg5-dev libqt5webkit5-dev libqt5location5 qtlocation5-dev qtdeclarative5-dev qtscript5-dev qtsensors5-dev qtmultimedia5-dev qtquick1-5-dev libasound2 libxmu-dev libxi-dev freeglut3-dev libasound2-dev libjack-dev</pre>
On a fresh Ubuntu 13.10 install, get these requirements from Ubuntu repositories:
sudo apt-get install build-essential cmake git libcurl4-openssl-dev libasound2 libxmu-dev libxi-dev freeglut3-dev libasound2-dev libjack-dev
Then [download lastest Qt packages](http://qt-project.org/downloads), untar/install to your prefered path
and set your `QT_CMAKE_PREFIX_PATH` environment variable as described above in the CMake section. It's
recommended to set the variable automatically on each shell instance to save this task in the future:
echo 'export QT_CMAKE_PREFIX_PATH=~/Qt5.2.0/5.2.0/gcc_64/lib/cmake' >> ~/.bashrc
Running Interface
-----

3
assignment-client/src/Agent.cpp
View file

@ -101,6 +101,9 @@ void Agent::run() {
// give this AvatarData object to the script engine
_scriptEngine.setAvatarData(&scriptedAvatar, "Avatar");
// register ourselves to the script engine
_scriptEngine.registerGlobalObject("Agent", this);
_scriptEngine.setScriptContents(scriptContents);
_scriptEngine.run();

5
assignment-client/src/Agent.h
View file

@ -21,9 +21,14 @@
class Agent : public ThreadedAssignment {
Q_OBJECT
Q_PROPERTY(bool isAvatar READ isAvatar WRITE setIsAvatar)
public:
Agent(const QByteArray& packet);
void setIsAvatar(bool isAvatar) { _scriptEngine.setIsAvatar(isAvatar); }
bool isAvatar() const { return _scriptEngine.isAvatar(); }
public slots:
void run();

3
assignment-client/src/AssignmentClient.cpp
View file

@ -90,7 +90,8 @@ AssignmentClient::AssignmentClient(int &argc, char **argv) :
timer->start(ASSIGNMENT_REQUEST_INTERVAL_MSECS);
// connect our readPendingDatagrams method to the readyRead() signal of the socket
connect(&nodeList->getNodeSocket(), SIGNAL(readyRead()), this, SLOT(readPendingDatagrams()));
connect(&nodeList->getNodeSocket(), &QUdpSocket::readyRead, this, &AssignmentClient::readPendingDatagrams,
Qt::QueuedConnection);
}
void AssignmentClient::sendAssignmentRequest() {

7
assignment-client/src/AssignmentFactory.cpp
View file

@ -19,10 +19,11 @@
#include "metavoxels/MetavoxelServer.h"
ThreadedAssignment* AssignmentFactory::unpackAssignment(const QByteArray& packet) {
int headerBytes = numBytesForPacketHeader(packet);
QDataStream packetStream(packet);
packetStream.skipRawData(numBytesForPacketHeader(packet));
quint8 packedType;
memcpy(&packedType, packet.data() + headerBytes, sizeof(packedType));
packetStream >> packedType;
Assignment::Type unpackedType = (Assignment::Type) packedType;

3
assignment-client/src/avatars/AvatarMixer.cpp
View file

@ -70,8 +70,7 @@ void broadcastAvatarData() {
QByteArray avatarByteArray;
avatarByteArray.append(otherNode->getUUID().toRfc4122());
AvatarData *nodeData = (AvatarData *)otherNode->getLinkedData();
AvatarData* nodeData = (AvatarData*) otherNode->getLinkedData();
avatarByteArray.append(nodeData->toByteArray());
if (avatarByteArray.size() + mixedAvatarByteArray.size() > MAX_PACKET_SIZE) {

675
domain-server/src/DomainServer.cpp
View file

@ -8,9 +8,11 @@
#include <signal.h>
#include <QtCore/QDir>
#include <QtCore/QJsonDocument>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonArray>
#include <QtCore/QStandardPaths>
#include <QtCore/QStringList>
#include <QtCore/QTimer>
@ -27,65 +29,37 @@ const char* VOXEL_SERVER_CONFIG = "voxelServerConfig";
const char* PARTICLE_SERVER_CONFIG = "particleServerConfig";
const char* METAVOXEL_SERVER_CONFIG = "metavoxelServerConfig";
void signalhandler(int sig){
if (sig == SIGINT) {
qApp->quit();
}
}
const quint16 DOMAIN_SERVER_HTTP_PORT = 8080;
DomainServer::DomainServer(int argc, char* argv[]) :
QCoreApplication(argc, argv),
_HTTPManager(DOMAIN_SERVER_HTTP_PORT, QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath()), this),
_assignmentQueueMutex(),
_staticAssignmentHash(),
_assignmentQueue(),
_staticAssignmentFile(QString("%1/config.ds").arg(QCoreApplication::applicationDirPath())),
_staticAssignmentFileData(NULL),
_voxelServerConfig(NULL),
_metavoxelServerConfig(NULL),
_hasCompletedRestartHold(false)
{
signal(SIGINT, signalhandler);
const char CUSTOM_PORT_OPTION[] = "-p";
const char* customPortString = getCmdOption(argc, (const char**) argv, CUSTOM_PORT_OPTION);
unsigned short domainServerPort = customPortString ? atoi(customPortString) : DEFAULT_DOMAIN_SERVER_PORT;
const char CONFIG_FILE_OPTION[] = "-c";
const char* configFilePath = getCmdOption(argc, (const char**) argv, CONFIG_FILE_OPTION);
if (!readConfigFile(configFilePath)) {
QByteArray voxelConfigOption = QString("--%1").arg(VOXEL_SERVER_CONFIG).toLocal8Bit();
_voxelServerConfig = getCmdOption(argc, (const char**) argv, voxelConfigOption.constData());
QByteArray particleConfigOption = QString("--%1").arg(PARTICLE_SERVER_CONFIG).toLocal8Bit();
_particleServerConfig = getCmdOption(argc, (const char**) argv, particleConfigOption.constData());
QByteArray metavoxelConfigOption = QString("--%1").arg(METAVOXEL_SERVER_CONFIG).toLocal8Bit();
_metavoxelServerConfig = getCmdOption(argc, (const char**) argv, metavoxelConfigOption.constData());
QStringList argumentList = arguments();
int argumentIndex = 0;
QSet<Assignment::Type> parsedTypes(QSet<Assignment::Type>() << Assignment::AgentType);
parseCommandLineTypeConfigs(argumentList, parsedTypes);
const QString CONFIG_FILE_OPTION = "--configFile";
if ((argumentIndex = argumentList.indexOf(CONFIG_FILE_OPTION)) != -1) {
QString configFilePath = argumentList.value(argumentIndex + 1);
readConfigFile(configFilePath, parsedTypes);
}
populateDefaultStaticAssignmentsExcludingTypes(parsedTypes);
NodeList* nodeList = NodeList::createInstance(NodeType::DomainServer, domainServerPort);
connect(nodeList, SIGNAL(nodeKilled(SharedNodePointer)), this, SLOT(nodeKilled(SharedNodePointer)));
if (!_staticAssignmentFile.exists() || _voxelServerConfig) {
if (_voxelServerConfig) {
// we have a new VS config, clear the existing file to start fresh
_staticAssignmentFile.remove();
}
prepopulateStaticAssignmentFile();
}
_staticAssignmentFile.open(QIODevice::ReadWrite);
_staticAssignmentFileData = _staticAssignmentFile.map(0, _staticAssignmentFile.size());
_staticAssignments = (Assignment*) _staticAssignmentFileData;
QTimer* silentNodeTimer = new QTimer(this);
connect(silentNodeTimer, SIGNAL(timeout()), nodeList, SLOT(removeSilentNodes()));
silentNodeTimer->start(NODE_SILENCE_THRESHOLD_USECS / 1000);
@ -94,8 +68,145 @@ DomainServer::DomainServer(int argc, char* argv[]) :
// fire a single shot timer to add static assignments back into the queue after a restart
QTimer::singleShot(RESTART_HOLD_TIME_MSECS, this, SLOT(addStaticAssignmentsBackToQueueAfterRestart()));
}
connect(this, SIGNAL(aboutToQuit()), SLOT(cleanup()));
void DomainServer::parseCommandLineTypeConfigs(const QStringList& argumentList, QSet<Assignment::Type>& excludedTypes) {
// check for configs from the command line, these take precedence
const QString CONFIG_TYPE_OPTION = "--configType";
int clConfigIndex = argumentList.indexOf(CONFIG_TYPE_OPTION);
// enumerate all CL config overrides and parse them to files
while (clConfigIndex != -1) {
int clConfigType = argumentList.value(clConfigIndex + 1).toInt();
if (clConfigType < Assignment::AllTypes && !excludedTypes.contains((Assignment::Type) clConfigIndex)) {
Assignment::Type assignmentType = (Assignment::Type) clConfigType;
createStaticAssignmentsForTypeGivenConfigString((Assignment::Type) assignmentType,
argumentList.value(clConfigIndex + 2));
excludedTypes.insert(assignmentType);
}
clConfigIndex = argumentList.indexOf(CONFIG_TYPE_OPTION, clConfigIndex + 1);
}
}
// Attempts to read configuration from specified path
// returns true on success, false otherwise
void DomainServer::readConfigFile(const QString& path, QSet<Assignment::Type>& excludedTypes) {
if (path.isEmpty()) {
// config file not specified
return;
}
if (!QFile::exists(path)) {
qWarning("Specified configuration file does not exist!");
return;
}
QFile configFile(path);
if (!configFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
qWarning("Can't open specified configuration file!");
return;
} else {
qDebug() << "Reading configuration from" << path;
}
QTextStream configStream(&configFile);
QByteArray configStringByteArray = configStream.readAll().toUtf8();
QJsonObject configDocObject = QJsonDocument::fromJson(configStringByteArray).object();
configFile.close();
QSet<Assignment::Type> appendedExcludedTypes = excludedTypes;
foreach (const QString& rootStringValue, configDocObject.keys()) {
int possibleConfigType = rootStringValue.toInt();
if (possibleConfigType < Assignment::AllTypes
&& !excludedTypes.contains((Assignment::Type) possibleConfigType)) {
// this is an appropriate config type and isn't already in our excluded types
// we are good to parse it
Assignment::Type assignmentType = (Assignment::Type) possibleConfigType;
QString configString = readServerAssignmentConfig(configDocObject, rootStringValue);
createStaticAssignmentsForTypeGivenConfigString(assignmentType, configString);
excludedTypes.insert(assignmentType);
}
}
}
// find assignment configurations on the specified node name and json object
// returns a string in the form of its equivalent cmd line params
QString DomainServer::readServerAssignmentConfig(const QJsonObject& jsonObject, const QString& nodeName) {
QJsonArray nodeArray = jsonObject[nodeName].toArray();
QStringList serverConfig;
foreach (const QJsonValue& childValue, nodeArray) {
QString cmdParams;
QJsonObject childObject = childValue.toObject();
QStringList keys = childObject.keys();
for (int i = 0; i < keys.size(); i++) {
QString key = keys[i];
QString value = childObject[key].toString();
// both cmd line params and json keys are the same
cmdParams += QString("--%1 %2 ").arg(key, value);
}
serverConfig << cmdParams;
}
// according to split() calls from DomainServer::prepopulateStaticAssignmentFile
// we shold simply join them with semicolons
return serverConfig.join(';');
}
void DomainServer::addStaticAssignmentToAssignmentHash(Assignment* newAssignment) {
qDebug() << "Inserting assignment" << *newAssignment << "to static assignment hash.";
_staticAssignmentHash.insert(newAssignment->getUUID(), SharedAssignmentPointer(newAssignment));
}
void DomainServer::createStaticAssignmentsForTypeGivenConfigString(Assignment::Type type, const QString& configString) {
// we have a string for config for this type
qDebug() << "Parsing command line config for assignment type" << type;
QStringList multiConfigList = configString.split(";", QString::SkipEmptyParts);
const QString ASSIGNMENT_CONFIG_POOL_REGEX = "--pool\\s*(\\w+)";
QRegExp poolRegex(ASSIGNMENT_CONFIG_POOL_REGEX);
// read each config to a payload for this type of assignment
for (int i = 0; i < multiConfigList.size(); i++) {
QString config = multiConfigList.at(i);
// check the config string for a pool
QString assignmentPool;
int poolIndex = poolRegex.indexIn(config);
if (poolIndex != -1) {
assignmentPool = poolRegex.cap(1);
// remove the pool from the config string, the assigned node doesn't need it
config.remove(poolIndex, poolRegex.matchedLength());
}
qDebug("Type %d config[%d] = %s", type, i, config.toLocal8Bit().constData());
Assignment* configAssignment = new Assignment(Assignment::CreateCommand, type, assignmentPool);
configAssignment->setPayload(config.toUtf8());
addStaticAssignmentToAssignmentHash(configAssignment);
}
}
void DomainServer::populateDefaultStaticAssignmentsExcludingTypes(const QSet<Assignment::Type>& excludedTypes) {
// enumerate over all assignment types and see if we've already excluded it
for (int defaultedType = Assignment::AudioMixerType; defaultedType != Assignment::AllTypes; defaultedType++) {
if (!excludedTypes.contains((Assignment::Type) defaultedType)) {
// type has not been set from a command line or config file config, use the default
// by clearing whatever exists and writing a single default assignment with no payload
Assignment* newAssignment = new Assignment(Assignment::CreateCommand, (Assignment::Type) defaultedType);
addStaticAssignmentToAssignmentHash(newAssignment);
}
}
}
void DomainServer::readAvailableDatagrams() {
@ -148,13 +259,13 @@ void DomainServer::readAvailableDatagrams() {
<< NodeType::AvatarMixer << NodeType::VoxelServer << NodeType::ParticleServer
<< NodeType::MetavoxelServer;
Assignment* matchingStaticAssignment = NULL;
SharedAssignmentPointer matchingStaticAssignment;
// check if this is a non-statically assigned node, a node that is assigned and checking in for the first time
// or a node that has already checked in and is continuing to report for duty
if (!STATICALLY_ASSIGNED_NODES.contains(nodeType)
|| ((matchingStaticAssignment = matchingStaticAssignmentForCheckIn(nodeUUID, nodeType))
|| checkInWithUUIDMatchesExistingNode(nodePublicAddress,
nodeLocalAddress,
nodeUUID)))
|| (matchingStaticAssignment = matchingStaticAssignmentForCheckIn(nodeUUID, nodeType))
|| nodeList->getInstance()->nodeWithUUID(nodeUUID))
{
SharedNodePointer checkInNode = nodeList->addOrUpdateNode(nodeUUID,
nodeType,
@ -167,19 +278,13 @@ void DomainServer::readAvailableDatagrams() {
if (matchingStaticAssignment) {
// this was a newly added node with a matching static assignment
// remove the matching assignment from the assignment queue so we don't take the next check in
// (if it exists)
if (_hasCompletedRestartHold) {
// remove the matching assignment from the assignment queue so we don't take the next check in
removeAssignmentFromQueue(matchingStaticAssignment);
removeMatchingAssignmentFromQueue(matchingStaticAssignment);
}
// set the linked data for this node to a copy of the matching assignment
// so we can re-queue it should the node die
Assignment* nodeCopyOfMatchingAssignment = new Assignment(*matchingStaticAssignment);
checkInNode->setLinkedData(nodeCopyOfMatchingAssignment);
}
quint8 numInterestTypes = 0;
packetStream >> numInterestTypes;
@ -210,34 +315,29 @@ void DomainServer::readAvailableDatagrams() {
}
} else if (requestType == PacketTypeRequestAssignment) {
if (_assignmentQueue.size() > 0) {
// construct the requested assignment from the packet data
Assignment requestAssignment(receivedPacket);
// construct the requested assignment from the packet data
Assignment requestAssignment(receivedPacket);
qDebug() << "Received a request for assignment type" << requestAssignment.getType()
<< "from" << senderSockAddr;
SharedAssignmentPointer assignmentToDeploy = deployableAssignmentForRequest(requestAssignment);
if (assignmentToDeploy) {
qDebug() << "Deploying assignment -" << *assignmentToDeploy.data() << "- to" << senderSockAddr;
qDebug("Received a request for assignment type %i from %s.",
requestAssignment.getType(), qPrintable(senderSockAddr.getAddress().toString()));
// give this assignment out, either the type matches or the requestor said they will take any
assignmentPacket.resize(numAssignmentPacketHeaderBytes);
Assignment* assignmentToDeploy = deployableAssignmentForRequest(requestAssignment);
QDataStream assignmentStream(&assignmentPacket, QIODevice::Append);
if (assignmentToDeploy) {
// give this assignment out, either the type matches or the requestor said they will take any
assignmentPacket.resize(numAssignmentPacketHeaderBytes);
QDataStream assignmentStream(&assignmentPacket, QIODevice::Append);
assignmentStream << *assignmentToDeploy;
nodeList->getNodeSocket().writeDatagram(assignmentPacket,
senderSockAddr.getAddress(), senderSockAddr.getPort());
if (assignmentToDeploy->getNumberOfInstances() == 0) {
// there are no more instances of this script to send out, delete it
delete assignmentToDeploy;
}
}
assignmentStream << *assignmentToDeploy.data();
nodeList->getNodeSocket().writeDatagram(assignmentPacket,
senderSockAddr.getAddress(), senderSockAddr.getPort());
} else {
qDebug() << "Received an invalid assignment request from" << senderSockAddr.getAddress();
qDebug() << "Unable to fulfill assignment request of type" << requestAssignment.getType()
<< "from" << senderSockAddr;
}
}
}
@ -281,70 +381,6 @@ QJsonObject jsonObjectForNode(Node* node) {
return nodeJson;
}
// Attempts to read configuration from specified path
// returns true on success, false otherwise
bool DomainServer::readConfigFile(const char* path) {
if (!path) {
// config file not specified
return false;
}
if (!QFile::exists(path)) {
qWarning("Specified configuration file does not exist!\n");
return false;
}
QFile configFile(path);
if (!configFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
qWarning("Can't open specified configuration file!\n");
return false;
} else {
qDebug("Reading configuration from %s\n", path);
}
QTextStream configStream(&configFile);
QByteArray configStringByteArray = configStream.readAll().toUtf8();
QJsonObject configDocObject = QJsonDocument::fromJson(configStringByteArray).object();
configFile.close();
QString voxelServerConfig = readServerAssignmentConfig(configDocObject, VOXEL_SERVER_CONFIG);
_voxelServerConfig = new char[strlen(voxelServerConfig.toLocal8Bit().constData()) +1];
_voxelServerConfig = strcpy((char *) _voxelServerConfig, voxelServerConfig.toLocal8Bit().constData() + '\0');
QString particleServerConfig = readServerAssignmentConfig(configDocObject, PARTICLE_SERVER_CONFIG);
_particleServerConfig = new char[strlen(particleServerConfig.toLocal8Bit().constData()) +1];
_particleServerConfig = strcpy((char *) _particleServerConfig, particleServerConfig.toLocal8Bit().constData() + '\0');
QString metavoxelServerConfig = readServerAssignmentConfig(configDocObject, METAVOXEL_SERVER_CONFIG);
_metavoxelServerConfig = new char[strlen(metavoxelServerConfig.toLocal8Bit().constData()) +1];
_metavoxelServerConfig = strcpy((char *) _metavoxelServerConfig, metavoxelServerConfig.toLocal8Bit().constData() + '\0');
return true;
}
// find assignment configurations on the specified node name and json object
// returns a string in the form of its equivalent cmd line params
QString DomainServer::readServerAssignmentConfig(QJsonObject jsonObject, const char* nodeName) {
QJsonArray nodeArray = jsonObject[nodeName].toArray();
QStringList serverConfig;
foreach (const QJsonValue & childValue, nodeArray) {
QString cmdParams;
QJsonObject childObject = childValue.toObject();
QStringList keys = childObject.keys();
for (int i = 0; i < keys.size(); i++) {
QString key = keys[i];
QString value = childObject[key].toString();
// both cmd line params and json keys are the same
cmdParams += QString("--%1 %2 ").arg(key, value);
}
serverConfig << cmdParams;
}
// according to split() calls from DomainServer::prepopulateStaticAssignmentFile
// we shold simply join them with semicolons
return serverConfig.join(';');
}
bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString& path) {
const QString JSON_MIME_TYPE = "application/json";
@ -373,24 +409,19 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
QJsonObject queuedAssignmentsJSON;
// add the queued but unfilled assignments to the json
std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
while (assignment != _assignmentQueue.end()) {
foreach(const SharedAssignmentPointer& assignment, _assignmentQueue) {
QJsonObject queuedAssignmentJSON;
QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
queuedAssignmentJSON[JSON_KEY_TYPE] = QString((*assignment)->getTypeName());
QString uuidString = uuidStringWithoutCurlyBraces(assignment->getUUID());
queuedAssignmentJSON[JSON_KEY_TYPE] = QString(assignment->getTypeName());
// if the assignment has a pool, add it
if (!(*assignment)->getPool().isEmpty()) {
queuedAssignmentJSON[JSON_KEY_POOL] = (*assignment)->getPool();
if (!assignment->getPool().isEmpty()) {
queuedAssignmentJSON[JSON_KEY_POOL] = assignment->getPool();
}
// add this queued assignment to the JSON
queuedAssignmentsJSON[uuidString] = queuedAssignmentJSON;
// push forward the iterator to check the next assignment
assignment++;
}
assignmentJSON["queued"] = queuedAssignmentsJSON;
@ -428,11 +459,8 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
// this is a script upload - ask the HTTPConnection to parse the form data
QList<FormData> formData = connection->parseFormData();
// create an assignment for this saved script, for now make it local only
Assignment* scriptAssignment = new Assignment(Assignment::CreateCommand,
Assignment::AgentType,
NULL,
Assignment::LocalLocation);
// create an assignment for this saved script
Assignment* scriptAssignment = new Assignment(Assignment::CreateCommand, Assignment::AgentType);
// check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
const QString ASSIGNMENT_INSTANCES_HEADER = "ASSIGNMENT-INSTANCES";
@ -466,10 +494,7 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
connection->respond(HTTPConnection::StatusCode200);
// add the script assigment to the assignment queue
// lock the assignment queue mutex since we're operating on a different thread than DS main
_assignmentQueueMutex.lock();
_assignmentQueue.push_back(scriptAssignment);
_assignmentQueueMutex.unlock();
_assignmentQueue.enqueue(SharedAssignmentPointer(scriptAssignment));
}
} else if (connection->requestOperation() == QNetworkAccessManager::DeleteOperation) {
if (path.startsWith(URI_NODE)) {
@ -504,307 +529,137 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
return false;
}
void DomainServer::addReleasedAssignmentBackToQueue(Assignment* releasedAssignment) {
qDebug() << "Adding assignment" << *releasedAssignment << " back to queue.";
// find this assignment in the static file
for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
if (_staticAssignments[i].getUUID() == releasedAssignment->getUUID()) {
// reset the UUID on the static assignment
_staticAssignments[i].resetUUID();
// put this assignment back in the queue so it goes out
_assignmentQueueMutex.lock();
_assignmentQueue.push_back(&_staticAssignments[i]);
_assignmentQueueMutex.unlock();
} else if (_staticAssignments[i].getUUID().isNull()) {
// we are at the blank part of the static assignments - break out
break;
}
}
void DomainServer::refreshStaticAssignmentAndAddToQueue(SharedAssignmentPointer& assignment) {
QUuid oldUUID = assignment->getUUID();
assignment->resetUUID();
qDebug() << "Reset UUID for assignment -" << *assignment.data() << "- and added to queue. Old UUID was"
<< uuidStringWithoutCurlyBraces(oldUUID);
// add the static assignment back under the right UUID, and to the queue
_staticAssignmentHash.insert(assignment->getUUID(), assignment);
_assignmentQueue.enqueue(assignment);
// remove the old assignment from the _staticAssignmentHash
// this must be done last so copies are created before the assignment passed by reference is killed
_staticAssignmentHash.remove(oldUUID);
}
void DomainServer::nodeKilled(SharedNodePointer node) {
// if this node has linked data it was from an assignment
if (node->getLinkedData()) {
Assignment* nodeAssignment = (Assignment*) node->getLinkedData();
addReleasedAssignmentBackToQueue(nodeAssignment);
// if this node's UUID matches a static assignment we need to throw it back in the assignment queue
SharedAssignmentPointer matchedAssignment = _staticAssignmentHash.value(node->getUUID());
if (matchedAssignment) {
refreshStaticAssignmentAndAddToQueue(matchedAssignment);
}
}
void DomainServer::prepopulateStaticAssignmentFile() {
int numFreshStaticAssignments = 0;
// write a fresh static assignment array to file
Assignment freshStaticAssignments[MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS];
// pre-populate the first static assignment list with assignments for root AuM, AvM, VS
freshStaticAssignments[numFreshStaticAssignments++] = Assignment(Assignment::CreateCommand, Assignment::AudioMixerType);
freshStaticAssignments[numFreshStaticAssignments++] = Assignment(Assignment::CreateCommand, Assignment::AvatarMixerType);
// Handle Domain/Voxel Server configuration command line arguments
if (_voxelServerConfig) {
qDebug("Reading Voxel Server Configuration.");
qDebug() << "config: " << _voxelServerConfig;
QString multiConfig((const char*) _voxelServerConfig);
QStringList multiConfigList = multiConfig.split(";");
// read each config to a payload for a VS assignment
for (int i = 0; i < multiConfigList.size(); i++) {
QString config = multiConfigList.at(i);
qDebug("config[%d]=%s", i, config.toLocal8Bit().constData());
// Now, parse the config to check for a pool
const char ASSIGNMENT_CONFIG_POOL_OPTION[] = "--pool";
QString assignmentPool;
int poolIndex = config.indexOf(ASSIGNMENT_CONFIG_POOL_OPTION);
if (poolIndex >= 0) {
int spaceBeforePoolIndex = config.indexOf(' ', poolIndex);
int spaceAfterPoolIndex = config.indexOf(' ', spaceBeforePoolIndex);
assignmentPool = config.mid(spaceBeforePoolIndex + 1, spaceAfterPoolIndex);
qDebug() << "The pool for this voxel-assignment is" << assignmentPool;
}
Assignment voxelServerAssignment(Assignment::CreateCommand,
Assignment::VoxelServerType,
(assignmentPool.isEmpty() ? NULL : assignmentPool.toLocal8Bit().constData()));
voxelServerAssignment.setPayload(config.toUtf8());
freshStaticAssignments[numFreshStaticAssignments++] = voxelServerAssignment;
}
} else {
Assignment rootVoxelServerAssignment(Assignment::CreateCommand, Assignment::VoxelServerType);
freshStaticAssignments[numFreshStaticAssignments++] = rootVoxelServerAssignment;
}
// Handle Domain/Particle Server configuration command line arguments
if (_particleServerConfig) {
qDebug("Reading Particle Server Configuration.");
qDebug() << "config: " << _particleServerConfig;
QString multiConfig((const char*) _particleServerConfig);
QStringList multiConfigList = multiConfig.split(";");
// read each config to a payload for a VS assignment
for (int i = 0; i < multiConfigList.size(); i++) {
QString config = multiConfigList.at(i);
qDebug("config[%d]=%s", i, config.toLocal8Bit().constData());
// Now, parse the config to check for a pool
const char ASSIGNMENT_CONFIG_POOL_OPTION[] = "--pool";
QString assignmentPool;
int poolIndex = config.indexOf(ASSIGNMENT_CONFIG_POOL_OPTION);
if (poolIndex >= 0) {
int spaceBeforePoolIndex = config.indexOf(' ', poolIndex);
int spaceAfterPoolIndex = config.indexOf(' ', spaceBeforePoolIndex);
assignmentPool = config.mid(spaceBeforePoolIndex + 1, spaceAfterPoolIndex);
qDebug() << "The pool for this particle-assignment is" << assignmentPool;
}
Assignment particleServerAssignment(Assignment::CreateCommand,
Assignment::ParticleServerType,
(assignmentPool.isEmpty() ? NULL : assignmentPool.toLocal8Bit().constData()));
particleServerAssignment.setPayload(config.toLocal8Bit());
freshStaticAssignments[numFreshStaticAssignments++] = particleServerAssignment;
}
} else {
Assignment rootParticleServerAssignment(Assignment::CreateCommand, Assignment::ParticleServerType);
freshStaticAssignments[numFreshStaticAssignments++] = rootParticleServerAssignment;
}
// handle metavoxel configuration command line argument
Assignment& metavoxelAssignment = (freshStaticAssignments[numFreshStaticAssignments++] =
Assignment(Assignment::CreateCommand, Assignment::MetavoxelServerType));
if (_metavoxelServerConfig) {
metavoxelAssignment.setPayload(QByteArray(_metavoxelServerConfig));
}
qDebug() << "Adding" << numFreshStaticAssignments << "static assignments to fresh file.";
_staticAssignmentFile.open(QIODevice::WriteOnly);
_staticAssignmentFile.write((char*) &freshStaticAssignments, sizeof(freshStaticAssignments));
_staticAssignmentFile.resize(MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS * sizeof(Assignment));
_staticAssignmentFile.close();
}
Assignment* DomainServer::matchingStaticAssignmentForCheckIn(const QUuid& checkInUUID, NodeType_t nodeType) {
// pull the UUID passed with the check in
SharedAssignmentPointer DomainServer::matchingStaticAssignmentForCheckIn(const QUuid& checkInUUID, NodeType_t nodeType) {
if (_hasCompletedRestartHold) {
_assignmentQueueMutex.lock();
// iterate the assignment queue to check for a match
std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
while (assignment != _assignmentQueue.end()) {
if ((*assignment)->getUUID() == checkInUUID) {
// return the matched assignment
_assignmentQueueMutex.unlock();
return *assignment;
// look for a match in the assignment hash
QQueue<SharedAssignmentPointer>::iterator i = _assignmentQueue.begin();
while (i != _assignmentQueue.end()) {
if (i->data()->getType() == Assignment::typeForNodeType(nodeType) && i->data()->getUUID() == checkInUUID) {
return _assignmentQueue.takeAt(i - _assignmentQueue.begin());
} else {
// no match, push deque iterator forwards
assignment++;
++i;
}
}
_assignmentQueueMutex.unlock();
} else {
for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
if (_staticAssignments[i].getUUID() == checkInUUID) {
// return matched assignment
return &_staticAssignments[i];
} else if (_staticAssignments[i].getUUID().isNull()) {
// end of static assignments, no match - return NULL
return NULL;
}
SharedAssignmentPointer matchingStaticAssignment = _staticAssignmentHash.value(checkInUUID);
if (matchingStaticAssignment && matchingStaticAssignment->getType() == nodeType) {
return matchingStaticAssignment;
}
}
return NULL;
return SharedAssignmentPointer();
}
Assignment* DomainServer::deployableAssignmentForRequest(Assignment& requestAssignment) {
_assignmentQueueMutex.lock();
SharedAssignmentPointer DomainServer::deployableAssignmentForRequest(const Assignment& requestAssignment) {
// this is an unassigned client talking to us directly for an assignment
// go through our queue and see if there are any assignments to give out
std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
QQueue<SharedAssignmentPointer>::iterator sharedAssignment = _assignmentQueue.begin();
while (assignment != _assignmentQueue.end()) {
while (sharedAssignment != _assignmentQueue.end()) {
Assignment* assignment = sharedAssignment->data();
bool requestIsAllTypes = requestAssignment.getType() == Assignment::AllTypes;
bool assignmentTypesMatch = (*assignment)->getType() == requestAssignment.getType();
bool nietherHasPool = (*assignment)->getPool().isEmpty() && requestAssignment.getPool().isEmpty();
bool assignmentPoolsMatch = (*assignment)->getPool() == requestAssignment.getPool();
bool assignmentTypesMatch = assignment->getType() == requestAssignment.getType();
bool nietherHasPool = assignment->getPool().isEmpty() && requestAssignment.getPool().isEmpty();
bool assignmentPoolsMatch = assignment->getPool() == requestAssignment.getPool();
if ((requestIsAllTypes || assignmentTypesMatch) && (nietherHasPool || assignmentPoolsMatch)) {
Assignment* deployableAssignment = *assignment;
if ((*assignment)->getType() == Assignment::AgentType) {
if (assignment->getType() == Assignment::AgentType) {
// if there is more than one instance to send out, simply decrease the number of instances
if ((*assignment)->getNumberOfInstances() == 1) {
_assignmentQueue.erase(assignment);
if (assignment->getNumberOfInstances() == 1) {
return _assignmentQueue.takeAt(sharedAssignment - _assignmentQueue.begin());
} else {
assignment->decrementNumberOfInstances();
return *sharedAssignment;
}
deployableAssignment->decrementNumberOfInstances();
} else {
// remove the assignment from the queue
_assignmentQueue.erase(assignment);
SharedAssignmentPointer deployableAssignment = _assignmentQueue.takeAt(sharedAssignment
- _assignmentQueue.begin());
// until we get a check-in from that GUID
// put assignment back in queue but stick it at the back so the others have a chance to go out
_assignmentQueue.push_back(deployableAssignment);
_assignmentQueue.enqueue(deployableAssignment);
// stop looping, we've handed out an assignment
return deployableAssignment;
}
// stop looping, we've handed out an assignment
_assignmentQueueMutex.unlock();
return deployableAssignment;
} else {
// push forward the iterator to check the next assignment
assignment++;
++sharedAssignment;
}
}
_assignmentQueueMutex.unlock();
return NULL;
return SharedAssignmentPointer();
}
void DomainServer::removeAssignmentFromQueue(Assignment* removableAssignment) {
_assignmentQueueMutex.lock();
std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
while (assignment != _assignmentQueue.end()) {
if ((*assignment)->getUUID() == removableAssignment->getUUID()) {
_assignmentQueue.erase(assignment);
void DomainServer::removeMatchingAssignmentFromQueue(const SharedAssignmentPointer& removableAssignment) {
QQueue<SharedAssignmentPointer>::iterator potentialMatchingAssignment = _assignmentQueue.begin();
while (potentialMatchingAssignment != _assignmentQueue.end()) {
if (potentialMatchingAssignment->data()->getUUID() == removableAssignment->getUUID()) {
_assignmentQueue.erase(potentialMatchingAssignment);
// we matched and removed an assignment, bail out
break;
} else {
// push forward the iterator to check the next assignment
assignment++;
++potentialMatchingAssignment;
}
}
_assignmentQueueMutex.unlock();
}
bool DomainServer::checkInWithUUIDMatchesExistingNode(const HifiSockAddr& nodePublicSocket,
const HifiSockAddr& nodeLocalSocket,
const QUuid& checkInUUID) {
NodeList* nodeList = NodeList::getInstance();
foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
if (node->getLinkedData()
&& nodePublicSocket == node->getPublicSocket()
&& nodeLocalSocket == node->getLocalSocket()
&& node->getUUID() == checkInUUID) {
// this is a matching existing node if the public socket, local socket, and UUID match
return true;
}
}
return false;
}
void DomainServer::addStaticAssignmentsBackToQueueAfterRestart() {
_hasCompletedRestartHold = true;
// if the domain-server has just restarted,
// check if there are static assignments in the file that we need to
// throw into the assignment queue
// pull anything in the static assignment file that isn't spoken for and add to the assignment queue
for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
if (_staticAssignments[i].getUUID().isNull()) {
// reached the end of static assignments, bail
break;
}
// check if there are static assignments that we need to throw into the assignment queue
QHash<QUuid, SharedAssignmentPointer> staticHashCopy = _staticAssignmentHash;
QHash<QUuid, SharedAssignmentPointer>::iterator staticAssignment = staticHashCopy.begin();
while (staticAssignment != staticHashCopy.end()) {
// add any of the un-matched static assignments to the queue
bool foundMatchingAssignment = false;
NodeList* nodeList = NodeList::getInstance();
// enumerate the nodes and check if there is one with an attached assignment with matching UUID
foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
if (node->getLinkedData()) {
Assignment* linkedAssignment = (Assignment*) node->getLinkedData();
if (linkedAssignment->getUUID() == _staticAssignments[i].getUUID()) {
foundMatchingAssignment = true;
break;
}
foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
if (node->getUUID() == staticAssignment->data()->getUUID()) {
foundMatchingAssignment = true;
}
}
if (!foundMatchingAssignment) {
// this assignment has not been fulfilled - reset the UUID and add it to the assignment queue
_staticAssignments[i].resetUUID();
qDebug() << "Adding static assignment to queue -" << _staticAssignments[i];
_assignmentQueueMutex.lock();
_assignmentQueue.push_back(&_staticAssignments[i]);
_assignmentQueueMutex.unlock();
refreshStaticAssignmentAndAddToQueue(*staticAssignment);
}
++staticAssignment;
}
}
void DomainServer::cleanup() {
_staticAssignmentFile.unmap(_staticAssignmentFileData);
_staticAssignmentFile.close();
}

45
domain-server/src/DomainServer.h
View file

@ -9,17 +9,16 @@
#ifndef __hifi__DomainServer__
#define __hifi__DomainServer__
#include <deque>
#include <QtCore/QCoreApplication>
#include <QtCore/QFile>
#include <QtCore/QMutex>
#include <QtCore/QHash>
#include <QtCore/QQueue>
#include <QtCore/QSharedPointer>
#include <Assignment.h>
#include <HTTPManager.h>
#include <NodeList.h>
const int MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS = 1000;
typedef QSharedPointer<Assignment> SharedAssignmentPointer;
class DomainServer : public QCoreApplication, public HTTPRequestHandler {
Q_OBJECT
@ -35,37 +34,27 @@ public slots:
void nodeKilled(SharedNodePointer node);
private:
bool readConfigFile(const char* path);
QString readServerAssignmentConfig(QJsonObject jsonObj, const char* nodeName);
void prepopulateStaticAssignmentFile();
Assignment* matchingStaticAssignmentForCheckIn(const QUuid& checkInUUID, NodeType_t nodeType);
Assignment* deployableAssignmentForRequest(Assignment& requestAssignment);
void removeAssignmentFromQueue(Assignment* removableAssignment);
bool checkInWithUUIDMatchesExistingNode(const HifiSockAddr& nodePublicSocket,
const HifiSockAddr& nodeLocalSocket,
const QUuid& checkInUUI);
void addReleasedAssignmentBackToQueue(Assignment* releasedAssignment);
void parseCommandLineTypeConfigs(const QStringList& argumentList, QSet<Assignment::Type>& excludedTypes);
void readConfigFile(const QString& path, QSet<Assignment::Type>& excludedTypes);
QString readServerAssignmentConfig(const QJsonObject& jsonObject, const QString& nodeName);
void addStaticAssignmentToAssignmentHash(Assignment* newAssignment);
void createStaticAssignmentsForTypeGivenConfigString(Assignment::Type type, const QString& configString);
void populateDefaultStaticAssignmentsExcludingTypes(const QSet<Assignment::Type>& excludedTypes);
SharedAssignmentPointer matchingStaticAssignmentForCheckIn(const QUuid& checkInUUID, NodeType_t nodeType);
SharedAssignmentPointer deployableAssignmentForRequest(const Assignment& requestAssignment);
void removeMatchingAssignmentFromQueue(const SharedAssignmentPointer& removableAssignment);
void refreshStaticAssignmentAndAddToQueue(SharedAssignmentPointer& assignment);
HTTPManager _HTTPManager;
QMutex _assignmentQueueMutex;
std::deque<Assignment*> _assignmentQueue;
QFile _staticAssignmentFile;
uchar* _staticAssignmentFileData;
Assignment* _staticAssignments;
const char* _voxelServerConfig;
const char* _particleServerConfig;
const char* _metavoxelServerConfig;
QHash<QUuid, SharedAssignmentPointer> _staticAssignmentHash;
QQueue<SharedAssignmentPointer> _assignmentQueue;
bool _hasCompletedRestartHold;
private slots:
void readAvailableDatagrams();
void addStaticAssignmentsBackToQueueAfterRestart();
void cleanup();
};
#endif /* defined(__hifi__DomainServer__) */

2
examples/clap.js
View file

@ -62,4 +62,4 @@ function maybePlaySound() {
}
// Connect a call back that happens every frame
Agent.willSendVisualDataCallback.connect(maybePlaySound);
Script.willSendVisualDataCallback.connect(maybePlaySound);

4
examples/collidingParticles.js
View file

@ -132,7 +132,7 @@ function draw() {
print(scriptB);
numberParticlesAdded++;
} else {
Agent.stop();
Script.stop();
}
print("Particles Stats: " + Particles.getLifetimeInSeconds() + " seconds," +
@ -150,5 +150,5 @@ function draw() {
// register the call back so it fires before each data send
print("here...\n");
Particles.setPacketsPerSecond(40000);
Agent.willSendVisualDataCallback.connect(draw);
Script.willSendVisualDataCallback.connect(draw);
print("and here...\n");

105
examples/controllerExample.js
View file

@ -48,6 +48,15 @@ function checkController() {
function keyPressEvent(event) {
print("keyPressEvent event.key=" + event.key);
print("keyPressEvent event.text=" + event.text);
print("keyPressEvent event.isShifted=" + event.isShifted);
print("keyPressEvent event.isControl=" + event.isControl);
print("keyPressEvent event.isMeta=" + event.isMeta);
print("keyPressEvent event.isAlt=" + event.isAlt);
print("keyPressEvent event.isKeypad=" + event.isKeypad);
if (event.key == "A".charCodeAt(0)) {
print("the A key was pressed");
}
@ -73,18 +82,106 @@ function touchEndEvent(event) {
}
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(checkController);
Script.willSendVisualDataCallback.connect(checkController);
// Map keyPress and mouse move events to our callbacks
Controller.keyPressEvent.connect(keyPressEvent);
var AKeyEvent = {
var KeyEvent_A = {
key: "A".charCodeAt(0),
text: "A",
isShifted: false,
isMeta: false
};
var KeyEvent_a = {
text: "a",
isShifted: false,
isMeta: false
};
var KeyEvent_a2 = {
key: "a".charCodeAt(0),
isShifted: false,
isMeta: false
};
var KeyEvent_a3 = {
text: "a"
};
var KeyEvent_A2 = {
text: "A"
};
var KeyEvent_9 = {
text: "9"
};
var KeyEvent_Num = {
text: "#"
};
var KeyEvent_At = {
text: "@"
};
var KeyEvent_MetaAt = {
text: "@",
isMeta: true
};
var KeyEvent_Up = {
text: "up"
};
var KeyEvent_Down = {
text: "down"
};
var KeyEvent_Left = {
text: "left"
};
var KeyEvent_Right = {
text: "right"
};
// prevent the A key from going through to the application
Controller.captureKeyEvents(AKeyEvent);
print("KeyEvent_A");
Controller.captureKeyEvents(KeyEvent_A);
print("KeyEvent_A2");
Controller.captureKeyEvents(KeyEvent_A2);
print("KeyEvent_a");
Controller.captureKeyEvents(KeyEvent_a);
print("KeyEvent_a2");
Controller.captureKeyEvents(KeyEvent_a2);
print("KeyEvent_a3");
Controller.captureKeyEvents(KeyEvent_a3);
print("KeyEvent_9");
Controller.captureKeyEvents(KeyEvent_9);
print("KeyEvent_Num");
Controller.captureKeyEvents(KeyEvent_Num);
print("KeyEvent_At");
Controller.captureKeyEvents(KeyEvent_At);
print("KeyEvent_MetaAt");
Controller.captureKeyEvents(KeyEvent_MetaAt);
print("KeyEvent_Up");
Controller.captureKeyEvents(KeyEvent_Up);
print("KeyEvent_Down");
Controller.captureKeyEvents(KeyEvent_Down);
print("KeyEvent_Left");
Controller.captureKeyEvents(KeyEvent_Left);
print("KeyEvent_Right");
Controller.captureKeyEvents(KeyEvent_Right);
Controller.mouseMoveEvent.connect(mouseMoveEvent);
@ -102,4 +199,4 @@ function scriptEnding() {
Controller.releaseTouchEvents();
}
Agent.scriptEnding.connect(scriptEnding);
Script.scriptEnding.connect(scriptEnding);

4
examples/count.js
View file

@ -20,7 +20,7 @@ function scriptEnding() {
}
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(displayCount);
Script.willSendVisualDataCallback.connect(displayCount);
// register our scriptEnding callback
Agent.scriptEnding.connect(scriptEnding);
Script.scriptEnding.connect(scriptEnding);

2
examples/drumStick.js
View file

@ -69,4 +69,4 @@ function checkSticks() {
}
// Connect a call back that happens every frame
Agent.willSendVisualDataCallback.connect(checkSticks);
Script.willSendVisualDataCallback.connect(checkSticks);

7
examples/editParticleExample.js
View file

@ -44,7 +44,6 @@ var particleID = Particles.addParticle(originalProperties);
function moveParticle() {
if (count >= moveUntil) {
//Agent.stop();
// delete it...
if (count == moveUntil) {
@ -54,8 +53,8 @@ function moveParticle() {
// stop it...
if (count >= stopAfter) {
print("calling Agent.stop()");
Agent.stop();
print("calling Script.stop()");
Script.stop();
}
count++;
@ -86,5 +85,5 @@ function moveParticle() {
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(moveParticle);
Script.willSendVisualDataCallback.connect(moveParticle);

10
examples/findParticleExample.js
View file

@ -1,5 +1,5 @@
//
// editParticleExample.js
// findParticleExample.js
// hifi
//
// Created by Brad Hefta-Gaub on 1/24/14.
@ -65,8 +65,8 @@ function findParticles() {
// run for a while, then clean up
// stop it...
if (iteration >= 100) {
print("calling Agent.stop()");
Agent.stop();
print("calling Script.stop()");
Script.stop();
}
print("--------------------------");
@ -122,7 +122,7 @@ function findParticles() {
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(findParticles);
Script.willSendVisualDataCallback.connect(findParticles);
// register our scriptEnding callback
Agent.scriptEnding.connect(scriptEnding);
Script.scriptEnding.connect(scriptEnding);

4
examples/fountain.js
View file

@ -60,8 +60,8 @@ function makeFountain() {
totalParticles++;
}
if (totalParticles > 100) {
Agent.stop();
Script.stop();
}
}
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(makeFountain);
Script.willSendVisualDataCallback.connect(makeFountain);

133
examples/gameoflife.js Normal file
View file

@ -0,0 +1,133 @@
// Add your JavaScript for assignment below this line
// The following is an example of Conway's Game of Life (http://en.wikipedia.org/wiki/Conway's_Game_of_Life)
var NUMBER_OF_CELLS_EACH_DIMENSION = 64;
var NUMBER_OF_CELLS = NUMBER_OF_CELLS_EACH_DIMENSION * NUMBER_OF_CELLS_EACH_DIMENSION;
var currentCells = [];
var nextCells = [];
var METER_LENGTH = 1;
var cellScale = (NUMBER_OF_CELLS_EACH_DIMENSION * METER_LENGTH) / NUMBER_OF_CELLS_EACH_DIMENSION;
// randomly populate the cell start values
for (var i = 0; i < NUMBER_OF_CELLS_EACH_DIMENSION; i++) {
// create the array to hold this row
currentCells[i] = [];
// create the array to hold this row in the nextCells array
nextCells[i] = [];
for (var j = 0; j < NUMBER_OF_CELLS_EACH_DIMENSION; j++) {
currentCells[i][j] = Math.floor(Math.random() * 2);
// put the same value in the nextCells array for first board draw
nextCells[i][j] = currentCells[i][j];
}
}
function isNeighbourAlive(i, j) {
if (i < 0 || i >= NUMBER_OF_CELLS_EACH_DIMENSION
|| i < 0 || j >= NUMBER_OF_CELLS_EACH_DIMENSION) {
return 0;
} else {
return currentCells[i][j];
}
}
function updateCells() {
var i = 0;
var j = 0;
for (i = 0; i < NUMBER_OF_CELLS_EACH_DIMENSION; i++) {
for (j = 0; j < NUMBER_OF_CELLS_EACH_DIMENSION; j++) {
// figure out the number of live neighbours for the i-j cell
var liveNeighbours =
isNeighbourAlive(i + 1, j - 1) + isNeighbourAlive(i + 1, j) + isNeighbourAlive(i + 1, j + 1) +
isNeighbourAlive(i, j - 1) + isNeighbourAlive(i, j + 1) +
isNeighbourAlive(i - 1, j - 1) + isNeighbourAlive(i - 1, j) + isNeighbourAlive(i - 1, j + 1);
if (currentCells[i][j]) {
// live cell
if (liveNeighbours < 2) {
// rule #1 - under-population - this cell will die
// mark it zero to mark the change
nextCells[i][j] = 0;
} else if (liveNeighbours < 4) {
// rule #2 - this cell lives
// mark it -1 to mark no change
nextCells[i][j] = -1;
} else {
// rule #3 - overcrowding - this cell dies
// mark it zero to mark the change
nextCells[i][j] = 0;
}
} else {
// dead cell
if (liveNeighbours == 3) {
// rule #4 - reproduction - this cell revives
// mark it one to mark the change
nextCells[i][j] = 1;
} else {
// this cell stays dead
// mark it -1 for no change
nextCells[i][j] = -1;
}
}
if (Math.random() < 0.001) {
// Random mutation to keep things interesting in there.
nextCells[i][j] = 1;
}
}
}
for (i = 0; i < NUMBER_OF_CELLS_EACH_DIMENSION; i++) {
for (j = 0; j < NUMBER_OF_CELLS_EACH_DIMENSION; j++) {
if (nextCells[i][j] != -1) {
// there has been a change to this cell, change the value in the currentCells array
currentCells[i][j] = nextCells[i][j];
}
}
}
}
function sendNextCells() {
for (var i = 0; i < NUMBER_OF_CELLS_EACH_DIMENSION; i++) {
for (var j = 0; j < NUMBER_OF_CELLS_EACH_DIMENSION; j++) {
if (nextCells[i][j] != -1) {
// there has been a change to the state of this cell, send it
// find the x and y position for this voxel, z = 0
var x = j * cellScale;
var y = i * cellScale;
// queue a packet to add a voxel for the new cell
var color = (nextCells[i][j] == 1) ? 255 : 1;
Voxels.setVoxel(x, y, 0, cellScale, color, color, color);
}
}
}
}
var sentFirstBoard = false;
function step() {
print("step()...");
if (sentFirstBoard) {
// we've already sent the first full board, perform a step in time
updateCells();
} else {
// this will be our first board send
sentFirstBoard = true;
}
sendNextCells();
}
print("here");
Script.willSendVisualDataCallback.connect(step);
Voxels.setPacketsPerSecond(200);
print("now here");

26
examples/globalCollisionsExample.js Normal file
View file

@ -0,0 +1,26 @@
//
// globalCollisionsExample.js
// hifi
//
// Created by Brad Hefta-Gaub on 1/29/14.
// Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
//
// This is an example script that demonstrates use of the Controller class
//
//
function particleCollisionWithVoxel(particle, voxel) {
print("particleCollisionWithVoxel()..");
print(" particle.getID()=" + particle.id);
print(" voxel color...=" + voxel.red + ", " + voxel.green + ", " + voxel.blue);
}
function particleCollisionWithParticle(particleA, particleB) {
print("particleCollisionWithParticle()..");
print(" particleA.getID()=" + particleA.id);
print(" particleB.getID()=" + particleB.id);
}
Particles.particleCollisionWithVoxel.connect(particleCollisionWithVoxel);
Particles.particleCollisionWithParticle.connect(particleCollisionWithParticle);

10
examples/gun.js
View file

@ -72,13 +72,13 @@ function checkController() {
" function collisionWithVoxel(voxel) { " +
" print('collisionWithVoxel(voxel)... '); " +
" print('myID=' + Particle.getID() + '\\n'); " +
" var voxelColor = voxel.getColor();" +
" print('voxelColor=' + voxelColor.red + ', ' + voxelColor.green + ', ' + voxelColor.blue + '\\n'); " +
" var voxelColor = { red: voxel.red, green: voxel.green, blue: voxel.blue };" +
" var voxelAt = { x: voxel.x, y: voxel.y, z: voxel.z };" +
" var voxelScale = voxel.s;" +
" print('voxelColor=' + voxel.red + ', ' + voxel.green + ', ' + voxel.blue + '\\n'); " +
" var myColor = Particle.getColor();" +
" print('myColor=' + myColor.red + ', ' + myColor.green + ', ' + myColor.blue + '\\n'); " +
" Particle.setColor(voxelColor); " +
" var voxelAt = voxel.getPosition();" +
" var voxelScale = voxel.getScale();" +
" Voxels.eraseVoxel(voxelAt.x, voxelAt.y, voxelAt.z, voxelScale); " +
" print('Voxels.eraseVoxel(' + voxelAt.x + ', ' + voxelAt.y + ', ' + voxelAt.z + ', ' + voxelScale + ')... \\n'); " +
" } " +
@ -99,4 +99,4 @@ function checkController() {
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(checkController);
Script.willSendVisualDataCallback.connect(checkController);

4
examples/lookWithMouse.js
View file

@ -70,5 +70,5 @@ MyAvatar.bodyPitch = 0;
MyAvatar.bodyRoll = 0;
// would be nice to change to update
Agent.willSendVisualDataCallback.connect(update);
Agent.scriptEnding.connect(scriptEnding);
Script.willSendVisualDataCallback.connect(update);
Script.scriptEnding.connect(scriptEnding);

2
examples/movingVoxel.js
View file

@ -41,4 +41,4 @@ function moveVoxel() {
Voxels.setPacketsPerSecond(300);
// Connect a call back that happens every frame
Agent.willSendVisualDataCallback.connect(moveVoxel);
Script.willSendVisualDataCallback.connect(moveVoxel);

8
examples/paintGun.js
View file

@ -65,13 +65,13 @@ function checkController() {
" function collisionWithVoxel(voxel) { " +
" print('collisionWithVoxel(voxel)... '); " +
" print('myID=' + Particle.getID() + '\\n'); " +
" var voxelColor = voxel.getColor();" +
" var voxelColor = { red: voxel.red, green: voxel.green, blue: voxel.blue };" +
" var voxelAt = { x: voxel.x, y: voxel.y, z: voxel.z };" +
" var voxelScale = voxel.s;" +
" print('voxelColor=' + voxelColor.red + ', ' + voxelColor.green + ', ' + voxelColor.blue + '\\n'); " +
" var myColor = Particle.getColor();" +
" print('myColor=' + myColor.red + ', ' + myColor.green + ', ' + myColor.blue + '\\n'); " +
" Particle.setColor(voxelColor); " +
" var voxelAt = voxel.getPosition();" +
" var voxelScale = voxel.getScale();" +
" Voxels.setVoxel(voxelAt.x, voxelAt.y, voxelAt.z, voxelScale, 255, 255, 0); " +
" print('Voxels.setVoxel(' + voxelAt.x + ', ' + voxelAt.y + ', ' + voxelAt.z + ', ' + voxelScale + ')... \\n'); " +
" } " +
@ -93,4 +93,4 @@ function checkController() {
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(checkController);
Script.willSendVisualDataCallback.connect(checkController);

4
examples/particleBird.js
View file

@ -95,7 +95,7 @@ function moveBird() {
var nowTimeInSeconds = new Date().getTime() / 1000;
if ((nowTimeInSeconds - startTimeInSeconds) >= birdLifetime) {
print("our bird is dying, stop our script");
Agent.stop();
Script.stop();
return;
}
@ -171,4 +171,4 @@ function moveBird() {
}
}
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(moveBird);
Script.willSendVisualDataCallback.connect(moveBird);

6
examples/particleModelExample.js
View file

@ -37,8 +37,8 @@ var ballParticleID = Particles.addParticle(ballProperties);
function endAfterAWhile() {
// stop it...
if (count >= stopAfter) {
print("calling Agent.stop()");
Agent.stop();
print("calling Script.stop()");
Script.stop();
}
print("count =" + count);
@ -47,5 +47,5 @@ function endAfterAWhile() {
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(endAfterAWhile);
Script.willSendVisualDataCallback.connect(endAfterAWhile);

2
examples/playSound.js
View file

@ -17,4 +17,4 @@ function maybePlaySound() {
}
// Connect a call back that happens every frame
Agent.willSendVisualDataCallback.connect(maybePlaySound);
Script.willSendVisualDataCallback.connect(maybePlaySound);

50
examples/rideAlongWithAParticleExample.js Normal file
View file

@ -0,0 +1,50 @@
//
// rideAlongWithAParticleExample.js
// hifi
//
// Created by Brad Hefta-Gaub on 1/24/14.
// Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
//
// This is an example script that demonstrates "finding" particles
//
var iteration = 0;
var lengthOfRide = 2000; // in iterations
var particleA = Particles.addParticle(
{
position: { x: 10, y: 0, z: 10 },
velocity: { x: 5, y: 0, z: 5 },
gravity: { x: 0, y: 0, z: 0 },
radius : 0.1,
color: { red: 0, green: 255, blue: 0 },
damping: 0,
lifetime: (lengthOfRide * 60) + 1
});
function rideWithParticle() {
if (iteration <= lengthOfRide) {
// Check to see if we've been notified of the actual identity of the particles we created
if (!particleA.isKnownID) {
particleA = Particles.identifyParticle(particleA);
}
var propertiesA = Particles.getParticleProperties(particleA);
var newPosition = propertiesA.position;
MyAvatar.position = { x: propertiesA.position.x,
y: propertiesA.position.y + 2,
z: propertiesA.position.z };
} else {
Script.stop();
}
iteration++;
print("iteration="+iteration);
}
// register the call back so it fires before each data send
Script.willSendVisualDataCallback.connect(rideWithParticle);

2
examples/toyball.js
View file

@ -226,4 +226,4 @@ function checkController() {
// register the call back so it fires before each data send
Agent.willSendVisualDataCallback.connect(checkController);
Script.willSendVisualDataCallback.connect(checkController);

2
examples/voxelBird.js
View file

@ -130,4 +130,4 @@ function moveBird() {
Voxels.setPacketsPerSecond(10000);
// Connect a call back that happens every frame
Agent.willSendVisualDataCallback.connect(moveBird);
Script.willSendVisualDataCallback.connect(moveBird);

51
interface/src/Application.cpp
View file

@ -117,11 +117,10 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
_frameCount(0),
_fps(120.0f),
_justStarted(true),
_voxelImporter(_window),
_voxelImporter(NULL),
_wantToKillLocalVoxels(false),
_audioScope(256, 200, true),
_avatarManager(),
_myAvatar(NULL),
_myAvatar(),
_profile(QString()),
_mirrorViewRect(QRect(MIRROR_VIEW_LEFT_PADDING, MIRROR_VIEW_TOP_PADDING, MIRROR_VIEW_WIDTH, MIRROR_VIEW_HEIGHT)),
_mouseX(0),
@ -1090,7 +1089,7 @@ void Application::keyPressEvent(QKeyEvent* event) {
_swatch.handleEvent(event->key(), Menu::getInstance()->isOptionChecked(MenuOption::VoxelGetColorMode));
break;
case Qt::Key_At:
Menu::getInstance()->goToUser();
Menu::getInstance()->goTo();
break;
default:
event->ignore();
@ -1410,10 +1409,10 @@ void Application::wheelEvent(QWheelEvent* event) {
void Application::sendPingPackets() {
QByteArray pingPacket = NodeList::getInstance()->constructPingPacket();
getInstance()->controlledBroadcastToNodes(pingPacket, NodeSet() << NodeType::VoxelServer
<< NodeType::ParticleServer
<< NodeType::AudioMixer << NodeType::AvatarMixer
<< NodeType::MetavoxelServer);
controlledBroadcastToNodes(pingPacket, NodeSet() << NodeType::VoxelServer
<< NodeType::ParticleServer
<< NodeType::AudioMixer << NodeType::AvatarMixer
<< NodeType::MetavoxelServer);
}
// Every second, check the frame rates and other stuff
@ -1670,7 +1669,12 @@ void Application::exportVoxels() {
}
void Application::importVoxels() {
if (_voxelImporter.exec()) {
if (!_voxelImporter) {
_voxelImporter = new VoxelImporter(_window);
_voxelImporter->init(_settings);
}
if (_voxelImporter->exec()) {
qDebug("[DEBUG] Import succeeded.");
} else {
qDebug("[DEBUG] Import failed.");
@ -1810,8 +1814,6 @@ void Application::init() {
_sharedVoxelSystem.changeTree(&_clipboard);
delete tmpTree;
_voxelImporter.init(_settings);
_environment.init();
_glowEffect.init();
@ -1875,6 +1877,17 @@ void Application::init() {
_particleCollisionSystem.init(&_particleEditSender, _particles.getTree(), _voxels.getTree(), &_audio, &_avatarManager);
// connect the _particleCollisionSystem to our script engine's ParticleScriptingInterface
connect(&_particleCollisionSystem,
SIGNAL(particleCollisionWithVoxel(const ParticleID&, const VoxelDetail&)),
ScriptEngine::getParticlesScriptingInterface(),
SLOT(forwardParticleCollisionWithVoxel(const ParticleID&, const VoxelDetail&)));
connect(&_particleCollisionSystem,
SIGNAL(particleCollisionWithParticle(const ParticleID&, const ParticleID&)),
ScriptEngine::getParticlesScriptingInterface(),
SLOT(forwardParticleCollisionWithParticle(const ParticleID&, const ParticleID&)));
_palette.init(_glWidget->width(), _glWidget->height());
_palette.addAction(Menu::getInstance()->getActionForOption(MenuOption::VoxelAddMode), 0, 0);
_palette.addAction(Menu::getInstance()->getActionForOption(MenuOption::VoxelDeleteMode), 0, 1);
@ -3842,18 +3855,12 @@ void Application::setMenuShortcutsEnabled(bool enabled) {
}
void Application::updateWindowTitle(){
QString title = "";
QString buildVersion = " (build " + applicationVersion() + ")";
QString username = _profile.getUsername();
if(!username.isEmpty()){
title += username;
title += " @ ";
}
title += NodeList::getInstance()->getDomainHostname();
title += buildVersion;
QString buildVersion = " (build " + applicationVersion() + ")";
NodeList* nodeList = NodeList::getInstance();
QString title = QString() + _profile.getUsername() + " " + nodeList->getOwnerUUID().toString()
+ " @ " + nodeList->getDomainHostname() + buildVersion;
qDebug("Application title set to: %s", title.toStdString().c_str());
_window->setWindowTitle(title);

4
interface/src/Application.h
View file

@ -264,7 +264,7 @@ private:
void updateProjectionMatrix(Camera& camera, bool updateViewFrustum = true);
static bool sendVoxelsOperation(OctreeElement* node, void* extraData);
static void sendPingPackets();
void sendPingPackets();
void initDisplay();
void init();
@ -353,7 +353,7 @@ private:
VoxelSystem _voxels;
VoxelTree _clipboard; // if I copy/paste
VoxelImporter _voxelImporter;
VoxelImporter* _voxelImporter;
VoxelSystem _sharedVoxelSystem;
ViewFrustum _sharedVoxelSystemViewFrustum;

2
interface/src/Audio.cpp
View file

@ -539,7 +539,7 @@ void Audio::toggleMute() {
}
void Audio::render(int screenWidth, int screenHeight) {
if (_audioInput) {
if (_audioInput && _audioOutput) {
glLineWidth(2.0);
glBegin(GL_LINES);
glColor3f(.93f, .93f, .93f);

4
interface/src/ImportDialog.cpp
View file

@ -231,10 +231,6 @@ void ImportDialog::setLayout() {
widget = findChild<QWidget*>("treeView");
widget->setAttribute(Qt::WA_MacShowFocusRect, false);
// remove reference to treeView
widget = NULL;
widget->deleteLater();
switchToResourcesParentIfRequired();
QFile styleSheet("resources/styles/import_dialog.qss");
if (styleSheet.open(QIODevice::ReadOnly)) {

89
interface/src/Menu.cpp
View file

@ -116,10 +116,10 @@ Menu::Menu() :
this,
SLOT(goToLocation()));
addActionToQMenuAndActionHash(fileMenu,
MenuOption::GoToUser,
MenuOption::GoTo,
Qt::Key_At,
this,
SLOT(goToUser()));
SLOT(goTo()));
addDisabledActionAndSeparator(fileMenu, "Settings");
@ -910,6 +910,60 @@ void Menu::goToDomain() {
sendFakeEnterEvent();
}
void Menu::goTo() {
QInputDialog gotoDialog(Application::getInstance()->getWindow());
gotoDialog.setWindowTitle("Go to");
gotoDialog.setLabelText("Destination:");
QString destination = Application::getInstance()->getProfile()->getUsername();
gotoDialog.setTextValue(destination);
gotoDialog.setWindowFlags(Qt::Sheet);
gotoDialog.resize(gotoDialog.parentWidget()->size().width() * DIALOG_RATIO_OF_WINDOW, gotoDialog.size().height());
int dialogReturn = gotoDialog.exec();
if (dialogReturn == QDialog::Accepted && !gotoDialog.textValue().isEmpty()) {
destination = gotoDialog.textValue();
QStringList coordinateItems = destination.split(QRegExp("_|,"), QString::SkipEmptyParts);
const int NUMBER_OF_COORDINATE_ITEMS = 3;
const int X_ITEM = 0;
const int Y_ITEM = 1;
const int Z_ITEM = 2;
if (coordinateItems.size() == NUMBER_OF_COORDINATE_ITEMS) {
double x = replaceLastOccurrence('-', '.', coordinateItems[X_ITEM].trimmed()).toDouble();
double y = replaceLastOccurrence('-', '.', coordinateItems[Y_ITEM].trimmed()).toDouble();
double z = replaceLastOccurrence('-', '.', coordinateItems[Z_ITEM].trimmed()).toDouble();
glm::vec3 newAvatarPos(x, y, z);
MyAvatar* myAvatar = Application::getInstance()->getAvatar();
glm::vec3 avatarPos = myAvatar->getPosition();
if (newAvatarPos != avatarPos) {
// send a node kill request, indicating to other clients that they should play the "disappeared" effect
MyAvatar::sendKillAvatar();
qDebug("Going To Location: %f, %f, %f...", x, y, z);
myAvatar->setPosition(newAvatarPos);
}
} else {
// there's a username entered by the user, make a request to the data-server
DataServerClient::getValuesForKeysAndUserString(
QStringList()
<< DataServerKey::Domain
<< DataServerKey::Position
<< DataServerKey::Orientation,
destination, Application::getInstance()->getProfile());
}
}
sendFakeEnterEvent();
}
void Menu::goToLocation() {
MyAvatar* myAvatar = Application::getInstance()->getAvatar();
glm::vec3 avatarPos = myAvatar->getPosition();
@ -954,26 +1008,6 @@ void Menu::goToLocation() {
sendFakeEnterEvent();
}
void Menu::goToUser() {
QInputDialog userDialog(Application::getInstance()->getWindow());
userDialog.setWindowTitle("Go to User");
userDialog.setLabelText("Destination user:");
QString username = Application::getInstance()->getProfile()->getUsername();
userDialog.setTextValue(username);
userDialog.setWindowFlags(Qt::Sheet);
userDialog.resize(userDialog.parentWidget()->size().width() * DIALOG_RATIO_OF_WINDOW, userDialog.size().height());
int dialogReturn = userDialog.exec();
if (dialogReturn == QDialog::Accepted && !userDialog.textValue().isEmpty()) {
// there's a username entered by the user, make a request to the data-server
DataServerClient::getValuesForKeysAndUserString(
QStringList() << DataServerKey::Domain << DataServerKey::Position << DataServerKey::Orientation,
userDialog.textValue(), Application::getInstance()->getProfile());
}
sendFakeEnterEvent();
}
void Menu::pasteToVoxel() {
QInputDialog pasteToOctalCodeDialog(Application::getInstance()->getWindow());
pasteToOctalCodeDialog.setWindowTitle("Paste to Voxel");
@ -1137,3 +1171,14 @@ void Menu::updateFrustumRenderModeAction() {
}
}
QString Menu::replaceLastOccurrence(QChar search, QChar replace, QString string) {
int lastIndex;
lastIndex = string.lastIndexOf(search);
if (lastIndex > 0) {
lastIndex = string.lastIndexOf(search);
string.replace(lastIndex, 1, replace);
}
return string;
}

5
interface/src/Menu.h
View file

@ -92,7 +92,7 @@ public slots:
void saveSettings(QSettings* settings = NULL);
void importSettings();
void exportSettings();
void goToUser();
void goTo();
void pasteToVoxel();
private slots:
@ -152,6 +152,7 @@ private:
QAction* _useVoxelShader;
int _maxVoxelPacketsPerSecond;
QMenu* _activeScriptsMenu;
QString replaceLastOccurrence(QChar search, QChar replace, QString string);
};
namespace MenuOption {
@ -209,7 +210,7 @@ namespace MenuOption {
const QString GlowMode = "Cycle Glow Mode";
const QString GoToDomain = "Go To Domain...";
const QString GoToLocation = "Go To Location...";
const QString GoToUser = "Go To User...";
const QString GoTo = "Go To...";
const QString ImportVoxels = "Import Voxels";
const QString ImportVoxelsClipboard = "Import Voxels to Clipboard";
const QString IncreaseAvatarSize = "Increase Avatar Size";

18
interface/src/VoxelImporter.cpp
View file

@ -24,15 +24,15 @@ private:
const QString SETTINGS_GROUP_NAME = "VoxelImport";
const QString IMPORT_DIALOG_SETTINGS_KEY = "ImportDialogSettings";
VoxelImporter::VoxelImporter(QWidget* parent)
: QObject(parent),
_voxelTree(true),
_importDialog(parent),
_currentTask(NULL),
_nextTask(NULL) {
connect(&_importDialog, SIGNAL(currentChanged(QString)), SLOT(preImport()));
connect(&_importDialog, SIGNAL(accepted()), SLOT(import()));
VoxelImporter::VoxelImporter(QWidget* parent) :
QObject(parent),
_voxelTree(true),
_importDialog(parent),
_currentTask(NULL),
_nextTask(NULL)
{
connect(&_importDialog, &QFileDialog::currentChanged, this, &VoxelImporter::preImport);
connect(&_importDialog, &QFileDialog::accepted, this, &VoxelImporter::import);
}
void VoxelImporter::saveSettings(QSettings* settings) {

12
interface/src/avatar/AvatarManager.cpp
View file

@ -162,13 +162,13 @@ void AvatarManager::processAvatarMixerDatagram(const QByteArray& datagram, const
int bytesRead = numBytesForPacketHeader(datagram);
QByteArray dummyAvatarByteArray = byteArrayWithPopluatedHeader(PacketTypeAvatarData);
int numDummyByteArrayHeaderBytes = dummyAvatarByteArray.size();
int numDummyHeaderBytes = dummyAvatarByteArray.size();
int numDummyHeaderBytesWithoutUUID = numDummyHeaderBytes - NUM_BYTES_RFC4122_UUID;
// enumerate over all of the avatars in this packet
// only add them if mixerWeakPointer points to something (meaning that mixer is still around)
while (bytesRead < datagram.size() && mixerWeakPointer.data()) {
QUuid nodeUUID = QUuid::fromRfc4122(datagram.mid(bytesRead, NUM_BYTES_RFC4122_UUID));
// TODO: skip the data if nodeUUID is same as MY_AVATAR_KEY
AvatarSharedPointer matchingAvatar = _avatarHash.value(nodeUUID);
@ -189,15 +189,13 @@ void AvatarManager::processAvatarMixerDatagram(const QByteArray& datagram, const
}
// copy the rest of the packet to the avatarData holder so we can read the next Avatar from there
dummyAvatarByteArray.resize(numDummyByteArrayHeaderBytes);
dummyAvatarByteArray.resize(numDummyHeaderBytesWithoutUUID);
// make this Avatar's UUID the UUID in the packet and tack the remaining data onto the end
dummyAvatarByteArray.replace(numDummyByteArrayHeaderBytes - NUM_BYTES_RFC4122_UUID,
NUM_BYTES_RFC4122_UUID + datagram.size() - bytesRead,
datagram.mid(bytesRead));
dummyAvatarByteArray.append(datagram.mid(bytesRead));
// have the matching (or new) avatar parse the data from the packet
bytesRead += matchingAvatar->parseData(dummyAvatarByteArray);
bytesRead += matchingAvatar->parseData(dummyAvatarByteArray) - numDummyHeaderBytesWithoutUUID;
}
}

5
interface/src/avatar/Profile.cpp
View file

@ -53,7 +53,10 @@ void Profile::setUUID(const QUuid& uuid) {
// when the UUID is changed we need set it appropriately on the NodeList instance
NodeList::getInstance()->setOwnerUUID(uuid);
}
// ask for a window title update so the new UUID is presented
Application::getInstance()->updateWindowTitle();
}
}
void Profile::setFaceModelURL(const QUrl& faceModelURL) {

28
interface/src/renderer/FBXReader.cpp
View file

@ -170,6 +170,7 @@ public:
const QByteArray& getDatum() const { return _datum; }
void pushBackToken(int token) { _pushedBackToken = token; }
void ungetChar(char ch) { _device->ungetChar(ch); }
private:
@ -221,7 +222,7 @@ int Tokenizer::nextToken() {
_datum.append(ch);
while (_device->getChar(&ch)) {
if (QChar(ch).isSpace() || ch == ';' || ch == ':' || ch == '{' || ch == '}' || ch == ',' || ch == '\"') {
_device->ungetChar(ch); // read until we encounter a special character, then replace it
ungetChar(ch); // read until we encounter a special character, then replace it
break;
}
_datum.append(ch);
@ -257,9 +258,17 @@ FBXNode parseTextFBXNode(Tokenizer& tokenizer) {
expectingDatum = true;
} else if (token == Tokenizer::DATUM_TOKEN && expectingDatum) {
node.properties.append(tokenizer.getDatum());
expectingDatum = false;
QByteArray datum = tokenizer.getDatum();
if ((token = tokenizer.nextToken()) == ':') {
tokenizer.ungetChar(':');
tokenizer.pushBackToken(Tokenizer::DATUM_TOKEN);
return node;
} else {
tokenizer.pushBackToken(token);
node.properties.append(datum);
expectingDatum = false;
}
} else {
tokenizer.pushBackToken(token);
return node;
@ -377,6 +386,9 @@ glm::mat4 createMat4(const QVector<double>& doubleVector) {
}
QVector<int> getIntVector(const QVariantList& properties, int index) {
if (index >= properties.size()) {
return QVector<int>();
}
QVector<int> vector = properties.at(index).value<QVector<int> >();
if (!vector.isEmpty()) {
return vector;
@ -388,6 +400,9 @@ QVector<int> getIntVector(const QVariantList& properties, int index) {
}
QVector<double> getDoubleVector(const QVariantList& properties, int index) {
if (index >= properties.size()) {
return QVector<double>();
}
QVector<double> vector = properties.at(index).value<QVector<double> >();
if (!vector.isEmpty()) {
return vector;
@ -1106,6 +1121,11 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping)
QVector<QString> modelIDs;
QSet<QString> remainingModels;
for (QHash<QString, FBXModel>::const_iterator model = models.constBegin(); model != models.constEnd(); model++) {
// make sure the parent is in the child map
QString parent = parentMap.value(model.key());
if (!childMap.contains(parent, model.key())) {
childMap.insert(parent, model.key());
}
remainingModels.insert(model.key());
}
while (!remainingModels.isEmpty()) {

117
libraries/avatars/src/AvatarData.cpp
View file

@ -172,105 +172,102 @@ int AvatarData::parseData(const QByteArray& packet) {
_handData = new HandData(this);
}
QDataStream packetStream(packet);
packetStream.skipRawData(numBytesForPacketHeader(packet));
// increment to push past the packet header
const unsigned char* startPosition = reinterpret_cast<const unsigned char*>(packet.data());
const unsigned char* sourceBuffer = startPosition + numBytesForPacketHeader(packet);
packetStream.readRawData(reinterpret_cast<char*>(&_position), sizeof(_position));
// Body world position
memcpy(&_position, sourceBuffer, sizeof(float) * 3);
sourceBuffer += sizeof(float) * 3;
// Body rotation (NOTE: This needs to become a quaternion to save two bytes)
uint16_t twoByteHolder;
packetStream >> twoByteHolder;
unpackFloatAngleFromTwoByte(&twoByteHolder, &_bodyYaw);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_bodyYaw);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_bodyPitch);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_bodyRoll);
packetStream >> twoByteHolder;
unpackFloatAngleFromTwoByte(&twoByteHolder, &_bodyPitch);
// Body scale
sourceBuffer += unpackFloatRatioFromTwoByte(sourceBuffer, _targetScale);
packetStream >> twoByteHolder;
unpackFloatAngleFromTwoByte(&twoByteHolder, &_bodyRoll);
// body scale
packetStream >> twoByteHolder;
unpackFloatRatioFromTwoByte(reinterpret_cast<const unsigned char*>(&twoByteHolder), _targetScale);
// Head rotation (NOTE: This needs to become a quaternion to save two bytes)
float headYaw, headPitch, headRoll;
packetStream >> twoByteHolder;
unpackFloatAngleFromTwoByte(&twoByteHolder, &headYaw);
packetStream >> twoByteHolder;
unpackFloatAngleFromTwoByte(&twoByteHolder, &headPitch);
packetStream >> twoByteHolder;
unpackFloatAngleFromTwoByte(&twoByteHolder, &headRoll);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &headYaw);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &headPitch);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &headRoll);
_headData->setYaw(headYaw);
_headData->setPitch(headPitch);
_headData->setRoll(headRoll);
// Head position relative to pelvis
packetStream >> _headData->_leanSideways;
packetStream >> _headData->_leanForward;
memcpy(&_headData->_leanSideways, sourceBuffer, sizeof(_headData->_leanSideways));
sourceBuffer += sizeof(float);
memcpy(&_headData->_leanForward, sourceBuffer, sizeof(_headData->_leanForward));
sourceBuffer += sizeof(_headData->_leanForward);
// Hand Position - is relative to body position
glm::vec3 handPositionRelative;
packetStream.readRawData(reinterpret_cast<char*>(&handPositionRelative), sizeof(handPositionRelative));
memcpy(&handPositionRelative, sourceBuffer, sizeof(float) * 3);
_handPosition = _position + handPositionRelative;
sourceBuffer += sizeof(float) * 3;
// Lookat Position
memcpy(&_headData->_lookAtPosition, sourceBuffer, sizeof(_headData->_lookAtPosition));
sourceBuffer += sizeof(_headData->_lookAtPosition);
packetStream.readRawData(reinterpret_cast<char*>(&_headData->_lookAtPosition), sizeof(_headData->_lookAtPosition));
// Instantaneous audio loudness (used to drive facial animation)
//sourceBuffer += unpackFloatFromByte(sourceBuffer, _audioLoudness, MAX_AUDIO_LOUDNESS);
packetStream >> _headData->_audioLoudness;
// the rest is a chat message
memcpy(&_headData->_audioLoudness, sourceBuffer, sizeof(float));
sourceBuffer += sizeof(float);
// the rest is a chat message
int chatMessageSize = *sourceBuffer++;
_chatMessage = string((char*)sourceBuffer, chatMessageSize);
sourceBuffer += chatMessageSize * sizeof(char);
quint8 chatMessageSize;
packetStream >> chatMessageSize;
_chatMessage = string(packet.data() + packetStream.device()->pos(), chatMessageSize);
packetStream.skipRawData(chatMessageSize);
// voxel sending features...
unsigned char bitItems = 0;
packetStream >> bitItems;
bitItems = (unsigned char)*sourceBuffer++;
// key state, stored as a semi-nibble in the bitItems
_keyState = (KeyState)getSemiNibbleAt(bitItems,KEY_STATE_START_BIT);
// hand state, stored as a semi-nibble in the bitItems
_handState = getSemiNibbleAt(bitItems,HAND_STATE_START_BIT);
_headData->_isFaceshiftConnected = oneAtBit(bitItems, IS_FACESHIFT_CONNECTED);
_isChatCirclingEnabled = oneAtBit(bitItems, IS_CHAT_CIRCLING_ENABLED);
// If it is connected, pack up the data
if (_headData->_isFaceshiftConnected) {
packetStream >> _headData->_leftEyeBlink;
packetStream >> _headData->_rightEyeBlink;
packetStream >> _headData->_averageLoudness;
packetStream >> _headData->_browAudioLift;
memcpy(&_headData->_leftEyeBlink, sourceBuffer, sizeof(float));
sourceBuffer += sizeof(float);
quint8 numBlendshapeCoefficients;
packetStream >> numBlendshapeCoefficients;
memcpy(&_headData->_rightEyeBlink, sourceBuffer, sizeof(float));
sourceBuffer += sizeof(float);
_headData->_blendshapeCoefficients.resize(numBlendshapeCoefficients);
packetStream.readRawData(reinterpret_cast<char*>(_headData->_blendshapeCoefficients.data()),
numBlendshapeCoefficients * sizeof(float));
memcpy(&_headData->_averageLoudness, sourceBuffer, sizeof(float));
sourceBuffer += sizeof(float);
memcpy(&_headData->_browAudioLift, sourceBuffer, sizeof(float));
sourceBuffer += sizeof(float);
_headData->_blendshapeCoefficients.resize(*sourceBuffer++);
memcpy(_headData->_blendshapeCoefficients.data(), sourceBuffer,
_headData->_blendshapeCoefficients.size() * sizeof(float));
sourceBuffer += _headData->_blendshapeCoefficients.size() * sizeof(float);
}
// pupil dilation
quint8 pupilByte;
packetStream >> pupilByte;
unpackFloatFromByte(&pupilByte, _headData->_pupilDilation, 1.0f);
sourceBuffer += unpackFloatFromByte(sourceBuffer, _headData->_pupilDilation, 1.0f);
// leap hand data
if (packetStream.device()->pos() < packet.size()) {
if (sourceBuffer - startPosition < packet.size()) {
// check passed, bytes match
packetStream.skipRawData(_handData->decodeRemoteData(packet.mid(packetStream.device()->pos())));
sourceBuffer += _handData->decodeRemoteData(packet.mid(sourceBuffer - startPosition));
}
return packetStream.device()->pos();
return sourceBuffer - startPosition;
}
void AvatarData::setClampedTargetScale(float targetScale) {

47
libraries/avatars/src/HandData.cpp
View file

@ -160,31 +160,21 @@ int HandData::encodeRemoteData(unsigned char* destinationBuffer) {
}
int HandData::decodeRemoteData(const QByteArray& dataByteArray) {
QDataStream packetStream(dataByteArray);
quint8 numHands;
packetStream >> numHands;
const unsigned char* startPosition;
const unsigned char* sourceBuffer = startPosition = reinterpret_cast<const unsigned char*>(dataByteArray.data());
unsigned int numHands = *sourceBuffer++;
for (unsigned int handIndex = 0; handIndex < numHands; ++handIndex) {
if (handIndex >= getNumPalms())
addNewPalm();
PalmData& palm = getPalms()[handIndex];
glm::vec3 handPosition;
glm::vec3 handNormal;
qint16 twoByteHolder;
sourceBuffer += unpackFloatVec3FromSignedTwoByteFixed(sourceBuffer, handPosition, fingerVectorRadix);
sourceBuffer += unpackFloatVec3FromSignedTwoByteFixed(sourceBuffer, handNormal, fingerVectorRadix);
unsigned int numFingers = *sourceBuffer++;
packetStream >> twoByteHolder;
unpackFloatVec3FromSignedTwoByteFixed(reinterpret_cast<const unsigned char*>(&twoByteHolder),
handPosition, fingerVectorRadix);
packetStream >> twoByteHolder;
unpackFloatVec3FromSignedTwoByteFixed(reinterpret_cast<const unsigned char*>(&twoByteHolder),
handNormal, fingerVectorRadix);
quint8 numFingers;
packetStream >> numFingers;
palm.setRawPosition(handPosition);
palm.setRawNormal(handNormal);
palm.setActive(true);
@ -195,18 +185,12 @@ int HandData::decodeRemoteData(const QByteArray& dataByteArray) {
for (unsigned int fingerIndex = 0; fingerIndex < numFingers; ++fingerIndex) {
if (fingerIndex < palm.getNumFingers()) {
FingerData& finger = palm.getFingers()[fingerIndex];
glm::vec3 tipPosition;
glm::vec3 rootPosition;
sourceBuffer += unpackFloatVec3FromSignedTwoByteFixed(sourceBuffer, tipPosition, fingerVectorRadix);
sourceBuffer += unpackFloatVec3FromSignedTwoByteFixed(sourceBuffer, rootPosition, fingerVectorRadix);
packetStream >> twoByteHolder;
unpackFloatVec3FromSignedTwoByteFixed(reinterpret_cast<const unsigned char*>(&twoByteHolder), tipPosition,
fingerVectorRadix);
packetStream >> twoByteHolder;
unpackFloatVec3FromSignedTwoByteFixed(reinterpret_cast<const unsigned char*>(&twoByteHolder), rootPosition,
fingerVectorRadix);
finger.setRawTipPosition(tipPosition);
finger.setRawRootPosition(rootPosition);
finger.setActive(true);
@ -225,14 +209,11 @@ int HandData::decodeRemoteData(const QByteArray& dataByteArray) {
}
// One byte for error checking safety.
unsigned char requiredLength = packetStream.device()->pos();
unsigned char checkLength;
packetStream >> checkLength;
unsigned char requiredLength = (unsigned char)(sourceBuffer - startPosition);
unsigned char checkLength = *sourceBuffer++;
assert(checkLength == requiredLength);
return packetStream.device()->pos();
return sourceBuffer - startPosition;
}
void HandData::setFingerTrailLength(unsigned int length) {

7
libraries/embedded-webserver/src/HTTPManager.cpp
View file

@ -63,7 +63,7 @@ bool HTTPManager::handleHTTPRequest(HTTPConnection* connection, const QString& p
QFile localFile(filePath);
localFile.open(QIODevice::ReadOnly);
QString localFileString(localFile.readAll());
QByteArray localFileData = localFile.readAll();
QFileInfo localFileInfo(filePath);
@ -77,6 +77,7 @@ bool HTTPManager::handleHTTPRequest(HTTPConnection* connection, const QString& p
int matchPosition = 0;
QString localFileString(localFileData);
while ((matchPosition = includeRegExp.indexIn(localFileString, matchPosition)) != -1) {
// check if this is a file or vitual include
@ -105,9 +106,11 @@ bool HTTPManager::handleHTTPRequest(HTTPConnection* connection, const QString& p
// push the match position forward so we can check the next match
matchPosition += includeRegExp.matchedLength();
}
localFileData = localFileString.toLocal8Bit();
}
connection->respond(HTTPConnection::StatusCode200, localFileString.toLocal8Bit(),
connection->respond(HTTPConnection::StatusCode200, localFileData,
qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
} else {

2
libraries/octree-server/src/OctreeServer.cpp
View file

@ -433,7 +433,7 @@ void OctreeServer::setArguments(int argc, char** argv) {
void OctreeServer::parsePayload() {
if (getPayload().size() > 0) {
QString config((const char*) _payload);
QString config(_payload);
// Now, parse the config
QStringList configList = config.split(" ");

3
libraries/octree/src/JurisdictionListener.cpp
View file

@ -45,8 +45,7 @@ bool JurisdictionListener::queueJurisdictionRequest() {
NodeList* nodeList = NodeList::getInstance();
foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
if (nodeList->getNodeActiveSocketOrPing(node.data()) &&
node->getType() == getNodeType()) {
if (nodeList->getNodeActiveSocketOrPing(node.data()) && node->getType() == getNodeType()) {
const HifiSockAddr* nodeAddress = node->getActiveSocket();
_packetSender.queuePacketForSending(*nodeAddress, QByteArray(reinterpret_cast<char*>(bufferOut), sizeOut));
nodeCount++;

2
libraries/octree/src/JurisdictionSender.cpp
View file

@ -64,7 +64,7 @@ bool JurisdictionSender::process() {
_nodesRequestingJurisdictions.pop();
SharedNodePointer node = NodeList::getInstance()->nodeWithUUID(nodeUUID);
if (node->getActiveSocket() != NULL) {
if (node && node->getActiveSocket() != NULL) {
const HifiSockAddr* nodeAddress = node->getActiveSocket();
_packetSender.queuePacketForSending(*nodeAddress, QByteArray(reinterpret_cast<char *>(bufferOut), sizeOut));
nodeCount++;

13
libraries/octree/src/OctreeQuery.cpp
View file

@ -24,7 +24,6 @@ static const float fingerVectorRadix = 4; // bits of precision when converting f
OctreeQuery::OctreeQuery() :
NodeData(),
_uuid(),
_cameraPosition(0,0,0),
_cameraOrientation(),
_cameraFov(0.0f),
@ -53,11 +52,6 @@ int OctreeQuery::getBroadcastData(unsigned char* destinationBuffer) {
// that can pack any type given the number of bytes
// and return the number of bytes to push the pointer
// UUID
QByteArray uuidByteArray = _uuid.toRfc4122();
memcpy(destinationBuffer, uuidByteArray.constData(), uuidByteArray.size());
destinationBuffer += uuidByteArray.size();
// camera details
memcpy(destinationBuffer, &_cameraPosition, sizeof(_cameraPosition));
destinationBuffer += sizeof(_cameraPosition);
@ -103,13 +97,6 @@ int OctreeQuery::parseData(const QByteArray& packet) {
const unsigned char* startPosition = reinterpret_cast<const unsigned char*>(packet.data());
const unsigned char* sourceBuffer = startPosition + numBytesPacketHeader;
// push past the node session UUID
sourceBuffer += NUM_BYTES_RFC4122_UUID;
// user UUID
_uuid = QUuid::fromRfc4122(QByteArray((char*) sourceBuffer, NUM_BYTES_RFC4122_UUID));
sourceBuffer += NUM_BYTES_RFC4122_UUID;
// camera details
memcpy(&_cameraPosition, sourceBuffer, sizeof(_cameraPosition));
sourceBuffer += sizeof(_cameraPosition);

5
libraries/octree/src/OctreeQuery.h
View file

@ -57,9 +57,6 @@ public:
int getBroadcastData(unsigned char* destinationBuffer);
int parseData(const QByteArray& packet);
QUuid& getUUID() { return _uuid; }
void setUUID(const QUuid& uuid) { _uuid = uuid; }
// getters for camera details
const glm::vec3& getCameraPosition() const { return _cameraPosition; }
const glm::quat& getCameraOrientation() const { return _cameraOrientation; }
@ -101,8 +98,6 @@ public slots:
void setBoundaryLevelAdjust(int boundaryLevelAdjust) { _boundaryLevelAdjust = boundaryLevelAdjust; }
protected:
QUuid _uuid;
// camera details for the avatar
glm::vec3 _cameraPosition;
glm::quat _cameraOrientation;

120
libraries/particles/src/Particle.cpp
View file

@ -13,6 +13,8 @@
#include <RegisteredMetaTypes.h>
#include <SharedUtil.h> // usecTimestampNow()
#include <VoxelsScriptingInterface.h>
#include <VoxelDetail.h>
// This is not ideal, but adding script-engine as a linked library, will cause a circular reference
// I'm open to other potential solutions. Could we change cmake to allow libraries to reference each others
@ -830,7 +832,7 @@ void Particle::update(const quint64& now) {
bool shouldDie = (getAge() > getLifetime()) || getShouldDie() || (!isInHand && isStopped && isReallyOld);
setShouldDie(shouldDie);
runUpdateScript(); // allow the javascript to alter our state
executeUpdateScripts(); // allow the javascript to alter our state
// If the ball is in hand, it doesn't move or have gravity effect it
if (!isInHand) {
@ -852,106 +854,62 @@ void Particle::update(const quint64& now) {
}
}
void Particle::runUpdateScript() {
void Particle::startParticleScriptContext(ScriptEngine& engine, ParticleScriptObject& particleScriptable) {
if (_voxelEditSender) {
engine.getVoxelsScriptingInterface()->setPacketSender(_voxelEditSender);
}
if (_particleEditSender) {
engine.getParticlesScriptingInterface()->setPacketSender(_particleEditSender);
}
// Add the "this" Particle object
engine.registerGlobalObject("Particle", &particleScriptable);
engine.evaluate();
}
void Particle::endParticleScriptContext(ScriptEngine& engine, ParticleScriptObject& particleScriptable) {
if (_voxelEditSender) {
_voxelEditSender->releaseQueuedMessages();
}
if (_particleEditSender) {
_particleEditSender->releaseQueuedMessages();
}
}
void Particle::executeUpdateScripts() {
// Only run this particle script if there's a script attached directly to the particle.
if (!_script.isEmpty()) {
ScriptEngine engine(_script); // no menu or controller interface...
if (_voxelEditSender) {
engine.getVoxelsScriptingInterface()->setPacketSender(_voxelEditSender);
}
if (_particleEditSender) {
engine.getParticlesScriptingInterface()->setPacketSender(_particleEditSender);
}
// Add the Particle object
ScriptEngine engine(_script);
ParticleScriptObject particleScriptable(this);
engine.registerGlobalObject("Particle", &particleScriptable);
// init and evaluate the script, but return so we can emit the collision
engine.evaluate();
startParticleScriptContext(engine, particleScriptable);
particleScriptable.emitUpdate();
// it seems like we may need to send out particle edits if the state of our particle was changed.
if (_voxelEditSender) {
_voxelEditSender->releaseQueuedMessages();
}
if (_particleEditSender) {
_particleEditSender->releaseQueuedMessages();
}
endParticleScriptContext(engine, particleScriptable);
}
}
void Particle::collisionWithParticle(Particle* other) {
// Only run this particle script if there's a script attached directly to the particle.
if (!_script.isEmpty()) {
ScriptEngine engine(_script); // no menu or controller interface...
if (_voxelEditSender) {
engine.getVoxelsScriptingInterface()->setPacketSender(_voxelEditSender);
}
if (_particleEditSender) {
engine.getParticlesScriptingInterface()->setPacketSender(_particleEditSender);
}
// Add the Particle object
ScriptEngine engine(_script);
ParticleScriptObject particleScriptable(this);
engine.registerGlobalObject("Particle", &particleScriptable);
// init and evaluate the script, but return so we can emit the collision
engine.evaluate();
startParticleScriptContext(engine, particleScriptable);
ParticleScriptObject otherParticleScriptable(other);
particleScriptable.emitCollisionWithParticle(&otherParticleScriptable);
// it seems like we may need to send out particle edits if the state of our particle was changed.
if (_voxelEditSender) {
_voxelEditSender->releaseQueuedMessages();
}
if (_particleEditSender) {
_particleEditSender->releaseQueuedMessages();
}
endParticleScriptContext(engine, particleScriptable);
}
}
void Particle::collisionWithVoxel(VoxelDetail* voxelDetails) {
// Only run this particle script if there's a script attached directly to the particle.
if (!_script.isEmpty()) {
ScriptEngine engine(_script); // no menu or controller interface...
// setup the packet senders and jurisdiction listeners of the script engine's scripting interfaces so
// we can use the same ones as our context.
if (_voxelEditSender) {
engine.getVoxelsScriptingInterface()->setPacketSender(_voxelEditSender);
}
if (_particleEditSender) {
engine.getParticlesScriptingInterface()->setPacketSender(_particleEditSender);
}
// Add the Particle object
ScriptEngine engine(_script);
ParticleScriptObject particleScriptable(this);
engine.registerGlobalObject("Particle", &particleScriptable);
// init and evaluate the script, but return so we can emit the collision
engine.evaluate();
VoxelDetailScriptObject voxelDetailsScriptable(voxelDetails);
particleScriptable.emitCollisionWithVoxel(&voxelDetailsScriptable);
// it seems like we may need to send out particle edits if the state of our particle was changed.
if (_voxelEditSender) {
_voxelEditSender->releaseQueuedMessages();
}
if (_particleEditSender) {
_particleEditSender->releaseQueuedMessages();
}
startParticleScriptContext(engine, particleScriptable);
particleScriptable.emitCollisionWithVoxel(*voxelDetails);
endParticleScriptContext(engine, particleScriptable);
}
}
void Particle::setAge(float age) {
quint64 ageInUsecs = age * USECS_PER_SECOND;
_created = usecTimestampNow() - ageInUsecs;

27
libraries/particles/src/Particle.h
View file

@ -20,13 +20,16 @@
#include <SharedUtil.h>
#include <OctreePacketData.h>
class VoxelsScriptingInterface;
class ParticlesScriptingInterface;
class VoxelEditPacketSender;
class Particle;
class ParticleEditPacketSender;
class ParticleProperties;
class Particle;
class ParticlesScriptingInterface;
class ParticleScriptObject;
class ParticleTree;
class ScriptEngine;
class VoxelEditPacketSender;
class VoxelsScriptingInterface;
struct VoxelDetail;
const uint32_t NEW_PARTICLE = 0xFFFFFFFF;
const uint32_t UNKNOWN_TOKEN = 0xFFFFFFFF;
@ -227,7 +230,8 @@ public:
const glm::vec3& getModelTranslation() const { return _modelTranslation; }
const glm::quat& getModelRotation() const { return _modelRotation; }
float getModelScale() const { return _modelScale; }
ParticleID getParticleID() const { return ParticleID(getID(), getCreatorTokenID(), getID() != UNKNOWN_PARTICLE_ID); }
ParticleProperties getProperties() const;
/// The last updated/simulated time of this particle from the time perspective of the authoritative server/source
@ -318,11 +322,9 @@ protected:
static VoxelEditPacketSender* _voxelEditSender;
static ParticleEditPacketSender* _particleEditSender;
void runUpdateScript();
static QScriptValue vec3toScriptValue(QScriptEngine *engine, const glm::vec3 &vec3);
static void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3);
static QScriptValue xColorToScriptValue(QScriptEngine *engine, const xColor& color);
static void xColorFromScriptValue(const QScriptValue &object, xColor& color);
void startParticleScriptContext(ScriptEngine& engine, ParticleScriptObject& particleScriptable);
void endParticleScriptContext(ScriptEngine& engine, ParticleScriptObject& particleScriptable);
void executeUpdateScripts();
void setAge(float age);
@ -366,10 +368,11 @@ class ParticleScriptObject : public QObject {
Q_OBJECT
public:
ParticleScriptObject(Particle* particle) { _particle = particle; }
//~ParticleScriptObject() { qDebug() << "~ParticleScriptObject() this=" << this; }
void emitUpdate() { emit update(); }
void emitCollisionWithParticle(QObject* other) { emit collisionWithParticle(other); }
void emitCollisionWithVoxel(QObject* voxel) { emit collisionWithVoxel(voxel); }
void emitCollisionWithVoxel(const VoxelDetail& voxel) { emit collisionWithVoxel(voxel); }
public slots:
unsigned int getID() const { return _particle->getID(); }
@ -414,7 +417,7 @@ public slots:
signals:
void update();
void collisionWithVoxel(QObject* voxel);
void collisionWithVoxel(const VoxelDetail& voxel);
void collisionWithParticle(QObject* other);
private:

15
libraries/particles/src/ParticleCollisionSystem.cpp
View file

@ -68,6 +68,17 @@ void ParticleCollisionSystem::checkParticle(Particle* particle) {
updateCollisionWithAvatars(particle);
}
void ParticleCollisionSystem::emitGlobalParicleCollisionWithVoxel(Particle* particle, VoxelDetail* voxelDetails) {
ParticleID particleID = particle->getParticleID();
emit particleCollisionWithVoxel(particleID, *voxelDetails);
}
void ParticleCollisionSystem::emitGlobalParicleCollisionWithParticle(Particle* particleA, Particle* particleB) {
ParticleID idA = particleA->getParticleID();
ParticleID idB = particleB->getParticleID();
emit particleCollisionWithParticle(idA, idB);
}
void ParticleCollisionSystem::updateCollisionWithVoxels(Particle* particle) {
glm::vec3 center = particle->getPosition() * (float)(TREE_SCALE);
float radius = particle->getRadius() * (float)(TREE_SCALE);
@ -83,6 +94,9 @@ void ParticleCollisionSystem::updateCollisionWithVoxels(Particle* particle) {
// let the particles run their collision scripts if they have them
particle->collisionWithVoxel(voxelDetails);
// let the global script run their collision scripts for particles if they have them
emitGlobalParicleCollisionWithVoxel(particle, voxelDetails);
updateCollisionSound(particle, collisionInfo._penetration, COLLISION_FREQUENCY);
collisionInfo._penetration /= (float)(TREE_SCALE);
particle->applyHardCollision(collisionInfo);
@ -110,6 +124,7 @@ void ParticleCollisionSystem::updateCollisionWithParticles(Particle* particleA)
if (glm::dot(relativeVelocity, penetration) > 0.0f) {
particleA->collisionWithParticle(particleB);
particleB->collisionWithParticle(particleA);
emitGlobalParicleCollisionWithParticle(particleA, particleB);
glm::vec3 axis = glm::normalize(penetration);
glm::vec3 axialVelocity = glm::dot(relativeVelocity, axis) * axis;

10
libraries/particles/src/ParticleCollisionSystem.h
View file

@ -31,7 +31,8 @@ class VoxelTree;
const glm::vec3 NO_ADDED_VELOCITY = glm::vec3(0);
class ParticleCollisionSystem {
class ParticleCollisionSystem : public QObject {
Q_OBJECT
public:
ParticleCollisionSystem(ParticleEditPacketSender* packetSender = NULL, ParticleTree* particles = NULL,
VoxelTree* voxels = NULL, AbstractAudioInterface* audio = NULL,
@ -51,9 +52,14 @@ public:
void queueParticlePropertiesUpdate(Particle* particle);
void updateCollisionSound(Particle* particle, const glm::vec3 &penetration, float frequency);
signals:
void particleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel);
void particleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB);
private:
static bool updateOperation(OctreeElement* element, void* extraData);
void emitGlobalParicleCollisionWithVoxel(Particle* particle, VoxelDetail* voxelDetails);
void emitGlobalParicleCollisionWithParticle(Particle* particleA, Particle* particleB);
ParticleEditPacketSender* _packetSender;
ParticleTree* _particles;

1
libraries/particles/src/ParticleTree.cpp
View file

@ -190,7 +190,6 @@ void ParticleTree::handleAddParticleResponse(const QByteArray& packet) {
int numBytesPacketHeader = numBytesForPacketHeader(packet);
const unsigned char* dataAt = reinterpret_cast<const unsigned char*>(packet.data()) + numBytesPacketHeader;
dataAt += numBytesPacketHeader;
uint32_t creatorTokenID;
memcpy(&creatorTokenID, dataAt, sizeof(creatorTokenID));

12
libraries/particles/src/ParticlesScriptingInterface.h
View file

@ -53,7 +53,19 @@ public slots:
/// finds particles within the search sphere specified by the center point and radius
/// this function will not find any particles in script engine contexts which don't have access to particles
QVector<ParticleID> findParticles(const glm::vec3& center, float radius) const;
/// inbound slots for external collision systems
void forwardParticleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel) {
emit particleCollisionWithVoxel(particleID, voxel);
}
void forwardParticleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB) {
emit particleCollisionWithParticle(idA, idB);
}
signals:
void particleCollisionWithVoxel(const ParticleID& particleID, const VoxelDetail& voxel);
void particleCollisionWithParticle(const ParticleID& idA, const ParticleID& idB);
private:
void queueParticleMessage(PacketType packetType, ParticleID particleID, const ParticleProperties& properties);

155
libraries/script-engine/src/EventTypes.cpp
View file

@ -8,22 +8,72 @@
// Used to register meta-types with Qt for very various event types so that they can be exposed to our
// scripting engine
#include <QDebug>
#include "EventTypes.h"
KeyEvent::KeyEvent() {
key = 0;
text = QString("");
isShifted = false;
isMeta = false;
isControl = false;
isValid = false;
}
KeyEvent::KeyEvent(const QKeyEvent& event) {
key = event.key();
text = event.text();
isShifted = event.modifiers().testFlag(Qt::ShiftModifier);
isMeta = event.modifiers().testFlag(Qt::ControlModifier);
isMeta = event.modifiers().testFlag(Qt::MetaModifier);
isControl = event.modifiers().testFlag(Qt::ControlModifier);
isAlt = event.modifiers().testFlag(Qt::AltModifier);
isKeypad = event.modifiers().testFlag(Qt::KeypadModifier);
isValid = true;
// handle special text for special characters...
if (key == Qt::Key_F1) {
text = "F1";
} else if (key == Qt::Key_F2) {
text = "F2";
} else if (key == Qt::Key_F3) {
text = "F3";
} else if (key == Qt::Key_F4) {
text = "F4";
} else if (key == Qt::Key_F5) {
text = "F5";
} else if (key == Qt::Key_F6) {
text = "F6";
} else if (key == Qt::Key_F7) {
text = "F7";
} else if (key == Qt::Key_F8) {
text = "F8";
} else if (key == Qt::Key_F9) {
text = "F9";
} else if (key == Qt::Key_F10) {
text = "F10";
} else if (key == Qt::Key_F11) {
text = "F11";
} else if (key == Qt::Key_F12) {
text = "F12";
} else if (key == Qt::Key_Up) {
text = "UP";
} else if (key == Qt::Key_Down) {
text = "DOWN";
} else if (key == Qt::Key_Left) {
text = "LEFT";
} else if (key == Qt::Key_Right) {
text = "RIGHT";
} else if (key == Qt::Key_Escape) {
text = "ESC";
} else if (key == Qt::Key_Tab) {
text = "TAB";
} else if (key == Qt::Key_Delete) {
text = "DELETE";
} else if (key == Qt::Key_Backspace) {
text = "BACKSPACE";
}
}
MouseEvent::MouseEvent(const QMouseEvent& event) {
@ -65,16 +115,113 @@ void registerEventTypes(QScriptEngine* engine) {
QScriptValue keyEventToScriptValue(QScriptEngine* engine, const KeyEvent& event) {
QScriptValue obj = engine->newObject();
obj.setProperty("key", event.key);
obj.setProperty("text", event.text);
obj.setProperty("isShifted", event.isShifted);
obj.setProperty("isMeta", event.isMeta);
obj.setProperty("isControl", event.isControl);
obj.setProperty("isAlt", event.isAlt);
obj.setProperty("isKeypad", event.isKeypad);
return obj;
}
void keyEventFromScriptValue(const QScriptValue &object, KeyEvent& event) {
event.key = object.property("key").toVariant().toInt();
event.isShifted = object.property("isShifted").toVariant().toBool();
event.isValid = false; // assume the worst
event.isMeta = object.property("isMeta").toVariant().toBool();
event.isValid = object.property("key").isValid();
event.isControl = object.property("isControl").toVariant().toBool();
event.isAlt = object.property("isAlt").toVariant().toBool();
event.isKeypad = object.property("isKeypad").toVariant().toBool();
QScriptValue key = object.property("key");
if (key.isValid()) {
event.key = key.toVariant().toInt();
event.text = QString(QChar(event.key));
event.isValid = true;
} else {
QScriptValue text = object.property("text");
if (text.isValid()) {
event.text = object.property("text").toVariant().toString();
// if the text is a special command, then map it here...
// TODO: come up with more elegant solution here, a map? is there a Qt function that gives nice names for keys?
if (event.text.toUpper() == "F1") {
event.key = Qt::Key_F1;
} else if (event.text.toUpper() == "F2") {
event.key = Qt::Key_F2;
} else if (event.text.toUpper() == "F3") {
event.key = Qt::Key_F3;
} else if (event.text.toUpper() == "F4") {
event.key = Qt::Key_F4;
} else if (event.text.toUpper() == "F5") {
event.key = Qt::Key_F5;
} else if (event.text.toUpper() == "F6") {
event.key = Qt::Key_F6;
} else if (event.text.toUpper() == "F7") {
event.key = Qt::Key_F7;
} else if (event.text.toUpper() == "F8") {
event.key = Qt::Key_F8;
} else if (event.text.toUpper() == "F9") {
event.key = Qt::Key_F9;
} else if (event.text.toUpper() == "F10") {
event.key = Qt::Key_F10;
} else if (event.text.toUpper() == "F11") {
event.key = Qt::Key_F11;
} else if (event.text.toUpper() == "F12") {
event.key = Qt::Key_F12;
} else if (event.text.toUpper() == "UP") {
event.key = Qt::Key_Up;
event.isKeypad = true;
} else if (event.text.toUpper() == "DOWN") {
event.key = Qt::Key_Down;
event.isKeypad = true;
} else if (event.text.toUpper() == "LEFT") {
event.key = Qt::Key_Left;
event.isKeypad = true;
} else if (event.text.toUpper() == "RIGHT") {
event.key = Qt::Key_Right;
event.isKeypad = true;
} else if (event.text.toUpper() == "ESC") {
event.key = Qt::Key_Escape;
} else if (event.text.toUpper() == "TAB") {
event.key = Qt::Key_Tab;
} else if (event.text.toUpper() == "DELETE") {
event.key = Qt::Key_Delete;
} else if (event.text.toUpper() == "BACKSPACE") {
event.key = Qt::Key_Backspace;
} else {
event.key = event.text.at(0).unicode();
}
event.isValid = true;
}
}
QScriptValue isShifted = object.property("isShifted");
if (isShifted.isValid()) {
event.isShifted = isShifted.toVariant().toBool();
} else {
// if no isShifted was included, get it from the text
QChar character = event.text.at(0);
if (character.isLetter() && character.isUpper()) {
event.isShifted = true;
} else {
// if it's a symbol, then attempt to detect shifted-ness
if (QString("~!@#$%^&*()_+{}|:\"<>?").contains(character)) {
event.isShifted = true;
}
}
}
const bool wantDebug = false;
if (wantDebug) {
qDebug() << "event.key=" << event.key
<< " event.text=" << event.text
<< " event.isShifted=" << event.isShifted
<< " event.isControl=" << event.isControl
<< " event.isMeta=" << event.isMeta
<< " event.isAlt=" << event.isAlt
<< " event.isKeypad=" << event.isKeypad;
}
}
QScriptValue mouseEventToScriptValue(QScriptEngine* engine, const MouseEvent& event) {

11
libraries/script-engine/src/EventTypes.h
View file

@ -24,10 +24,19 @@ public:
KeyEvent();
KeyEvent(const QKeyEvent& event);
inline bool operator==(const KeyEvent& other) const {
return other.key == key && other.isShifted == isShifted && other.isMeta == isMeta; }
return other.key == key
&& other.isShifted == isShifted
&& other.isControl == isControl
&& other.isMeta == isMeta
&& other.isAlt == isAlt
&& other.isKeypad == isKeypad; }
int key;
QString text;
bool isShifted;
bool isControl;
bool isMeta;
bool isAlt;
bool isKeypad;
bool isValid;
};

10
libraries/script-engine/src/ScriptEngine.cpp
View file

@ -19,6 +19,7 @@
#include <PacketHeaders.h>
#include <UUID.h>
#include <VoxelConstants.h>
#include <VoxelDetail.h>
#include <ParticlesScriptingInterface.h>
#include <Sound.h>
@ -41,6 +42,7 @@ static QScriptValue soundConstructor(QScriptContext* context, QScriptEngine* eng
ScriptEngine::ScriptEngine(const QString& scriptContents, bool wantMenuItems, const QString& fileNameString, AbstractMenuInterface* menu,
AbstractControllerScriptingInterface* controllerScriptingInterface) :
_isAvatar(false),
_dataServerScriptingInterface(),
_avatarData(NULL)
{
@ -114,10 +116,12 @@ void ScriptEngine::init() {
_voxelsScriptingInterface.init();
_particlesScriptingInterface.init();
// register meta-type for glm::vec3 conversions
// register various meta-types
registerMetaTypes(&_engine);
registerVoxelMetaTypes(&_engine);
//registerParticleMetaTypes(&_engine);
registerEventTypes(&_engine);
qScriptRegisterMetaType(&_engine, ParticlePropertiesToScriptValue, ParticlePropertiesFromScriptValue);
qScriptRegisterMetaType(&_engine, ParticleIDtoScriptValue, ParticleIDfromScriptValue);
qScriptRegisterSequenceMetaType<QVector<ParticleID> >(&_engine);
@ -129,7 +133,7 @@ void ScriptEngine::init() {
QScriptValue injectionOptionValue = _engine.scriptValueFromQMetaObject<AudioInjectorOptions>();
_engine.globalObject().setProperty("AudioInjectionOptions", injectionOptionValue);
registerGlobalObject("Agent", this);
registerGlobalObject("Script", this);
registerGlobalObject("Audio", &_audioScriptingInterface);
registerGlobalObject("Controller", _controllerScriptingInterface);
registerGlobalObject("Data", &_dataServerScriptingInterface);

6
libraries/script-engine/src/ScriptEngine.h
View file

@ -31,8 +31,6 @@ const QString NO_SCRIPT("");
class ScriptEngine : public QObject {
Q_OBJECT
Q_PROPERTY(bool isAvatar READ isAvatar WRITE setIsAvatar)
public:
ScriptEngine(const QString& scriptContents = NO_SCRIPT, bool wantMenuItems = false,
const QString& scriptMenuName = QString(""), AbstractMenuInterface* menu = NULL,
@ -41,10 +39,10 @@ public:
~ScriptEngine();
/// Access the VoxelsScriptingInterface in order to initialize it with a custom packet sender and jurisdiction listener
VoxelsScriptingInterface* getVoxelsScriptingInterface() { return &_voxelsScriptingInterface; }
static VoxelsScriptingInterface* getVoxelsScriptingInterface() { return &_voxelsScriptingInterface; }
/// Access the ParticlesScriptingInterface in order to initialize it with a custom packet sender and jurisdiction listener
ParticlesScriptingInterface* getParticlesScriptingInterface() { return &_particlesScriptingInterface; }
static ParticlesScriptingInterface* getParticlesScriptingInterface() { return &_particlesScriptingInterface; }
/// Access the DataServerScriptingInterface for access to its underlying UUID
const DataServerScriptingInterface& getDataServerScriptingInterface() { return _dataServerScriptingInterface; }

45
libraries/shared/src/Assignment.cpp
View file

@ -14,9 +14,6 @@
#include "Assignment.h"
const char IPv4_ADDRESS_DESIGNATOR = 4;
const char IPv6_ADDRESS_DESIGNATOR = 6;
Assignment::Type Assignment::typeForNodeType(NodeType_t nodeType) {
switch (nodeType) {
case NodeType::AudioMixer:
@ -55,6 +52,7 @@ Assignment::Assignment() :
}
Assignment::Assignment(Assignment::Command command, Assignment::Type type, const QString& pool, Assignment::Location location) :
_uuid(),
_command(command),
_type(type),
_pool(pool),
@ -85,20 +83,7 @@ Assignment::Assignment(const QByteArray& packet) :
QDataStream packetStream(packet);
packetStream.skipRawData(numBytesForPacketHeader(packet));
uchar assignmentType;
packetStream >> assignmentType;
_type = (Assignment::Type) assignmentType;
if (_command != Assignment::RequestCommand) {
// read the GUID for this assignment
packetStream >> _uuid;
}
packetStream >> _pool;
if (!packetStream.atEnd()) {
_payload = packet.mid(packetStream.device()->pos());
}
packetStream >> *this;
}
#ifdef WIN32
@ -159,18 +144,26 @@ const char* Assignment::getTypeName() const {
QDebug operator<<(QDebug debug, const Assignment &assignment) {
debug.nospace() << "UUID: " << qPrintable(assignment.getUUID().toString()) <<
", Type: " << assignment.getType();
return debug.nospace();
if (!assignment.getPool().isEmpty()) {
debug << ", Pool: " << assignment.getPool();
}
return debug.space();
}
QDataStream& operator<<(QDataStream &out, const Assignment& assignment) {
out << (quint8) assignment._type;
// pack the UUID for this assignment, if this is an assignment create or deploy
if (assignment._command != Assignment::RequestCommand) {
out << assignment._uuid;
}
out << assignment._pool << assignment._payload;
out << (quint8) assignment._type << assignment._uuid << assignment._pool << assignment._payload;
return out;
}
QDataStream& operator>>(QDataStream &in, Assignment& assignment) {
quint8 packedType;
in >> packedType;
assignment._type = (Assignment::Type) packedType;
in >> assignment._uuid >> assignment._pool >> assignment._payload;
return in;
}

4
libraries/shared/src/Assignment.h
View file

@ -20,7 +20,6 @@
#include "NodeList.h"
const int MAX_PAYLOAD_BYTES = 1024;
const int MAX_ASSIGNMENT_POOL_BYTES = 64 + sizeof('\0');
const QString emptyPool = QString();
@ -76,7 +75,7 @@ public:
Assignment::Location getLocation() const { return _location; }
const QByteArray& getPayload() const { return _payload; }
void setPayload(const QByteArray& payload) { _payload = payload; }
void setPayload(const QByteArray& payload) { _payload = payload.left(MAX_PAYLOAD_BYTES); }
void setPool(const QString& pool) { _pool = pool; };
const QString& getPool() const { return _pool; }
@ -92,6 +91,7 @@ public:
friend QDebug operator<<(QDebug debug, const Assignment& assignment);
friend QDataStream& operator<<(QDataStream &out, const Assignment& assignment);
friend QDataStream& operator>>(QDataStream &in, Assignment& assignment);
protected:
QUuid _uuid; /// the 16 byte UUID for this assignment

14
libraries/shared/src/NodeList.cpp
View file

@ -119,13 +119,13 @@ void NodeList::timePingReply(const QByteArray& packet) {
if (matchingNode) {
QDataStream packetStream(packet);
packetStream.device()->seek(numBytesForPacketHeader(packet));
packetStream.skipRawData(numBytesForPacketHeader(packet));
qint64 ourOriginalTime, othersReplyTime;
quint64 ourOriginalTime, othersReplyTime;
packetStream >> ourOriginalTime >> othersReplyTime;
qint64 now = usecTimestampNow();
quint64 now = usecTimestampNow();
int pingTime = now - ourOriginalTime;
int oneWayFlightTime = pingTime / 2; // half of the ping is our one way flight
@ -554,8 +554,11 @@ QByteArray NodeList::constructPingPacket() {
}
QByteArray NodeList::constructPingReplyPacket(const QByteArray& pingPacket) {
QDataStream pingPacketStream(pingPacket);
pingPacketStream.skipRawData(numBytesForPacketHeader(pingPacket));
quint64 timeFromOriginalPing;
memcpy(&timeFromOriginalPing, pingPacket.data() + numBytesForPacketHeader(pingPacket), sizeof(timeFromOriginalPing));
pingPacketStream >> timeFromOriginalPing;
QByteArray replyPacket = byteArrayWithPopluatedHeader(PacketTypePingReply);
QDataStream packetStream(&replyPacket, QIODevice::Append);
@ -621,8 +624,7 @@ SharedNodePointer NodeList::addOrUpdateNode(const QUuid& uuid, char nodeType,
}
}
unsigned NodeList::broadcastToNodes(const QByteArray& packet,
const NodeSet& destinationNodeTypes) {
unsigned NodeList::broadcastToNodes(const QByteArray& packet, const NodeSet& destinationNodeTypes) {
unsigned n = 0;
foreach (const SharedNodePointer& node, getNodeHash()) {

2
libraries/shared/src/PacketHeaders.cpp
View file

@ -80,7 +80,7 @@ bool packetVersionMatch(const QByteArray& packet) {
// currently this just checks if the version in the packet matches our return from versionForPacketType
// may need to be expanded in the future for types and versions that take > than 1 byte
if (packet[1] == versionForPacketType(packetTypeForPacket(packet)) || packet[0] == PacketTypeStunResponse) {
if (packet[1] == versionForPacketType(packetTypeForPacket(packet)) || packetTypeForPacket(packet) == PacketTypeStunResponse) {
return true;
} else {
PacketType mismatchType = packetTypeForPacket(packet);

1
libraries/shared/src/RegisteredMetaTypes.h
View file

@ -22,6 +22,7 @@ Q_DECLARE_METATYPE(glm::vec2)
Q_DECLARE_METATYPE(glm::quat)
Q_DECLARE_METATYPE(xColor)
void registerMetaTypes(QScriptEngine* engine);
QScriptValue vec3toScriptValue(QScriptEngine* engine, const glm::vec3 &vec3);

1
libraries/shared/src/SharedUtil.cpp
View file

@ -231,7 +231,6 @@ void sharedMessageHandler(QtMsgType type, const QMessageLogContext& context, con
fprintf(stdout, "%s", message.toLocal8Bit().constData());
}
unsigned char* pointToOctalCode(float x, float y, float z, float s) {
return pointToVoxel(x, y, z, s);
}

11
libraries/shared/src/SharedUtil.h
View file

@ -96,20 +96,9 @@ bool cmdOptionExists(int argc, const char * argv[],const char* option);
void sharedMessageHandler(QtMsgType type, const QMessageLogContext& context, const QString &message);
struct VoxelDetail {
float x;
float y;
float z;
float s;
unsigned char red;
unsigned char green;
unsigned char blue;
};
unsigned char* pointToVoxel(float x, float y, float z, float s, unsigned char r = 0, unsigned char g = 0, unsigned char b = 0);
unsigned char* pointToOctalCode(float x, float y, float z, float s);
#ifdef _WIN32
void usleep(int waitTime);
#endif

37
libraries/voxels/src/VoxelDetail.cpp Normal file
View file

@ -0,0 +1,37 @@
//
// VoxelDetail.cpp
// hifi
//
// Created by Brad Hefta-Gaub on 1/29/2014
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "VoxelDetail.h"
void registerVoxelMetaTypes(QScriptEngine* engine) {
qScriptRegisterMetaType(engine, voxelDetailToScriptValue, voxelDetailFromScriptValue);
}
QScriptValue voxelDetailToScriptValue(QScriptEngine* engine, const VoxelDetail& voxelDetail) {
QScriptValue obj = engine->newObject();
obj.setProperty("x", voxelDetail.x * (float)TREE_SCALE);
obj.setProperty("y", voxelDetail.y * (float)TREE_SCALE);
obj.setProperty("z", voxelDetail.z * (float)TREE_SCALE);
obj.setProperty("s", voxelDetail.s * (float)TREE_SCALE);
obj.setProperty("red", voxelDetail.red);
obj.setProperty("green", voxelDetail.green);
obj.setProperty("blue", voxelDetail.blue);
return obj;
}
void voxelDetailFromScriptValue(const QScriptValue &object, VoxelDetail& voxelDetail) {
voxelDetail.x = object.property("x").toVariant().toFloat() / (float)TREE_SCALE;
voxelDetail.y = object.property("y").toVariant().toFloat() / (float)TREE_SCALE;
voxelDetail.z = object.property("z").toVariant().toFloat() / (float)TREE_SCALE;
voxelDetail.s = object.property("s").toVariant().toFloat() / (float)TREE_SCALE;
voxelDetail.red = object.property("red").toVariant().toInt();
voxelDetail.green = object.property("green").toVariant().toInt();
voxelDetail.blue = object.property("blue").toVariant().toInt();
}

36
libraries/voxels/src/VoxelDetail.h Normal file
View file

@ -0,0 +1,36 @@
//
// VoxelDetail.h
// hifi
//
// Created by Brad Hefta-Gaub on 1/29/2014
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
//
#ifndef __hifi__VoxelDetail__
#define __hifi__VoxelDetail__
#include <QtScript/QScriptEngine>
#include <SharedUtil.h>
#include "VoxelConstants.h"
struct VoxelDetail {
float x;
float y;
float z;
float s;
unsigned char red;
unsigned char green;
unsigned char blue;
};
Q_DECLARE_METATYPE(VoxelDetail)
void registerVoxelMetaTypes(QScriptEngine* engine);
QScriptValue voxelDetailToScriptValue(QScriptEngine* engine, const VoxelDetail& color);
void voxelDetailFromScriptValue(const QScriptValue &object, VoxelDetail& color);
#endif /* defined(__hifi__VoxelDetail__) */

4
libraries/voxels/src/VoxelEditPacketSender.cpp
View file

@ -70,14 +70,14 @@ bool createVoxelEditMessage(PacketType command, short int sequence,
// cleanup
delete[] voxelData;
}
if (success) {
// finally, copy the result to the output
bufferOut = new unsigned char[actualMessageSize];
sizeOut = actualMessageSize;
memcpy(bufferOut, messageBuffer, actualMessageSize);
}
delete[] messageBuffer; // clean up our temporary buffer
return success;
}

1
libraries/voxels/src/VoxelEditPacketSender.h
View file

@ -12,6 +12,7 @@
#define __shared__VoxelEditPacketSender__
#include <OctreeEditPacketSender.h>
#include "VoxelDetail.h"
/// Utility for processing, packing, queueing and sending of outbound edit voxel messages.
class VoxelEditPacketSender : public OctreeEditPacketSender {

1
libraries/voxels/src/VoxelTreeElement.h
View file

@ -91,5 +91,4 @@ protected:
nodeColor _currentColor; /// Client only, false color of this voxel, 4 bytes
};
#endif /* defined(__hifi__VoxelTreeElement__) */

16
libraries/voxels/src/VoxelsScriptingInterface.h
View file

@ -57,20 +57,4 @@ private:
void queueVoxelAdd(PacketType addPacketType, VoxelDetail& addVoxelDetails);
};
class VoxelDetailScriptObject : public QObject {
Q_OBJECT
public:
VoxelDetailScriptObject(VoxelDetail* voxelDetail) { _voxelDetail = voxelDetail; }
public slots:
/// position in meter units
glm::vec3 getPosition() const { return glm::vec3(_voxelDetail->x, _voxelDetail->y, _voxelDetail->z) * (float)TREE_SCALE; }
xColor getColor() const { xColor color = { _voxelDetail->red, _voxelDetail->green, _voxelDetail->blue }; return color; }
/// scale in meter units
float getScale() const { return _voxelDetail->s * (float)TREE_SCALE; }
private:
VoxelDetail* _voxelDetail;
};
#endif /* defined(__hifi__VoxelsScriptingInterface__) */