From 9ea53f8070b11aa37a0866994af4fc4e9c5d2980 Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Wed, 4 Jun 2014 11:38:46 -0700 Subject: [PATCH 01/42] some testing with editModels --- examples/editModels.js | 76 ++++++++++++++++++++++++++---------------- 1 file changed, 47 insertions(+), 29 deletions(-) diff --git a/examples/editModels.js b/examples/editModels.js index 24ab7da1a1..c2072a46cd 100644 --- a/examples/editModels.js +++ b/examples/editModels.js @@ -152,6 +152,7 @@ function controller(wichSide) { this.jointsIntersectingFromStart.push(i); } } + this.showLaser(false); } } @@ -196,6 +197,7 @@ function controller(wichSide) { this.grabbing = false; this.modelID.isKnownID = false; this.jointsIntersectingFromStart = []; + this.showLaser(true); } this.checkTrigger = function () { @@ -258,41 +260,43 @@ function controller(wichSide) { Overlays.editOverlay(this.laser, { position: startPosition, - end: endPosition, - visible: true + end: endPosition }); Overlays.editOverlay(this.ball, { - position: endPosition, - visible: true + position: endPosition }); Overlays.editOverlay(this.leftRight, { position: Vec3.sum(endPosition, Vec3.multiply(this.right, 2 * this.guideScale)), - end: Vec3.sum(endPosition, Vec3.multiply(this.right, -2 * this.guideScale)), - visible: true + end: Vec3.sum(endPosition, Vec3.multiply(this.right, -2 * this.guideScale)) }); Overlays.editOverlay(this.topDown, {position: Vec3.sum(endPosition, Vec3.multiply(this.up, 2 * this.guideScale)), - end: Vec3.sum(endPosition, Vec3.multiply(this.up, -2 * this.guideScale)), - visible: true + end: Vec3.sum(endPosition, Vec3.multiply(this.up, -2 * this.guideScale)) }); + this.showLaser(!this.grabbing); } - this.hideLaser = function() { - Overlays.editOverlay(this.laser, { visible: false }); - Overlays.editOverlay(this.ball, { visible: false }); - Overlays.editOverlay(this.leftRight, { visible: false }); - Overlays.editOverlay(this.topDown, { visible: false }); + this.showLaser = function(show) { + Overlays.editOverlay(this.laser, { visible: show }); + Overlays.editOverlay(this.ball, { visible: show }); + Overlays.editOverlay(this.leftRight, { visible: show }); + Overlays.editOverlay(this.topDown, { visible: show }); } this.moveModel = function () { if (this.grabbing) { - var newPosition = Vec3.sum(this.palmPosition, - Vec3.multiply(this.front, this.x)); - newPosition = Vec3.sum(newPosition, - Vec3.multiply(this.up, this.y)); - newPosition = Vec3.sum(newPosition, - Vec3.multiply(this.right, this.z)); + var forward = Vec3.multiplyQbyV(MyAvatar.orientation, { x: 0, y: 0, z: -1 }); + var d = Vec3.dot(forward, MyAvatar.position); + + var factor1 = Vec3.dot(forward, this.palmPosition) - d; + var factor2 = Vec3.dot(forward, this.oldModelPosition) - d; + var vector = Vec3.subtract(this.palmPosition, this.oldPalmPosition); + + var newPosition = Vec3.sum(this.oldModelPosition, + Vec3.multiply(vector, + factor2 / factor1)); + var newRotation = Quat.multiply(this.rotation, Quat.inverse(this.oldRotation)); @@ -457,20 +461,34 @@ function moveModels() { var newPosition = Vec3.sum(middle, Vec3.multiply(Vec3.subtract(leftController.oldModelPosition, oldMiddle), ratio)); - //Vec3.print("Ratio : " + ratio + " New position: ", newPosition); - var rotation = Quat.multiply(leftController.rotation, - Quat.inverse(leftController.oldRotation)); + + + var u = Vec3.normalize(Vec3.subtract(rightController.oldPalmPosition, leftController.oldPalmPosition)); + var v = Vec3.normalize(Vec3.subtract(rightController.palmPosition, leftController.palmPosition)); + + var cos_theta = Vec3.dot(Vec3.normalize(u), Vec3.normalize(v)); + var angle = Math.acos(cos_theta); + var w = Vec3.normalize(Vec3.cross(u, v)); + + + var rotation = Quat.angleAxis(angle, w); + + rotation = Quat.multiply(rotation, leftController.oldModelRotation); Models.editModel(leftController.modelID, { - position: newPosition, - //modelRotation: rotation, - radius: leftController.oldModelRadius * ratio + //position: newPosition, + modelRotation: rotation, + //radius: leftController.oldModelRadius * ratio }); - leftController.oldModelPosition = newPosition; + //leftController.oldModelPosition = newPosition; leftController.oldModelRotation = rotation; - leftController.oldModelRadius *= ratio; + //leftController.oldModelRadius *= ratio; + + //rightController.oldModelPosition = newPosition; + rightController.oldModelRotation = rotation; + //rightController.oldModelRadius *= ratio; return; } @@ -498,8 +516,8 @@ function checkController(deltaTime) { if (hydraConnected) { hydraConnected = false; - leftController.hideLaser(); - rightController.hideLaser(); + leftController.showLaser(false); + rightController.showLaser(false); } } From 15863198d1f8a0792361e8af317080aa5cc0f75c Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Wed, 4 Jun 2014 13:52:31 -0700 Subject: [PATCH 02/42] change editModels icon --- examples/editModels.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/editModels.js b/examples/editModels.js index c2072a46cd..47da9b0c0a 100644 --- a/examples/editModels.js +++ b/examples/editModels.js @@ -528,7 +528,7 @@ function initToolBar() { toolBar = new ToolBar(0, 0, ToolBar.VERTICAL); // New Model newModel = toolBar.addTool({ - imageURL: toolIconUrl + "voxel-tool.svg", + imageURL: toolIconUrl + "add-model-tool.svg", subImage: { x: 0, y: Tool.IMAGE_WIDTH, width: Tool.IMAGE_WIDTH, height: Tool.IMAGE_HEIGHT }, width: toolWidth, height: toolHeight, visible: true, From 79092e3e81a7605c49d38050521c133c92595d88 Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Wed, 4 Jun 2014 14:18:28 -0700 Subject: [PATCH 03/42] editModels now has 2 modes --- examples/editModels.js | 150 ++++++++++++++++++++++++++++------------- 1 file changed, 102 insertions(+), 48 deletions(-) diff --git a/examples/editModels.js b/examples/editModels.js index 47da9b0c0a..24360c526d 100644 --- a/examples/editModels.js +++ b/examples/editModels.js @@ -42,6 +42,8 @@ var toolBar; var jointList = MyAvatar.getJointNames(); +var mode = 0; + function isLocked(properties) { // special case to lock the ground plane model in hq. if (location.hostname == "hq.highfidelity.io" && @@ -57,6 +59,7 @@ function controller(wichSide) { this.palm = 2 * wichSide; this.tip = 2 * wichSide + 1; this.trigger = wichSide; + this.bumper = 6 * wichSide + 5; this.oldPalmPosition = Controller.getSpatialControlPosition(this.palm); this.palmPosition = Controller.getSpatialControlPosition(this.palm); @@ -77,6 +80,7 @@ function controller(wichSide) { this.rotation = this.oldRotation; this.triggerValue = Controller.getTriggerValue(this.trigger); + this.bumperValue = Controller.isButtonPressed(this.bumper); this.pressed = false; // is trigger pressed this.pressing = false; // is trigger being pressed (is pressed now but wasn't previously) @@ -274,7 +278,7 @@ function controller(wichSide) { Overlays.editOverlay(this.topDown, {position: Vec3.sum(endPosition, Vec3.multiply(this.up, 2 * this.guideScale)), end: Vec3.sum(endPosition, Vec3.multiply(this.up, -2 * this.guideScale)) }); - this.showLaser(!this.grabbing); + this.showLaser(!this.grabbing || mode == 0); } this.showLaser = function(show) { @@ -286,20 +290,44 @@ function controller(wichSide) { this.moveModel = function () { if (this.grabbing) { - var forward = Vec3.multiplyQbyV(MyAvatar.orientation, { x: 0, y: 0, z: -1 }); - var d = Vec3.dot(forward, MyAvatar.position); + var newPosition; + var newRotation; - var factor1 = Vec3.dot(forward, this.palmPosition) - d; - var factor2 = Vec3.dot(forward, this.oldModelPosition) - d; - var vector = Vec3.subtract(this.palmPosition, this.oldPalmPosition); - - var newPosition = Vec3.sum(this.oldModelPosition, - Vec3.multiply(vector, - factor2 / factor1)); + switch (mode) { + case 0: + newPosition = Vec3.sum(this.palmPosition, + Vec3.multiply(this.front, this.x)); + newPosition = Vec3.sum(newPosition, + Vec3.multiply(this.up, this.y)); + newPosition = Vec3.sum(newPosition, + Vec3.multiply(this.right, this.z)); + break; + case 1: + var forward = Vec3.multiplyQbyV(MyAvatar.orientation, { x: 0, y: 0, z: -1 }); + var d = Vec3.dot(forward, MyAvatar.position); + + var factor1 = Vec3.dot(forward, this.palmPosition) - d; + var factor2 = Vec3.dot(forward, this.oldModelPosition) - d; + var vector = Vec3.subtract(this.palmPosition, this.oldPalmPosition); + + if (factor2 < 0) { + factor2 = 0; + } + if (factor1 <= 0) { + factor1 = 1; + factor2 = 1; + } + + newPosition = Vec3.sum(this.oldModelPosition, + Vec3.multiply(vector, + factor2 / factor1)); + break; + } - var newRotation = Quat.multiply(this.rotation, - Quat.inverse(this.oldRotation)); + + newRotation = Quat.multiply(this.rotation, + Quat.inverse(this.oldRotation)); newRotation = Quat.multiply(newRotation, this.oldModelRotation); @@ -345,6 +373,21 @@ function controller(wichSide) { this.triggerValue = Controller.getTriggerValue(this.trigger); + var bumperValue = Controller.isButtonPressed(this.bumper); + if (bumperValue && !this.bumperValue) { + if (mode == 0) { + mode = 1; + Overlays.editOverlay(leftController.laser, { color: { red: 0, green: 0, blue: 255 } }); + Overlays.editOverlay(rightController.laser, { color: { red: 0, green: 0, blue: 255 } }); + } else { + mode = 0; + Overlays.editOverlay(leftController.laser, { color: { red: 255, green: 0, blue: 0 } }); + Overlays.editOverlay(rightController.laser, { color: { red: 255, green: 0, blue: 0 } }); + } + } + this.bumperValue = bumperValue; + + this.checkTrigger(); this.moveLaser(); @@ -443,52 +486,63 @@ var rightController = new controller(RIGHT); function moveModels() { if (leftController.grabbing && rightController.grabbing && rightController.modelID.id == leftController.modelID.id) { - //print("Both controllers"); - var oldLeftPoint = Vec3.sum(leftController.oldPalmPosition, Vec3.multiply(leftController.oldFront, leftController.x)); - var oldRightPoint = Vec3.sum(rightController.oldPalmPosition, Vec3.multiply(rightController.oldFront, rightController.x)); - - var oldMiddle = Vec3.multiply(Vec3.sum(oldLeftPoint, oldRightPoint), 0.5); - var oldLength = Vec3.length(Vec3.subtract(oldLeftPoint, oldRightPoint)); + var newPosition = this.oldModelPosition; + var rotation = this.oldModelRotation; + var ratio = 1; - var leftPoint = Vec3.sum(leftController.palmPosition, Vec3.multiply(leftController.front, leftController.x)); - var rightPoint = Vec3.sum(rightController.palmPosition, Vec3.multiply(rightController.front, rightController.x)); - - var middle = Vec3.multiply(Vec3.sum(leftPoint, rightPoint), 0.5); - var length = Vec3.length(Vec3.subtract(leftPoint, rightPoint)); - - var ratio = length / oldLength; - - var newPosition = Vec3.sum(middle, - Vec3.multiply(Vec3.subtract(leftController.oldModelPosition, oldMiddle), ratio)); - - - var u = Vec3.normalize(Vec3.subtract(rightController.oldPalmPosition, leftController.oldPalmPosition)); - var v = Vec3.normalize(Vec3.subtract(rightController.palmPosition, leftController.palmPosition)); - - var cos_theta = Vec3.dot(Vec3.normalize(u), Vec3.normalize(v)); - var angle = Math.acos(cos_theta); - var w = Vec3.normalize(Vec3.cross(u, v)); - - - var rotation = Quat.angleAxis(angle, w); - - - rotation = Quat.multiply(rotation, leftController.oldModelRotation); + switch (mode) { + case 0: + var oldLeftPoint = Vec3.sum(leftController.oldPalmPosition, Vec3.multiply(leftController.oldFront, leftController.x)); + var oldRightPoint = Vec3.sum(rightController.oldPalmPosition, Vec3.multiply(rightController.oldFront, rightController.x)); + + var oldMiddle = Vec3.multiply(Vec3.sum(oldLeftPoint, oldRightPoint), 0.5); + var oldLength = Vec3.length(Vec3.subtract(oldLeftPoint, oldRightPoint)); + + + var leftPoint = Vec3.sum(leftController.palmPosition, Vec3.multiply(leftController.front, leftController.x)); + var rightPoint = Vec3.sum(rightController.palmPosition, Vec3.multiply(rightController.front, rightController.x)); + + var middle = Vec3.multiply(Vec3.sum(leftPoint, rightPoint), 0.5); + var length = Vec3.length(Vec3.subtract(leftPoint, rightPoint)); + + + ratio = length / oldLength; + newPosition = Vec3.sum(middle, + Vec3.multiply(Vec3.subtract(leftController.oldModelPosition, oldMiddle), ratio)); + break; + case 1: + var u = Vec3.normalize(Vec3.subtract(rightController.oldPalmPosition, leftController.oldPalmPosition)); + var v = Vec3.normalize(Vec3.subtract(rightController.palmPosition, leftController.palmPosition)); + + var cos_theta = Vec3.dot(u, v); + if (cos_theta > 1) { + cos_theta = 1; + } + var angle = Math.acos(cos_theta) / Math.PI * 180; + if (angle < 0.1) { + return; + + } + var w = Vec3.normalize(Vec3.cross(u, v)); + + rotation = Quat.multiply(Quat.angleAxis(angle, w), leftController.oldModelRotation); + break; + } Models.editModel(leftController.modelID, { - //position: newPosition, + position: newPosition, modelRotation: rotation, - //radius: leftController.oldModelRadius * ratio + radius: leftController.oldModelRadius * ratio }); - //leftController.oldModelPosition = newPosition; + leftController.oldModelPosition = newPosition; leftController.oldModelRotation = rotation; - //leftController.oldModelRadius *= ratio; + leftController.oldModelRadius *= ratio; - //rightController.oldModelPosition = newPosition; + rightController.oldModelPosition = newPosition; rightController.oldModelRotation = rotation; - //rightController.oldModelRadius *= ratio; + rightController.oldModelRadius *= ratio; return; } From c1d1a8de5c3bb0aaf23be67190e5cfabfe492836 Mon Sep 17 00:00:00 2001 From: Joseph Gilley Date: Thu, 5 Jun 2014 00:26:45 -0400 Subject: [PATCH 04/42] Fix for users with some special characters in their password not being able to log in using the login overlay in the Interface. --- libraries/networking/src/AccountManager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/networking/src/AccountManager.cpp b/libraries/networking/src/AccountManager.cpp index 7d27332a57..b4aedbcb7c 100644 --- a/libraries/networking/src/AccountManager.cpp +++ b/libraries/networking/src/AccountManager.cpp @@ -313,7 +313,7 @@ void AccountManager::requestAccessToken(const QString& login, const QString& pas QByteArray postData; postData.append("grant_type=password&"); postData.append("username=" + login + "&"); - postData.append("password=" + password + "&"); + postData.append("password=" + QUrl::toPercentEncoding(password) + "&"); postData.append("scope=" + ACCOUNT_MANAGER_REQUESTED_SCOPE); request.setUrl(grantURL); From c44dba78cb3ad4458fe3abb75695967afb763c27 Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Thu, 5 Jun 2014 15:32:55 -0700 Subject: [PATCH 05/42] Provide a reasonably painless way to stream enums that aren't object properties. --- libraries/metavoxels/src/Bitstream.h | 34 ++++++++++++++++++++++--- tests/metavoxels/src/MetavoxelTests.cpp | 7 +++-- tests/metavoxels/src/MetavoxelTests.h | 3 +++ 3 files changed, 38 insertions(+), 6 deletions(-) diff --git a/libraries/metavoxels/src/Bitstream.h b/libraries/metavoxels/src/Bitstream.h index 146713910f..9945284775 100644 --- a/libraries/metavoxels/src/Bitstream.h +++ b/libraries/metavoxels/src/Bitstream.h @@ -1037,12 +1037,12 @@ public: }; /// Macro for registering simple type streamers. -#define REGISTER_SIMPLE_TYPE_STREAMER(x) static int x##Streamer = \ - Bitstream::registerTypeStreamer(qMetaTypeId(), new SimpleTypeStreamer()); +#define REGISTER_SIMPLE_TYPE_STREAMER(X) static int X##Streamer = \ + Bitstream::registerTypeStreamer(qMetaTypeId(), new SimpleTypeStreamer()); /// Macro for registering collection type streamers. -#define REGISTER_COLLECTION_TYPE_STREAMER(x) static int x##Streamer = \ - Bitstream::registerTypeStreamer(qMetaTypeId(), new CollectionTypeStreamer()); +#define REGISTER_COLLECTION_TYPE_STREAMER(X) static int x##Streamer = \ + Bitstream::registerTypeStreamer(qMetaTypeId(), new CollectionTypeStreamer()); /// Declares the metatype and the streaming operators. The last lines /// ensure that the generated file will be included in the link phase. @@ -1077,6 +1077,25 @@ public: _Pragma(STRINGIFY(unused(_TypePtr##X))) #endif +#define DECLARE_ENUM_METATYPE(S, N) Q_DECLARE_METATYPE(S::N) \ + Bitstream& operator<<(Bitstream& out, const S::N& obj); \ + Bitstream& operator>>(Bitstream& in, S::N& obj); \ + template<> inline void Bitstream::writeRawDelta(const S::N& value, const S::N& reference) { *this << value; } \ + template<> inline void Bitstream::readRawDelta(S::N& value, const S::N& reference) { *this >> value; } + +#define IMPLEMENT_ENUM_METATYPE(S, N) \ + static int S##N##MetaTypeId = registerEnumMetaType(S::staticMetaObject.enumerator( \ + S::staticMetaObject.indexOfEnumerator(#N))); \ + Bitstream& operator<<(Bitstream& out, const S::N& obj) { \ + static int bits = static_cast(Bitstream::getTypeStreamer(qMetaTypeId()))->getBits(); \ + return out.write(&obj, bits); \ + } \ + Bitstream& operator>>(Bitstream& in, S::N& obj) { \ + static int bits = static_cast(Bitstream::getTypeStreamer(qMetaTypeId()))->getBits(); \ + obj = (S::N)0; \ + return in.read(&obj, bits); \ + } + /// Registers a simple type and its streamer. template int registerSimpleMetaType() { int type = qRegisterMetaType(); @@ -1084,6 +1103,13 @@ template int registerSimpleMetaType() { return type; } +/// Registers an enum type and its streamer. +template int registerEnumMetaType(const QMetaEnum& metaEnum) { + int type = qRegisterMetaType(); + Bitstream::registerTypeStreamer(type, new EnumTypeStreamer(metaEnum)); + return type; +} + /// Registers a streamable type and its streamer. template int registerStreamableMetaType() { int type = qRegisterMetaType(); diff --git a/tests/metavoxels/src/MetavoxelTests.cpp b/tests/metavoxels/src/MetavoxelTests.cpp index 603f63b587..cb1b5c7900 100644 --- a/tests/metavoxels/src/MetavoxelTests.cpp +++ b/tests/metavoxels/src/MetavoxelTests.cpp @@ -20,6 +20,8 @@ REGISTER_META_OBJECT(TestSharedObjectA) REGISTER_META_OBJECT(TestSharedObjectB) +IMPLEMENT_ENUM_METATYPE(TestSharedObjectA, TestEnum) + MetavoxelTests::MetavoxelTests(int& argc, char** argv) : QCoreApplication(argc, argv) { } @@ -80,6 +82,7 @@ static TestMessageC createRandomMessageC() { message.bar = rand(); message.baz = randFloat(); message.bong.foo = createRandomBytes(); + message.bong.baz = getRandomTestEnum(); return message; } @@ -252,7 +255,7 @@ static QVariant createRandomMessage() { return QVariant::fromValue(message); } case 1: { - TestMessageB message = { createRandomBytes(), createRandomSharedObject() }; + TestMessageB message = { createRandomBytes(), createRandomSharedObject(), getRandomTestEnum() }; return QVariant::fromValue(message); } case 2: @@ -273,7 +276,7 @@ static bool messagesEqual(const QVariant& firstMessage, const QVariant& secondMe } else if (type == TestMessageB::Type) { TestMessageB first = firstMessage.value(); TestMessageB second = secondMessage.value(); - return first.foo == second.foo && equals(first.bar, second.bar); + return first.foo == second.foo && equals(first.bar, second.bar) && first.baz == second.baz; } else if (type == TestMessageC::Type) { return firstMessage.value() == secondMessage.value(); diff --git a/tests/metavoxels/src/MetavoxelTests.h b/tests/metavoxels/src/MetavoxelTests.h index 5e020b1e60..ffd1311f00 100644 --- a/tests/metavoxels/src/MetavoxelTests.h +++ b/tests/metavoxels/src/MetavoxelTests.h @@ -106,6 +106,8 @@ private: TestFlags _bong; }; +DECLARE_ENUM_METATYPE(TestSharedObjectA, TestEnum) + /// Another simple shared object. class TestSharedObjectB : public SharedObject { Q_OBJECT @@ -169,6 +171,7 @@ public: STREAM QByteArray foo; STREAM SharedObjectPointer bar; + STREAM TestSharedObjectA::TestEnum baz; }; DECLARE_STREAMABLE_METATYPE(TestMessageB) From 887561a4e134e97d30ad11131c83952fc986815c Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Thu, 5 Jun 2014 15:39:43 -0700 Subject: [PATCH 06/42] Slight simplification. --- libraries/metavoxels/src/Bitstream.h | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/libraries/metavoxels/src/Bitstream.h b/libraries/metavoxels/src/Bitstream.h index 9945284775..caf0adf7fc 100644 --- a/libraries/metavoxels/src/Bitstream.h +++ b/libraries/metavoxels/src/Bitstream.h @@ -1084,19 +1084,18 @@ public: template<> inline void Bitstream::readRawDelta(S::N& value, const S::N& reference) { *this >> value; } #define IMPLEMENT_ENUM_METATYPE(S, N) \ - static int S##N##MetaTypeId = registerEnumMetaType(S::staticMetaObject.enumerator( \ + static int S##N##Bits = registerEnumMetaType(S::staticMetaObject.enumerator( \ S::staticMetaObject.indexOfEnumerator(#N))); \ Bitstream& operator<<(Bitstream& out, const S::N& obj) { \ - static int bits = static_cast(Bitstream::getTypeStreamer(qMetaTypeId()))->getBits(); \ - return out.write(&obj, bits); \ + return out.write(&obj, S##N##Bits); \ } \ Bitstream& operator>>(Bitstream& in, S::N& obj) { \ - static int bits = static_cast(Bitstream::getTypeStreamer(qMetaTypeId()))->getBits(); \ obj = (S::N)0; \ - return in.read(&obj, bits); \ + return in.read(&obj, S##N##Bits); \ } /// Registers a simple type and its streamer. +/// \return the metatype id template int registerSimpleMetaType() { int type = qRegisterMetaType(); Bitstream::registerTypeStreamer(type, new SimpleTypeStreamer()); @@ -1104,13 +1103,16 @@ template int registerSimpleMetaType() { } /// Registers an enum type and its streamer. +/// \return the number of bits required to stream the enum template int registerEnumMetaType(const QMetaEnum& metaEnum) { int type = qRegisterMetaType(); - Bitstream::registerTypeStreamer(type, new EnumTypeStreamer(metaEnum)); - return type; + EnumTypeStreamer* streamer = new EnumTypeStreamer(metaEnum); + Bitstream::registerTypeStreamer(type, streamer); + return streamer->getBits(); } /// Registers a streamable type and its streamer. +/// \return the metatype id template int registerStreamableMetaType() { int type = qRegisterMetaType(); Bitstream::registerTypeStreamer(type, new StreamableTypeStreamer()); @@ -1118,6 +1120,7 @@ template int registerStreamableMetaType() { } /// Registers a collection type and its streamer. +/// \return the metatype id template int registerCollectionMetaType() { int type = qRegisterMetaType(); Bitstream::registerTypeStreamer(type, new CollectionTypeStreamer()); From 145a159233604285fb2f180e9111fd677b601e1b Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Thu, 5 Jun 2014 15:45:25 -0700 Subject: [PATCH 07/42] Slight glow on laser intersection --- examples/editModels.js | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/examples/editModels.js b/examples/editModels.js index 24360c526d..8e2f6b4911 100644 --- a/examples/editModels.js +++ b/examples/editModels.js @@ -252,6 +252,7 @@ function controller(wichSide) { return { valid: false }; } + this.glowedIntersectingModel = { isKnownID: false }; this.moveLaser = function () { // the overlays here are anchored to the avatar, which means they are specified in the avatar's local frame @@ -279,6 +280,22 @@ function controller(wichSide) { end: Vec3.sum(endPosition, Vec3.multiply(this.up, -2 * this.guideScale)) }); this.showLaser(!this.grabbing || mode == 0); + + + if (!this.grabbing) { + if (this.glowedIntersectingModel.isKnownID) { + Models.editModel(this.glowedIntersectingModel, { glowLevel: 0.0 }); + } + + var intersection = Models.findRayIntersection({ + origin: this.palmPosition, + direction: this.front + }); + if (intersection.accurate && intersection.modelID.isKnownID) { + this.glowedIntersectingModel = intersection.modelID; + Models.editModel(this.glowedIntersectingModel, { glowLevel: 0.25 }); + } + } } this.showLaser = function(show) { From 0bdd20abc9d06a8d986a44c0232cd8c75dbc6ea7 Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Thu, 5 Jun 2014 15:46:07 -0700 Subject: [PATCH 08/42] Coding Standard --- libraries/models/src/ModelTree.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/models/src/ModelTree.cpp b/libraries/models/src/ModelTree.cpp index e88a969061..466d4c5273 100644 --- a/libraries/models/src/ModelTree.cpp +++ b/libraries/models/src/ModelTree.cpp @@ -185,7 +185,7 @@ void ModelTree::addModel(const ModelItemID& modelID, const ModelItemProperties& glm::vec3 position = model.getPosition(); float size = std::max(MINIMUM_MODEL_ELEMENT_SIZE, model.getRadius()); - ModelTreeElement* element = (ModelTreeElement*)getOrCreateChildElementAt(position.x, position.y, position.z, size); + ModelTreeElement* element = static_cast(getOrCreateChildElementAt(position.x, position.y, position.z, size)); element->storeModel(model); _isDirty = true; From 150477eea44d0438137333499fcda498072c76ea Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Thu, 5 Jun 2014 15:47:25 -0700 Subject: [PATCH 09/42] Models.addModel now returns a more accurate modelID --- libraries/models/src/ModelItem.cpp | 31 +++++-------------- libraries/models/src/ModelItem.h | 1 + .../models/src/ModelsScriptingInterface.cpp | 3 +- 3 files changed, 11 insertions(+), 24 deletions(-) diff --git a/libraries/models/src/ModelItem.cpp b/libraries/models/src/ModelItem.cpp index b6f4fe6c1d..810129a81f 100644 --- a/libraries/models/src/ModelItem.cpp +++ b/libraries/models/src/ModelItem.cpp @@ -47,6 +47,12 @@ uint32_t ModelItem::getNextCreatorTokenID() { return creatorTokenID; } +uint32_t ModelItem::getNextModelItemID() { + uint32_t modelID = _nextID; + _nextID++; + return modelID; +} + void ModelItem::handleAddModelResponse(const QByteArray& packet) { const unsigned char* dataAt = reinterpret_cast(packet.data()); int numBytesPacketHeader = numBytesForPacketHeader(packet); @@ -70,31 +76,10 @@ ModelItem::ModelItem() { } ModelItem::ModelItem(const ModelItemID& modelItemID, const ModelItemProperties& properties) { - _id = modelItemID.id; _creatorTokenID = modelItemID.creatorTokenID; - - // init values with defaults before calling setProperties - uint64_t now = usecTimestampNow(); - _lastEdited = now; - _lastUpdated = now; - - _position = glm::vec3(0,0,0); - _radius = 0; - rgbColor noColor = { 0, 0, 0 }; - memcpy(_color, noColor, sizeof(_color)); - _shouldDie = false; - _modelURL = MODEL_DEFAULT_MODEL_URL; - _modelRotation = MODEL_DEFAULT_MODEL_ROTATION; - // animation related - _animationURL = MODEL_DEFAULT_ANIMATION_URL; - _animationIsPlaying = false; - _animationFrameIndex = 0.0f; - _animationFPS = MODEL_DEFAULT_ANIMATION_FPS; - _glowLevel = 0.0f; - - _jointMappingCompleted = false; - _lastAnimated = now; + rgbColor defaultColor = { 0, 0, 0 }; + init(glm::vec3(), 0.0f, defaultColor, modelItemID.id); setProperties(properties); } diff --git a/libraries/models/src/ModelItem.h b/libraries/models/src/ModelItem.h index 9a558f2ef4..563d394419 100644 --- a/libraries/models/src/ModelItem.h +++ b/libraries/models/src/ModelItem.h @@ -276,6 +276,7 @@ public: // these methods allow you to create models, and later edit them. static uint32_t getIDfromCreatorTokenID(uint32_t creatorTokenID); static uint32_t getNextCreatorTokenID(); + static uint32_t getNextModelItemID(); static void handleAddModelResponse(const QByteArray& packet); void mapJoints(const QStringList& modelJointNames); diff --git a/libraries/models/src/ModelsScriptingInterface.cpp b/libraries/models/src/ModelsScriptingInterface.cpp index 7e08571fe5..f4cbf14086 100644 --- a/libraries/models/src/ModelsScriptingInterface.cpp +++ b/libraries/models/src/ModelsScriptingInterface.cpp @@ -28,8 +28,9 @@ ModelItemID ModelsScriptingInterface::addModel(const ModelItemProperties& proper // The application will keep track of creatorTokenID uint32_t creatorTokenID = ModelItem::getNextCreatorTokenID(); + uint32_t modelID = ModelItem::getNextModelItemID(); - ModelItemID id(NEW_MODEL, creatorTokenID, false ); + ModelItemID id(modelID, creatorTokenID, false ); // queue the packet queueModelMessage(PacketTypeModelAddOrEdit, id, properties); From c333fb904f88fa109a8776bd5a8a11b8ed17bbd0 Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Thu, 5 Jun 2014 16:45:13 -0700 Subject: [PATCH 10/42] Working on tests for delta streaming. --- tests/metavoxels/src/MetavoxelTests.cpp | 32 ++++++++++++++++++++++++- tests/metavoxels/src/MetavoxelTests.h | 21 ++++++++++++++++ 2 files changed, 52 insertions(+), 1 deletion(-) diff --git a/tests/metavoxels/src/MetavoxelTests.cpp b/tests/metavoxels/src/MetavoxelTests.cpp index cb1b5c7900..c4d973ad05 100644 --- a/tests/metavoxels/src/MetavoxelTests.cpp +++ b/tests/metavoxels/src/MetavoxelTests.cpp @@ -229,6 +229,20 @@ Endpoint::Endpoint(const QByteArray& datagramHeader) : connect(_sequencer, SIGNAL(receivedHighPriorityMessage(const QVariant&)), SLOT(handleHighPriorityMessage(const QVariant&))); + connect(_sequencer, SIGNAL(sendAcknowledged(int)), SLOT(clearSendRecordsBefore(int))); + connect(_sequencer, SIGNAL(receiveAcknowledged(int)), SLOT(clearReceiveRecordsBefore(int))); + + // insert the baseline send record + SendRecord sendRecord = { 0 }; + _sendRecords.append(sendRecord); + + // insert the baseline receive record + ReceiveRecord receiveRecord = { 0 }; + _receiveRecords.append(receiveRecord); + + // create the object that represents out delta-encoded state + //_localState = new TestSharedObjectA(); + connect(_sequencer->getReliableInputChannel(), SIGNAL(receivedMessage(const QVariant&)), SLOT(handleReliableMessage(const QVariant&))); @@ -326,7 +340,7 @@ bool Endpoint::simulate(int iterationNumber) { // send a packet try { Bitstream& out = _sequencer->startPacket(); - SequencedTestMessage message = { iterationNumber, createRandomMessage() }; + SequencedTestMessage message = { iterationNumber, createRandomMessage(), _localState }; _unreliableMessagesSent.append(message); unreliableMessagesSent++; out << message; @@ -337,6 +351,10 @@ bool Endpoint::simulate(int iterationNumber) { return true; } + // record the send + SendRecord record = { _sequencer->getOutgoingPacketNumber(), _localState }; + _sendRecords.append(record); + return false; } @@ -387,6 +405,10 @@ void Endpoint::readMessage(Bitstream& in) { SequencedTestMessage message; in >> message; + // record the receipt + ReceiveRecord record = { _sequencer->getIncomingPacketNumber(), message.state }; + _receiveRecords.append(record); + for (QList::iterator it = _other->_unreliableMessagesSent.begin(); it != _other->_unreliableMessagesSent.end(); it++) { if (it->sequenceNumber == message.sequenceNumber) { @@ -430,6 +452,14 @@ void Endpoint::readReliableChannel() { streamedBytesReceived += bytes.size(); } +void Endpoint::clearSendRecordsBefore(int index) { + _sendRecords.erase(_sendRecords.begin(), _sendRecords.begin() + index + 1); +} + +void Endpoint::clearReceiveRecordsBefore(int index) { + _receiveRecords.erase(_receiveRecords.begin(), _receiveRecords.begin() + index + 1); +} + TestSharedObjectA::TestSharedObjectA(float foo, TestEnum baz, TestFlags bong) : _foo(foo), _baz(baz), diff --git a/tests/metavoxels/src/MetavoxelTests.h b/tests/metavoxels/src/MetavoxelTests.h index ffd1311f00..dc294692af 100644 --- a/tests/metavoxels/src/MetavoxelTests.h +++ b/tests/metavoxels/src/MetavoxelTests.h @@ -54,9 +54,29 @@ private slots: void handleReliableMessage(const QVariant& message); void readReliableChannel(); + void clearSendRecordsBefore(int index); + void clearReceiveRecordsBefore(int index); + private: + class SendRecord { + public: + int packetNumber; + SharedObjectPointer localState; + }; + + class ReceiveRecord { + public: + int packetNumber; + SharedObjectPointer remoteState; + }; + DatagramSequencer* _sequencer; + QList _sendRecords; + QList _receiveRecords; + + SharedObjectPointer _localState; + Endpoint* _other; QList > _delayedDatagrams; float _highPriorityMessagesToSend; @@ -195,6 +215,7 @@ public: STREAM int sequenceNumber; STREAM QVariant submessage; + STREAM SharedObjectPointer state; }; DECLARE_STREAMABLE_METATYPE(SequencedTestMessage) From 005a314695545fd1c9d24a6161f4e6bff77c0928 Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Thu, 5 Jun 2014 17:30:19 -0700 Subject: [PATCH 11/42] Reenable enum streamers here. --- libraries/metavoxels/src/Bitstream.cpp | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/libraries/metavoxels/src/Bitstream.cpp b/libraries/metavoxels/src/Bitstream.cpp index 387b41a839..30d34580d7 100644 --- a/libraries/metavoxels/src/Bitstream.cpp +++ b/libraries/metavoxels/src/Bitstream.cpp @@ -92,14 +92,13 @@ int Bitstream::registerMetaObject(const char* className, const QMetaObject* meta } // register the streamers for all enumerators - // temporarily disabled: crashes on Windows - //for (int i = 0; i < metaObject->enumeratorCount(); i++) { - // QMetaEnum metaEnum = metaObject->enumerator(i); - // const TypeStreamer*& streamer = getEnumStreamers()[QPair(metaEnum.scope(), metaEnum.name())]; - // if (!streamer) { - // getEnumStreamersByName().insert(getEnumName(metaEnum), streamer = new EnumTypeStreamer(metaEnum)); - // } - //} + for (int i = 0; i < metaObject->enumeratorCount(); i++) { + QMetaEnum metaEnum = metaObject->enumerator(i); + const TypeStreamer*& streamer = getEnumStreamers()[QPair(metaEnum.scope(), metaEnum.name())]; + if (!streamer) { + getEnumStreamersByName().insert(getEnumName(metaEnum), streamer = new EnumTypeStreamer(metaEnum)); + } + } return 0; } From 9322e1f71b5d3e0f31127f3ef3b1762a24bdcd4f Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Thu, 5 Jun 2014 17:36:56 -0700 Subject: [PATCH 12/42] More work on editModels --- examples/editModels.js | 205 ++++++++++++++++++++++++++++------------- 1 file changed, 139 insertions(+), 66 deletions(-) diff --git a/examples/editModels.js b/examples/editModels.js index 8e2f6b4911..67e2bdb198 100644 --- a/examples/editModels.js +++ b/examples/editModels.js @@ -18,7 +18,8 @@ var toolWidth = 50; var LASER_WIDTH = 4; var LASER_COLOR = { red: 255, green: 0, blue: 0 }; -var LASER_LENGTH_FACTOR = 5; +var LASER_LENGTH_FACTOR = 500 +; var LEFT = 0; var RIGHT = 1; @@ -92,6 +93,11 @@ function controller(wichSide) { this.oldModelPosition; this.oldModelRadius; + this.positionAtGrab; + this.rotationAtGrab; + this.modelPositionAtGrab; + this.modelRotationAtGrab; + this.jointsIntersectingFromStart = []; this.laser = Overlays.addOverlay("line3d", { @@ -149,6 +155,11 @@ function controller(wichSide) { this.oldModelRotation = properties.modelRotation; this.oldModelRadius = properties.radius; + this.positionAtGrab = this.palmPosition; + this.rotationAtGrab = this.rotation; + this.modelPositionAtGrab = properties.position; + this.modelRotationAtGrab = properties.modelRotation; + this.jointsIntersectingFromStart = []; for (var i = 0; i < jointList.length; i++) { var distance = Vec3.distance(MyAvatar.getJointPosition(jointList[i]), this.oldModelPosition); @@ -174,12 +185,16 @@ function controller(wichSide) { } } - print("closestJoint: " + jointList[closestJointIndex]); - print("closestJointDistance (attach max distance): " + closestJointDistance + " (" + this.oldModelRadius + ")"); + if (closestJointIndex != -1) { + print("closestJoint: " + jointList[closestJointIndex]); + print("closestJointDistance (attach max distance): " + closestJointDistance + " (" + this.oldModelRadius + ")"); + } if (closestJointDistance < this.oldModelRadius) { - if (this.jointsIntersectingFromStart.indexOf(closestJointIndex) != -1) { + if (this.jointsIntersectingFromStart.indexOf(closestJointIndex) != -1 || + (leftController.grabbing && rightController.grabbing && + leftController.modelID.id == rightController.modelID.id)) { // Do nothing } else { print("Attaching to " + jointList[closestJointIndex]); @@ -193,6 +208,7 @@ function controller(wichSide) { MyAvatar.attach(this.modelURL, jointList[closestJointIndex], attachmentOffset, attachmentRotation, 2.0 * this.oldModelRadius, true, false); + Models.deleteModel(this.modelID); } } @@ -281,12 +297,11 @@ function controller(wichSide) { }); this.showLaser(!this.grabbing || mode == 0); - + if (this.glowedIntersectingModel.isKnownID) { + Models.editModel(this.glowedIntersectingModel, { glowLevel: 0.0 }); + this.glowedIntersectingModel.isKnownID = false; + } if (!this.grabbing) { - if (this.glowedIntersectingModel.isKnownID) { - Models.editModel(this.glowedIntersectingModel, { glowLevel: 0.0 }); - } - var intersection = Models.findRayIntersection({ origin: this.palmPosition, direction: this.front @@ -307,6 +322,14 @@ function controller(wichSide) { this.moveModel = function () { if (this.grabbing) { + if (!this.modelID.isKnownID) { + print("Unknown grabbed ID " + this.modelID.id + ", isKnown: " + this.modelID.isKnownID); + this.modelID = Models.findRayIntersection({ + origin: this.palmPosition, + direction: this.front + }).modelID; + print("Identified ID " + this.modelID.id + ", isKnown: " + this.modelID.isKnownID); + } var newPosition; var newRotation; @@ -318,15 +341,22 @@ function controller(wichSide) { Vec3.multiply(this.up, this.y)); newPosition = Vec3.sum(newPosition, Vec3.multiply(this.right, this.z)); + + + newRotation = Quat.multiply(this.rotation, + Quat.inverse(this.oldRotation)); + newRotation = Quat.multiply(newRotation, + this.oldModelRotation); break; case 1: var forward = Vec3.multiplyQbyV(MyAvatar.orientation, { x: 0, y: 0, z: -1 }); var d = Vec3.dot(forward, MyAvatar.position); - var factor1 = Vec3.dot(forward, this.palmPosition) - d; - var factor2 = Vec3.dot(forward, this.oldModelPosition) - d; - var vector = Vec3.subtract(this.palmPosition, this.oldPalmPosition); + var factor1 = Vec3.dot(forward, this.positionAtGrab) - d; + var factor2 = Vec3.dot(forward, this.modelPositionAtGrab) - d; + var vector = Vec3.subtract(this.palmPosition, this.positionAtGrab); + print("factor1: " + factor1 + ", factor2: " + factor2); if (factor2 < 0) { factor2 = 0; } @@ -335,19 +365,17 @@ function controller(wichSide) { factor2 = 1; } - newPosition = Vec3.sum(this.oldModelPosition, + newPosition = Vec3.sum(this.modelPositionAtGrab, Vec3.multiply(vector, factor2 / factor1)); + + newRotation = Quat.multiply(this.rotation, + Quat.inverse(this.rotationAtGrab)); + newRotation = Quat.multiply(newRotation, + this.modelRotationAtGrab); break; } - - - newRotation = Quat.multiply(this.rotation, - Quat.inverse(this.oldRotation)); - newRotation = Quat.multiply(newRotation, - this.oldModelRotation); - Models.editModel(this.modelID, { position: newPosition, modelRotation: newRotation @@ -367,8 +395,46 @@ function controller(wichSide) { for (var i = 0; i < indicesToRemove.length; ++i) { this.jointsIntersectingFromStart.splice(this.jointsIntersectingFromStart.indexOf(indicesToRemove[i], 1)); } + + + jointList = MyAvatar.getJointNames(); + + var closestJointIndex = -1; + var closestJointDistance = 999999; + for (var i = 0; i < jointList.length; i++) { + var distance = Vec3.distance(MyAvatar.getJointPosition(jointList[i]), this.oldModelPosition); + if (distance < closestJointDistance) { + closestJointDistance = distance; + closestJointIndex = i; + } + } + + if (closestJointDistance < this.oldModelRadius) { + if (this.jointsIntersectingFromStart.indexOf(closestJointIndex) != -1 || + (leftController.grabbing && rightController.grabbing && + leftController.modelID.id == rightController.modelID.id)) { + // Do nothing + } else { + Vec3.print("Ball at: ", MyAvatar.getJointPosition(closestJointIndex)); + Overlays.editOverlay(this.ballGlowingJoint, { + position: MyAvatar.getJointPosition(closestJointIndex), + glowLevel: 0.25, + visible: true + }); + } + } else { + Overlays.editOverlay(this.ballGlowingJoint, { glowLevel: 0.0, visible: false }); + } } } + this.ballGlowingJoint = Overlays.addOverlay("sphere", { + position: { x: 0, y: 0, z: 0 }, + size: 1, + solid: true, + color: { red: 0, green: 255, blue: 0 }, + alpha: 1, + visible: false, + anchor: "MyAvatar"}); this.update = function () { this.oldPalmPosition = this.palmPosition; @@ -420,8 +486,12 @@ function controller(wichSide) { var attachmentIndex = -1; var attachmentX = LASER_LENGTH_FACTOR; + var newModel; + var newProperties; + for (var i = 0; i < attachments.length; ++i) { - var position = Vec3.sum(MyAvatar.getJointPosition(attachments[i].jointName), attachments[i].translation); + var position = Vec3.sum(MyAvatar.getJointPosition(attachments[i].jointName), + Vec3.multiplyQbyV(MyAvatar.getJointCombinedRotation(attachments[i].jointName), attachments[i].translation)); var scale = attachments[i].scale; var A = this.palmPosition; @@ -439,53 +509,56 @@ function controller(wichSide) { } if (attachmentIndex != -1) { + print("Detaching: " + attachments[attachmentIndex].modelURL); MyAvatar.detachOne(attachments[attachmentIndex].modelURL, attachments[attachmentIndex].jointName); - Models.addModel({ - position: Vec3.sum(MyAvatar.getJointPosition(attachments[attachmentIndex].jointName), - attachments[attachmentIndex].translation), - modelRotation: Quat.multiply(MyAvatar.getJointCombinedRotation(attachments[attachmentIndex].jointName), - attachments[attachmentIndex].rotation), - radius: attachments[attachmentIndex].scale / 2.0, - modelURL: attachments[attachmentIndex].modelURL - }); - } - - // There is none so ... - // Checking model tree - Vec3.print("Looking at: ", this.palmPosition); - var pickRay = { origin: this.palmPosition, - direction: Vec3.normalize(Vec3.subtract(this.tipPosition, this.palmPosition)) }; - var foundIntersection = Models.findRayIntersection(pickRay); - - if(!foundIntersection.accurate) { - return; - } - var foundModel = foundIntersection.modelID; - - if (!foundModel.isKnownID) { - var identify = Models.identifyModel(foundModel); - if (!identify.isKnownID) { - print("Unknown ID " + identify.id + " (update loop " + foundModel.id + ")"); - return; - } - foundModel = identify; - } - - var properties = Models.getModelProperties(foundModel); - print("foundModel.modelURL=" + properties.modelURL); - - if (isLocked(properties)) { - print("Model locked " + properties.id); + + newProperties = { + position: Vec3.sum(MyAvatar.getJointPosition(attachments[attachmentIndex].jointName), + Vec3.multiplyQbyV(MyAvatar.getJointCombinedRotation(attachments[attachmentIndex].jointName), attachments[attachmentIndex].translation)), + modelRotation: Quat.multiply(MyAvatar.getJointCombinedRotation(attachments[attachmentIndex].jointName), + attachments[attachmentIndex].rotation), + radius: attachments[attachmentIndex].scale / 2.0, + modelURL: attachments[attachmentIndex].modelURL + }; + newModel = Models.addModel(newProperties); } else { - print("Checking properties: " + properties.id + " " + properties.isKnownID); - var check = this.checkModel(properties); - if (check.valid) { - this.grab(foundModel, properties); - this.x = check.x; - this.y = check.y; - this.z = check.z; + // There is none so ... + // Checking model tree + Vec3.print("Looking at: ", this.palmPosition); + var pickRay = { origin: this.palmPosition, + direction: Vec3.normalize(Vec3.subtract(this.tipPosition, this.palmPosition)) }; + var foundIntersection = Models.findRayIntersection(pickRay); + + if(!foundIntersection.accurate) { + print("No accurate intersection"); return; } + newModel = foundIntersection.modelID; + + if (!newModel.isKnownID) { + var identify = Models.identifyModel(newModel); + if (!identify.isKnownID) { + print("Unknown ID " + identify.id + " (update loop " + newModel.id + ")"); + return; + } + newModel = identify; + } + newProperties = Models.getModelProperties(newModel); + } + + + print("foundModel.modelURL=" + newProperties.modelURL); + + if (isLocked(newProperties)) { + print("Model locked " + newProperties.id); + } else { + this.grab(newModel, newProperties); + + var check = this.checkModel(newProperties); + this.x = check.x; + this.y = check.y; + this.z = check.z; + return; } } } @@ -503,8 +576,8 @@ var rightController = new controller(RIGHT); function moveModels() { if (leftController.grabbing && rightController.grabbing && rightController.modelID.id == leftController.modelID.id) { - var newPosition = this.oldModelPosition; - var rotation = this.oldModelRotation; + var newPosition = leftController.oldModelPosition; + var rotation = leftController.oldModelRotation; var ratio = 1; From 1a7e3a859cafe5c344b912b221580f12981abd92 Mon Sep 17 00:00:00 2001 From: wangyix Date: Thu, 5 Jun 2014 18:00:58 -0700 Subject: [PATCH 13/42] started work on resending nacked packets --- assignment-client/src/models/ModelServer.cpp | 2 +- .../src/octree/OctreeQueryNode.cpp | 35 ++++++++++++++- .../src/octree/OctreeQueryNode.h | 16 ++++++- .../src/octree/OctreeSendThread.cpp | 36 ++++++++++++++- .../src/octree/OctreeSendThread.h | 3 ++ assignment-client/src/octree/OctreeServer.cpp | 28 ++++++++++-- .../src/octree/SentPacketHistory.cpp | 45 +++++++++++++++++++ .../src/octree/SentPacketHistory.h | 36 +++++++++++++++ .../src/particles/ParticleServer.cpp | 2 +- assignment-client/src/voxels/VoxelServer.cpp | 2 +- libraries/networking/src/PacketHeaders.h | 1 + 11 files changed, 196 insertions(+), 10 deletions(-) create mode 100644 assignment-client/src/octree/SentPacketHistory.cpp create mode 100644 assignment-client/src/octree/SentPacketHistory.h diff --git a/assignment-client/src/models/ModelServer.cpp b/assignment-client/src/models/ModelServer.cpp index ff2367ec6e..07359f001a 100644 --- a/assignment-client/src/models/ModelServer.cpp +++ b/assignment-client/src/models/ModelServer.cpp @@ -106,7 +106,7 @@ int ModelServer::sendSpecialPacket(OctreeQueryNode* queryNode, const SharedNodeP //qDebug() << "sending PacketType_MODEL_ERASE packetLength:" << packetLength; NodeList::getInstance()->writeDatagram((char*) outputBuffer, packetLength, SharedNodePointer(node)); - queryNode->incrementSequenceNumber(); + queryNode->packetSent(outputBuffer, packetLength); } nodeData->setLastDeletedModelsSentAt(deletePacketSentAt); diff --git a/assignment-client/src/octree/OctreeQueryNode.cpp b/assignment-client/src/octree/OctreeQueryNode.cpp index 6acd85bff6..e0ca6a4f1e 100644 --- a/assignment-client/src/octree/OctreeQueryNode.cpp +++ b/assignment-client/src/octree/OctreeQueryNode.cpp @@ -41,7 +41,8 @@ OctreeQueryNode::OctreeQueryNode() : _sequenceNumber(0), _lastRootTimestamp(0), _myPacketType(PacketTypeUnknown), - _isShuttingDown(false) + _isShuttingDown(false), + _sentPacketHistory(1000) { } @@ -362,3 +363,35 @@ void OctreeQueryNode::dumpOutOfView() { } } } + +void OctreeQueryNode::packetSent() { + packetSent(_octreePacket, getPacketLength()); +} + +void OctreeQueryNode::packetSent(unsigned char* packet, int packetLength) { + packetSent(QByteArray((char*)packet, packetLength)); +} + +void OctreeQueryNode::packetSent(const QByteArray& packet) { + _sentPacketHistory.packetSent(_sequenceNumber, packet); + _sequenceNumber++; +} + + +void OctreeQueryNode::addSequenceNumbersToResend(const QList& sequenceNumbers) { + _sequenceNumbersToResend.append(sequenceNumbers); +} + +bool OctreeQueryNode::hasNextPacketToResend() const { + return !_sequenceNumbersToResend.isEmpty(); +} + +const QByteArray* OctreeQueryNode::getNextPacketToResend() { + + if (!_sequenceNumbersToResend.isEmpty()) { + const QByteArray* nextPacket = _sentPacketHistory.getPacket(_sequenceNumbersToResend.first()); + _sequenceNumbersToResend.pop_front(); + return nextPacket; // could be null + } + return NULL; +} \ No newline at end of file diff --git a/assignment-client/src/octree/OctreeQueryNode.h b/assignment-client/src/octree/OctreeQueryNode.h index eb420039e6..4a2355f7cc 100644 --- a/assignment-client/src/octree/OctreeQueryNode.h +++ b/assignment-client/src/octree/OctreeQueryNode.h @@ -23,6 +23,9 @@ #include #include #include // for SharedAssignmentPointer +#include "SentPacketHistory.h" + +#include // i added dis class OctreeSendThread; @@ -100,10 +103,16 @@ public: void forceNodeShutdown(); bool isShuttingDown() const { return _isShuttingDown; } - void incrementSequenceNumber() { _sequenceNumber++; } + void packetSent(); + void packetSent(unsigned char* packet, int packetLength); + void packetSent(const QByteArray& packet); OCTREE_PACKET_SEQUENCE getSequenceNumber() const { return _sequenceNumber; } - + + void addSequenceNumbersToResend(const QList& sequenceNumbers); + bool hasNextPacketToResend() const; + const QByteArray* getNextPacketToResend(); + private slots: void sendThreadFinished(); @@ -146,6 +155,9 @@ private: PacketType _myPacketType; bool _isShuttingDown; + +SentPacketHistory _sentPacketHistory; +QQueue _sequenceNumbersToResend; }; #endif // hifi_OctreeQueryNode_h diff --git a/assignment-client/src/octree/OctreeSendThread.cpp b/assignment-client/src/octree/OctreeSendThread.cpp index 9e4dbcd347..5767f2623b 100644 --- a/assignment-client/src/octree/OctreeSendThread.cpp +++ b/assignment-client/src/octree/OctreeSendThread.cpp @@ -274,13 +274,47 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes trueBytesSent += nodeData->getPacketLength(); truePacketsSent++; packetsSent++; - nodeData->incrementSequenceNumber(); + nodeData->packetSent(); nodeData->resetOctreePacket(); } return packetsSent; } + + + + +int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { + + int packetsSent = 0; + + const QByteArray* packet; + while (nodeData->hasNextPacketToResend()) { + packet = nodeData->getNextPacketToResend(); + if (packet) { + NodeList::getInstance()->writeDatagram(*packet, _node); + packetsSent++; + + // ?????? + _totalBytes += packet->size(); + _totalPackets++; + _totalWastedBytes += MAX_PACKET_SIZE - packet->size(); // ??? + } + } + +} + + + + + + + + + + + /// Version of voxel distributor that sends the deepest LOD level at once int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrustumChanged) { diff --git a/assignment-client/src/octree/OctreeSendThread.h b/assignment-client/src/octree/OctreeSendThread.h index d8eed27802..cc0cdac3ad 100644 --- a/assignment-client/src/octree/OctreeSendThread.h +++ b/assignment-client/src/octree/OctreeSendThread.h @@ -55,6 +55,9 @@ private: int _nodeMissingCount; bool _isShuttingDown; + +int resendNackedPackets(OctreeQueryNode* nodeData); + }; #endif // hifi_OctreeSendThread_h diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp index 5769c15ef1..f60f0fc2d5 100644 --- a/assignment-client/src/octree/OctreeServer.cpp +++ b/assignment-client/src/octree/OctreeServer.cpp @@ -832,14 +832,14 @@ void OctreeServer::readPendingDatagrams() { PacketType packetType = packetTypeForPacket(receivedPacket); SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket); if (packetType == getMyQueryMessageType()) { - + // If we got a query packet, then we're talking to an agent, and we // need to make sure we have it in our nodeList. if (matchingNode) { nodeList->updateNodeWithDataFromPacket(matchingNode, receivedPacket); - OctreeQueryNode* nodeData = (OctreeQueryNode*) matchingNode->getLinkedData(); + OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); if (nodeData && !nodeData->isOctreeSendThreadInitalized()) { - + // NOTE: this is an important aspect of the proper ref counting. The send threads/node data need to // know that the OctreeServer/Assignment will not get deleted on it while it's still active. The // solution is to get the shared pointer for the current assignment. We need to make sure this is the @@ -848,6 +848,28 @@ void OctreeServer::readPendingDatagrams() { nodeData->initializeOctreeSendThread(sharedAssignment, matchingNode); } } + + } else if (packetType == PacketTypeOctreeDataNack) { + +// parse packet for sequence numbers that need to be resent +int numBytesPacketHeader = numBytesForPacketHeader(receivedPacket); +const unsigned char* dataAt = reinterpret_cast(receivedPacket.data()) + numBytesPacketHeader; + +uint16_t numSequenceNumbers = (*(uint16_t*)dataAt); +dataAt += sizeof(uint16_t); + +// read sequence numbers +QList sequenceNumbers; +for (int i = 0; i < numSequenceNumbers; i++) { + sequenceNumbers.append(*(OCTREE_PACKET_SEQUENCE*)dataAt); + dataAt += sizeof(OCTREE_PACKET_SEQUENCE); +} + +OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); // move this or something +nodeData->addSequenceNumbersToResend(sequenceNumbers); + + + } else if (packetType == PacketTypeJurisdictionRequest) { _jurisdictionSender->queueReceivedPacket(matchingNode, receivedPacket); } else if (_octreeInboundPacketProcessor && getOctree()->handlesEditPacketType(packetType)) { diff --git a/assignment-client/src/octree/SentPacketHistory.cpp b/assignment-client/src/octree/SentPacketHistory.cpp new file mode 100644 index 0000000000..0de163a23d --- /dev/null +++ b/assignment-client/src/octree/SentPacketHistory.cpp @@ -0,0 +1,45 @@ +// +// SentPacketHistory.cpp +// assignement-client/src/octree +// +// Created by Yixin Wang on 6/5/2014 +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#include "SentPacketHistory.h" + +SentPacketHistory::SentPacketHistory(int size) + : _sentPackets(size), + _newestPacketAt(0), + _numExistingPackets(0), + _newestSequenceNumber(0) +{ +} + +void SentPacketHistory::packetSent(OCTREE_PACKET_SEQUENCE sequenceNumber, const QByteArray& packet) { + _newestSequenceNumber = sequenceNumber; + + // increment _newestPacketAt cyclically, insert new packet there + _newestPacketAt = (_newestPacketAt == _sentPackets.size() - 1) ? 0 : _newestPacketAt + 1; + _sentPackets[_newestPacketAt] = packet; + + if (_numExistingPackets < _sentPackets.size()) { + _numExistingPackets++; + } +} + + +const QByteArray* SentPacketHistory::getPacket(OCTREE_PACKET_SEQUENCE sequenceNumber) const { + + OCTREE_PACKET_SEQUENCE seqDiff = _newestSequenceNumber - sequenceNumber; + if (!(seqDiff >= 0 && seqDiff < _numExistingPackets)) { + return NULL; + } + + int packetAt = _newestPacketAt - seqDiff; + if (packetAt < 0) { packetAt += _sentPackets.size(); } + + return &_sentPackets.at(packetAt); +} \ No newline at end of file diff --git a/assignment-client/src/octree/SentPacketHistory.h b/assignment-client/src/octree/SentPacketHistory.h new file mode 100644 index 0000000000..cbc50bc73c --- /dev/null +++ b/assignment-client/src/octree/SentPacketHistory.h @@ -0,0 +1,36 @@ +// +// SentPacketHistory.h +// assignement-client/src/octree +// +// Created by Yixin Wang on 6/5/2014 +// +// Distributed under the Apache License, Version 2.0. +// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html +// + +#ifndef hifi_SentPacketHistory_h +#define hifi_SentPacketHistory_h + +#include +#include + +#include "OctreePacketData.h" + +class SentPacketHistory { + +public: + SentPacketHistory(int size); + + void packetSent(OCTREE_PACKET_SEQUENCE sequenceNumber, const QByteArray& packet); + const QByteArray* getPacket(OCTREE_PACKET_SEQUENCE sequenceNumber) const; + +private: + + QVector _sentPackets; // circular buffer + int _newestPacketAt; + int _numExistingPackets; + + OCTREE_PACKET_SEQUENCE _newestSequenceNumber; +}; + +#endif diff --git a/assignment-client/src/particles/ParticleServer.cpp b/assignment-client/src/particles/ParticleServer.cpp index 1dd65f11f3..e7a0f75dfd 100644 --- a/assignment-client/src/particles/ParticleServer.cpp +++ b/assignment-client/src/particles/ParticleServer.cpp @@ -106,7 +106,7 @@ int ParticleServer::sendSpecialPacket(OctreeQueryNode* queryNode, const SharedNo //qDebug() << "sending PacketType_PARTICLE_ERASE packetLength:" << packetLength; NodeList::getInstance()->writeDatagram((char*) outputBuffer, packetLength, SharedNodePointer(node)); - queryNode->incrementSequenceNumber(); + queryNode->packetSent(outputBuffer, packetLength); } nodeData->setLastDeletedParticlesSentAt(deletePacketSentAt); diff --git a/assignment-client/src/voxels/VoxelServer.cpp b/assignment-client/src/voxels/VoxelServer.cpp index 8f4a8bab36..34b01f529a 100644 --- a/assignment-client/src/voxels/VoxelServer.cpp +++ b/assignment-client/src/voxels/VoxelServer.cpp @@ -75,7 +75,7 @@ int VoxelServer::sendSpecialPacket(OctreeQueryNode* queryNode, const SharedNodeP } NodeList::getInstance()->writeDatagram((char*) _tempOutputBuffer, envPacketLength, SharedNodePointer(node)); - queryNode->incrementSequenceNumber(); + queryNode->packetSent(_tempOutputBuffer, envPacketLength); return envPacketLength; } diff --git a/libraries/networking/src/PacketHeaders.h b/libraries/networking/src/PacketHeaders.h index 9c764f9f02..a73ffe8564 100644 --- a/libraries/networking/src/PacketHeaders.h +++ b/libraries/networking/src/PacketHeaders.h @@ -66,6 +66,7 @@ enum PacketType { PacketTypeModelAddOrEdit, PacketTypeModelErase, PacketTypeModelAddResponse, + PacketTypeOctreeDataNack }; typedef char PacketVersion; From e8724b02f307e8f265cd08dc79d6a2cd17813d43 Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Fri, 6 Jun 2014 08:50:57 -0700 Subject: [PATCH 14/42] add CapsuleShape::setEndPoints() --- libraries/shared/src/CapsuleShape.cpp | 32 +++++++++++++++------------ libraries/shared/src/CapsuleShape.h | 1 + 2 files changed, 19 insertions(+), 14 deletions(-) diff --git a/libraries/shared/src/CapsuleShape.cpp b/libraries/shared/src/CapsuleShape.cpp index 11bd70f8d2..8e887107dc 100644 --- a/libraries/shared/src/CapsuleShape.cpp +++ b/libraries/shared/src/CapsuleShape.cpp @@ -33,20 +33,7 @@ CapsuleShape::CapsuleShape(float radius, float halfHeight, const glm::vec3& posi CapsuleShape::CapsuleShape(float radius, const glm::vec3& startPoint, const glm::vec3& endPoint) : Shape(Shape::CAPSULE_SHAPE), _radius(radius), _halfHeight(0.0f) { - glm::vec3 axis = endPoint - startPoint; - _position = 0.5f * (endPoint + startPoint); - float height = glm::length(axis); - if (height > EPSILON) { - _halfHeight = 0.5f * height; - axis /= height; - glm::vec3 yAxis(0.0f, 1.0f, 0.0f); - float angle = glm::angle(axis, yAxis); - if (angle > EPSILON) { - axis = glm::normalize(glm::cross(yAxis, axis)); - _rotation = glm::angleAxis(angle, axis); - } - } - updateBoundingRadius(); + setEndPoints(startPoint, endPoint); } /// \param[out] startPoint is the center of start cap @@ -80,3 +67,20 @@ void CapsuleShape::setRadiusAndHalfHeight(float radius, float halfHeight) { updateBoundingRadius(); } +void CapsuleShape::setEndPoints(const glm::vec3& startPoint, const glm::vec3& endPoint) { + glm::vec3 axis = endPoint - startPoint; + _position = 0.5f * (endPoint + startPoint); + float height = glm::length(axis); + if (height > EPSILON) { + _halfHeight = 0.5f * height; + axis /= height; + glm::vec3 yAxis(0.0f, 1.0f, 0.0f); + float angle = glm::angle(axis, yAxis); + if (angle > EPSILON) { + axis = glm::normalize(glm::cross(yAxis, axis)); + _rotation = glm::angleAxis(angle, axis); + } + } + updateBoundingRadius(); +} + diff --git a/libraries/shared/src/CapsuleShape.h b/libraries/shared/src/CapsuleShape.h index 0889f6b2f3..756ae18911 100644 --- a/libraries/shared/src/CapsuleShape.h +++ b/libraries/shared/src/CapsuleShape.h @@ -37,6 +37,7 @@ public: void setRadius(float radius); void setHalfHeight(float height); void setRadiusAndHalfHeight(float radius, float height); + void setEndPoints(const glm::vec3& startPoint, const glm::vec3& endPoint); protected: void updateBoundingRadius() { _boundingRadius = _radius + _halfHeight; } From 551029c2f5e696f054f987d34b40fa6da56a8697 Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Fri, 6 Jun 2014 08:51:22 -0700 Subject: [PATCH 15/42] slave SkeletonModel's collision shapes to RagDoll --- interface/src/Menu.cpp | 1 + interface/src/Menu.h | 1 + interface/src/avatar/SkeletonModel.cpp | 20 +++++++++-- interface/src/avatar/SkeletonModel.h | 1 + interface/src/renderer/Model.h | 2 +- interface/src/renderer/RagDoll.cpp | 46 +++++++++++++++++++++++--- interface/src/renderer/RagDoll.h | 23 +++++++++++-- 7 files changed, 82 insertions(+), 12 deletions(-) diff --git a/interface/src/Menu.cpp b/interface/src/Menu.cpp index 5d9cd1f1c4..e429a81fa2 100644 --- a/interface/src/Menu.cpp +++ b/interface/src/Menu.cpp @@ -353,6 +353,7 @@ Menu::Menu() : addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::RenderSkeletonCollisionShapes); addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::RenderHeadCollisionShapes); addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::RenderBoundingCollisionShapes); + addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::CollideAsRagDoll); addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::LookAtVectors, 0, false); addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, diff --git a/interface/src/Menu.h b/interface/src/Menu.h index 6bc9adef05..c7d3a94741 100644 --- a/interface/src/Menu.h +++ b/interface/src/Menu.h @@ -311,6 +311,7 @@ namespace MenuOption { const QString CascadedShadows = "Cascaded"; const QString Chat = "Chat..."; const QString ChatCircling = "Chat Circling"; + const QString CollideAsRagDoll = "Collide As RagDoll"; const QString CollideWithAvatars = "Collide With Avatars"; const QString CollideWithEnvironment = "Collide With World Boundaries"; const QString CollideWithParticles = "Collide With Particles"; diff --git a/interface/src/avatar/SkeletonModel.cpp b/interface/src/avatar/SkeletonModel.cpp index f5ca1ab218..ca40ba1d64 100644 --- a/interface/src/avatar/SkeletonModel.cpp +++ b/interface/src/avatar/SkeletonModel.cpp @@ -23,7 +23,10 @@ SkeletonModel::SkeletonModel(Avatar* owningAvatar) : void SkeletonModel::setJointStates(QVector states) { Model::setJointStates(states); - _ragDoll.init(_jointStates); + + if (isActive() && _owningAvatar->isMyAvatar()) { + _ragDoll.init(_jointStates); + } } const float PALM_PRIORITY = 3.0f; @@ -88,7 +91,7 @@ void SkeletonModel::simulate(float deltaTime, bool fullUpdate) { } void SkeletonModel::simulateRagDoll(float deltaTime) { - _ragDoll.slaveToSkeleton(_jointStates, 0.5f); + _ragDoll.slaveToSkeleton(_jointStates, 0.1f); // fraction = 0.1f left intentionally low for demo purposes float MIN_CONSTRAINT_ERROR = 0.005f; // 5mm int MAX_ITERATIONS = 4; @@ -141,7 +144,9 @@ void SkeletonModel::getBodyShapes(QVector& shapes) const { void SkeletonModel::renderIKConstraints() { renderJointConstraints(getRightHandJointIndex()); renderJointConstraints(getLeftHandJointIndex()); - renderRagDoll(); + if (isActive() && _owningAvatar->isMyAvatar()) { + renderRagDoll(); + } } class IndexValue { @@ -254,6 +259,15 @@ void SkeletonModel::updateJointState(int index) { } } +void SkeletonModel::updateShapePositions() { + if (isActive() && _owningAvatar->isMyAvatar() && + Menu::getInstance()->isOptionChecked(MenuOption::CollideAsRagDoll)) { + _ragDoll.updateShapes(_jointShapes, _rotation, _translation); + } else { + Model::updateShapePositions(); + } +} + void SkeletonModel::maybeUpdateLeanRotation(const JointState& parentState, const FBXJoint& joint, JointState& state) { if (!_owningAvatar->isMyAvatar() || Application::getInstance()->getPrioVR()->isActive()) { return; diff --git a/interface/src/avatar/SkeletonModel.h b/interface/src/avatar/SkeletonModel.h index d733d937ee..086973807d 100644 --- a/interface/src/avatar/SkeletonModel.h +++ b/interface/src/avatar/SkeletonModel.h @@ -29,6 +29,7 @@ public: void simulate(float deltaTime, bool fullUpdate = true); void simulateRagDoll(float deltaTime); + void updateShapePositions(); /// \param jointIndex index of hand joint /// \param shapes[out] list in which is stored pointers to hand shapes diff --git a/interface/src/renderer/Model.h b/interface/src/renderer/Model.h index 3bc261ed44..11e6861775 100644 --- a/interface/src/renderer/Model.h +++ b/interface/src/renderer/Model.h @@ -140,7 +140,7 @@ public: void clearShapes(); void rebuildShapes(); void resetShapePositions(); - void updateShapePositions(); + virtual void updateShapePositions(); void renderJointCollisionShapes(float alpha); void renderBoundingCollisionShapes(float alpha); diff --git a/interface/src/renderer/RagDoll.cpp b/interface/src/renderer/RagDoll.cpp index 54fb776552..e2654d737f 100644 --- a/interface/src/renderer/RagDoll.cpp +++ b/interface/src/renderer/RagDoll.cpp @@ -15,13 +15,15 @@ #include #include +#include +#include #include "RagDoll.h" // ---------------------------------------------------------------------------- // FixedConstraint // ---------------------------------------------------------------------------- -FixedConstraint::FixedConstraint() : _point(NULL), _anchor(0.0f, 0.0f, 0.0f) { +FixedConstraint::FixedConstraint(glm::vec3* point, const glm::vec3& anchor ) : _point(point), _anchor(anchor) { } float FixedConstraint::enforce() { @@ -42,9 +44,9 @@ void FixedConstraint::setAnchor(const glm::vec3& anchor) { // ---------------------------------------------------------------------------- // DistanceConstraint // ---------------------------------------------------------------------------- -DistanceConstraint::DistanceConstraint(glm::vec3* pointA, glm::vec3* pointB) : _distance(-1.0f) { - _points[0] = pointA; - _points[1] = pointB; +DistanceConstraint::DistanceConstraint(glm::vec3* startPoint, glm::vec3* endPoint) : _distance(-1.0f) { + _points[0] = startPoint; + _points[1] = endPoint; _distance = glm::distance(*(_points[0]), *(_points[1])); } @@ -70,6 +72,28 @@ float DistanceConstraint::enforce() { return glm::abs(newDistance - _distance); } +void DistanceConstraint::updateProxyShape(Shape* shape, const glm::quat& rotation, const glm::vec3& translation) const { + if (!shape) { + return; + } + switch (shape->getType()) { + case Shape::SPHERE_SHAPE: { + // sphere collides at endPoint + SphereShape* sphere = static_cast(shape); + sphere->setPosition(translation + rotation * (*_points[1])); + } + break; + case Shape::CAPSULE_SHAPE: { + // capsule collides from startPoint to endPoint + CapsuleShape* capsule = static_cast(shape); + capsule->setEndPoints(translation + rotation * (*_points[0]), translation + rotation * (*_points[1])); + } + break; + default: + break; + } +} + // ---------------------------------------------------------------------------- // RagDoll // ---------------------------------------------------------------------------- @@ -90,12 +114,16 @@ void RagDoll::init(const QVector& states) { _points.push_back(state.getPosition()); int parentIndex = state.getFBXJoint().parentIndex; assert(parentIndex < i); - if (parentIndex != -1) { + if (parentIndex == -1) { + FixedConstraint* anchor = new FixedConstraint(&(_points[i]), glm::vec3(0.0f)); + _constraints.push_back(anchor); + } else { DistanceConstraint* stick = new DistanceConstraint(&(_points[i]), &(_points[parentIndex])); _constraints.push_back(stick); } } } + /// Delete all data. void RagDoll::clear() { int numConstraints = _constraints.size(); @@ -129,3 +157,11 @@ float RagDoll::enforceConstraints() { } return maxDistance; } + +void RagDoll::updateShapes(const QVector& shapes, const glm::quat& rotation, const glm::vec3& translation) const { + int numShapes = shapes.size(); + int numConstraints = _constraints.size(); + for (int i = 0; i < numShapes && i < numConstraints; ++i) { + _constraints[i]->updateProxyShape(shapes[i], rotation, translation); + } +} diff --git a/interface/src/renderer/RagDoll.h b/interface/src/renderer/RagDoll.h index 1d23973827..60e242d19b 100644 --- a/interface/src/renderer/RagDoll.h +++ b/interface/src/renderer/RagDoll.h @@ -14,6 +14,8 @@ #include "renderer/Model.h" +class Shape; + class Constraint { public: Constraint() {} @@ -22,11 +24,20 @@ public: /// Enforce contraint by moving relevant points. /// \return max distance of point movement virtual float enforce() = 0; + + /// \param shape pointer to shape that will be this Constraint's collision proxy + /// \param rotation rotation into shape's collision frame + /// \param translation translation into shape's collision frame + /// Moves the shape such that it will collide at this constraint's position + virtual void updateProxyShape(Shape* shape, const glm::quat& rotation, const glm::vec3& translation) const {} + +protected: + int _type; }; class FixedConstraint : public Constraint { public: - FixedConstraint(); + FixedConstraint(glm::vec3* point, const glm::vec3& anchor); float enforce(); void setPoint(glm::vec3* point); void setAnchor(const glm::vec3& anchor); @@ -37,10 +48,11 @@ private: class DistanceConstraint : public Constraint { public: - DistanceConstraint(glm::vec3* pointA, glm::vec3* pointB); + DistanceConstraint(glm::vec3* startPoint, glm::vec3* endPoint); DistanceConstraint(const DistanceConstraint& other); float enforce(); void setDistance(float distance); + void updateProxyShape(Shape* shape, const glm::quat& rotation, const glm::vec3& translation) const; private: float _distance; glm::vec3* _points[2]; @@ -69,7 +81,12 @@ public: float enforceConstraints(); const QVector& getPoints() const { return _points; } - + + /// \param shapes list of shapes to be updated with new positions + /// \param rotation rotation into shapes' collision frame + /// \param translation translation into shapes' collision frame + void updateShapes(const QVector& shapes, const glm::quat& rotation, const glm::vec3& translation) const; + private: QVector _constraints; QVector _points; From 5461a06e992b2b7dd5bb2e1aff16a347a87963b6 Mon Sep 17 00:00:00 2001 From: wangyix Date: Fri, 6 Jun 2014 09:33:14 -0700 Subject: [PATCH 16/42] completed code to resend nacked packets on AC --- .../src/octree/OctreeQueryNode.cpp | 16 ++++++++-------- .../src/octree/OctreeQueryNode.h | 8 ++++---- .../src/octree/OctreeSendThread.cpp | 19 ++++++++++--------- assignment-client/src/octree/OctreeServer.cpp | 5 ++++- 4 files changed, 26 insertions(+), 22 deletions(-) diff --git a/assignment-client/src/octree/OctreeQueryNode.cpp b/assignment-client/src/octree/OctreeQueryNode.cpp index e0ca6a4f1e..208be5951b 100644 --- a/assignment-client/src/octree/OctreeQueryNode.cpp +++ b/assignment-client/src/octree/OctreeQueryNode.cpp @@ -364,7 +364,7 @@ void OctreeQueryNode::dumpOutOfView() { } } -void OctreeQueryNode::packetSent() { +void OctreeQueryNode::octreePacketSent() { packetSent(_octreePacket, getPacketLength()); } @@ -379,18 +379,18 @@ void OctreeQueryNode::packetSent(const QByteArray& packet) { void OctreeQueryNode::addSequenceNumbersToResend(const QList& sequenceNumbers) { - _sequenceNumbersToResend.append(sequenceNumbers); + _nackedSequenceNumbers.append(sequenceNumbers); } -bool OctreeQueryNode::hasNextPacketToResend() const { - return !_sequenceNumbersToResend.isEmpty(); +bool OctreeQueryNode::hasNextNackedPacket() const { + return !_nackedSequenceNumbers.isEmpty(); } -const QByteArray* OctreeQueryNode::getNextPacketToResend() { +const QByteArray* OctreeQueryNode::getNextNackedPacket() { - if (!_sequenceNumbersToResend.isEmpty()) { - const QByteArray* nextPacket = _sentPacketHistory.getPacket(_sequenceNumbersToResend.first()); - _sequenceNumbersToResend.pop_front(); + if (!_nackedSequenceNumbers.isEmpty()) { + const QByteArray* nextPacket = _sentPacketHistory.getPacket(_nackedSequenceNumbers.first()); + _nackedSequenceNumbers.pop_front(); return nextPacket; // could be null } return NULL; diff --git a/assignment-client/src/octree/OctreeQueryNode.h b/assignment-client/src/octree/OctreeQueryNode.h index 4a2355f7cc..e1707cc899 100644 --- a/assignment-client/src/octree/OctreeQueryNode.h +++ b/assignment-client/src/octree/OctreeQueryNode.h @@ -103,15 +103,15 @@ public: void forceNodeShutdown(); bool isShuttingDown() const { return _isShuttingDown; } - void packetSent(); + void octreePacketSent(); void packetSent(unsigned char* packet, int packetLength); void packetSent(const QByteArray& packet); OCTREE_PACKET_SEQUENCE getSequenceNumber() const { return _sequenceNumber; } void addSequenceNumbersToResend(const QList& sequenceNumbers); - bool hasNextPacketToResend() const; - const QByteArray* getNextPacketToResend(); + bool hasNextNackedPacket() const; + const QByteArray* getNextNackedPacket(); private slots: void sendThreadFinished(); @@ -157,7 +157,7 @@ private: bool _isShuttingDown; SentPacketHistory _sentPacketHistory; -QQueue _sequenceNumbersToResend; +QQueue _nackedSequenceNumbers; }; #endif // hifi_OctreeQueryNode_h diff --git a/assignment-client/src/octree/OctreeSendThread.cpp b/assignment-client/src/octree/OctreeSendThread.cpp index 5767f2623b..befea80380 100644 --- a/assignment-client/src/octree/OctreeSendThread.cpp +++ b/assignment-client/src/octree/OctreeSendThread.cpp @@ -85,6 +85,7 @@ bool OctreeSendThread::process() { if (nodeData && !nodeData->isShuttingDown()) { bool viewFrustumChanged = nodeData->updateCurrentViewFrustum(); packetDistributor(nodeData, viewFrustumChanged); +resendNackedPackets(nodeData); } } } @@ -274,7 +275,7 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes trueBytesSent += nodeData->getPacketLength(); truePacketsSent++; packetsSent++; - nodeData->packetSent(); + nodeData->octreePacketSent(); nodeData->resetOctreePacket(); } @@ -287,11 +288,14 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { + const int maxPacketsSent = 10; + int packetsSent = 0; const QByteArray* packet; - while (nodeData->hasNextPacketToResend()) { - packet = nodeData->getNextPacketToResend(); + while (nodeData->hasNextNackedPacket() && packetsSent < maxPacketsSent) { + packet = nodeData->getNextNackedPacket(); + // packet will be NULL if it's not in nodeData's packet history if (packet) { NodeList::getInstance()->writeDatagram(*packet, _node); packetsSent++; @@ -302,7 +306,9 @@ int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { _totalWastedBytes += MAX_PACKET_SIZE - packet->size(); // ??? } } - + +printf("\t\t re-sent %d packets!\n", packetsSent); + return packetsSent; } @@ -310,11 +316,6 @@ int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { - - - - - /// Version of voxel distributor that sends the deepest LOD level at once int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrustumChanged) { diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp index f60f0fc2d5..46eb7aac16 100644 --- a/assignment-client/src/octree/OctreeServer.cpp +++ b/assignment-client/src/octree/OctreeServer.cpp @@ -861,8 +861,11 @@ dataAt += sizeof(uint16_t); // read sequence numbers QList sequenceNumbers; for (int i = 0; i < numSequenceNumbers; i++) { - sequenceNumbers.append(*(OCTREE_PACKET_SEQUENCE*)dataAt); + OCTREE_PACKET_SEQUENCE sequenceNumber = (*(OCTREE_PACKET_SEQUENCE*)dataAt); + sequenceNumbers.append(sequenceNumber); dataAt += sizeof(OCTREE_PACKET_SEQUENCE); + +printf("\t\t\t nacked packet: seq = %d\n", sequenceNumber); } OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); // move this or something From 4209c1102f56420a0024baa1ec997b008f3a329e Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Fri, 6 Jun 2014 10:26:08 -0700 Subject: [PATCH 17/42] Revert "Models.addModel now returns a more accurate modelID" This reverts commit 150477eea44d0438137333499fcda498072c76ea. --- libraries/models/src/ModelItem.cpp | 31 ++++++++++++++----- libraries/models/src/ModelItem.h | 1 - .../models/src/ModelsScriptingInterface.cpp | 3 +- 3 files changed, 24 insertions(+), 11 deletions(-) diff --git a/libraries/models/src/ModelItem.cpp b/libraries/models/src/ModelItem.cpp index 810129a81f..b6f4fe6c1d 100644 --- a/libraries/models/src/ModelItem.cpp +++ b/libraries/models/src/ModelItem.cpp @@ -47,12 +47,6 @@ uint32_t ModelItem::getNextCreatorTokenID() { return creatorTokenID; } -uint32_t ModelItem::getNextModelItemID() { - uint32_t modelID = _nextID; - _nextID++; - return modelID; -} - void ModelItem::handleAddModelResponse(const QByteArray& packet) { const unsigned char* dataAt = reinterpret_cast(packet.data()); int numBytesPacketHeader = numBytesForPacketHeader(packet); @@ -76,10 +70,31 @@ ModelItem::ModelItem() { } ModelItem::ModelItem(const ModelItemID& modelItemID, const ModelItemProperties& properties) { + _id = modelItemID.id; _creatorTokenID = modelItemID.creatorTokenID; + + // init values with defaults before calling setProperties + uint64_t now = usecTimestampNow(); + _lastEdited = now; + _lastUpdated = now; + + _position = glm::vec3(0,0,0); + _radius = 0; + rgbColor noColor = { 0, 0, 0 }; + memcpy(_color, noColor, sizeof(_color)); + _shouldDie = false; + _modelURL = MODEL_DEFAULT_MODEL_URL; + _modelRotation = MODEL_DEFAULT_MODEL_ROTATION; - rgbColor defaultColor = { 0, 0, 0 }; - init(glm::vec3(), 0.0f, defaultColor, modelItemID.id); + // animation related + _animationURL = MODEL_DEFAULT_ANIMATION_URL; + _animationIsPlaying = false; + _animationFrameIndex = 0.0f; + _animationFPS = MODEL_DEFAULT_ANIMATION_FPS; + _glowLevel = 0.0f; + + _jointMappingCompleted = false; + _lastAnimated = now; setProperties(properties); } diff --git a/libraries/models/src/ModelItem.h b/libraries/models/src/ModelItem.h index 563d394419..9a558f2ef4 100644 --- a/libraries/models/src/ModelItem.h +++ b/libraries/models/src/ModelItem.h @@ -276,7 +276,6 @@ public: // these methods allow you to create models, and later edit them. static uint32_t getIDfromCreatorTokenID(uint32_t creatorTokenID); static uint32_t getNextCreatorTokenID(); - static uint32_t getNextModelItemID(); static void handleAddModelResponse(const QByteArray& packet); void mapJoints(const QStringList& modelJointNames); diff --git a/libraries/models/src/ModelsScriptingInterface.cpp b/libraries/models/src/ModelsScriptingInterface.cpp index f4cbf14086..7e08571fe5 100644 --- a/libraries/models/src/ModelsScriptingInterface.cpp +++ b/libraries/models/src/ModelsScriptingInterface.cpp @@ -28,9 +28,8 @@ ModelItemID ModelsScriptingInterface::addModel(const ModelItemProperties& proper // The application will keep track of creatorTokenID uint32_t creatorTokenID = ModelItem::getNextCreatorTokenID(); - uint32_t modelID = ModelItem::getNextModelItemID(); - ModelItemID id(modelID, creatorTokenID, false ); + ModelItemID id(NEW_MODEL, creatorTokenID, false ); // queue the packet queueModelMessage(PacketTypeModelAddOrEdit, id, properties); From 0fc6354b6cb14b5391761252183a167fb9999b32 Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Fri, 6 Jun 2014 11:18:55 -0700 Subject: [PATCH 18/42] Fix for streaming the same object. --- libraries/metavoxels/src/Bitstream.cpp | 6 ++++-- tests/metavoxels/src/MetavoxelTests.cpp | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/libraries/metavoxels/src/Bitstream.cpp b/libraries/metavoxels/src/Bitstream.cpp index 30d34580d7..bc187d9f3d 100644 --- a/libraries/metavoxels/src/Bitstream.cpp +++ b/libraries/metavoxels/src/Bitstream.cpp @@ -224,7 +224,8 @@ void Bitstream::persistWriteMappings(const WriteMappings& mappings) { } connect(it.key().data(), SIGNAL(destroyed(QObject*)), SLOT(clearSharedObject(QObject*))); QPointer& reference = _sharedObjectReferences[it.key()->getOriginID()]; - if (reference) { + if (reference && reference != it.key()) { + // the object has been replaced by a successor, so we can forget about the original _sharedObjectStreamer.removePersistentID(reference); reference->disconnect(this); } @@ -258,7 +259,8 @@ void Bitstream::persistReadMappings(const ReadMappings& mappings) { continue; } QPointer& reference = _sharedObjectReferences[it.value()->getRemoteOriginID()]; - if (reference) { + if (reference && reference != it.value()) { + // the object has been replaced by a successor, so we can forget about the original _sharedObjectStreamer.removePersistentValue(reference.data()); } reference = it.value(); diff --git a/tests/metavoxels/src/MetavoxelTests.cpp b/tests/metavoxels/src/MetavoxelTests.cpp index c4d973ad05..eec26ae411 100644 --- a/tests/metavoxels/src/MetavoxelTests.cpp +++ b/tests/metavoxels/src/MetavoxelTests.cpp @@ -183,7 +183,7 @@ bool MetavoxelTests::run() { bob.setOther(&alice); // perform a large number of simulation iterations - const int SIMULATION_ITERATIONS = 100000; + const int SIMULATION_ITERATIONS = 10000; for (int i = 0; i < SIMULATION_ITERATIONS; i++) { if (alice.simulate(i) || bob.simulate(i)) { return true; @@ -241,7 +241,7 @@ Endpoint::Endpoint(const QByteArray& datagramHeader) : _receiveRecords.append(receiveRecord); // create the object that represents out delta-encoded state - //_localState = new TestSharedObjectA(); + _localState = new TestSharedObjectA(); connect(_sequencer->getReliableInputChannel(), SIGNAL(receivedMessage(const QVariant&)), SLOT(handleReliableMessage(const QVariant&))); From 69adf8d0dd8edcb3314016ce8076d9b4c26e429a Mon Sep 17 00:00:00 2001 From: Atlante45 Date: Fri, 6 Jun 2014 11:19:43 -0700 Subject: [PATCH 19/42] Removed extra debug, fix model jumping when releasing one of the two triggers. --- examples/editModels.js | 50 ++++++++++-------------------------------- 1 file changed, 11 insertions(+), 39 deletions(-) diff --git a/examples/editModels.js b/examples/editModels.js index 67e2bdb198..93a34b9a3a 100644 --- a/examples/editModels.js +++ b/examples/editModels.js @@ -356,7 +356,6 @@ function controller(wichSide) { var factor2 = Vec3.dot(forward, this.modelPositionAtGrab) - d; var vector = Vec3.subtract(this.palmPosition, this.positionAtGrab); - print("factor1: " + factor1 + ", factor2: " + factor2); if (factor2 < 0) { factor2 = 0; } @@ -395,46 +394,8 @@ function controller(wichSide) { for (var i = 0; i < indicesToRemove.length; ++i) { this.jointsIntersectingFromStart.splice(this.jointsIntersectingFromStart.indexOf(indicesToRemove[i], 1)); } - - - jointList = MyAvatar.getJointNames(); - - var closestJointIndex = -1; - var closestJointDistance = 999999; - for (var i = 0; i < jointList.length; i++) { - var distance = Vec3.distance(MyAvatar.getJointPosition(jointList[i]), this.oldModelPosition); - if (distance < closestJointDistance) { - closestJointDistance = distance; - closestJointIndex = i; - } - } - - if (closestJointDistance < this.oldModelRadius) { - if (this.jointsIntersectingFromStart.indexOf(closestJointIndex) != -1 || - (leftController.grabbing && rightController.grabbing && - leftController.modelID.id == rightController.modelID.id)) { - // Do nothing - } else { - Vec3.print("Ball at: ", MyAvatar.getJointPosition(closestJointIndex)); - Overlays.editOverlay(this.ballGlowingJoint, { - position: MyAvatar.getJointPosition(closestJointIndex), - glowLevel: 0.25, - visible: true - }); - } - } else { - Overlays.editOverlay(this.ballGlowingJoint, { glowLevel: 0.0, visible: false }); - } } } - this.ballGlowingJoint = Overlays.addOverlay("sphere", { - position: { x: 0, y: 0, z: 0 }, - size: 1, - solid: true, - color: { red: 0, green: 255, blue: 0 }, - alpha: 1, - visible: false, - anchor: "MyAvatar"}); this.update = function () { this.oldPalmPosition = this.palmPosition; @@ -617,6 +578,17 @@ function moveModels() { var w = Vec3.normalize(Vec3.cross(u, v)); rotation = Quat.multiply(Quat.angleAxis(angle, w), leftController.oldModelRotation); + + + leftController.positionAtGrab = leftController.palmPosition; + leftController.rotationAtGrab = leftController.rotation; + leftController.modelPositionAtGrab = leftController.oldModelPosition; + leftController.modelRotationAtGrab = rotation; + + rightController.positionAtGrab = rightController.palmPosition; + rightController.rotationAtGrab = rightController.rotation; + rightController.modelPositionAtGrab = rightController.oldModelPosition; + rightController.modelRotationAtGrab = rotation; break; } From 56d9bc5215a60b72cc6696e9d21eb14f4caf312d Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Fri, 6 Jun 2014 11:37:45 -0700 Subject: [PATCH 20/42] Working on delta-streaming tests. --- tests/metavoxels/src/MetavoxelTests.cpp | 33 ++++++++++++++++++++++++- tests/metavoxels/src/MetavoxelTests.h | 1 + 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/tests/metavoxels/src/MetavoxelTests.cpp b/tests/metavoxels/src/MetavoxelTests.cpp index eec26ae411..b2dcc1dd45 100644 --- a/tests/metavoxels/src/MetavoxelTests.cpp +++ b/tests/metavoxels/src/MetavoxelTests.cpp @@ -38,6 +38,7 @@ static int streamedBytesSent = 0; static int streamedBytesReceived = 0; static int sharedObjectsCreated = 0; static int sharedObjectsDestroyed = 0; +static int objectMutationsPerformed = 0; static QByteArray createRandomBytes(int minimumSize, int maximumSize) { QByteArray bytes(randIntInRange(minimumSize, maximumSize), 0); @@ -196,6 +197,7 @@ bool MetavoxelTests::run() { qDebug() << "Sent" << streamedBytesSent << "streamed bytes, received" << streamedBytesReceived; qDebug() << "Sent" << datagramsSent << "datagrams, received" << datagramsReceived; qDebug() << "Created" << sharedObjectsCreated << "shared objects, destroyed" << sharedObjectsDestroyed; + qDebug() << "Performed" << objectMutationsPerformed << "object mutations"; qDebug(); qDebug() << "Running serialization tests..."; @@ -272,13 +274,37 @@ static QVariant createRandomMessage() { TestMessageB message = { createRandomBytes(), createRandomSharedObject(), getRandomTestEnum() }; return QVariant::fromValue(message); } - case 2: default: { return QVariant::fromValue(createRandomMessageC()); } } } +static SharedObjectPointer mutate(const SharedObjectPointer& state) { + switch(randIntInRange(0, 3)) { + case 0: { + SharedObjectPointer newState = state->clone(true); + static_cast(newState.data())->setFoo(randFloat()); + objectMutationsPerformed++; + return newState; + } + case 1: { + SharedObjectPointer newState = state->clone(true); + static_cast(newState.data())->setBaz(getRandomTestEnum()); + objectMutationsPerformed++; + return newState; + } + case 2: { + SharedObjectPointer newState = state->clone(true); + static_cast(newState.data())->setBong(getRandomTestFlags()); + objectMutationsPerformed++; + return newState; + } + default: + return state; + } +} + static bool messagesEqual(const QVariant& firstMessage, const QVariant& secondMessage) { int type = firstMessage.userType(); if (secondMessage.userType() != type) { @@ -337,6 +363,9 @@ bool Endpoint::simulate(int iterationNumber) { _reliableMessagesToSend -= 1.0f; } + // tweak the local state + _localState = mutate(_localState); + // send a packet try { Bitstream& out = _sequencer->startPacket(); @@ -405,6 +434,8 @@ void Endpoint::readMessage(Bitstream& in) { SequencedTestMessage message; in >> message; + _remoteState = message.state; + // record the receipt ReceiveRecord record = { _sequencer->getIncomingPacketNumber(), message.state }; _receiveRecords.append(record); diff --git a/tests/metavoxels/src/MetavoxelTests.h b/tests/metavoxels/src/MetavoxelTests.h index dc294692af..345ea624df 100644 --- a/tests/metavoxels/src/MetavoxelTests.h +++ b/tests/metavoxels/src/MetavoxelTests.h @@ -76,6 +76,7 @@ private: QList _receiveRecords; SharedObjectPointer _localState; + SharedObjectPointer _remoteState; Endpoint* _other; QList > _delayedDatagrams; From 8cd5ec3b54e4e5b0f1cdebf2bf20833e8ebcac2b Mon Sep 17 00:00:00 2001 From: wangyix Date: Fri, 6 Jun 2014 11:50:34 -0700 Subject: [PATCH 21/42] started work on sending nack packets from client --- .../src/octree/OctreeSendThread.cpp | 4 +- interface/src/Application.cpp | 59 ++++++++++++++++++- interface/src/Application.h | 6 ++ libraries/octree/src/OctreeSceneStats.cpp | 15 +++++ libraries/octree/src/OctreeSceneStats.h | 4 ++ 5 files changed, 85 insertions(+), 3 deletions(-) diff --git a/assignment-client/src/octree/OctreeSendThread.cpp b/assignment-client/src/octree/OctreeSendThread.cpp index befea80380..032b45fcdf 100644 --- a/assignment-client/src/octree/OctreeSendThread.cpp +++ b/assignment-client/src/octree/OctreeSendThread.cpp @@ -288,12 +288,12 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { - const int maxPacketsSent = 10; + const int MAX_PACKETS_RESEND = 10; int packetsSent = 0; const QByteArray* packet; - while (nodeData->hasNextNackedPacket() && packetsSent < maxPacketsSent) { + while (nodeData->hasNextNackedPacket() && packetsSent < MAX_PACKETS_RESEND) { packet = nodeData->getNextNackedPacket(); // packet will be NULL if it's not in nodeData's packet history if (packet) { diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index de3c354b27..358bb1bde3 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -167,7 +167,8 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) : _applicationOverlay(), _runningScriptsWidget(new RunningScriptsWidget(_window)), _runningScriptsWidgetWasVisible(false), - _trayIcon(new QSystemTrayIcon(_window)) + _trayIcon(new QSystemTrayIcon(_window)), + _lastNackTime(usecTimestampNow()) { // read the ApplicationInfo.ini file for Name/Version/Domain information QSettings applicationInfo(Application::resourcesPath() + "info/ApplicationInfo.ini", QSettings::IniFormat); @@ -2091,7 +2092,63 @@ void Application::updateMyAvatar(float deltaTime) { _lastQueriedViewFrustum = _viewFrustum; } } + +// sent a nack packet containing missing sequence numbers of received packets +{ + quint64 now = usecTimestampNow(); + quint64 sinceLastNack = now - _lastNackTime; + const quint64 TOO_LONG_SINCE_LAST_NACK = 100 * MSECS_PER_SECOND; + if (sinceLastNack > TOO_LONG_SINCE_LAST_NACK) { + _lastNackTime = now; + + //_octreeServerSceneStats- + } } +} + + +void Application::sendNack() { + /* + // now that we know the node ID, let's add these stats to the stats for that node... + _octreeSceneStatsLock.lockForWrite(); + if (_octreeServerSceneStats.find(nodeUUID) != _octreeServerSceneStats.end()) { + OctreeSceneStats& stats = _octreeServerSceneStats[nodeUUID]; + stats.trackIncomingOctreePacket(packet, wasStatsPacket, sendingNode->getClockSkewUsec()); + } + _octreeSceneStatsLock.unlock(); + */ + + char packet[MAX_PACKET_SIZE]; + NodeList* nodeList = NodeList::getInstance(); + + // iterates thru all nodes in NodeList + foreach(const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) { + + char* dataAt = packet; + int bytesRemaining = MAX_PACKET_SIZE; + + int numBytesPacketHeader = populatePacketHeader(packet, PacketTypeOctreeDataNack, node->getUUID()); + dataAt += numBytesPacketHeader; + bytesRemaining -= numBytesPacketHeader; + + + + uint16_t numSequenceNumbers; + + + + + OctreeSceneStats& stats = _octreeServerSceneStats[node->getUUID()]; + int numSequenceNumbersAvailable = stats.getNumSequenceNumberToNack(); + + + // make sure we still have an active socket + nodeList->writeUnverifiedDatagram(reinterpret_cast(queryPacket), packetLength, node); + } +} + + + void Application::queryOctree(NodeType_t serverType, PacketType packetType, NodeToJurisdictionMap& jurisdictions) { diff --git a/interface/src/Application.h b/interface/src/Application.h index f3d9c0fd27..670ec35238 100644 --- a/interface/src/Application.h +++ b/interface/src/Application.h @@ -411,6 +411,10 @@ private: static void attachNewHeadToNode(Node *newNode); static void* networkReceive(void* args); // network receive thread + void sendNack(); + + + MainWindow* _window; GLCanvas* _glWidget; // our GLCanvas has a couple extra features @@ -580,6 +584,8 @@ private: bool _runningScriptsWidgetWasVisible; QSystemTrayIcon* _trayIcon; + +quint64 _lastNackTime; }; #endif // hifi_Application_h diff --git a/libraries/octree/src/OctreeSceneStats.cpp b/libraries/octree/src/OctreeSceneStats.cpp index 9580ae6d13..a25b72bedd 100644 --- a/libraries/octree/src/OctreeSceneStats.cpp +++ b/libraries/octree/src/OctreeSceneStats.cpp @@ -46,6 +46,7 @@ OctreeSceneStats::OctreeSceneStats() : _incomingReallyLate(0), _incomingPossibleDuplicate(0), _missingSequenceNumbers(), +_sequenceNumbersToNack(), _incomingFlightTimeAverage(samples), _jurisdictionRoot(NULL) { @@ -158,6 +159,7 @@ void OctreeSceneStats::copyFromOther(const OctreeSceneStats& other) { _incomingPossibleDuplicate = other._incomingPossibleDuplicate; _missingSequenceNumbers = other._missingSequenceNumbers; +_missingSequenceNumbersToNack = other._missingSequenceNumbersToNack; } @@ -926,6 +928,7 @@ void OctreeSceneStats::trackIncomingOctreePacket(const QByteArray& packet, qDebug() << "found it in _missingSequenceNumbers"; } _missingSequenceNumbers.remove(sequence); +_sequenceNumbersToNack.remove(sequence); _incomingLikelyLost--; _incomingRecovered++; } else { @@ -955,6 +958,7 @@ void OctreeSceneStats::trackIncomingOctreePacket(const QByteArray& packet, _incomingLikelyLost += missing; for(unsigned int missingSequence = expected; missingSequence < sequence; missingSequence++) { _missingSequenceNumbers << missingSequence; +_sequenceNumbersToNack << missingSequence; } } } @@ -982,9 +986,20 @@ void OctreeSceneStats::trackIncomingOctreePacket(const QByteArray& packet, qDebug() << "pruning really old missing sequence:" << missingItem; } _missingSequenceNumbers.remove(missingItem); +_sequenceNumbersToNack.remove(missingItem); } } } } +bool OctreeSceneStats::getNumSequenceNumberToNack() const { + return _sequenceNumbersToNack.size(); +} + +uint16_t OctreeSceneStats::getNextSequenceNumberToNack() { + QSet::Iterator it = _sequenceNumbersToNack.begin(); + uint16_t sequenceNumber = *it; + _sequenceNumbersToNack.remove(sequenceNumber); + return sequenceNumber; +} \ No newline at end of file diff --git a/libraries/octree/src/OctreeSceneStats.h b/libraries/octree/src/OctreeSceneStats.h index ef22fd7c1c..e6664083b0 100644 --- a/libraries/octree/src/OctreeSceneStats.h +++ b/libraries/octree/src/OctreeSceneStats.h @@ -172,6 +172,9 @@ public: quint32 getIncomingPossibleDuplicate() const { return _incomingPossibleDuplicate; } float getIncomingFlightTimeAverage() { return _incomingFlightTimeAverage.getAverage(); } +bool getNumSequenceNumberToNack() const; +uint16_t getNextSequenceNumberToNack(); + private: void copyFromOther(const OctreeSceneStats& other); @@ -273,6 +276,7 @@ private: quint32 _incomingReallyLate; /// out of order and later than MAX_MISSING_SEQUENCE_OLD_AGE late quint32 _incomingPossibleDuplicate; /// out of order possibly a duplicate QSet _missingSequenceNumbers; +QSet _sequenceNumbersToNack; SimpleMovingAverage _incomingFlightTimeAverage; // features related items From 361461516c8675897adb331edab325db298ebf1a Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Fri, 6 Jun 2014 14:26:20 -0700 Subject: [PATCH 22/42] Check the delta-encoded objects, report bytes sent/received. --- tests/metavoxels/src/MetavoxelTests.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/tests/metavoxels/src/MetavoxelTests.cpp b/tests/metavoxels/src/MetavoxelTests.cpp index b2dcc1dd45..81f1840342 100644 --- a/tests/metavoxels/src/MetavoxelTests.cpp +++ b/tests/metavoxels/src/MetavoxelTests.cpp @@ -28,6 +28,8 @@ MetavoxelTests::MetavoxelTests(int& argc, char** argv) : static int datagramsSent = 0; static int datagramsReceived = 0; +static int bytesSent = 0; +static int bytesReceived = 0; static int highPriorityMessagesSent = 0; static int highPriorityMessagesReceived = 0; static int unreliableMessagesSent = 0; @@ -195,7 +197,8 @@ bool MetavoxelTests::run() { qDebug() << "Sent" << unreliableMessagesSent << "unreliable messages, received" << unreliableMessagesReceived; qDebug() << "Sent" << reliableMessagesSent << "reliable messages, received" << reliableMessagesReceived; qDebug() << "Sent" << streamedBytesSent << "streamed bytes, received" << streamedBytesReceived; - qDebug() << "Sent" << datagramsSent << "datagrams, received" << datagramsReceived; + qDebug() << "Sent" << datagramsSent << "datagrams with" << bytesSent << "bytes, received" << + datagramsReceived << "with" << bytesReceived << "bytes"; qDebug() << "Created" << sharedObjectsCreated << "shared objects, destroyed" << sharedObjectsDestroyed; qDebug() << "Performed" << objectMutationsPerformed << "object mutations"; qDebug(); @@ -389,6 +392,7 @@ bool Endpoint::simulate(int iterationNumber) { void Endpoint::sendDatagram(const QByteArray& datagram) { datagramsSent++; + bytesSent += datagram.size(); // some datagrams are dropped const float DROP_PROBABILITY = 0.1f; @@ -414,6 +418,7 @@ void Endpoint::sendDatagram(const QByteArray& datagram) { _other->_sequencer->receivedDatagram(datagram); datagramsReceived++; + bytesReceived += datagram.size(); } void Endpoint::handleHighPriorityMessage(const QVariant& message) { @@ -446,6 +451,9 @@ void Endpoint::readMessage(Bitstream& in) { if (!messagesEqual(it->submessage, message.submessage)) { throw QString("Sent/received unreliable message mismatch."); } + if (!it->state->equals(message.state)) { + throw QString("Delta-encoded object mismatch."); + } _other->_unreliableMessagesSent.erase(_other->_unreliableMessagesSent.begin(), it + 1); unreliableMessagesReceived++; return; From 5c4748556206e940758b46d41625b25deb962f5c Mon Sep 17 00:00:00 2001 From: wangyix Date: Fri, 6 Jun 2014 14:27:51 -0700 Subject: [PATCH 23/42] client-side nack sending complete; ready to test --- interface/src/Application.cpp | 55 ++++++++++++----------- libraries/octree/src/OctreeSceneStats.cpp | 2 +- libraries/octree/src/OctreeSceneStats.h | 2 +- 3 files changed, 32 insertions(+), 27 deletions(-) diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 358bb1bde3..7333960689 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2100,23 +2100,13 @@ void Application::updateMyAvatar(float deltaTime) { const quint64 TOO_LONG_SINCE_LAST_NACK = 100 * MSECS_PER_SECOND; if (sinceLastNack > TOO_LONG_SINCE_LAST_NACK) { _lastNackTime = now; - - //_octreeServerSceneStats- + sendNack(); } } } void Application::sendNack() { - /* - // now that we know the node ID, let's add these stats to the stats for that node... - _octreeSceneStatsLock.lockForWrite(); - if (_octreeServerSceneStats.find(nodeUUID) != _octreeServerSceneStats.end()) { - OctreeSceneStats& stats = _octreeServerSceneStats[nodeUUID]; - stats.trackIncomingOctreePacket(packet, wasStatsPacket, sendingNode->getClockSkewUsec()); - } - _octreeSceneStatsLock.unlock(); - */ char packet[MAX_PACKET_SIZE]; NodeList* nodeList = NodeList::getInstance(); @@ -2124,26 +2114,41 @@ void Application::sendNack() { // iterates thru all nodes in NodeList foreach(const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) { - char* dataAt = packet; - int bytesRemaining = MAX_PACKET_SIZE; + if (node->getActiveSocket() && + ( node->getType() == NodeType::VoxelServer + || node->getType() == NodeType::ParticleServer + || node->getType() == NodeType::ModelServer) + ) { - int numBytesPacketHeader = populatePacketHeader(packet, PacketTypeOctreeDataNack, node->getUUID()); - dataAt += numBytesPacketHeader; - bytesRemaining -= numBytesPacketHeader; - - + OctreeSceneStats& stats = _octreeServerSceneStats[node->getUUID()]; - uint16_t numSequenceNumbers; + char* dataAt = packet; + int bytesRemaining = MAX_PACKET_SIZE; + + // pack header + int numBytesPacketHeader = populatePacketHeader(packet, PacketTypeOctreeDataNack, node->getUUID()); + dataAt += numBytesPacketHeader; + bytesRemaining -= numBytesPacketHeader; + + int numPacketsRoomFor = (bytesRemaining - sizeof(uint16_t)) / sizeof(OCTREE_PACKET_SEQUENCE); + // calculate and pack number of sequence numbers + uint16_t numSequenceNumbers = min(stats.getNumSequenceNumbersToNack(), numPacketsRoomFor); + uint16_t* numSequenceNumbersAt = (uint16_t*)dataAt; + *numSequenceNumbersAt = numSequenceNumbers; + dataAt += sizeof(uint16_t); + // pack sequence numbers + for (int i = 0; i < numSequenceNumbers; i++) { + OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; + *sequenceNumberAt = stats.getNextSequenceNumberToNack(); + dataAt += sizeof(OCTREE_PACKET_SEQUENCE); + } - OctreeSceneStats& stats = _octreeServerSceneStats[node->getUUID()]; - int numSequenceNumbersAvailable = stats.getNumSequenceNumberToNack(); - - - // make sure we still have an active socket - nodeList->writeUnverifiedDatagram(reinterpret_cast(queryPacket), packetLength, node); + // make sure we still have an active socket???? + nodeList->writeUnverifiedDatagram(packet, dataAt - packet, node); + } } } diff --git a/libraries/octree/src/OctreeSceneStats.cpp b/libraries/octree/src/OctreeSceneStats.cpp index a25b72bedd..01332fbc46 100644 --- a/libraries/octree/src/OctreeSceneStats.cpp +++ b/libraries/octree/src/OctreeSceneStats.cpp @@ -993,7 +993,7 @@ _sequenceNumbersToNack.remove(missingItem); } -bool OctreeSceneStats::getNumSequenceNumberToNack() const { +int OctreeSceneStats::getNumSequenceNumbersToNack() const { return _sequenceNumbersToNack.size(); } diff --git a/libraries/octree/src/OctreeSceneStats.h b/libraries/octree/src/OctreeSceneStats.h index e6664083b0..ca9bf7c74b 100644 --- a/libraries/octree/src/OctreeSceneStats.h +++ b/libraries/octree/src/OctreeSceneStats.h @@ -172,7 +172,7 @@ public: quint32 getIncomingPossibleDuplicate() const { return _incomingPossibleDuplicate; } float getIncomingFlightTimeAverage() { return _incomingFlightTimeAverage.getAverage(); } -bool getNumSequenceNumberToNack() const; +int getNumSequenceNumbersToNack() const; uint16_t getNextSequenceNumberToNack(); private: From bd2148d4b7eef48d46c6171f801521a4eb1dead8 Mon Sep 17 00:00:00 2001 From: wangyix Date: Fri, 6 Jun 2014 14:33:53 -0700 Subject: [PATCH 24/42] added write lock/unlock ...for _octreeSceneStatsLock --- interface/src/Application.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 7333960689..6d6c7d64ab 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2120,6 +2120,8 @@ void Application::sendNack() { || node->getType() == NodeType::ModelServer) ) { + _octreeSceneStatsLock.lockForWrite(); + OctreeSceneStats& stats = _octreeServerSceneStats[node->getUUID()]; char* dataAt = packet; @@ -2146,6 +2148,8 @@ void Application::sendNack() { dataAt += sizeof(OCTREE_PACKET_SEQUENCE); } + _octreeSceneStatsLock.unlock(); + // make sure we still have an active socket???? nodeList->writeUnverifiedDatagram(packet, dataAt - packet, node); } From 0b1bffa83ca55957d174aa7e7fc0aa3e7916c07d Mon Sep 17 00:00:00 2001 From: wangyix Date: Fri, 6 Jun 2014 15:03:54 -0700 Subject: [PATCH 25/42] added random packet drops; ready to test --- .../src/octree/OctreeSendThread.cpp | 7 +++---- interface/src/Application.cpp | 7 ++++++- libraries/networking/src/LimitedNodeList.cpp | 17 +++++++++++++++++ libraries/networking/src/LimitedNodeList.h | 3 +++ libraries/octree/src/OctreeSceneStats.cpp | 2 +- 5 files changed, 30 insertions(+), 6 deletions(-) diff --git a/assignment-client/src/octree/OctreeSendThread.cpp b/assignment-client/src/octree/OctreeSendThread.cpp index 032b45fcdf..e5c47f5d2d 100644 --- a/assignment-client/src/octree/OctreeSendThread.cpp +++ b/assignment-client/src/octree/OctreeSendThread.cpp @@ -181,7 +181,7 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes // actually send it OctreeServer::didCallWriteDatagram(this); - NodeList::getInstance()->writeDatagram((char*) statsMessage, statsMessageLength, _node); +NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*) statsMessage, statsMessageLength, _node); packetSent = true; } else { // not enough room in the packet, send two packets @@ -215,8 +215,7 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes packetsSent++; OctreeServer::didCallWriteDatagram(this); - NodeList::getInstance()->writeDatagram((char*) nodeData->getPacket(), nodeData->getPacketLength(), _node); - +NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*)nodeData->getPacket(), nodeData->getPacketLength(), _node); packetSent = true; thisWastedBytes = MAX_PACKET_SIZE - nodeData->getPacketLength(); @@ -245,7 +244,7 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes if (nodeData->isPacketWaiting() && !nodeData->isShuttingDown()) { // just send the voxel packet OctreeServer::didCallWriteDatagram(this); - NodeList::getInstance()->writeDatagram((char*) nodeData->getPacket(), nodeData->getPacketLength(), _node); +NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*)nodeData->getPacket(), nodeData->getPacketLength(), _node); packetSent = true; int thisWastedBytes = MAX_PACKET_SIZE - nodeData->getPacketLength(); diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 6d6c7d64ab..75980af934 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2097,7 +2097,7 @@ void Application::updateMyAvatar(float deltaTime) { { quint64 now = usecTimestampNow(); quint64 sinceLastNack = now - _lastNackTime; - const quint64 TOO_LONG_SINCE_LAST_NACK = 100 * MSECS_PER_SECOND; + const quint64 TOO_LONG_SINCE_LAST_NACK = 250 * MSECS_PER_SECOND; if (sinceLastNack > TOO_LONG_SINCE_LAST_NACK) { _lastNackTime = now; sendNack(); @@ -2108,6 +2108,8 @@ void Application::updateMyAvatar(float deltaTime) { void Application::sendNack() { +printf("\n\t sendNack()...\n"); + char packet[MAX_PACKET_SIZE]; NodeList* nodeList = NodeList::getInstance(); @@ -2142,11 +2144,14 @@ void Application::sendNack() { dataAt += sizeof(uint16_t); // pack sequence numbers +printf("\t\t packed %d seq #s:", numSequenceNumbers); for (int i = 0; i < numSequenceNumbers; i++) { OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; *sequenceNumberAt = stats.getNextSequenceNumberToNack(); dataAt += sizeof(OCTREE_PACKET_SEQUENCE); +printf(" %d,", *sequenceNumberAt); } +printf("\n"); _octreeSceneStatsLock.unlock(); diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp index c0d7941edf..f9630c9102 100644 --- a/libraries/networking/src/LimitedNodeList.cpp +++ b/libraries/networking/src/LimitedNodeList.cpp @@ -271,6 +271,23 @@ qint64 LimitedNodeList::writeDatagram(const char* data, qint64 size, const Share return writeDatagram(QByteArray(data, size), destinationNode, overridenSockAddr); } +qint64 LimitedNodeList::writeDatagram2(int seq, const char* data, qint64 size, const SharedNodePointer& destinationNode, + const HifiSockAddr& overridenSockAddr) { + + qint64 ret; + + if (randFloat() < 0.8f) { + ret = writeDatagram(QByteArray(data, size), destinationNode, overridenSockAddr); + } + else { + printf("\t\t\t dropped packet seq = %d!!!\n", seq); + } + + + return ret; +} + + qint64 LimitedNodeList::writeUnverifiedDatagram(const char* data, qint64 size, const SharedNodePointer& destinationNode, const HifiSockAddr& overridenSockAddr) { return writeUnverifiedDatagram(QByteArray(data, size), destinationNode, overridenSockAddr); diff --git a/libraries/networking/src/LimitedNodeList.h b/libraries/networking/src/LimitedNodeList.h index a4bc8022bf..b3481885c8 100644 --- a/libraries/networking/src/LimitedNodeList.h +++ b/libraries/networking/src/LimitedNodeList.h @@ -72,6 +72,9 @@ public: qint64 writeDatagram(const char* data, qint64 size, const SharedNodePointer& destinationNode, const HifiSockAddr& overridenSockAddr = HifiSockAddr()); +qint64 writeDatagram2(int seq, const char* data, qint64 size, const SharedNodePointer& destinationNode, + const HifiSockAddr& overridenSockAddr = HifiSockAddr()); + qint64 writeUnverifiedDatagram(const char* data, qint64 size, const SharedNodePointer& destinationNode, const HifiSockAddr& overridenSockAddr = HifiSockAddr()); diff --git a/libraries/octree/src/OctreeSceneStats.cpp b/libraries/octree/src/OctreeSceneStats.cpp index 01332fbc46..a93b2d0374 100644 --- a/libraries/octree/src/OctreeSceneStats.cpp +++ b/libraries/octree/src/OctreeSceneStats.cpp @@ -159,7 +159,7 @@ void OctreeSceneStats::copyFromOther(const OctreeSceneStats& other) { _incomingPossibleDuplicate = other._incomingPossibleDuplicate; _missingSequenceNumbers = other._missingSequenceNumbers; -_missingSequenceNumbersToNack = other._missingSequenceNumbersToNack; +_sequenceNumbersToNack = other._sequenceNumbersToNack; } From 2fec0a9db603e09e7314a4221e761141a57b127d Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Fri, 6 Jun 2014 15:50:28 -0700 Subject: [PATCH 26/42] Fixes for Windows. --- libraries/metavoxels/src/Bitstream.cpp | 87 ++++++++++++++++---------- libraries/metavoxels/src/Bitstream.h | 27 ++++---- 2 files changed, 71 insertions(+), 43 deletions(-) diff --git a/libraries/metavoxels/src/Bitstream.cpp b/libraries/metavoxels/src/Bitstream.cpp index bc187d9f3d..6f4af8ed5f 100644 --- a/libraries/metavoxels/src/Bitstream.cpp +++ b/libraries/metavoxels/src/Bitstream.cpp @@ -79,10 +79,6 @@ IDStreamer& IDStreamer::operator>>(int& value) { return *this; } -static QByteArray getEnumName(const QMetaEnum& metaEnum) { - return QByteArray(metaEnum.scope()) + "::" + metaEnum.name(); -} - int Bitstream::registerMetaObject(const char* className, const QMetaObject* metaObject) { getMetaObjects().insert(className, metaObject); @@ -90,16 +86,6 @@ int Bitstream::registerMetaObject(const char* className, const QMetaObject* meta for (const QMetaObject* superClass = metaObject; superClass; superClass = superClass->superClass()) { getMetaObjectSubClasses().insert(superClass, metaObject); } - - // register the streamers for all enumerators - for (int i = 0; i < metaObject->enumeratorCount(); i++) { - QMetaEnum metaEnum = metaObject->enumerator(i); - const TypeStreamer*& streamer = getEnumStreamers()[QPair(metaEnum.scope(), metaEnum.name())]; - if (!streamer) { - getEnumStreamersByName().insert(getEnumName(metaEnum), streamer = new EnumTypeStreamer(metaEnum)); - } - } - return 0; } @@ -1030,12 +1016,34 @@ QHash& Bitstream::getTypeStreamers() { } QHash, const TypeStreamer*>& Bitstream::getEnumStreamers() { - static QHash, const TypeStreamer*> enumStreamers; + static QHash, const TypeStreamer*> enumStreamers = createEnumStreamers(); + return enumStreamers; +} + +QHash, const TypeStreamer*> Bitstream::createEnumStreamers() { + QHash, const TypeStreamer*> enumStreamers; + foreach (const QMetaObject* metaObject, getMetaObjects()) { + for (int i = 0; i < metaObject->enumeratorCount(); i++) { + QMetaEnum metaEnum = metaObject->enumerator(i); + const TypeStreamer*& streamer = enumStreamers[QPair(metaEnum.scope(), metaEnum.name())]; + if (!streamer) { + streamer = new EnumTypeStreamer(metaEnum); + } + } + } return enumStreamers; } QHash& Bitstream::getEnumStreamersByName() { - static QHash enumStreamersByName; + static QHash enumStreamersByName = createEnumStreamersByName(); + return enumStreamersByName; +} + +QHash Bitstream::createEnumStreamersByName() { + QHash enumStreamersByName; + foreach (const TypeStreamer* streamer, getEnumStreamers()) { + enumStreamersByName.insert(streamer->getName(), streamer); + } return enumStreamersByName; } @@ -1462,17 +1470,21 @@ QDebug& operator<<(QDebug& debug, const QMetaObject* metaObject) { return debug << (metaObject ? metaObject->className() : "null"); } +EnumTypeStreamer::EnumTypeStreamer(const QMetaObject* metaObject, const char* name) : + _metaObject(metaObject), + _enumName(name), + _name(QByteArray(metaObject->className()) + "::" + name), + _bits(-1) { + + setType(QMetaType::Int); +} + EnumTypeStreamer::EnumTypeStreamer(const QMetaEnum& metaEnum) : + _name(QByteArray(metaEnum.scope()) + "::" + metaEnum.name()), _metaEnum(metaEnum), - _name(getEnumName(metaEnum)) { - - setType(QMetaType::Int); - - int highestValue = 0; - for (int j = 0; j < metaEnum.keyCount(); j++) { - highestValue = qMax(highestValue, metaEnum.value(j)); - } - _bits = getBitsForHighestValue(highestValue); + _bits(-1) { + + setType(QMetaType::Int); } const char* EnumTypeStreamer::getName() const { @@ -1484,10 +1496,21 @@ TypeReader::Type EnumTypeStreamer::getReaderType() const { } int EnumTypeStreamer::getBits() const { + if (_bits == -1) { + int highestValue = 0; + QMetaEnum metaEnum = getMetaEnum(); + for (int j = 0; j < metaEnum.keyCount(); j++) { + highestValue = qMax(highestValue, metaEnum.value(j)); + } + const_cast(this)->_bits = getBitsForHighestValue(highestValue); + } return _bits; } QMetaEnum EnumTypeStreamer::getMetaEnum() const { + if (!_metaEnum.isValid()) { + const_cast(this)->_metaEnum = _metaObject->enumerator(_metaObject->indexOfEnumerator(_enumName)); + } return _metaEnum; } @@ -1497,12 +1520,12 @@ bool EnumTypeStreamer::equal(const QVariant& first, const QVariant& second) cons void EnumTypeStreamer::write(Bitstream& out, const QVariant& value) const { int intValue = value.toInt(); - out.write(&intValue, _bits); + out.write(&intValue, getBits()); } QVariant EnumTypeStreamer::read(Bitstream& in) const { int intValue = 0; - in.read(&intValue, _bits); + in.read(&intValue, getBits()); return intValue; } @@ -1512,7 +1535,7 @@ void EnumTypeStreamer::writeDelta(Bitstream& out, const QVariant& value, const Q out << false; } else { out << true; - out.write(&intValue, _bits); + out.write(&intValue, getBits()); } } @@ -1521,7 +1544,7 @@ void EnumTypeStreamer::readDelta(Bitstream& in, QVariant& value, const QVariant& in >> changed; if (changed) { int intValue = 0; - in.read(&intValue, _bits); + in.read(&intValue, getBits()); value = intValue; } else { value = reference; @@ -1530,17 +1553,17 @@ void EnumTypeStreamer::readDelta(Bitstream& in, QVariant& value, const QVariant& void EnumTypeStreamer::writeRawDelta(Bitstream& out, const QVariant& value, const QVariant& reference) const { int intValue = value.toInt(); - out.write(&intValue, _bits); + out.write(&intValue, getBits()); } void EnumTypeStreamer::readRawDelta(Bitstream& in, QVariant& value, const QVariant& reference) const { int intValue = 0; - in.read(&intValue, _bits); + in.read(&intValue, getBits()); value = intValue; } void EnumTypeStreamer::setEnumValue(QVariant& object, int value, const QHash& mappings) const { - if (_metaEnum.isFlag()) { + if (getMetaEnum().isFlag()) { int combined = 0; for (QHash::const_iterator it = mappings.constBegin(); it != mappings.constEnd(); it++) { if (value & it.key()) { diff --git a/libraries/metavoxels/src/Bitstream.h b/libraries/metavoxels/src/Bitstream.h index caf0adf7fc..b0c33754f9 100644 --- a/libraries/metavoxels/src/Bitstream.h +++ b/libraries/metavoxels/src/Bitstream.h @@ -427,7 +427,9 @@ private: static QMultiHash& getMetaObjectSubClasses(); static QHash& getTypeStreamers(); static QHash, const TypeStreamer*>& getEnumStreamers(); + static QHash, const TypeStreamer*> createEnumStreamers(); static QHash& getEnumStreamersByName(); + static QHash createEnumStreamersByName(); static QVector getPropertyReaders(const QMetaObject* metaObject); }; @@ -938,8 +940,9 @@ public: class EnumTypeStreamer : public TypeStreamer { public: + EnumTypeStreamer(const QMetaObject* metaObject, const char* name); EnumTypeStreamer(const QMetaEnum& metaEnum); - + virtual const char* getName() const; virtual TypeReader::Type getReaderType() const; virtual int getBits() const; @@ -955,8 +958,10 @@ public: private: - QMetaEnum _metaEnum; + const QMetaObject* _metaObject; + const char* _enumName; QByteArray _name; + QMetaEnum _metaEnum; int _bits; }; @@ -1084,14 +1089,15 @@ public: template<> inline void Bitstream::readRawDelta(S::N& value, const S::N& reference) { *this >> value; } #define IMPLEMENT_ENUM_METATYPE(S, N) \ - static int S##N##Bits = registerEnumMetaType(S::staticMetaObject.enumerator( \ - S::staticMetaObject.indexOfEnumerator(#N))); \ + static int S##N##MetaTypeId = registerEnumMetaType(&S::staticMetaObject, #N); \ Bitstream& operator<<(Bitstream& out, const S::N& obj) { \ - return out.write(&obj, S##N##Bits); \ + static int bits = Bitstream::getTypeStreamer(qMetaTypeId())->getBits(); \ + return out.write(&obj, bits); \ } \ Bitstream& operator>>(Bitstream& in, S::N& obj) { \ + static int bits = Bitstream::getTypeStreamer(qMetaTypeId())->getBits(); \ obj = (S::N)0; \ - return in.read(&obj, S##N##Bits); \ + return in.read(&obj, bits); \ } /// Registers a simple type and its streamer. @@ -1103,12 +1109,11 @@ template int registerSimpleMetaType() { } /// Registers an enum type and its streamer. -/// \return the number of bits required to stream the enum -template int registerEnumMetaType(const QMetaEnum& metaEnum) { +/// \return the metatype id +template int registerEnumMetaType(const QMetaObject* metaObject, const char* name) { int type = qRegisterMetaType(); - EnumTypeStreamer* streamer = new EnumTypeStreamer(metaEnum); - Bitstream::registerTypeStreamer(type, streamer); - return streamer->getBits(); + Bitstream::registerTypeStreamer(type, new EnumTypeStreamer(metaObject, name)); + return type; } /// Registers a streamable type and its streamer. From 384fe51937d169f4fd34d7edbf15350e9331e77b Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Fri, 6 Jun 2014 16:38:52 -0700 Subject: [PATCH 27/42] If we're going to initialize one mapping lazily, we might as well initialize some more that way. --- libraries/metavoxels/src/Bitstream.cpp | 119 ++++++++++++++----------- libraries/metavoxels/src/Bitstream.h | 13 ++- 2 files changed, 71 insertions(+), 61 deletions(-) diff --git a/libraries/metavoxels/src/Bitstream.cpp b/libraries/metavoxels/src/Bitstream.cpp index 6f4af8ed5f..d9242ad9b7 100644 --- a/libraries/metavoxels/src/Bitstream.cpp +++ b/libraries/metavoxels/src/Bitstream.cpp @@ -298,7 +298,7 @@ void Bitstream::writeRawDelta(const QObject* value, const QObject* reference) { } const QMetaObject* metaObject = value->metaObject(); _metaObjectStreamer << metaObject; - foreach (const PropertyWriter& propertyWriter, getPropertyWriters(metaObject)) { + foreach (const PropertyWriter& propertyWriter, getPropertyWriters().value(metaObject)) { propertyWriter.writeDelta(*this, value, reference); } } @@ -476,7 +476,7 @@ Bitstream& Bitstream::operator<<(const QObject* object) { } const QMetaObject* metaObject = object->metaObject(); _metaObjectStreamer << metaObject; - foreach (const PropertyWriter& propertyWriter, getPropertyWriters(metaObject)) { + foreach (const PropertyWriter& propertyWriter, getPropertyWriters().value(metaObject)) { propertyWriter.write(*this, object); } return *this; @@ -561,7 +561,7 @@ Bitstream& Bitstream::operator<(const QMetaObject* metaObject) { if (_metadataType == NO_METADATA) { return *this; } - const QVector& propertyWriters = getPropertyWriters(metaObject); + const QVector& propertyWriters = getPropertyWriters().value(metaObject); *this << propertyWriters.size(); QCryptographicHash hash(QCryptographicHash::Md5); foreach (const PropertyWriter& propertyWriter, propertyWriters) { @@ -595,7 +595,7 @@ Bitstream& Bitstream::operator>(ObjectReader& objectReader) { qWarning() << "Unknown class name: " << className << "\n"; } if (_metadataType == NO_METADATA) { - objectReader = ObjectReader(className, metaObject, getPropertyReaders(metaObject)); + objectReader = ObjectReader(className, metaObject, getPropertyReaders().value(metaObject)); return *this; } int storedPropertyCount; @@ -619,7 +619,7 @@ Bitstream& Bitstream::operator>(ObjectReader& objectReader) { QCryptographicHash hash(QCryptographicHash::Md5); bool matches = true; if (metaObject) { - const QVector& propertyWriters = getPropertyWriters(metaObject); + const QVector& propertyWriters = getPropertyWriters().value(metaObject); if (propertyWriters.size() == properties.size()) { for (int i = 0; i < propertyWriters.size(); i++) { const PropertyWriter& propertyWriter = propertyWriters.at(i); @@ -638,7 +638,7 @@ Bitstream& Bitstream::operator>(ObjectReader& objectReader) { QByteArray remoteHashResult(localHashResult.size(), 0); read(remoteHashResult.data(), remoteHashResult.size() * BITS_IN_BYTE); if (metaObject && matches && localHashResult == remoteHashResult) { - objectReader = ObjectReader(className, metaObject, getPropertyReaders(metaObject)); + objectReader = ObjectReader(className, metaObject, getPropertyReaders().value(metaObject)); return *this; } } @@ -975,31 +975,6 @@ void Bitstream::clearSharedObject(QObject* object) { } } -const QVector& Bitstream::getPropertyWriters(const QMetaObject* metaObject) { - QVector& propertyWriters = _propertyWriters[metaObject]; - if (propertyWriters.isEmpty()) { - for (int i = 0; i < metaObject->propertyCount(); i++) { - QMetaProperty property = metaObject->property(i); - if (!property.isStored()) { - continue; - } - const TypeStreamer* streamer; - if (property.isEnumType()) { - QMetaEnum metaEnum = property.enumerator(); - streamer = getEnumStreamers().value(QPair( - QByteArray::fromRawData(metaEnum.scope(), strlen(metaEnum.scope())), - QByteArray::fromRawData(metaEnum.name(), strlen(metaEnum.name())))); - } else { - streamer = getTypeStreamers().value(property.userType()); - } - if (streamer) { - propertyWriters.append(PropertyWriter(property, streamer)); - } - } - } - return propertyWriters; -} - QHash& Bitstream::getMetaObjects() { static QHash metaObjects; return metaObjects; @@ -1015,7 +990,7 @@ QHash& Bitstream::getTypeStreamers() { return typeStreamers; } -QHash, const TypeStreamer*>& Bitstream::getEnumStreamers() { +const QHash, const TypeStreamer*>& Bitstream::getEnumStreamers() { static QHash, const TypeStreamer*> enumStreamers = createEnumStreamers(); return enumStreamers; } @@ -1034,7 +1009,7 @@ QHash, const TypeStreamer*> Bitstream::createEnumS return enumStreamers; } -QHash& Bitstream::getEnumStreamersByName() { +const QHash& Bitstream::getEnumStreamersByName() { static QHash enumStreamersByName = createEnumStreamersByName(); return enumStreamersByName; } @@ -1047,32 +1022,68 @@ QHash Bitstream::createEnumStreamersByName() { return enumStreamersByName; } -QVector Bitstream::getPropertyReaders(const QMetaObject* metaObject) { - QVector propertyReaders; - if (!metaObject) { - return propertyReaders; - } - for (int i = 0; i < metaObject->propertyCount(); i++) { - QMetaProperty property = metaObject->property(i); - if (!property.isStored()) { - continue; - } - const TypeStreamer* streamer; - if (property.isEnumType()) { - QMetaEnum metaEnum = property.enumerator(); - streamer = getEnumStreamers().value(QPair( - QByteArray::fromRawData(metaEnum.scope(), strlen(metaEnum.scope())), - QByteArray::fromRawData(metaEnum.name(), strlen(metaEnum.name())))); - } else { - streamer = getTypeStreamers().value(property.userType()); - } - if (streamer) { - propertyReaders.append(PropertyReader(TypeReader(QByteArray(), streamer), property)); +const QHash >& Bitstream::getPropertyReaders() { + static QHash > propertyReaders = createPropertyReaders(); + return propertyReaders; +} + +QHash > Bitstream::createPropertyReaders() { + QHash > propertyReaders; + foreach (const QMetaObject* metaObject, getMetaObjects()) { + QVector& readers = propertyReaders[metaObject]; + for (int i = 0; i < metaObject->propertyCount(); i++) { + QMetaProperty property = metaObject->property(i); + if (!property.isStored()) { + continue; + } + const TypeStreamer* streamer; + if (property.isEnumType()) { + QMetaEnum metaEnum = property.enumerator(); + streamer = getEnumStreamers().value(QPair( + QByteArray::fromRawData(metaEnum.scope(), strlen(metaEnum.scope())), + QByteArray::fromRawData(metaEnum.name(), strlen(metaEnum.name())))); + } else { + streamer = getTypeStreamers().value(property.userType()); + } + if (streamer) { + readers.append(PropertyReader(TypeReader(QByteArray(), streamer), property)); + } } } return propertyReaders; } +const QHash >& Bitstream::getPropertyWriters() { + static QHash > propertyWriters = createPropertyWriters(); + return propertyWriters; +} + +QHash > Bitstream::createPropertyWriters() { + QHash > propertyWriters; + foreach (const QMetaObject* metaObject, getMetaObjects()) { + QVector& writers = propertyWriters[metaObject]; + for (int i = 0; i < metaObject->propertyCount(); i++) { + QMetaProperty property = metaObject->property(i); + if (!property.isStored()) { + continue; + } + const TypeStreamer* streamer; + if (property.isEnumType()) { + QMetaEnum metaEnum = property.enumerator(); + streamer = getEnumStreamers().value(QPair( + QByteArray::fromRawData(metaEnum.scope(), strlen(metaEnum.scope())), + QByteArray::fromRawData(metaEnum.name(), strlen(metaEnum.name())))); + } else { + streamer = getTypeStreamers().value(property.userType()); + } + if (streamer) { + writers.append(PropertyWriter(property, streamer)); + } + } + } + return propertyWriters; +} + TypeReader::TypeReader(const QByteArray& typeName, const TypeStreamer* streamer) : _typeName(typeName), _streamer(streamer), diff --git a/libraries/metavoxels/src/Bitstream.h b/libraries/metavoxels/src/Bitstream.h index b0c33754f9..80adfc4e8b 100644 --- a/libraries/metavoxels/src/Bitstream.h +++ b/libraries/metavoxels/src/Bitstream.h @@ -400,8 +400,6 @@ private slots: private: - const QVector& getPropertyWriters(const QMetaObject* metaObject); - QDataStream& _underlying; quint8 _byte; int _position; @@ -421,16 +419,17 @@ private: QHash _metaObjectSubstitutions; QHash _typeStreamerSubstitutions; - QHash > _propertyWriters; - static QHash& getMetaObjects(); static QMultiHash& getMetaObjectSubClasses(); static QHash& getTypeStreamers(); - static QHash, const TypeStreamer*>& getEnumStreamers(); + static const QHash, const TypeStreamer*>& getEnumStreamers(); static QHash, const TypeStreamer*> createEnumStreamers(); - static QHash& getEnumStreamersByName(); + static const QHash& getEnumStreamersByName(); static QHash createEnumStreamersByName(); - static QVector getPropertyReaders(const QMetaObject* metaObject); + static const QHash >& getPropertyReaders(); + static QHash > createPropertyReaders(); + static const QHash >& getPropertyWriters(); + static QHash > createPropertyWriters(); }; template inline void Bitstream::writeDelta(const T& value, const T& reference) { From b39559d86086f3b78fff66e5476553c315ba9a28 Mon Sep 17 00:00:00 2001 From: wangyix Date: Fri, 6 Jun 2014 17:44:30 -0700 Subject: [PATCH 28/42] packet recovery seems to be working Seems to impact FPS a lot. OctreeSceneStats is not being locked (causes freezing, need to find out why). --- .../src/octree/OctreeQueryNode.cpp | 5 --- .../src/octree/OctreeQueryNode.h | 4 ++- .../src/octree/OctreeSendThread.cpp | 3 +- assignment-client/src/octree/OctreeServer.cpp | 35 ++++++++++--------- interface/src/Application.cpp | 16 +++++---- libraries/networking/src/LimitedNodeList.cpp | 4 +-- libraries/networking/src/PacketHeaders.h | 3 +- 7 files changed, 37 insertions(+), 33 deletions(-) diff --git a/assignment-client/src/octree/OctreeQueryNode.cpp b/assignment-client/src/octree/OctreeQueryNode.cpp index 208be5951b..cf01e9a864 100644 --- a/assignment-client/src/octree/OctreeQueryNode.cpp +++ b/assignment-client/src/octree/OctreeQueryNode.cpp @@ -377,11 +377,6 @@ void OctreeQueryNode::packetSent(const QByteArray& packet) { _sequenceNumber++; } - -void OctreeQueryNode::addSequenceNumbersToResend(const QList& sequenceNumbers) { - _nackedSequenceNumbers.append(sequenceNumbers); -} - bool OctreeQueryNode::hasNextNackedPacket() const { return !_nackedSequenceNumbers.isEmpty(); } diff --git a/assignment-client/src/octree/OctreeQueryNode.h b/assignment-client/src/octree/OctreeQueryNode.h index e1707cc899..b79367503c 100644 --- a/assignment-client/src/octree/OctreeQueryNode.h +++ b/assignment-client/src/octree/OctreeQueryNode.h @@ -109,7 +109,9 @@ public: OCTREE_PACKET_SEQUENCE getSequenceNumber() const { return _sequenceNumber; } - void addSequenceNumbersToResend(const QList& sequenceNumbers); + void addNackedSequenceNumber(OCTREE_PACKET_SEQUENCE sequenceNumber) { + _nackedSequenceNumbers.append(sequenceNumber); + } bool hasNextNackedPacket() const; const QByteArray* getNextNackedPacket(); diff --git a/assignment-client/src/octree/OctreeSendThread.cpp b/assignment-client/src/octree/OctreeSendThread.cpp index e5c47f5d2d..cb8a773a64 100644 --- a/assignment-client/src/octree/OctreeSendThread.cpp +++ b/assignment-client/src/octree/OctreeSendThread.cpp @@ -305,7 +305,8 @@ int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { _totalWastedBytes += MAX_PACKET_SIZE - packet->size(); // ??? } } - + +if (packetsSent > 0) printf("\t\t re-sent %d packets!\n", packetsSent); return packetsSent; } diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp index 46eb7aac16..8cf1649cdb 100644 --- a/assignment-client/src/octree/OctreeServer.cpp +++ b/assignment-client/src/octree/OctreeServer.cpp @@ -832,10 +832,9 @@ void OctreeServer::readPendingDatagrams() { PacketType packetType = packetTypeForPacket(receivedPacket); SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket); if (packetType == getMyQueryMessageType()) { - // If we got a query packet, then we're talking to an agent, and we // need to make sure we have it in our nodeList. - if (matchingNode) { + if (matchingNode) { nodeList->updateNodeWithDataFromPacket(matchingNode, receivedPacket); OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); if (nodeData && !nodeData->isOctreeSendThreadInitalized()) { @@ -852,25 +851,29 @@ void OctreeServer::readPendingDatagrams() { } else if (packetType == PacketTypeOctreeDataNack) { // parse packet for sequence numbers that need to be resent -int numBytesPacketHeader = numBytesForPacketHeader(receivedPacket); -const unsigned char* dataAt = reinterpret_cast(receivedPacket.data()) + numBytesPacketHeader; -uint16_t numSequenceNumbers = (*(uint16_t*)dataAt); -dataAt += sizeof(uint16_t); +if (matchingNode) { -// read sequence numbers -QList sequenceNumbers; -for (int i = 0; i < numSequenceNumbers; i++) { - OCTREE_PACKET_SEQUENCE sequenceNumber = (*(OCTREE_PACKET_SEQUENCE*)dataAt); - sequenceNumbers.append(sequenceNumber); - dataAt += sizeof(OCTREE_PACKET_SEQUENCE); + OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); -printf("\t\t\t nacked packet: seq = %d\n", sequenceNumber); + int numBytesPacketHeader = numBytesForPacketHeader(receivedPacket); + const unsigned char* dataAt = reinterpret_cast(receivedPacket.data()) + numBytesPacketHeader; + + uint16_t numSequenceNumbers = (*(uint16_t*)dataAt); + dataAt += sizeof(uint16_t); + +printf("\t received nack packet containing %d seq nums\n", numSequenceNumbers); + + // read sequence numbers + for (int i = 0; i < numSequenceNumbers; i++) { + OCTREE_PACKET_SEQUENCE sequenceNumber = (*(OCTREE_PACKET_SEQUENCE*)dataAt); + nodeData->addNackedSequenceNumber(sequenceNumber); + dataAt += sizeof(OCTREE_PACKET_SEQUENCE); + +printf("\t seq = %d\n", sequenceNumber); + } } -OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); // move this or something -nodeData->addSequenceNumbersToResend(sequenceNumbers); - } else if (packetType == PacketTypeJurisdictionRequest) { diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 07bef852f2..a28343eb96 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2110,8 +2110,6 @@ void Application::updateMyAvatar(float deltaTime) { void Application::sendNack() { -printf("\n\t sendNack()...\n"); - char packet[MAX_PACKET_SIZE]; NodeList* nodeList = NodeList::getInstance(); @@ -2124,15 +2122,18 @@ printf("\n\t sendNack()...\n"); || node->getType() == NodeType::ModelServer) ) { - _octreeSceneStatsLock.lockForWrite(); + //_octreeSceneStatsLock.lockForWrite(); OctreeSceneStats& stats = _octreeServerSceneStats[node->getUUID()]; + int numSequenceNumbersAvailable = stats.getNumSequenceNumbersToNack(); + if (numSequenceNumbersAvailable == 0) + continue; char* dataAt = packet; int bytesRemaining = MAX_PACKET_SIZE; // pack header - int numBytesPacketHeader = populatePacketHeader(packet, PacketTypeOctreeDataNack, node->getUUID()); + int numBytesPacketHeader = populatePacketHeader(packet, PacketTypeOctreeDataNack); dataAt += numBytesPacketHeader; bytesRemaining -= numBytesPacketHeader; @@ -2140,12 +2141,13 @@ printf("\n\t sendNack()...\n"); // calculate and pack number of sequence numbers - uint16_t numSequenceNumbers = min(stats.getNumSequenceNumbersToNack(), numPacketsRoomFor); + uint16_t numSequenceNumbers = min(numSequenceNumbersAvailable, numPacketsRoomFor); uint16_t* numSequenceNumbersAt = (uint16_t*)dataAt; *numSequenceNumbersAt = numSequenceNumbers; dataAt += sizeof(uint16_t); // pack sequence numbers +printf("\n\t sending nack...\n"); printf("\t\t packed %d seq #s:", numSequenceNumbers); for (int i = 0; i < numSequenceNumbers; i++) { OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; @@ -2155,10 +2157,10 @@ printf(" %d,", *sequenceNumberAt); } printf("\n"); - _octreeSceneStatsLock.unlock(); + //_octreeSceneStatsLock.unlock(); // make sure we still have an active socket???? - nodeList->writeUnverifiedDatagram(packet, dataAt - packet, node); + nodeList->writeUnverifiedDatagram(packet, dataAt-packet, node); } } } diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp index f9630c9102..15cebc26ac 100644 --- a/libraries/networking/src/LimitedNodeList.cpp +++ b/libraries/networking/src/LimitedNodeList.cpp @@ -274,13 +274,13 @@ qint64 LimitedNodeList::writeDatagram(const char* data, qint64 size, const Share qint64 LimitedNodeList::writeDatagram2(int seq, const char* data, qint64 size, const SharedNodePointer& destinationNode, const HifiSockAddr& overridenSockAddr) { - qint64 ret; + qint64 ret = -1; if (randFloat() < 0.8f) { ret = writeDatagram(QByteArray(data, size), destinationNode, overridenSockAddr); } else { - printf("\t\t\t dropped packet seq = %d!!!\n", seq); + printf("dropped packet seq = %d --------------------------\n", seq); } diff --git a/libraries/networking/src/PacketHeaders.h b/libraries/networking/src/PacketHeaders.h index a73ffe8564..eac2f88870 100644 --- a/libraries/networking/src/PacketHeaders.h +++ b/libraries/networking/src/PacketHeaders.h @@ -75,7 +75,8 @@ const QSet NON_VERIFIED_PACKETS = QSet() << PacketTypeDomainServerRequireDTLS << PacketTypeDomainConnectRequest << PacketTypeDomainList << PacketTypeDomainListRequest << PacketTypeDomainOAuthRequest << PacketTypeCreateAssignment << PacketTypeRequestAssignment << PacketTypeStunResponse - << PacketTypeNodeJsonStats << PacketTypeVoxelQuery << PacketTypeParticleQuery << PacketTypeModelQuery; + << PacketTypeNodeJsonStats << PacketTypeVoxelQuery << PacketTypeParticleQuery << PacketTypeModelQuery +<< PacketTypeOctreeDataNack; const int NUM_BYTES_MD5_HASH = 16; const int NUM_STATIC_HEADER_BYTES = sizeof(PacketVersion) + NUM_BYTES_RFC4122_UUID; From 52860908128fe0052a18981ace38b2ec06da2a46 Mon Sep 17 00:00:00 2001 From: wangyix Date: Fri, 6 Jun 2014 17:52:48 -0700 Subject: [PATCH 29/42] removed interface print statements --- interface/src/Application.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index a28343eb96..87e82b21a2 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2147,15 +2147,15 @@ void Application::sendNack() { dataAt += sizeof(uint16_t); // pack sequence numbers -printf("\n\t sending nack...\n"); -printf("\t\t packed %d seq #s:", numSequenceNumbers); +//printf("\n\t sending nack...\n"); +//printf("\t\t packed %d seq #s:", numSequenceNumbers); for (int i = 0; i < numSequenceNumbers; i++) { OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; *sequenceNumberAt = stats.getNextSequenceNumberToNack(); dataAt += sizeof(OCTREE_PACKET_SEQUENCE); -printf(" %d,", *sequenceNumberAt); +//printf(" %d,", *sequenceNumberAt); } -printf("\n"); +//printf("\n"); //_octreeSceneStatsLock.unlock(); From 6eac0ee2aeb262feee7a192b17c786c933e1d8db Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Mon, 9 Jun 2014 10:58:56 -0700 Subject: [PATCH 30/42] Avoid crash on zero-length normals. --- libraries/fbx/src/FBXReader.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/libraries/fbx/src/FBXReader.cpp b/libraries/fbx/src/FBXReader.cpp index 60412cf0ce..d668349b96 100644 --- a/libraries/fbx/src/FBXReader.cpp +++ b/libraries/fbx/src/FBXReader.cpp @@ -894,14 +894,19 @@ FBXBlendshape extractBlendshape(const FBXNode& object) { } void setTangents(FBXMesh& mesh, int firstIndex, int secondIndex) { - glm::vec3 normal = glm::normalize(mesh.normals.at(firstIndex)); - glm::vec3 bitangent = glm::cross(normal, mesh.vertices.at(secondIndex) - mesh.vertices.at(firstIndex)); + const glm::vec3& normal = mesh.normals.at(firstIndex); + float normalLength = glm::length(normal); + if (normalLength < EPSILON) { + return; + } + glm::vec3 normalizedNormal = normal / normalLength; + glm::vec3 bitangent = glm::cross(normalizedNormal, mesh.vertices.at(secondIndex) - mesh.vertices.at(firstIndex)); if (glm::length(bitangent) < EPSILON) { return; } glm::vec2 texCoordDelta = mesh.texCoords.at(secondIndex) - mesh.texCoords.at(firstIndex); - mesh.tangents[firstIndex] += glm::cross(glm::angleAxis( - - atan2f(-texCoordDelta.t, texCoordDelta.s), normal) * glm::normalize(bitangent), normal); + mesh.tangents[firstIndex] += glm::cross(glm::angleAxis(-atan2f(-texCoordDelta.t, texCoordDelta.s), normalizedNormal) * + glm::normalize(bitangent), normalizedNormal); } QVector getIndices(const QVector ids, QVector modelIDs) { From a1e208ae3d3173ca4490a9d96941e860adf9e0b0 Mon Sep 17 00:00:00 2001 From: Andrzej Kapolka Date: Mon, 9 Jun 2014 11:03:50 -0700 Subject: [PATCH 31/42] Simplification. If the normal is zero, then the cross product will also be zero, so we can just have the one check and postpone normalization until afterwards. --- libraries/fbx/src/FBXReader.cpp | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/libraries/fbx/src/FBXReader.cpp b/libraries/fbx/src/FBXReader.cpp index d668349b96..9aeb81a2a3 100644 --- a/libraries/fbx/src/FBXReader.cpp +++ b/libraries/fbx/src/FBXReader.cpp @@ -895,16 +895,12 @@ FBXBlendshape extractBlendshape(const FBXNode& object) { void setTangents(FBXMesh& mesh, int firstIndex, int secondIndex) { const glm::vec3& normal = mesh.normals.at(firstIndex); - float normalLength = glm::length(normal); - if (normalLength < EPSILON) { - return; - } - glm::vec3 normalizedNormal = normal / normalLength; - glm::vec3 bitangent = glm::cross(normalizedNormal, mesh.vertices.at(secondIndex) - mesh.vertices.at(firstIndex)); + glm::vec3 bitangent = glm::cross(normal, mesh.vertices.at(secondIndex) - mesh.vertices.at(firstIndex)); if (glm::length(bitangent) < EPSILON) { return; } glm::vec2 texCoordDelta = mesh.texCoords.at(secondIndex) - mesh.texCoords.at(firstIndex); + glm::vec3 normalizedNormal = glm::normalize(normal); mesh.tangents[firstIndex] += glm::cross(glm::angleAxis(-atan2f(-texCoordDelta.t, texCoordDelta.s), normalizedNormal) * glm::normalize(bitangent), normalizedNormal); } From 3bc457d4d2ea981f3c12bb8605bfe078f9c180bf Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 11:14:02 -0700 Subject: [PATCH 32/42] added octree scene stats locking and unlocking --- .../src/octree/OctreeQueryNode.cpp | 8 +-- .../src/octree/OctreeSendThread.cpp | 3 - interface/src/Application.cpp | 69 ++++++++++++------- libraries/octree/src/OctreeSceneStats.h | 4 +- 4 files changed, 49 insertions(+), 35 deletions(-) diff --git a/assignment-client/src/octree/OctreeQueryNode.cpp b/assignment-client/src/octree/OctreeQueryNode.cpp index cf01e9a864..5cfe5501e1 100644 --- a/assignment-client/src/octree/OctreeQueryNode.cpp +++ b/assignment-client/src/octree/OctreeQueryNode.cpp @@ -382,11 +382,9 @@ bool OctreeQueryNode::hasNextNackedPacket() const { } const QByteArray* OctreeQueryNode::getNextNackedPacket() { - if (!_nackedSequenceNumbers.isEmpty()) { - const QByteArray* nextPacket = _sentPacketHistory.getPacket(_nackedSequenceNumbers.first()); - _nackedSequenceNumbers.pop_front(); - return nextPacket; // could be null + // could return null if packet is not in the history + return _sentPacketHistory.getPacket(_nackedSequenceNumbers.takeFirst()); } return NULL; -} \ No newline at end of file +} diff --git a/assignment-client/src/octree/OctreeSendThread.cpp b/assignment-client/src/octree/OctreeSendThread.cpp index cb8a773a64..6f39cd28dc 100644 --- a/assignment-client/src/octree/OctreeSendThread.cpp +++ b/assignment-client/src/octree/OctreeSendThread.cpp @@ -288,18 +288,15 @@ NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*)no int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { const int MAX_PACKETS_RESEND = 10; - int packetsSent = 0; const QByteArray* packet; while (nodeData->hasNextNackedPacket() && packetsSent < MAX_PACKETS_RESEND) { packet = nodeData->getNextNackedPacket(); - // packet will be NULL if it's not in nodeData's packet history if (packet) { NodeList::getInstance()->writeDatagram(*packet, _node); packetsSent++; - // ?????? _totalBytes += packet->size(); _totalPackets++; _totalWastedBytes += MAX_PACKET_SIZE - packet->size(); // ??? diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 87e82b21a2..f8152bb62b 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2107,6 +2107,21 @@ void Application::updateMyAvatar(float deltaTime) { } } +/*/ Attempt to identify the sender from it's address. + if (sendingNode) { + QUuid nodeUUID = sendingNode->getUUID(); + + // now that we know the node ID, let's add these stats to the stats for that node... + _octreeSceneStatsLock.lockForWrite(); + if (_octreeServerSceneStats.find(nodeUUID) != _octreeServerSceneStats.end()) { + OctreeSceneStats& stats = _octreeServerSceneStats[nodeUUID]; + stats.trackIncomingOctreePacket(packet, wasStatsPacket, sendingNode->getClockSkewUsec()); + } + _octreeSceneStatsLock.unlock(); + } + */ + + void Application::sendNack() { @@ -2122,13 +2137,6 @@ void Application::sendNack() { || node->getType() == NodeType::ModelServer) ) { - //_octreeSceneStatsLock.lockForWrite(); - - OctreeSceneStats& stats = _octreeServerSceneStats[node->getUUID()]; - int numSequenceNumbersAvailable = stats.getNumSequenceNumbersToNack(); - if (numSequenceNumbersAvailable == 0) - continue; - char* dataAt = packet; int bytesRemaining = MAX_PACKET_SIZE; @@ -2136,28 +2144,39 @@ void Application::sendNack() { int numBytesPacketHeader = populatePacketHeader(packet, PacketTypeOctreeDataNack); dataAt += numBytesPacketHeader; bytesRemaining -= numBytesPacketHeader; - - int numPacketsRoomFor = (bytesRemaining - sizeof(uint16_t)) / sizeof(OCTREE_PACKET_SEQUENCE); + int numSequenceNumbersRoomFor = (bytesRemaining - sizeof(uint16_t)) / sizeof(OCTREE_PACKET_SEQUENCE); - // calculate and pack number of sequence numbers - uint16_t numSequenceNumbers = min(numSequenceNumbersAvailable, numPacketsRoomFor); - uint16_t* numSequenceNumbersAt = (uint16_t*)dataAt; - *numSequenceNumbersAt = numSequenceNumbers; - dataAt += sizeof(uint16_t); + QUuid nodeUUID = node->getUUID(); - // pack sequence numbers -//printf("\n\t sending nack...\n"); -//printf("\t\t packed %d seq #s:", numSequenceNumbers); - for (int i = 0; i < numSequenceNumbers; i++) { - OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; - *sequenceNumberAt = stats.getNextSequenceNumberToNack(); - dataAt += sizeof(OCTREE_PACKET_SEQUENCE); -//printf(" %d,", *sequenceNumberAt); + _octreeSceneStatsLock.lockForWrite(); + if (_octreeServerSceneStats.find(nodeUUID) != _octreeServerSceneStats.end()) { + OctreeSceneStats& stats = _octreeServerSceneStats[nodeUUID]; + + int numSequenceNumbersAvailable = stats.getNumSequenceNumbersToNack(); + if (numSequenceNumbersAvailable == 0) { + _octreeSceneStatsLock.unlock(); + continue; + } + + // calculate and pack number of sequence numbers + uint16_t numSequenceNumbers = min(numSequenceNumbersAvailable, numSequenceNumbersRoomFor); + uint16_t* numSequenceNumbersAt = (uint16_t*)dataAt; + *numSequenceNumbersAt = numSequenceNumbers; + dataAt += sizeof(uint16_t); + + // pack sequence numbers + //printf("\n\t sending nack...\n"); + //printf("\t\t packed %d seq #s:", numSequenceNumbers); + for (int i = 0; i < numSequenceNumbers; i++) { + OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; + *sequenceNumberAt = stats.getNextSequenceNumberToNack(); + dataAt += sizeof(OCTREE_PACKET_SEQUENCE); + //printf(" %d,", *sequenceNumberAt); + } + //printf("\n"); } -//printf("\n"); - - //_octreeSceneStatsLock.unlock(); + _octreeSceneStatsLock.unlock(); // make sure we still have an active socket???? nodeList->writeUnverifiedDatagram(packet, dataAt-packet, node); diff --git a/libraries/octree/src/OctreeSceneStats.h b/libraries/octree/src/OctreeSceneStats.h index ca9bf7c74b..ac9b1606c1 100644 --- a/libraries/octree/src/OctreeSceneStats.h +++ b/libraries/octree/src/OctreeSceneStats.h @@ -275,8 +275,8 @@ private: quint32 _incomingLate; /// out of order later than expected quint32 _incomingReallyLate; /// out of order and later than MAX_MISSING_SEQUENCE_OLD_AGE late quint32 _incomingPossibleDuplicate; /// out of order possibly a duplicate - QSet _missingSequenceNumbers; -QSet _sequenceNumbersToNack; + QSet _missingSequenceNumbers; +QSet _sequenceNumbersToNack; SimpleMovingAverage _incomingFlightTimeAverage; // features related items From 4f9da0cc3716dccf58ce25affc15cb1b9886040e Mon Sep 17 00:00:00 2001 From: Andrew Meadows Date: Mon, 9 Jun 2014 11:50:31 -0700 Subject: [PATCH 33/42] fix whitespace formatting --- interface/src/renderer/RagDoll.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/interface/src/renderer/RagDoll.cpp b/interface/src/renderer/RagDoll.cpp index e2654d737f..305724d6e4 100644 --- a/interface/src/renderer/RagDoll.cpp +++ b/interface/src/renderer/RagDoll.cpp @@ -23,7 +23,7 @@ // ---------------------------------------------------------------------------- // FixedConstraint // ---------------------------------------------------------------------------- -FixedConstraint::FixedConstraint(glm::vec3* point, const glm::vec3& anchor ) : _point(point), _anchor(anchor) { +FixedConstraint::FixedConstraint(glm::vec3* point, const glm::vec3& anchor) : _point(point), _anchor(anchor) { } float FixedConstraint::enforce() { @@ -84,7 +84,7 @@ void DistanceConstraint::updateProxyShape(Shape* shape, const glm::quat& rotatio } break; case Shape::CAPSULE_SHAPE: { - // capsule collides from startPoint to endPoint + // capsule collides from startPoint to endPoint CapsuleShape* capsule = static_cast(shape); capsule->setEndPoints(translation + rotation * (*_points[0]), translation + rotation * (*_points[1])); } From 936f04cececd2e29177d9189f25487e623ff7240 Mon Sep 17 00:00:00 2001 From: barnold1953 Date: Mon, 9 Jun 2014 11:55:29 -0700 Subject: [PATCH 34/42] Simple raypicking for scripts with oculus rift. --- interface/src/Camera.cpp | 8 +++++++- interface/src/ui/ApplicationOverlay.cpp | 21 +++++++++++++++++++-- interface/src/ui/ApplicationOverlay.h | 3 ++- 3 files changed, 28 insertions(+), 4 deletions(-) diff --git a/interface/src/Camera.cpp b/interface/src/Camera.cpp index f9ee5bdd25..0e33e14f32 100644 --- a/interface/src/Camera.cpp +++ b/interface/src/Camera.cpp @@ -18,6 +18,7 @@ #include "Camera.h" #include "Menu.h" #include "Util.h" +#include "devices/OculusManager.h" const float CAMERA_FIRST_PERSON_MODE_UP_SHIFT = 0.0f; const float CAMERA_FIRST_PERSON_MODE_DISTANCE = 0.0f; @@ -264,7 +265,12 @@ PickRay CameraScriptableObject::computePickRay(float x, float y) { float screenWidth = Application::getInstance()->getGLWidget()->width(); float screenHeight = Application::getInstance()->getGLWidget()->height(); PickRay result; - _viewFrustum->computePickRay(x / screenWidth, y / screenHeight, result.origin, result.direction); + if (OculusManager::isConnected()) { + result.origin = _camera->getPosition(); + Application::getInstance()->getApplicationOverlay().computeOculusPickRay(x / screenWidth, y / screenHeight, result.direction); + } else { + _viewFrustum->computePickRay(x / screenWidth, y / screenHeight, result.origin, result.direction); + } return result; } diff --git a/interface/src/ui/ApplicationOverlay.cpp b/interface/src/ui/ApplicationOverlay.cpp index 49ec8ecddb..f5de7459a8 100644 --- a/interface/src/ui/ApplicationOverlay.cpp +++ b/interface/src/ui/ApplicationOverlay.cpp @@ -297,6 +297,25 @@ void ApplicationOverlay::displayOverlayTexture(Camera& whichCamera) { glDisable(GL_TEXTURE_2D); } +const float textureFov = PI / 2.5f; + +void ApplicationOverlay::computeOculusPickRay(float x, float y, glm::vec3& direction) const { + glm::quat rot = Application::getInstance()->getAvatar()->getOrientation(); + + //invert y direction + y = 1.0 - y; + + //Get position on hemisphere UI + x = sin((x - 0.5f) * textureFov); + y = sin((y - 0.5f) * textureFov); + + float dist = sqrt(x * x + y * y); + float z = -sqrt(1.0f - dist * dist); + + //Rotate the UI pick ray by the avatar orientation + direction = glm::normalize(rot * glm::vec3(x, y, z)); +} + // Fast helper functions inline float max(float a, float b) { return (a > b) ? a : b; @@ -306,8 +325,6 @@ inline float min(float a, float b) { return (a < b) ? a : b; } -const float textureFov = PI / 2.5f; - // Draws the FBO texture for Oculus rift. TODO: Draw a curved texture instead of plane. void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) { diff --git a/interface/src/ui/ApplicationOverlay.h b/interface/src/ui/ApplicationOverlay.h index 8817549277..1bf0e18816 100644 --- a/interface/src/ui/ApplicationOverlay.h +++ b/interface/src/ui/ApplicationOverlay.h @@ -15,7 +15,7 @@ class Overlays; class QOpenGLFramebufferObject; -// Handles the drawing of the overlays to the scree +// Handles the drawing of the overlays to the screen class ApplicationOverlay { public: @@ -27,6 +27,7 @@ public: void renderOverlay(bool renderToTexture = false); void displayOverlayTexture(Camera& whichCamera); void displayOverlayTextureOculus(Camera& whichCamera); + void computeOculusPickRay(float x, float y, glm::vec3& direction) const; // Getters QOpenGLFramebufferObject* getFramebufferObject(); From 529dd827a2d613aa6c6b3fd74d9dfcbeaf9de72e Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 12:00:19 -0700 Subject: [PATCH 35/42] moved around code in sendNack() a bit --- interface/src/Application.cpp | 65 ++++++++++++---------- libraries/networking/src/PacketHeaders.cpp | 2 +- libraries/octree/src/OctreeSceneStats.h | 4 +- 3 files changed, 38 insertions(+), 33 deletions(-) diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index f8152bb62b..3ebfe728de 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2137,6 +2137,25 @@ void Application::sendNack() { || node->getType() == NodeType::ModelServer) ) { + QUuid nodeUUID = node->getUUID(); + + + _octreeSceneStatsLock.lockForWrite(); + + // retreive octree scene stats of this node + if (_octreeServerSceneStats.find(nodeUUID) == _octreeServerSceneStats.end()) { + _octreeSceneStatsLock.unlock(); + continue; + } + OctreeSceneStats& stats = _octreeServerSceneStats[nodeUUID]; + + // check if there are any sequence numbers that need to be nacked + int numSequenceNumbersAvailable = stats.getNumSequenceNumbersToNack(); + if (numSequenceNumbersAvailable == 0) { + _octreeSceneStatsLock.unlock(); + continue; + } + char* dataAt = packet; int bytesRemaining = MAX_PACKET_SIZE; @@ -2146,40 +2165,26 @@ void Application::sendNack() { bytesRemaining -= numBytesPacketHeader; int numSequenceNumbersRoomFor = (bytesRemaining - sizeof(uint16_t)) / sizeof(OCTREE_PACKET_SEQUENCE); + // calculate and pack the number of sequence numbers + uint16_t numSequenceNumbers = min(numSequenceNumbersAvailable, numSequenceNumbersRoomFor); + uint16_t* numSequenceNumbersAt = (uint16_t*)dataAt; + *numSequenceNumbersAt = numSequenceNumbers; + dataAt += sizeof(uint16_t); - QUuid nodeUUID = node->getUUID(); - - _octreeSceneStatsLock.lockForWrite(); - if (_octreeServerSceneStats.find(nodeUUID) != _octreeServerSceneStats.end()) { - OctreeSceneStats& stats = _octreeServerSceneStats[nodeUUID]; - - int numSequenceNumbersAvailable = stats.getNumSequenceNumbersToNack(); - if (numSequenceNumbersAvailable == 0) { - _octreeSceneStatsLock.unlock(); - continue; - } - - // calculate and pack number of sequence numbers - uint16_t numSequenceNumbers = min(numSequenceNumbersAvailable, numSequenceNumbersRoomFor); - uint16_t* numSequenceNumbersAt = (uint16_t*)dataAt; - *numSequenceNumbersAt = numSequenceNumbers; - dataAt += sizeof(uint16_t); - - // pack sequence numbers - //printf("\n\t sending nack...\n"); - //printf("\t\t packed %d seq #s:", numSequenceNumbers); - for (int i = 0; i < numSequenceNumbers; i++) { - OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; - *sequenceNumberAt = stats.getNextSequenceNumberToNack(); - dataAt += sizeof(OCTREE_PACKET_SEQUENCE); - //printf(" %d,", *sequenceNumberAt); - } - //printf("\n"); + // pack sequence numbers +//printf("\n\t sending nack...\n"); +//printf("\t\t packed %d seq #s:", numSequenceNumbers); + for (int i = 0; i < numSequenceNumbers; i++) { + OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; + *sequenceNumberAt = stats.getNextSequenceNumberToNack(); + dataAt += sizeof(OCTREE_PACKET_SEQUENCE); +//printf(" %d,", *sequenceNumberAt); } +//printf("\n"); + _octreeSceneStatsLock.unlock(); - // make sure we still have an active socket???? - nodeList->writeUnverifiedDatagram(packet, dataAt-packet, node); + nodeList->writeUnverifiedDatagram(packet, dataAt - packet, node); } } } diff --git a/libraries/networking/src/PacketHeaders.cpp b/libraries/networking/src/PacketHeaders.cpp index 7278f1fbcb..e2bc46b3be 100644 --- a/libraries/networking/src/PacketHeaders.cpp +++ b/libraries/networking/src/PacketHeaders.cpp @@ -108,7 +108,7 @@ int populatePacketHeader(char* packet, PacketType type, const QUuid& connectionU position += NUM_BYTES_RFC4122_UUID; if (!NON_VERIFIED_PACKETS.contains(type)) { - // pack 16 bytes of zeros where the md5 hash will be placed one data is packed + // pack 16 bytes of zeros where the md5 hash will be placed once data is packed memset(position, 0, NUM_BYTES_MD5_HASH); position += NUM_BYTES_MD5_HASH; } diff --git a/libraries/octree/src/OctreeSceneStats.h b/libraries/octree/src/OctreeSceneStats.h index ac9b1606c1..ca9bf7c74b 100644 --- a/libraries/octree/src/OctreeSceneStats.h +++ b/libraries/octree/src/OctreeSceneStats.h @@ -275,8 +275,8 @@ private: quint32 _incomingLate; /// out of order later than expected quint32 _incomingReallyLate; /// out of order and later than MAX_MISSING_SEQUENCE_OLD_AGE late quint32 _incomingPossibleDuplicate; /// out of order possibly a duplicate - QSet _missingSequenceNumbers; -QSet _sequenceNumbersToNack; + QSet _missingSequenceNumbers; +QSet _sequenceNumbersToNack; SimpleMovingAverage _incomingFlightTimeAverage; // features related items From aa694d69678d94c71d3961de068e5bf0d1a4c562 Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 12:35:26 -0700 Subject: [PATCH 36/42] removed debug code --- .../src/octree/OctreeQueryNode.cpp | 20 +++++++++ .../src/octree/OctreeQueryNode.h | 11 ++--- .../src/octree/OctreeSendThread.cpp | 22 +++------- .../src/octree/OctreeSendThread.h | 2 +- assignment-client/src/octree/OctreeServer.cpp | 36 ++++------------ .../src/octree/SentPacketHistory.cpp | 5 ++- .../src/octree/SentPacketHistory.h | 1 - interface/src/Application.cpp | 42 ++++--------------- interface/src/Application.h | 4 +- libraries/networking/src/LimitedNodeList.cpp | 17 -------- libraries/networking/src/LimitedNodeList.h | 3 -- libraries/networking/src/PacketHeaders.h | 2 +- libraries/octree/src/OctreeSceneStats.cpp | 12 +++--- libraries/octree/src/OctreeSceneStats.h | 9 ++-- 14 files changed, 64 insertions(+), 122 deletions(-) diff --git a/assignment-client/src/octree/OctreeQueryNode.cpp b/assignment-client/src/octree/OctreeQueryNode.cpp index 5cfe5501e1..f8b5e34472 100644 --- a/assignment-client/src/octree/OctreeQueryNode.cpp +++ b/assignment-client/src/octree/OctreeQueryNode.cpp @@ -388,3 +388,23 @@ const QByteArray* OctreeQueryNode::getNextNackedPacket() { } return NULL; } + +void OctreeQueryNode::parseNackPacket(QByteArray& packet) { + + int numBytesPacketHeader = numBytesForPacketHeader(packet); + const unsigned char* dataAt = reinterpret_cast(packet.data()) + numBytesPacketHeader; + + uint16_t numSequenceNumbers = (*(uint16_t*)dataAt); + dataAt += sizeof(uint16_t); + + printf("\t received nack packet containing %d seq nums\n", numSequenceNumbers); + + // read sequence numbers + for (int i = 0; i < numSequenceNumbers; i++) { + OCTREE_PACKET_SEQUENCE sequenceNumber = (*(OCTREE_PACKET_SEQUENCE*)dataAt); + _nackedSequenceNumbers.enqueue(sequenceNumber); + dataAt += sizeof(OCTREE_PACKET_SEQUENCE); + + printf("\t seq = %d\n", sequenceNumber); + } +} diff --git a/assignment-client/src/octree/OctreeQueryNode.h b/assignment-client/src/octree/OctreeQueryNode.h index b79367503c..d955d3fdf7 100644 --- a/assignment-client/src/octree/OctreeQueryNode.h +++ b/assignment-client/src/octree/OctreeQueryNode.h @@ -24,8 +24,7 @@ #include #include // for SharedAssignmentPointer #include "SentPacketHistory.h" - -#include // i added dis +#include class OctreeSendThread; @@ -109,9 +108,7 @@ public: OCTREE_PACKET_SEQUENCE getSequenceNumber() const { return _sequenceNumber; } - void addNackedSequenceNumber(OCTREE_PACKET_SEQUENCE sequenceNumber) { - _nackedSequenceNumbers.append(sequenceNumber); - } + void parseNackPacket(QByteArray& packet); bool hasNextNackedPacket() const; const QByteArray* getNextNackedPacket(); @@ -158,8 +155,8 @@ private: PacketType _myPacketType; bool _isShuttingDown; -SentPacketHistory _sentPacketHistory; -QQueue _nackedSequenceNumbers; + SentPacketHistory _sentPacketHistory; + QQueue _nackedSequenceNumbers; }; #endif // hifi_OctreeQueryNode_h diff --git a/assignment-client/src/octree/OctreeSendThread.cpp b/assignment-client/src/octree/OctreeSendThread.cpp index 6f39cd28dc..30e3011ae8 100644 --- a/assignment-client/src/octree/OctreeSendThread.cpp +++ b/assignment-client/src/octree/OctreeSendThread.cpp @@ -85,7 +85,7 @@ bool OctreeSendThread::process() { if (nodeData && !nodeData->isShuttingDown()) { bool viewFrustumChanged = nodeData->updateCurrentViewFrustum(); packetDistributor(nodeData, viewFrustumChanged); -resendNackedPackets(nodeData); + resendNackedPackets(nodeData); } } } @@ -181,7 +181,7 @@ int OctreeSendThread::handlePacketSend(OctreeQueryNode* nodeData, int& trueBytes // actually send it OctreeServer::didCallWriteDatagram(this); -NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*) statsMessage, statsMessageLength, _node); + NodeList::getInstance()->writeDatagram((char*) statsMessage, statsMessageLength, _node); packetSent = true; } else { // not enough room in the packet, send two packets @@ -215,7 +215,7 @@ NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*) s packetsSent++; OctreeServer::didCallWriteDatagram(this); -NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*)nodeData->getPacket(), nodeData->getPacketLength(), _node); + NodeList::getInstance()->writeDatagram((char*)nodeData->getPacket(), nodeData->getPacketLength(), _node); packetSent = true; thisWastedBytes = MAX_PACKET_SIZE - nodeData->getPacketLength(); @@ -244,7 +244,7 @@ NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*)no if (nodeData->isPacketWaiting() && !nodeData->isShuttingDown()) { // just send the voxel packet OctreeServer::didCallWriteDatagram(this); -NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*)nodeData->getPacket(), nodeData->getPacketLength(), _node); + NodeList::getInstance()->writeDatagram((char*)nodeData->getPacket(), nodeData->getPacketLength(), _node); packetSent = true; int thisWastedBytes = MAX_PACKET_SIZE - nodeData->getPacketLength(); @@ -281,10 +281,6 @@ NodeList::getInstance()->writeDatagram2(nodeData->getSequenceNumber(), (char*)no return packetsSent; } - - - - int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { const int MAX_PACKETS_RESEND = 10; @@ -299,20 +295,12 @@ int OctreeSendThread::resendNackedPackets(OctreeQueryNode* nodeData) { _totalBytes += packet->size(); _totalPackets++; - _totalWastedBytes += MAX_PACKET_SIZE - packet->size(); // ??? + _totalWastedBytes += MAX_PACKET_SIZE - packet->size(); } } - -if (packetsSent > 0) -printf("\t\t re-sent %d packets!\n", packetsSent); return packetsSent; } - - - - - /// Version of voxel distributor that sends the deepest LOD level at once int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrustumChanged) { diff --git a/assignment-client/src/octree/OctreeSendThread.h b/assignment-client/src/octree/OctreeSendThread.h index cc0cdac3ad..e7599ebcd2 100644 --- a/assignment-client/src/octree/OctreeSendThread.h +++ b/assignment-client/src/octree/OctreeSendThread.h @@ -56,7 +56,7 @@ private: int _nodeMissingCount; bool _isShuttingDown; -int resendNackedPackets(OctreeQueryNode* nodeData); + int resendNackedPackets(OctreeQueryNode* nodeData); }; diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp index 8cf1649cdb..9d3402b895 100644 --- a/assignment-client/src/octree/OctreeServer.cpp +++ b/assignment-client/src/octree/OctreeServer.cpp @@ -849,33 +849,15 @@ void OctreeServer::readPendingDatagrams() { } } else if (packetType == PacketTypeOctreeDataNack) { - -// parse packet for sequence numbers that need to be resent - -if (matchingNode) { - - OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); - - int numBytesPacketHeader = numBytesForPacketHeader(receivedPacket); - const unsigned char* dataAt = reinterpret_cast(receivedPacket.data()) + numBytesPacketHeader; - - uint16_t numSequenceNumbers = (*(uint16_t*)dataAt); - dataAt += sizeof(uint16_t); - -printf("\t received nack packet containing %d seq nums\n", numSequenceNumbers); - - // read sequence numbers - for (int i = 0; i < numSequenceNumbers; i++) { - OCTREE_PACKET_SEQUENCE sequenceNumber = (*(OCTREE_PACKET_SEQUENCE*)dataAt); - nodeData->addNackedSequenceNumber(sequenceNumber); - dataAt += sizeof(OCTREE_PACKET_SEQUENCE); - -printf("\t seq = %d\n", sequenceNumber); - } -} - - - + // If we got a nack packet, then we're talking to an agent, and we + // need to make sure we have it in our nodeList. + if (matchingNode) { + nodeList->updateNodeWithDataFromPacket(matchingNode, receivedPacket); + OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); + if (nodeData) { + nodeData->parseNackPacket(receivedPacket); + } + } } else if (packetType == PacketTypeJurisdictionRequest) { _jurisdictionSender->queueReceivedPacket(matchingNode, receivedPacket); } else if (_octreeInboundPacketProcessor && getOctree()->handlesEditPacketType(packetType)) { diff --git a/assignment-client/src/octree/SentPacketHistory.cpp b/assignment-client/src/octree/SentPacketHistory.cpp index 0de163a23d..751e46e786 100644 --- a/assignment-client/src/octree/SentPacketHistory.cpp +++ b/assignment-client/src/octree/SentPacketHistory.cpp @@ -21,7 +21,8 @@ SentPacketHistory::SentPacketHistory(int size) void SentPacketHistory::packetSent(OCTREE_PACKET_SEQUENCE sequenceNumber, const QByteArray& packet) { _newestSequenceNumber = sequenceNumber; - // increment _newestPacketAt cyclically, insert new packet there + // increment _newestPacketAt cyclically, insert new packet there. + // this will overwrite the oldest packet in the buffer _newestPacketAt = (_newestPacketAt == _sentPackets.size() - 1) ? 0 : _newestPacketAt + 1; _sentPackets[_newestPacketAt] = packet; @@ -42,4 +43,4 @@ const QByteArray* SentPacketHistory::getPacket(OCTREE_PACKET_SEQUENCE sequenceNu if (packetAt < 0) { packetAt += _sentPackets.size(); } return &_sentPackets.at(packetAt); -} \ No newline at end of file +} diff --git a/assignment-client/src/octree/SentPacketHistory.h b/assignment-client/src/octree/SentPacketHistory.h index cbc50bc73c..4231400ac1 100644 --- a/assignment-client/src/octree/SentPacketHistory.h +++ b/assignment-client/src/octree/SentPacketHistory.h @@ -25,7 +25,6 @@ public: const QByteArray* getPacket(OCTREE_PACKET_SEQUENCE sequenceNumber) const; private: - QVector _sentPackets; // circular buffer int _newestPacketAt; int _numExistingPackets; diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 3ebfe728de..18a8d3ba12 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2095,33 +2095,17 @@ void Application::updateMyAvatar(float deltaTime) { } } -// sent a nack packet containing missing sequence numbers of received packets -{ - quint64 now = usecTimestampNow(); - quint64 sinceLastNack = now - _lastNackTime; - const quint64 TOO_LONG_SINCE_LAST_NACK = 250 * MSECS_PER_SECOND; - if (sinceLastNack > TOO_LONG_SINCE_LAST_NACK) { - _lastNackTime = now; - sendNack(); - } -} -} - -/*/ Attempt to identify the sender from it's address. - if (sendingNode) { - QUuid nodeUUID = sendingNode->getUUID(); - - // now that we know the node ID, let's add these stats to the stats for that node... - _octreeSceneStatsLock.lockForWrite(); - if (_octreeServerSceneStats.find(nodeUUID) != _octreeServerSceneStats.end()) { - OctreeSceneStats& stats = _octreeServerSceneStats[nodeUUID]; - stats.trackIncomingOctreePacket(packet, wasStatsPacket, sendingNode->getClockSkewUsec()); + // sent a nack packet containing missing sequence numbers of received packets + { + quint64 now = usecTimestampNow(); + quint64 sinceLastNack = now - _lastNackTime; + const quint64 TOO_LONG_SINCE_LAST_NACK = 250 * MSECS_PER_SECOND; + if (sinceLastNack > TOO_LONG_SINCE_LAST_NACK) { + _lastNackTime = now; + sendNack(); } - _octreeSceneStatsLock.unlock(); } - */ - - +} void Application::sendNack() { @@ -2139,7 +2123,6 @@ void Application::sendNack() { QUuid nodeUUID = node->getUUID(); - _octreeSceneStatsLock.lockForWrite(); // retreive octree scene stats of this node @@ -2172,15 +2155,11 @@ void Application::sendNack() { dataAt += sizeof(uint16_t); // pack sequence numbers -//printf("\n\t sending nack...\n"); -//printf("\t\t packed %d seq #s:", numSequenceNumbers); for (int i = 0; i < numSequenceNumbers; i++) { OCTREE_PACKET_SEQUENCE* sequenceNumberAt = (OCTREE_PACKET_SEQUENCE*)dataAt; *sequenceNumberAt = stats.getNextSequenceNumberToNack(); dataAt += sizeof(OCTREE_PACKET_SEQUENCE); -//printf(" %d,", *sequenceNumberAt); } -//printf("\n"); _octreeSceneStatsLock.unlock(); @@ -2189,9 +2168,6 @@ void Application::sendNack() { } } - - - void Application::queryOctree(NodeType_t serverType, PacketType packetType, NodeToJurisdictionMap& jurisdictions) { // if voxels are disabled, then don't send this at all... diff --git a/interface/src/Application.h b/interface/src/Application.h index 670ec35238..170be43493 100644 --- a/interface/src/Application.h +++ b/interface/src/Application.h @@ -413,8 +413,6 @@ private: void sendNack(); - - MainWindow* _window; GLCanvas* _glWidget; // our GLCanvas has a couple extra features @@ -585,7 +583,7 @@ private: QSystemTrayIcon* _trayIcon; -quint64 _lastNackTime; + quint64 _lastNackTime; }; #endif // hifi_Application_h diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp index 15cebc26ac..c0d7941edf 100644 --- a/libraries/networking/src/LimitedNodeList.cpp +++ b/libraries/networking/src/LimitedNodeList.cpp @@ -271,23 +271,6 @@ qint64 LimitedNodeList::writeDatagram(const char* data, qint64 size, const Share return writeDatagram(QByteArray(data, size), destinationNode, overridenSockAddr); } -qint64 LimitedNodeList::writeDatagram2(int seq, const char* data, qint64 size, const SharedNodePointer& destinationNode, - const HifiSockAddr& overridenSockAddr) { - - qint64 ret = -1; - - if (randFloat() < 0.8f) { - ret = writeDatagram(QByteArray(data, size), destinationNode, overridenSockAddr); - } - else { - printf("dropped packet seq = %d --------------------------\n", seq); - } - - - return ret; -} - - qint64 LimitedNodeList::writeUnverifiedDatagram(const char* data, qint64 size, const SharedNodePointer& destinationNode, const HifiSockAddr& overridenSockAddr) { return writeUnverifiedDatagram(QByteArray(data, size), destinationNode, overridenSockAddr); diff --git a/libraries/networking/src/LimitedNodeList.h b/libraries/networking/src/LimitedNodeList.h index b3481885c8..a4bc8022bf 100644 --- a/libraries/networking/src/LimitedNodeList.h +++ b/libraries/networking/src/LimitedNodeList.h @@ -72,9 +72,6 @@ public: qint64 writeDatagram(const char* data, qint64 size, const SharedNodePointer& destinationNode, const HifiSockAddr& overridenSockAddr = HifiSockAddr()); -qint64 writeDatagram2(int seq, const char* data, qint64 size, const SharedNodePointer& destinationNode, - const HifiSockAddr& overridenSockAddr = HifiSockAddr()); - qint64 writeUnverifiedDatagram(const char* data, qint64 size, const SharedNodePointer& destinationNode, const HifiSockAddr& overridenSockAddr = HifiSockAddr()); diff --git a/libraries/networking/src/PacketHeaders.h b/libraries/networking/src/PacketHeaders.h index eac2f88870..8ac5333d10 100644 --- a/libraries/networking/src/PacketHeaders.h +++ b/libraries/networking/src/PacketHeaders.h @@ -76,7 +76,7 @@ const QSet NON_VERIFIED_PACKETS = QSet() << PacketTypeDomainList << PacketTypeDomainListRequest << PacketTypeDomainOAuthRequest << PacketTypeCreateAssignment << PacketTypeRequestAssignment << PacketTypeStunResponse << PacketTypeNodeJsonStats << PacketTypeVoxelQuery << PacketTypeParticleQuery << PacketTypeModelQuery -<< PacketTypeOctreeDataNack; + << PacketTypeOctreeDataNack; const int NUM_BYTES_MD5_HASH = 16; const int NUM_STATIC_HEADER_BYTES = sizeof(PacketVersion) + NUM_BYTES_RFC4122_UUID; diff --git a/libraries/octree/src/OctreeSceneStats.cpp b/libraries/octree/src/OctreeSceneStats.cpp index a93b2d0374..868ef29886 100644 --- a/libraries/octree/src/OctreeSceneStats.cpp +++ b/libraries/octree/src/OctreeSceneStats.cpp @@ -46,7 +46,7 @@ OctreeSceneStats::OctreeSceneStats() : _incomingReallyLate(0), _incomingPossibleDuplicate(0), _missingSequenceNumbers(), -_sequenceNumbersToNack(), + _sequenceNumbersToNack(), _incomingFlightTimeAverage(samples), _jurisdictionRoot(NULL) { @@ -159,7 +159,7 @@ void OctreeSceneStats::copyFromOther(const OctreeSceneStats& other) { _incomingPossibleDuplicate = other._incomingPossibleDuplicate; _missingSequenceNumbers = other._missingSequenceNumbers; -_sequenceNumbersToNack = other._sequenceNumbersToNack; + _sequenceNumbersToNack = other._sequenceNumbersToNack; } @@ -928,7 +928,7 @@ void OctreeSceneStats::trackIncomingOctreePacket(const QByteArray& packet, qDebug() << "found it in _missingSequenceNumbers"; } _missingSequenceNumbers.remove(sequence); -_sequenceNumbersToNack.remove(sequence); + _sequenceNumbersToNack.remove(sequence); _incomingLikelyLost--; _incomingRecovered++; } else { @@ -958,7 +958,7 @@ _sequenceNumbersToNack.remove(sequence); _incomingLikelyLost += missing; for(unsigned int missingSequence = expected; missingSequence < sequence; missingSequence++) { _missingSequenceNumbers << missingSequence; -_sequenceNumbersToNack << missingSequence; + _sequenceNumbersToNack << missingSequence; } } } @@ -986,7 +986,7 @@ _sequenceNumbersToNack << missingSequence; qDebug() << "pruning really old missing sequence:" << missingItem; } _missingSequenceNumbers.remove(missingItem); -_sequenceNumbersToNack.remove(missingItem); + _sequenceNumbersToNack.remove(missingItem); } } } @@ -1002,4 +1002,4 @@ uint16_t OctreeSceneStats::getNextSequenceNumberToNack() { uint16_t sequenceNumber = *it; _sequenceNumbersToNack.remove(sequenceNumber); return sequenceNumber; -} \ No newline at end of file +} diff --git a/libraries/octree/src/OctreeSceneStats.h b/libraries/octree/src/OctreeSceneStats.h index ca9bf7c74b..182bd6c86c 100644 --- a/libraries/octree/src/OctreeSceneStats.h +++ b/libraries/octree/src/OctreeSceneStats.h @@ -16,6 +16,7 @@ #include #include #include "JurisdictionMap.h" +#include "OctreePacketData.h" #define GREENISH 0x40ff40d0 #define YELLOWISH 0xffef40c0 @@ -172,8 +173,8 @@ public: quint32 getIncomingPossibleDuplicate() const { return _incomingPossibleDuplicate; } float getIncomingFlightTimeAverage() { return _incomingFlightTimeAverage.getAverage(); } -int getNumSequenceNumbersToNack() const; -uint16_t getNextSequenceNumberToNack(); + int getNumSequenceNumbersToNack() const; + OCTREE_PACKET_SEQUENCE getNextSequenceNumberToNack(); private: @@ -275,8 +276,8 @@ private: quint32 _incomingLate; /// out of order later than expected quint32 _incomingReallyLate; /// out of order and later than MAX_MISSING_SEQUENCE_OLD_AGE late quint32 _incomingPossibleDuplicate; /// out of order possibly a duplicate - QSet _missingSequenceNumbers; -QSet _sequenceNumbersToNack; + QSet _missingSequenceNumbers; + QSet _sequenceNumbersToNack; SimpleMovingAverage _incomingFlightTimeAverage; // features related items From 968ea3563caebf1ca080c62542ce32927135e98d Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 12:37:42 -0700 Subject: [PATCH 37/42] removed an extra space --- assignment-client/src/octree/OctreeServer.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp index 9d3402b895..f51d65fcef 100644 --- a/assignment-client/src/octree/OctreeServer.cpp +++ b/assignment-client/src/octree/OctreeServer.cpp @@ -834,11 +834,11 @@ void OctreeServer::readPendingDatagrams() { if (packetType == getMyQueryMessageType()) { // If we got a query packet, then we're talking to an agent, and we // need to make sure we have it in our nodeList. - if (matchingNode) { + if (matchingNode) { nodeList->updateNodeWithDataFromPacket(matchingNode, receivedPacket); OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData(); if (nodeData && !nodeData->isOctreeSendThreadInitalized()) { - + // NOTE: this is an important aspect of the proper ref counting. The send threads/node data need to // know that the OctreeServer/Assignment will not get deleted on it while it's still active. The // solution is to get the shared pointer for the current assignment. We need to make sure this is the From 0fce7e721a5135b742b71bd418519743ca799cc5 Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 12:40:01 -0700 Subject: [PATCH 38/42] removed more spaces --- assignment-client/src/octree/SentPacketHistory.cpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/assignment-client/src/octree/SentPacketHistory.cpp b/assignment-client/src/octree/SentPacketHistory.cpp index 751e46e786..85e164bc41 100644 --- a/assignment-client/src/octree/SentPacketHistory.cpp +++ b/assignment-client/src/octree/SentPacketHistory.cpp @@ -20,12 +20,11 @@ SentPacketHistory::SentPacketHistory(int size) void SentPacketHistory::packetSent(OCTREE_PACKET_SEQUENCE sequenceNumber, const QByteArray& packet) { _newestSequenceNumber = sequenceNumber; - + // increment _newestPacketAt cyclically, insert new packet there. // this will overwrite the oldest packet in the buffer _newestPacketAt = (_newestPacketAt == _sentPackets.size() - 1) ? 0 : _newestPacketAt + 1; _sentPackets[_newestPacketAt] = packet; - if (_numExistingPackets < _sentPackets.size()) { _numExistingPackets++; } @@ -33,14 +32,11 @@ void SentPacketHistory::packetSent(OCTREE_PACKET_SEQUENCE sequenceNumber, const const QByteArray* SentPacketHistory::getPacket(OCTREE_PACKET_SEQUENCE sequenceNumber) const { - OCTREE_PACKET_SEQUENCE seqDiff = _newestSequenceNumber - sequenceNumber; if (!(seqDiff >= 0 && seqDiff < _numExistingPackets)) { return NULL; } - int packetAt = _newestPacketAt - seqDiff; if (packetAt < 0) { packetAt += _sentPackets.size(); } - return &_sentPackets.at(packetAt); } From 412d3e19fecab6dec650ae7842beddf5b282fc50 Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 12:56:00 -0700 Subject: [PATCH 39/42] removed debug prints in parseNackPacket() --- assignment-client/src/octree/OctreeQueryNode.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/assignment-client/src/octree/OctreeQueryNode.cpp b/assignment-client/src/octree/OctreeQueryNode.cpp index f8b5e34472..372f15a76b 100644 --- a/assignment-client/src/octree/OctreeQueryNode.cpp +++ b/assignment-client/src/octree/OctreeQueryNode.cpp @@ -394,17 +394,14 @@ void OctreeQueryNode::parseNackPacket(QByteArray& packet) { int numBytesPacketHeader = numBytesForPacketHeader(packet); const unsigned char* dataAt = reinterpret_cast(packet.data()) + numBytesPacketHeader; + // read number of sequence numbers uint16_t numSequenceNumbers = (*(uint16_t*)dataAt); dataAt += sizeof(uint16_t); - printf("\t received nack packet containing %d seq nums\n", numSequenceNumbers); - // read sequence numbers for (int i = 0; i < numSequenceNumbers; i++) { OCTREE_PACKET_SEQUENCE sequenceNumber = (*(OCTREE_PACKET_SEQUENCE*)dataAt); _nackedSequenceNumbers.enqueue(sequenceNumber); dataAt += sizeof(OCTREE_PACKET_SEQUENCE); - - printf("\t seq = %d\n", sequenceNumber); } } From ff2a5342ee8f4208b465fabc2c925954b225e90b Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 12:57:50 -0700 Subject: [PATCH 40/42] removed another extra space --- assignment-client/src/octree/OctreeServer.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp index f51d65fcef..cb60f0816e 100644 --- a/assignment-client/src/octree/OctreeServer.cpp +++ b/assignment-client/src/octree/OctreeServer.cpp @@ -847,7 +847,6 @@ void OctreeServer::readPendingDatagrams() { nodeData->initializeOctreeSendThread(sharedAssignment, matchingNode); } } - } else if (packetType == PacketTypeOctreeDataNack) { // If we got a nack packet, then we're talking to an agent, and we // need to make sure we have it in our nodeList. From e45f2fed4b83b9014c5cfeb20c810fe04dde0239 Mon Sep 17 00:00:00 2001 From: wangyix Date: Mon, 9 Jun 2014 13:42:45 -0700 Subject: [PATCH 41/42] changed writelock to readlock plus a coding standard fix --- assignment-client/src/octree/SentPacketHistory.cpp | 4 +++- interface/src/Application.cpp | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/assignment-client/src/octree/SentPacketHistory.cpp b/assignment-client/src/octree/SentPacketHistory.cpp index 85e164bc41..0ea7fd8b69 100644 --- a/assignment-client/src/octree/SentPacketHistory.cpp +++ b/assignment-client/src/octree/SentPacketHistory.cpp @@ -37,6 +37,8 @@ const QByteArray* SentPacketHistory::getPacket(OCTREE_PACKET_SEQUENCE sequenceNu return NULL; } int packetAt = _newestPacketAt - seqDiff; - if (packetAt < 0) { packetAt += _sentPackets.size(); } + if (packetAt < 0) { + packetAt += _sentPackets.size(); + } return &_sentPackets.at(packetAt); } diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 18a8d3ba12..574df09ee2 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -2123,7 +2123,7 @@ void Application::sendNack() { QUuid nodeUUID = node->getUUID(); - _octreeSceneStatsLock.lockForWrite(); + _octreeSceneStatsLock.lockForRead(); // retreive octree scene stats of this node if (_octreeServerSceneStats.find(nodeUUID) == _octreeServerSceneStats.end()) { From ee71d34f021ba90327ac96e1b9094c858679604f Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Mon, 9 Jun 2014 14:03:47 -0700 Subject: [PATCH 42/42] add a crash guard around negative silent samples --- libraries/audio/src/PositionalAudioRingBuffer.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/libraries/audio/src/PositionalAudioRingBuffer.cpp b/libraries/audio/src/PositionalAudioRingBuffer.cpp index 94a88897e3..bb47c6de9e 100644 --- a/libraries/audio/src/PositionalAudioRingBuffer.cpp +++ b/libraries/audio/src/PositionalAudioRingBuffer.cpp @@ -55,7 +55,9 @@ int PositionalAudioRingBuffer::parseData(const QByteArray& packet) { readBytes += sizeof(int16_t); - addSilentFrame(numSilentSamples); + if (numSilentSamples > 0) { + addSilentFrame(numSilentSamples); + } } else { // there is audio data to read readBytes += writeData(packet.data() + readBytes, packet.size() - readBytes);