mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-07-22 18:03:19 +02:00
Merge branch 'master' of https://github.com/worklist/hifi into pointy
This commit is contained in:
Andrzej Kapolka
commit
b02c5f103d
32 changed files with 1888 additions and 391 deletions
|
|
@ -8,6 +8,7 @@
|
|||
|
||||
#include <cstring>
|
||||
|
||||
#include <Node.h>
|
||||
#include <PacketHeaders.h>
|
||||
|
||||
#include "PositionalAudioRingBuffer.h"
|
||||
|
|
@ -16,19 +17,75 @@ PositionalAudioRingBuffer::PositionalAudioRingBuffer() :
|
|||
AudioRingBuffer(false),
|
||||
_position(0.0f, 0.0f, 0.0f),
|
||||
_orientation(0.0f, 0.0f, 0.0f, 0.0f),
|
||||
_willBeAddedToMix(false)
|
||||
_willBeAddedToMix(false),
|
||||
_listenMode(AudioRingBuffer::NORMAL),
|
||||
_listenRadius(0.0f)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
PositionalAudioRingBuffer::~PositionalAudioRingBuffer() {
|
||||
}
|
||||
|
||||
bool PositionalAudioRingBuffer::isListeningToNode(Node& other) const {
|
||||
switch (_listenMode) {
|
||||
default:
|
||||
case AudioRingBuffer::NORMAL:
|
||||
return true;
|
||||
break;
|
||||
|
||||
case AudioRingBuffer::OMNI_DIRECTIONAL_POINT: {
|
||||
PositionalAudioRingBuffer* otherNodeBuffer = (PositionalAudioRingBuffer*) other.getLinkedData();
|
||||
float distance = glm::distance(_position, otherNodeBuffer->_position);
|
||||
return distance <= _listenRadius;
|
||||
break;
|
||||
}
|
||||
case AudioRingBuffer::SELECTED_SOURCES:
|
||||
for (int i = 0; i < _listenSources.size(); i++) {
|
||||
if (other.getNodeID() == _listenSources[i]) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int PositionalAudioRingBuffer::parseData(unsigned char* sourceBuffer, int numBytes) {
|
||||
unsigned char* currentBuffer = sourceBuffer + numBytesForPacketHeader(sourceBuffer);
|
||||
currentBuffer += sizeof(uint16_t); // the source ID
|
||||
currentBuffer += parseListenModeData(currentBuffer, numBytes - (currentBuffer - sourceBuffer));
|
||||
currentBuffer += parsePositionalData(currentBuffer, numBytes - (currentBuffer - sourceBuffer));
|
||||
currentBuffer += parseAudioSamples(currentBuffer, numBytes - (currentBuffer - sourceBuffer));
|
||||
|
||||
return currentBuffer - sourceBuffer;
|
||||
}
|
||||
|
||||
int PositionalAudioRingBuffer::parseListenModeData(unsigned char* sourceBuffer, int numBytes) {
|
||||
unsigned char* currentBuffer = sourceBuffer;
|
||||
|
||||
memcpy(&_listenMode, currentBuffer, sizeof(_listenMode));
|
||||
currentBuffer += sizeof(_listenMode);
|
||||
|
||||
if (_listenMode == AudioRingBuffer::OMNI_DIRECTIONAL_POINT) {
|
||||
memcpy(&_listenRadius, currentBuffer, sizeof(_listenRadius));
|
||||
currentBuffer += sizeof(_listenRadius);
|
||||
} else if (_listenMode == AudioRingBuffer::SELECTED_SOURCES) {
|
||||
int listenSourcesCount;
|
||||
memcpy(&listenSourcesCount, currentBuffer, sizeof(listenSourcesCount));
|
||||
currentBuffer += sizeof(listenSourcesCount);
|
||||
for (int i = 0; i < listenSourcesCount; i++) {
|
||||
int sourceID;
|
||||
memcpy(&sourceID, currentBuffer, sizeof(sourceID));
|
||||
currentBuffer += sizeof(sourceID);
|
||||
_listenSources.push_back(sourceID);
|
||||
}
|
||||
}
|
||||
|
||||
return currentBuffer - sourceBuffer;
|
||||
}
|
||||
|
||||
int PositionalAudioRingBuffer::parsePositionalData(unsigned char* sourceBuffer, int numBytes) {
|
||||
unsigned char* currentBuffer = sourceBuffer;
|
||||
|
||||
|
|
@ -63,6 +120,6 @@ bool PositionalAudioRingBuffer::shouldBeAddedToMix(int numJitterBufferSamples) {
|
|||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
printf("packet mismatch...\n");
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@
|
|||
#ifndef __hifi__PositionalAudioRingBuffer__
|
||||
#define __hifi__PositionalAudioRingBuffer__
|
||||
|
||||
#include <vector>
|
||||
#include <glm/gtx/quaternion.hpp>
|
||||
|
||||
#include <AudioRingBuffer.h>
|
||||
|
|
@ -16,9 +17,11 @@
|
|||
class PositionalAudioRingBuffer : public AudioRingBuffer {
|
||||
public:
|
||||
PositionalAudioRingBuffer();
|
||||
~PositionalAudioRingBuffer();
|
||||
|
||||
int parseData(unsigned char* sourceBuffer, int numBytes);
|
||||
int parsePositionalData(unsigned char* sourceBuffer, int numBytes);
|
||||
int parseListenModeData(unsigned char* sourceBuffer, int numBytes);
|
||||
|
||||
bool shouldBeAddedToMix(int numJitterBufferSamples);
|
||||
|
||||
|
|
@ -28,6 +31,9 @@ public:
|
|||
const glm::vec3& getPosition() const { return _position; }
|
||||
const glm::quat& getOrientation() const { return _orientation; }
|
||||
|
||||
bool isListeningToNode(Node& other) const;
|
||||
ListenMode getListeningMode() const { return _listenMode; }
|
||||
|
||||
protected:
|
||||
// disallow copying of PositionalAudioRingBuffer objects
|
||||
PositionalAudioRingBuffer(const PositionalAudioRingBuffer&);
|
||||
|
|
@ -36,6 +42,10 @@ protected:
|
|||
glm::vec3 _position;
|
||||
glm::quat _orientation;
|
||||
bool _willBeAddedToMix;
|
||||
|
||||
ListenMode _listenMode;
|
||||
float _listenRadius;
|
||||
std::vector<int> _listenSources;
|
||||
};
|
||||
|
||||
#endif /* defined(__hifi__PositionalAudioRingBuffer__) */
|
||||
|
|
|
|||
|
|
@ -141,7 +141,6 @@ int main(int argc, const char* argv[]) {
|
|||
|
||||
for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
|
||||
PositionalAudioRingBuffer* positionalRingBuffer = (PositionalAudioRingBuffer*) node->getLinkedData();
|
||||
|
||||
if (positionalRingBuffer && positionalRingBuffer->shouldBeAddedToMix(JITTER_BUFFER_SAMPLES)) {
|
||||
// this is a ring buffer that is ready to go
|
||||
// set its flag so we know to push its buffer when all is said and done
|
||||
|
|
@ -159,12 +158,13 @@ int main(int argc, const char* argv[]) {
|
|||
// zero out the client mix for this node
|
||||
memset(clientSamples, 0, sizeof(clientSamples));
|
||||
|
||||
// loop through all other nodes that have sufficient audio to mix
|
||||
for (NodeList::iterator otherNode = nodeList->begin(); otherNode != nodeList->end(); otherNode++) {
|
||||
if (((PositionalAudioRingBuffer*) otherNode->getLinkedData())->willBeAddedToMix()
|
||||
&& (otherNode != node || (otherNode == node && nodeRingBuffer->shouldLoopbackForNode()))) {
|
||||
|
||||
PositionalAudioRingBuffer* otherNodeBuffer = (PositionalAudioRingBuffer*) otherNode->getLinkedData();
|
||||
|
||||
// based on our listen mode we will do this mixing...
|
||||
if (nodeRingBuffer->isListeningToNode(*otherNode)) {
|
||||
float bearingRelativeAngleToSource = 0.0f;
|
||||
float attenuationCoefficient = 1.0f;
|
||||
int numSamplesDelay = 0;
|
||||
|
|
@ -172,7 +172,8 @@ int main(int argc, const char* argv[]) {
|
|||
|
||||
stk::TwoPole* otherNodeTwoPole = NULL;
|
||||
|
||||
if (otherNode != node) {
|
||||
// only do axis/distance attenuation when in normal mode
|
||||
if (otherNode != node && nodeRingBuffer->getListeningMode() == AudioRingBuffer::NORMAL) {
|
||||
|
||||
glm::vec3 listenerPosition = nodeRingBuffer->getPosition();
|
||||
glm::vec3 relativePosition = otherNodeBuffer->getPosition() - nodeRingBuffer->getPosition();
|
||||
|
|
@ -325,6 +326,7 @@ int main(int argc, const char* argv[]) {
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(clientPacket + numBytesPacketHeader, clientSamples, sizeof(clientSamples));
|
||||
nodeList->getNodeSocket()->send(node->getPublicSocket(), clientPacket, sizeof(clientPacket));
|
||||
|
|
@ -340,7 +342,6 @@ int main(int argc, const char* argv[]) {
|
|||
if (nodeBuffer->getNextOutput() >= nodeBuffer->getBuffer() + RING_BUFFER_LENGTH_SAMPLES) {
|
||||
nodeBuffer->setNextOutput(nodeBuffer->getBuffer());
|
||||
}
|
||||
|
||||
nodeBuffer->setWillBeAddedToMix(false);
|
||||
}
|
||||
}
|
||||
|
|
@ -350,14 +351,15 @@ int main(int argc, const char* argv[]) {
|
|||
packetVersionMatch(packetData)) {
|
||||
if (packetData[0] == PACKET_TYPE_MICROPHONE_AUDIO_NO_ECHO ||
|
||||
packetData[0] == PACKET_TYPE_MICROPHONE_AUDIO_WITH_ECHO) {
|
||||
|
||||
unsigned char* currentBuffer = packetData + numBytesForPacketHeader(packetData);
|
||||
uint16_t sourceID;
|
||||
memcpy(&sourceID, currentBuffer, sizeof(sourceID));
|
||||
|
||||
Node* avatarNode = nodeList->addOrUpdateNode(nodeAddress,
|
||||
nodeAddress,
|
||||
NODE_TYPE_AGENT,
|
||||
nodeList->getLastNodeID());
|
||||
|
||||
if (avatarNode->getNodeID() == nodeList->getLastNodeID()) {
|
||||
nodeList->increaseNodeID();
|
||||
}
|
||||
sourceID);
|
||||
|
||||
nodeList->updateNodeWithData(nodeAddress, packetData, receivedBytes);
|
||||
|
||||
|
|
|
|||
|
|
@ -51,6 +51,53 @@ void attachAvatarDataToNode(Node* newNode) {
|
|||
}
|
||||
}
|
||||
|
||||
// NOTE: some additional optimizations to consider.
|
||||
// 1) use the view frustum to cull those avatars that are out of view. Since avatar data doesn't need to be present
|
||||
// if the avatar is not in view or in the keyhole.
|
||||
// 2) after culling for view frustum, sort order the avatars by distance, send the closest ones first.
|
||||
// 3) if we need to rate limit the amount of data we send, we can use a distance weighted "semi-random" function to
|
||||
// determine which avatars are included in the packet stream
|
||||
// 4) we should optimize the avatar data format to be more compact (100 bytes is pretty wasteful).
|
||||
void broadcastAvatarData(NodeList* nodeList, sockaddr* nodeAddress) {
|
||||
static unsigned char broadcastPacketBuffer[MAX_PACKET_SIZE];
|
||||
static unsigned char avatarDataBuffer[MAX_PACKET_SIZE];
|
||||
unsigned char* broadcastPacket = (unsigned char*)&broadcastPacketBuffer[0];
|
||||
int numHeaderBytes = populateTypeAndVersion(broadcastPacket, PACKET_TYPE_BULK_AVATAR_DATA);
|
||||
unsigned char* currentBufferPosition = broadcastPacket + numHeaderBytes;
|
||||
int packetLength = currentBufferPosition - broadcastPacket;
|
||||
int packetsSent = 0;
|
||||
|
||||
// send back a packet with other active node data to this node
|
||||
for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
|
||||
if (node->getLinkedData() && !socketMatch(nodeAddress, node->getActiveSocket())) {
|
||||
unsigned char* avatarDataEndpoint = addNodeToBroadcastPacket((unsigned char*)&avatarDataBuffer[0], &*node);
|
||||
int avatarDataLength = avatarDataEndpoint - (unsigned char*)&avatarDataBuffer;
|
||||
|
||||
if (avatarDataLength + packetLength <= MAX_PACKET_SIZE) {
|
||||
memcpy(currentBufferPosition, &avatarDataBuffer[0], avatarDataLength);
|
||||
packetLength += avatarDataLength;
|
||||
currentBufferPosition += avatarDataLength;
|
||||
} else {
|
||||
packetsSent++;
|
||||
//printf("packetsSent=%d packetLength=%d\n", packetsSent, packetLength);
|
||||
nodeList->getNodeSocket()->send(nodeAddress, broadcastPacket, currentBufferPosition - broadcastPacket);
|
||||
|
||||
// reset the packet
|
||||
currentBufferPosition = broadcastPacket + numHeaderBytes;
|
||||
packetLength = currentBufferPosition - broadcastPacket;
|
||||
|
||||
// copy the avatar that didn't fit into the next packet
|
||||
memcpy(currentBufferPosition, &avatarDataBuffer[0], avatarDataLength);
|
||||
packetLength += avatarDataLength;
|
||||
currentBufferPosition += avatarDataLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
packetsSent++;
|
||||
//printf("packetsSent=%d packetLength=%d\n", packetsSent, packetLength);
|
||||
nodeList->getNodeSocket()->send(nodeAddress, broadcastPacket, currentBufferPosition - broadcastPacket);
|
||||
}
|
||||
|
||||
int main(int argc, const char* argv[]) {
|
||||
|
||||
NodeList* nodeList = NodeList::createInstance(NODE_TYPE_AVATAR_MIXER, AVATAR_LISTEN_PORT);
|
||||
|
|
@ -68,13 +115,10 @@ int main(int argc, const char* argv[]) {
|
|||
nodeList->startSilentNodeRemovalThread();
|
||||
|
||||
sockaddr* nodeAddress = new sockaddr;
|
||||
unsigned char *packetData = new unsigned char[MAX_PACKET_SIZE];
|
||||
ssize_t receivedBytes = 0;
|
||||
|
||||
unsigned char *broadcastPacket = new unsigned char[MAX_PACKET_SIZE];
|
||||
int numHeaderBytes = populateTypeAndVersion(broadcastPacket, PACKET_TYPE_BULK_AVATAR_DATA);
|
||||
unsigned char* packetData = new unsigned char[MAX_PACKET_SIZE];
|
||||
|
||||
unsigned char* currentBufferPosition = NULL;
|
||||
|
||||
uint16_t nodeID = 0;
|
||||
Node* avatarNode = NULL;
|
||||
|
|
@ -104,17 +148,7 @@ int main(int argc, const char* argv[]) {
|
|||
// parse positional data from an node
|
||||
nodeList->updateNodeWithData(avatarNode, packetData, receivedBytes);
|
||||
case PACKET_TYPE_INJECT_AUDIO:
|
||||
currentBufferPosition = broadcastPacket + numHeaderBytes;
|
||||
|
||||
// send back a packet with other active node data to this node
|
||||
for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
|
||||
if (node->getLinkedData() && !socketMatch(nodeAddress, node->getActiveSocket())) {
|
||||
currentBufferPosition = addNodeToBroadcastPacket(currentBufferPosition, &*node);
|
||||
}
|
||||
}
|
||||
|
||||
nodeList->getNodeSocket()->send(nodeAddress, broadcastPacket, currentBufferPosition - broadcastPacket);
|
||||
|
||||
broadcastAvatarData(nodeList, nodeAddress);
|
||||
break;
|
||||
case PACKET_TYPE_AVATAR_VOXEL_URL:
|
||||
case PACKET_TYPE_AVATAR_FACE_VIDEO:
|
||||
|
|
|
|||
|
|
@ -40,11 +40,13 @@ bool hasInjectedAudioOnce = false;
|
|||
float sleepIntervalMin = 1.00;
|
||||
float sleepIntervalMax = 2.00;
|
||||
char *sourceAudioFile = NULL;
|
||||
const char *allowedParameters = ":sc::a::f::t::r:";
|
||||
const char *allowedParameters = ":sc::a::f::t::r:l";
|
||||
float floatArguments[4] = {0.0f, 0.0f, 0.0f, 0.0f};
|
||||
unsigned char volume = DEFAULT_INJECTOR_VOLUME;
|
||||
float triggerDistance = 0.0f;
|
||||
float radius = 0.0f;
|
||||
bool wantsLocalDomain = false;
|
||||
|
||||
|
||||
void usage(void) {
|
||||
std::cout << "High Fidelity - Interface audio injector" << std::endl;
|
||||
|
|
@ -54,6 +56,7 @@ void usage(void) {
|
|||
std::cout << " -f FILENAME Name of audio source file. Required - RAW format, 22050hz 16bit signed mono" << std::endl;
|
||||
std::cout << " -t FLOAT Trigger distance for injection. If not specified will loop constantly" << std::endl;
|
||||
std::cout << " -r FLOAT Radius for spherical source. If not specified injected audio is point source" << std::endl;
|
||||
std::cout << " -l Local domain mode." << std::endl;
|
||||
}
|
||||
|
||||
bool processParameters(int parameterCount, char* parameterData[]) {
|
||||
|
|
@ -96,6 +99,9 @@ bool processParameters(int parameterCount, char* parameterData[]) {
|
|||
::radius = atof(optarg);
|
||||
std::cout << "[DEBUG] Injector radius: " << optarg << std::endl;
|
||||
break;
|
||||
case 'l':
|
||||
::wantsLocalDomain = true;
|
||||
break;
|
||||
default:
|
||||
usage();
|
||||
return false;
|
||||
|
|
@ -111,6 +117,7 @@ void createAvatarDataForNode(Node* node) {
|
|||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
|
||||
// new seed for random audio sleep times
|
||||
srand(time(0));
|
||||
|
||||
|
|
@ -126,6 +133,11 @@ int main(int argc, char* argv[]) {
|
|||
// create an NodeList instance to handle communication with other nodes
|
||||
NodeList* nodeList = NodeList::createInstance(NODE_TYPE_AUDIO_INJECTOR, AUDIO_UDP_SEND_PORT);
|
||||
|
||||
if (::wantsLocalDomain) {
|
||||
printf("Local Domain MODE!\n");
|
||||
nodeList->setDomainIPToLocalhost();
|
||||
}
|
||||
|
||||
// start the node list thread that will kill off nodes when they stop talking
|
||||
nodeList->startSilentNodeRemovalThread();
|
||||
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ include_directories(external/fervor/)
|
|||
|
||||
# run qt moc on qt-enabled headers
|
||||
qt4_wrap_cpp(INTERFACE_SRCS src/Application.h src/Webcam.h src/avatar/AvatarVoxelSystem.h
|
||||
src/avatar/Face.h src/ui/BandwidthDialog.h)
|
||||
src/avatar/Face.h src/ui/BandwidthDialog.h src/ui/VoxelStatsDialog.h)
|
||||
|
||||
# create the executable, make it a bundle on OS X
|
||||
add_executable(${TARGET_NAME} MACOSX_BUNDLE ${INTERFACE_SRCS})
|
||||
|
|
|
|||
|
|
@ -56,6 +56,8 @@
|
|||
#include <PairingHandler.h>
|
||||
#include <PerfStat.h>
|
||||
|
||||
#include <VoxelSceneStats.h>
|
||||
|
||||
#include "Application.h"
|
||||
#include "InterfaceConfig.h"
|
||||
#include "LogDisplay.h"
|
||||
|
|
@ -174,6 +176,7 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
|
|||
_window(new QMainWindow(desktop())),
|
||||
_glWidget(new GLCanvas()),
|
||||
_bandwidthDialog(NULL),
|
||||
_voxelStatsDialog(NULL),
|
||||
_displayLevels(false),
|
||||
_frameCount(0),
|
||||
_fps(120.0f),
|
||||
|
|
@ -200,6 +203,7 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
|
|||
_mouseVoxelScale(1.0f / 1024.0f),
|
||||
_justEditedVoxel(false),
|
||||
_isLookingAtOtherAvatar(false),
|
||||
_lookatIndicatorScale(1.0f),
|
||||
_paintOn(false),
|
||||
_dominantColor(0),
|
||||
_perfStatsOn(false),
|
||||
|
|
@ -1147,6 +1151,21 @@ void Application::bandwidthDetailsClosed() {
|
|||
delete dlg;
|
||||
}
|
||||
|
||||
void Application::voxelStatsDetails() {
|
||||
if (!_voxelStatsDialog) {
|
||||
_voxelStatsDialog = new VoxelStatsDialog(_glWidget, &_voxelSceneStats);
|
||||
connect(_voxelStatsDialog, SIGNAL(closed()), SLOT(voxelStatsDetailsClosed()));
|
||||
_voxelStatsDialog->show();
|
||||
}
|
||||
_voxelStatsDialog->raise();
|
||||
}
|
||||
|
||||
void Application::voxelStatsDetailsClosed() {
|
||||
QDialog* dlg = _voxelStatsDialog;
|
||||
_voxelStatsDialog = NULL;
|
||||
delete dlg;
|
||||
}
|
||||
|
||||
void Application::editPreferences() {
|
||||
QDialog dialog(_glWidget);
|
||||
dialog.setWindowTitle("Interface Preferences");
|
||||
|
|
@ -1751,6 +1770,7 @@ void Application::initMenu() {
|
|||
(_bandwidthDisplayOn = toolsMenu->addAction("Bandwidth Display"))->setCheckable(true);
|
||||
_bandwidthDisplayOn->setChecked(true);
|
||||
toolsMenu->addAction("Bandwidth Details", this, SLOT(bandwidthDetails()));
|
||||
toolsMenu->addAction("Voxel Stats Details", this, SLOT(voxelStatsDetails()));
|
||||
|
||||
|
||||
QMenu* voxelMenu = menuBar->addMenu("Voxels");
|
||||
|
|
@ -1835,6 +1855,11 @@ void Application::initMenu() {
|
|||
(_simulateLeapHand = debugMenu->addAction("Simulate Leap Hand"))->setCheckable(true);
|
||||
(_testRaveGlove = debugMenu->addAction("Test RaveGlove"))->setCheckable(true);
|
||||
|
||||
QMenu* audioDebugMenu = debugMenu->addMenu("Audio Debugging Tools");
|
||||
audioDebugMenu->addAction("Listen Mode Normal", this, SLOT(setListenModeNormal()), Qt::CTRL | Qt::Key_1);
|
||||
audioDebugMenu->addAction("Listen Mode Point/Radius", this, SLOT(setListenModePoint()), Qt::CTRL | Qt::Key_2);
|
||||
audioDebugMenu->addAction("Listen Mode Single Source", this, SLOT(setListenModeSingleSource()), Qt::CTRL | Qt::Key_3);
|
||||
|
||||
QMenu* settingsMenu = menuBar->addMenu("Settings");
|
||||
(_settingsAutosave = settingsMenu->addAction("Autosave"))->setCheckable(true);
|
||||
_settingsAutosave->setChecked(true);
|
||||
|
|
@ -1846,6 +1871,30 @@ void Application::initMenu() {
|
|||
_networkAccessManager = new QNetworkAccessManager(this);
|
||||
}
|
||||
|
||||
void Application::setListenModeNormal() {
|
||||
_audio.setListenMode(AudioRingBuffer::NORMAL);
|
||||
}
|
||||
|
||||
void Application::setListenModePoint() {
|
||||
_audio.setListenMode(AudioRingBuffer::OMNI_DIRECTIONAL_POINT);
|
||||
_audio.setListenRadius(1.0);
|
||||
}
|
||||
|
||||
void Application::setListenModeSingleSource() {
|
||||
_audio.setListenMode(AudioRingBuffer::SELECTED_SOURCES);
|
||||
_audio.clearListenSources();
|
||||
|
||||
glm::vec3 mouseRayOrigin = _myAvatar.getMouseRayOrigin();
|
||||
glm::vec3 mouseRayDirection = _myAvatar.getMouseRayDirection();
|
||||
glm::vec3 eyePositionIgnored;
|
||||
uint16_t nodeID;
|
||||
|
||||
if (isLookingAtOtherAvatar(mouseRayOrigin, mouseRayDirection, eyePositionIgnored, nodeID)) {
|
||||
_audio.addListenSource(nodeID);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Application::updateFrustumRenderModeAction() {
|
||||
switch (_frustumDrawingMode) {
|
||||
default:
|
||||
|
|
@ -1934,7 +1983,10 @@ const float MAX_AVATAR_EDIT_VELOCITY = 1.0f;
|
|||
const float MAX_VOXEL_EDIT_DISTANCE = 20.0f;
|
||||
const float HEAD_SPHERE_RADIUS = 0.07;
|
||||
|
||||
bool Application::isLookingAtOtherAvatar(glm::vec3& mouseRayOrigin, glm::vec3& mouseRayDirection, glm::vec3& eyePosition) {
|
||||
|
||||
bool Application::isLookingAtOtherAvatar(glm::vec3& mouseRayOrigin, glm::vec3& mouseRayDirection,
|
||||
glm::vec3& eyePosition, uint16_t& nodeID) {
|
||||
|
||||
NodeList* nodeList = NodeList::getInstance();
|
||||
for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
|
||||
if (node->getLinkedData() != NULL && node->getType() == NODE_TYPE_AGENT) {
|
||||
|
|
@ -1942,7 +1994,9 @@ bool Application::isLookingAtOtherAvatar(glm::vec3& mouseRayOrigin, glm::vec3& m
|
|||
glm::vec3 headPosition = avatar->getHead().getPosition();
|
||||
if (rayIntersectsSphere(mouseRayOrigin, mouseRayDirection, headPosition, HEAD_SPHERE_RADIUS)) {
|
||||
eyePosition = avatar->getHead().getEyeLevelPosition();
|
||||
_lookatIndicatorScale = avatar->getScale();
|
||||
_lookatOtherPosition = headPosition;
|
||||
nodeID = avatar->getOwningNode()->getNodeID();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -1952,11 +2006,13 @@ bool Application::isLookingAtOtherAvatar(glm::vec3& mouseRayOrigin, glm::vec3& m
|
|||
|
||||
void Application::renderLookatIndicator(glm::vec3 pointOfInterest, Camera& whichCamera) {
|
||||
|
||||
const float DISTANCE_FROM_HEAD_SPHERE = 0.1f;
|
||||
const float DISTANCE_FROM_HEAD_SPHERE = 0.1f * _lookatIndicatorScale;
|
||||
const float INDICATOR_RADIUS = 0.1f * _lookatIndicatorScale;
|
||||
const float YELLOW[] = { 1.0f, 1.0f, 0.0f };
|
||||
const int NUM_SEGMENTS = 30;
|
||||
glm::vec3 haloOrigin(pointOfInterest.x, pointOfInterest.y + DISTANCE_FROM_HEAD_SPHERE, pointOfInterest.z);
|
||||
glColor3f(YELLOW[0], YELLOW[1], YELLOW[2]);
|
||||
renderCircle(haloOrigin, 0.1f, glm::vec3(0.0f, 1.0f, 0.0f), 30);
|
||||
renderCircle(haloOrigin, INDICATOR_RADIUS, IDENTITY_UP, NUM_SEGMENTS);
|
||||
}
|
||||
|
||||
void Application::update(float deltaTime) {
|
||||
|
|
@ -1986,7 +2042,9 @@ void Application::update(float deltaTime) {
|
|||
|
||||
// Set where I am looking based on my mouse ray (so that other people can see)
|
||||
glm::vec3 eyePosition;
|
||||
if (_isLookingAtOtherAvatar = isLookingAtOtherAvatar(mouseRayOrigin, mouseRayDirection, eyePosition)) {
|
||||
uint16_t ignored;
|
||||
_isLookingAtOtherAvatar = isLookingAtOtherAvatar(mouseRayOrigin, mouseRayDirection, eyePosition, ignored);
|
||||
if (_isLookingAtOtherAvatar) {
|
||||
// If the mouse is over another avatar's head...
|
||||
glm::vec3 myLookAtFromMouse(eyePosition);
|
||||
_myAvatar.getHead().setLookAtPosition(myLookAtFromMouse);
|
||||
|
|
@ -2003,7 +2061,7 @@ void Application::update(float deltaTime) {
|
|||
glm::vec3 front = orientation * IDENTITY_FRONT;
|
||||
glm::vec3 up = orientation * IDENTITY_UP;
|
||||
glm::vec3 towardVoxel = getMouseVoxelWorldCoordinates(_mouseVoxelDragging)
|
||||
- _myAvatar.getCameraPosition(); // is this an error? getCameraPosition dne
|
||||
- _myAvatar.getCameraPosition();
|
||||
towardVoxel = front * glm::length(towardVoxel);
|
||||
glm::vec3 lateralToVoxel = glm::cross(up, glm::normalize(towardVoxel)) * glm::length(towardVoxel);
|
||||
_voxelThrust = glm::vec3(0, 0, 0);
|
||||
|
|
@ -2103,10 +2161,8 @@ void Application::update(float deltaTime) {
|
|||
|
||||
// Leap finger-sensing device
|
||||
LeapManager::enableFakeFingers(_simulateLeapHand->isChecked() || _testRaveGlove->isChecked());
|
||||
LeapManager::nextFrame();
|
||||
_myAvatar.getHand().setRaveGloveActive(_testRaveGlove->isChecked());
|
||||
_myAvatar.getHand().setLeapFingers(LeapManager::getFingerTips(), LeapManager::getFingerRoots());
|
||||
_myAvatar.getHand().setLeapHands(LeapManager::getHandPositions(), LeapManager::getHandNormals());
|
||||
LeapManager::nextFrame(_myAvatar);
|
||||
|
||||
// Read serial port interface devices
|
||||
if (_serialHeadSensor.isActive()) {
|
||||
|
|
@ -2193,6 +2249,9 @@ void Application::update(float deltaTime) {
|
|||
if (_bandwidthDialog) {
|
||||
_bandwidthDialog->update();
|
||||
}
|
||||
if (_voxelStatsDialog) {
|
||||
_voxelStatsDialog->update();
|
||||
}
|
||||
|
||||
// Update audio stats for procedural sounds
|
||||
#ifndef _WIN32
|
||||
|
|
@ -2250,7 +2309,9 @@ void Application::updateAvatar(float deltaTime) {
|
|||
_viewFrustum.computePickRay(MIDPOINT_OF_SCREEN, MIDPOINT_OF_SCREEN, screenCenterRayOrigin, screenCenterRayDirection);
|
||||
|
||||
glm::vec3 eyePosition;
|
||||
if (_isLookingAtOtherAvatar = isLookingAtOtherAvatar(screenCenterRayOrigin, screenCenterRayDirection, eyePosition)) {
|
||||
uint16_t ignored;
|
||||
_isLookingAtOtherAvatar = isLookingAtOtherAvatar(screenCenterRayOrigin, screenCenterRayDirection, eyePosition, ignored);
|
||||
if (_isLookingAtOtherAvatar) {
|
||||
glm::vec3 myLookAtFromMouse(eyePosition);
|
||||
_myAvatar.getHead().setLookAtPosition(myLookAtFromMouse);
|
||||
}
|
||||
|
|
@ -2278,7 +2339,7 @@ void Application::updateAvatar(float deltaTime) {
|
|||
// actually need to calculate the view frustum planes to send these details
|
||||
// to the server.
|
||||
loadViewFrustum(_myCamera, _viewFrustum);
|
||||
_myAvatar.setCameraPosition(_viewFrustum.getPosition()); // setCameraPosition() dne
|
||||
_myAvatar.setCameraPosition(_viewFrustum.getPosition());
|
||||
_myAvatar.setCameraOrientation(_viewFrustum.getOrientation());
|
||||
_myAvatar.setCameraFov(_viewFrustum.getFieldOfView());
|
||||
_myAvatar.setCameraAspectRatio(_viewFrustum.getAspectRatio());
|
||||
|
|
@ -2845,28 +2906,20 @@ void Application::displayStats() {
|
|||
drawtext(10, statsVerticalOffset + 230, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
|
||||
|
||||
voxelStats.str("");
|
||||
voxelStats << "Voxels Created: " << _voxels.getVoxelsCreated() / 1000.f << "K (" << _voxels.getVoxelsCreatedPerSecondAverage() / 1000.f
|
||||
<< "Kps) ";
|
||||
char* voxelDetails = _voxelSceneStats.getItemValue(VoxelSceneStats::ITEM_VOXELS);
|
||||
voxelStats << "Voxels Sent from Server: " << voxelDetails;
|
||||
drawtext(10, statsVerticalOffset + 250, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
|
||||
|
||||
voxelStats.str("");
|
||||
voxelStats << "Voxels Colored: " << _voxels.getVoxelsColored() / 1000.f << "K (" << _voxels.getVoxelsColoredPerSecondAverage() / 1000.f
|
||||
<< "Kps) ";
|
||||
voxelDetails = _voxelSceneStats.getItemValue(VoxelSceneStats::ITEM_ELAPSED);
|
||||
voxelStats << "Scene Send Time from Server: " << voxelDetails;
|
||||
drawtext(10, statsVerticalOffset + 270, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
|
||||
|
||||
voxelStats.str("");
|
||||
voxelStats << "Voxel Bits Read: " << _voxels.getVoxelsBytesRead() * 8.f / 1000000.f
|
||||
<< "M (" << _voxels.getVoxelsBytesReadPerSecondAverage() * 8.f / 1000000.f << " Mbps)";
|
||||
voxelDetails = _voxelSceneStats.getItemValue(VoxelSceneStats::ITEM_ENCODE);
|
||||
voxelStats << "Encode Time on Server: " << voxelDetails;
|
||||
drawtext(10, statsVerticalOffset + 290, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
|
||||
|
||||
voxelStats.str("");
|
||||
float voxelsBytesPerColored = _voxels.getVoxelsColored()
|
||||
? ((float) _voxels.getVoxelsBytesRead() / _voxels.getVoxelsColored())
|
||||
: 0;
|
||||
|
||||
voxelStats << "Voxels Bits per Colored: " << voxelsBytesPerColored * 8;
|
||||
drawtext(10, statsVerticalOffset + 310, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
|
||||
|
||||
Node *avatarMixer = NodeList::getInstance()->soloNodeOfType(NODE_TYPE_AVATAR_MIXER);
|
||||
char avatarMixerStats[200];
|
||||
|
||||
|
|
@ -3420,16 +3473,37 @@ void* Application::networkReceive(void* args) {
|
|||
case PACKET_TYPE_VOXEL_DATA_MONOCHROME:
|
||||
case PACKET_TYPE_Z_COMMAND:
|
||||
case PACKET_TYPE_ERASE_VOXEL:
|
||||
case PACKET_TYPE_VOXEL_STATS:
|
||||
case PACKET_TYPE_ENVIRONMENT_DATA: {
|
||||
|
||||
unsigned char* messageData = app->_incomingPacket;
|
||||
ssize_t messageLength = bytesReceived;
|
||||
|
||||
// note: PACKET_TYPE_VOXEL_STATS can have PACKET_TYPE_VOXEL_DATA or PACKET_TYPE_VOXEL_DATA_MONOCHROME
|
||||
// immediately following them inside the same packet. So, we process the PACKET_TYPE_VOXEL_STATS first
|
||||
// then process any remaining bytes as if it was another packet
|
||||
if (messageData[0] == PACKET_TYPE_VOXEL_STATS) {
|
||||
int statsMessageLength = app->_voxelSceneStats.unpackFromMessage(messageData, messageLength);
|
||||
if (messageLength > statsMessageLength) {
|
||||
messageData += statsMessageLength;
|
||||
messageLength -= statsMessageLength;
|
||||
if (!packetVersionMatch(messageData)) {
|
||||
break; // bail since piggyback data doesn't match our versioning
|
||||
}
|
||||
} else {
|
||||
break; // bail since no piggyback data
|
||||
}
|
||||
} // fall through to piggyback message
|
||||
|
||||
if (app->_renderVoxels->isChecked()) {
|
||||
Node* voxelServer = NodeList::getInstance()->soloNodeOfType(NODE_TYPE_VOXEL_SERVER);
|
||||
if (voxelServer && socketMatch(voxelServer->getActiveSocket(), &senderAddress)) {
|
||||
voxelServer->lock();
|
||||
|
||||
if (app->_incomingPacket[0] == PACKET_TYPE_ENVIRONMENT_DATA) {
|
||||
app->_environment.parseData(&senderAddress, app->_incomingPacket, bytesReceived);
|
||||
if (messageData[0] == PACKET_TYPE_ENVIRONMENT_DATA) {
|
||||
app->_environment.parseData(&senderAddress, messageData, messageLength);
|
||||
} else {
|
||||
app->_voxels.parseData(app->_incomingPacket, bytesReceived);
|
||||
app->_voxels.parseData(messageData, messageLength);
|
||||
}
|
||||
|
||||
voxelServer->unlock();
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@
|
|||
#include "avatar/HandControl.h"
|
||||
#include "ui/BandwidthDialog.h"
|
||||
#include "ui/ChatEntry.h"
|
||||
#include "ui/VoxelStatsDialog.h"
|
||||
|
||||
class QAction;
|
||||
class QActionGroup;
|
||||
|
|
@ -121,6 +122,9 @@ private slots:
|
|||
void editPreferences();
|
||||
void bandwidthDetailsClosed();
|
||||
|
||||
void voxelStatsDetails();
|
||||
void voxelStatsDetailsClosed();
|
||||
|
||||
void pair();
|
||||
|
||||
void setRenderMirrored(bool mirrored);
|
||||
|
|
@ -170,6 +174,10 @@ private slots:
|
|||
void copyVoxels();
|
||||
void pasteVoxels();
|
||||
void runTests();
|
||||
void setListenModeNormal();
|
||||
void setListenModePoint();
|
||||
void setListenModeSingleSource();
|
||||
|
||||
|
||||
void renderCoverageMap();
|
||||
void renderCoverageMapsRecursively(CoverageMap* map);
|
||||
|
|
@ -199,7 +207,9 @@ private:
|
|||
void init();
|
||||
|
||||
void update(float deltaTime);
|
||||
bool isLookingAtOtherAvatar(glm::vec3& mouseRayOrigin, glm::vec3& mouseRayDirection, glm::vec3& eyePosition);
|
||||
bool isLookingAtOtherAvatar(glm::vec3& mouseRayOrigin, glm::vec3& mouseRayDirection,
|
||||
glm::vec3& eyePosition, uint16_t& nodeID);
|
||||
|
||||
void renderLookatIndicator(glm::vec3 pointOfInterest, Camera& whichCamera);
|
||||
void updateAvatar(float deltaTime);
|
||||
void loadViewFrustum(Camera& camera, ViewFrustum& viewFrustum);
|
||||
|
|
@ -284,6 +294,7 @@ private:
|
|||
|
||||
BandwidthMeter _bandwidthMeter;
|
||||
BandwidthDialog* _bandwidthDialog;
|
||||
VoxelStatsDialog* _voxelStatsDialog;
|
||||
|
||||
SerialInterface _serialHeadSensor;
|
||||
QNetworkAccessManager* _networkAccessManager;
|
||||
|
|
@ -373,6 +384,7 @@ private:
|
|||
|
||||
bool _isLookingAtOtherAvatar;
|
||||
glm::vec3 _lookatOtherPosition;
|
||||
float _lookatIndicatorScale;
|
||||
|
||||
bool _paintOn; // Whether to paint voxels as you fly around
|
||||
unsigned char _dominantColor; // The dominant color of the voxel we're painting
|
||||
|
|
@ -416,6 +428,8 @@ private:
|
|||
|
||||
ToolsPalette _palette;
|
||||
Swatch _swatch;
|
||||
|
||||
VoxelSceneStats _voxelSceneStats;
|
||||
};
|
||||
|
||||
#endif /* defined(__interface__Application__) */
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ inline void Audio::performIO(int16_t* inputLeft, int16_t* outputLeft, int16_t* o
|
|||
|
||||
// we need the amount of bytes in the buffer + 1 for type
|
||||
// + 12 for 3 floats for position + float for bearing + 1 attenuation byte
|
||||
unsigned char dataPacket[BUFFER_LENGTH_BYTES_PER_CHANNEL + leadingBytes];
|
||||
unsigned char dataPacket[MAX_PACKET_SIZE];
|
||||
|
||||
PACKET_TYPE packetType = (Application::getInstance()->shouldEchoAudio())
|
||||
? PACKET_TYPE_MICROPHONE_AUDIO_WITH_ECHO
|
||||
|
|
@ -120,6 +120,33 @@ inline void Audio::performIO(int16_t* inputLeft, int16_t* outputLeft, int16_t* o
|
|||
|
||||
unsigned char* currentPacketPtr = dataPacket + populateTypeAndVersion(dataPacket, packetType);
|
||||
|
||||
// pack Source Data
|
||||
uint16_t ownerID = NodeList::getInstance()->getOwnerID();
|
||||
memcpy(currentPacketPtr, &ownerID, sizeof(ownerID));
|
||||
currentPacketPtr += (sizeof(ownerID));
|
||||
leadingBytes += (sizeof(ownerID));
|
||||
|
||||
// pack Listen Mode Data
|
||||
memcpy(currentPacketPtr, &_listenMode, sizeof(_listenMode));
|
||||
currentPacketPtr += (sizeof(_listenMode));
|
||||
leadingBytes += (sizeof(_listenMode));
|
||||
|
||||
if (_listenMode == AudioRingBuffer::OMNI_DIRECTIONAL_POINT) {
|
||||
memcpy(currentPacketPtr, &_listenRadius, sizeof(_listenRadius));
|
||||
currentPacketPtr += (sizeof(_listenRadius));
|
||||
leadingBytes += (sizeof(_listenRadius));
|
||||
} else if (_listenMode == AudioRingBuffer::SELECTED_SOURCES) {
|
||||
int listenSourceCount = _listenSources.size();
|
||||
memcpy(currentPacketPtr, &listenSourceCount, sizeof(listenSourceCount));
|
||||
currentPacketPtr += (sizeof(listenSourceCount));
|
||||
leadingBytes += (sizeof(listenSourceCount));
|
||||
for (int i = 0; i < listenSourceCount; i++) {
|
||||
memcpy(currentPacketPtr, &_listenSources[i], sizeof(_listenSources[i]));
|
||||
currentPacketPtr += sizeof(_listenSources[i]);
|
||||
leadingBytes += sizeof(_listenSources[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// memcpy the three float positions
|
||||
memcpy(currentPacketPtr, &headPosition, sizeof(headPosition));
|
||||
currentPacketPtr += (sizeof(headPosition));
|
||||
|
|
@ -309,6 +336,24 @@ void Audio::reset() {
|
|||
_ringBuffer.reset();
|
||||
}
|
||||
|
||||
void Audio::addListenSource(int sourceID) {
|
||||
_listenSources.push_back(sourceID);
|
||||
}
|
||||
|
||||
void Audio::clearListenSources() {
|
||||
_listenSources.clear();
|
||||
}
|
||||
|
||||
void Audio::removeListenSource(int sourceID) {
|
||||
for (int i = 0; i < _listenSources.size(); i++) {
|
||||
if (_listenSources[i] == sourceID) {
|
||||
_listenSources.erase(_listenSources.begin() + i);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Audio::Audio(Oscilloscope* scope, int16_t initialJitterBufferSamples) :
|
||||
_stream(NULL),
|
||||
_ringBuffer(true),
|
||||
|
|
@ -338,7 +383,9 @@ Audio::Audio(Oscilloscope* scope, int16_t initialJitterBufferSamples) :
|
|||
_collisionSoundNoise(0.0f),
|
||||
_collisionSoundDuration(0.0f),
|
||||
_proceduralEffectSample(0),
|
||||
_heartbeatMagnitude(0.0f)
|
||||
_heartbeatMagnitude(0.0f),
|
||||
_listenMode(AudioRingBuffer::NORMAL),
|
||||
_listenRadius(0.0f)
|
||||
{
|
||||
outputPortAudioError(Pa_Initialize());
|
||||
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@
|
|||
#ifndef __interface__Audio__
|
||||
#define __interface__Audio__
|
||||
|
||||
#include <vector>
|
||||
#include <portaudio.h>
|
||||
#include <AudioRingBuffer.h>
|
||||
#include <StdDev.h>
|
||||
|
|
@ -54,6 +55,11 @@ public:
|
|||
// The results of the analysis are written to the log.
|
||||
bool eventuallyAnalyzePing();
|
||||
|
||||
void setListenMode(AudioRingBuffer::ListenMode mode) { _listenMode = mode; };
|
||||
void setListenRadius(float radius) { _listenRadius = radius; };
|
||||
void addListenSource(int sourceID);
|
||||
void removeListenSource(int sourceID);
|
||||
void clearListenSources();
|
||||
|
||||
private:
|
||||
PaStream* _stream;
|
||||
|
|
@ -91,6 +97,10 @@ private:
|
|||
int _proceduralEffectSample;
|
||||
float _heartbeatMagnitude;
|
||||
|
||||
AudioRingBuffer::ListenMode _listenMode;
|
||||
float _listenRadius;
|
||||
std::vector<int> _listenSources;
|
||||
|
||||
// Audio callback in class context.
|
||||
inline void performIO(int16_t* inputLeft, int16_t* outputLeft, int16_t* outputRight);
|
||||
|
||||
|
|
|
|||
|
|
@ -7,57 +7,28 @@
|
|||
//
|
||||
|
||||
#include "LeapManager.h"
|
||||
#include "avatar/Avatar.h"
|
||||
#include <Leap.h>
|
||||
#include <dlfcn.h> // needed for RTLD_LAZY
|
||||
#include <sstream>
|
||||
|
||||
// Uncomment the next line to use Leap-smoothed stabilized (slower) data.
|
||||
//#define USE_STABILIZED_DATA
|
||||
|
||||
bool LeapManager::_libraryExists = false;
|
||||
bool LeapManager::_doFakeFingers = false;
|
||||
Leap::Controller* LeapManager::_controller = NULL;
|
||||
HifiLeapListener* LeapManager::_listener = NULL;
|
||||
|
||||
namespace {
|
||||
glm::vec3 fakeHandOffset(0.0f, 50.0f, 50.0f);
|
||||
} // end anonymous namespace
|
||||
|
||||
class HifiLeapListener : public Leap::Listener {
|
||||
public:
|
||||
HifiLeapListener() {}
|
||||
virtual ~HifiLeapListener() {}
|
||||
|
||||
Leap::Frame lastFrame;
|
||||
std::vector<glm::vec3> fingerTips;
|
||||
std::vector<glm::vec3> fingerRoots;
|
||||
std::vector<glm::vec3> handPositions;
|
||||
std::vector<glm::vec3> handNormals;
|
||||
|
||||
virtual void onFrame(const Leap::Controller& controller) {
|
||||
#ifndef LEAP_STUBS
|
||||
Leap::Frame frame = controller.frame();
|
||||
int numFingers = frame.fingers().count();
|
||||
fingerTips.resize(numFingers);
|
||||
fingerRoots.resize(numFingers);
|
||||
for (int i = 0; i < numFingers; ++i) {
|
||||
const Leap::Finger& thisFinger = frame.fingers()[i];
|
||||
const Leap::Vector pos = thisFinger.stabilizedTipPosition();
|
||||
fingerTips[i] = glm::vec3(pos.x, pos.y, pos.z);
|
||||
|
||||
const Leap::Vector root = pos - thisFinger.direction() * thisFinger.length();
|
||||
fingerRoots[i] = glm::vec3(root.x, root.y, root.z);
|
||||
}
|
||||
|
||||
int numHands = frame.hands().count();
|
||||
handPositions.resize(numHands);
|
||||
handNormals.resize(numHands);
|
||||
for (int i = 0; i < numHands; ++i) {
|
||||
const Leap::Hand& thisHand = frame.hands()[i];
|
||||
const Leap::Vector pos = thisHand.palmPosition();
|
||||
handPositions[i] = glm::vec3(pos.x, pos.y, pos.z);
|
||||
|
||||
const Leap::Vector norm = thisHand.palmNormal();
|
||||
handNormals[i] = glm::vec3(norm.x, norm.y, norm.z);
|
||||
}
|
||||
lastFrame = frame;
|
||||
lastFrame = controller.frame();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -80,10 +51,199 @@ void LeapManager::terminate() {
|
|||
_controller = NULL;
|
||||
}
|
||||
|
||||
void LeapManager::nextFrame() {
|
||||
void LeapManager::nextFrame(Avatar& avatar) {
|
||||
// Apply the frame data directly to the avatar.
|
||||
Hand& hand = avatar.getHand();
|
||||
|
||||
// If we actually get valid Leap data, this will be set to true;
|
||||
bool gotRealData = false;
|
||||
|
||||
if (controllersExist()) {
|
||||
_listener->onFrame(*_controller);
|
||||
}
|
||||
|
||||
#ifndef LEAP_STUBS
|
||||
if (controllersExist()) {
|
||||
gotRealData = true;
|
||||
// First, see which palms and fingers are still valid.
|
||||
Leap::Frame& frame = _listener->lastFrame;
|
||||
|
||||
// Note that this is O(n^2) at worst, but n is very small.
|
||||
|
||||
// After this many frames of no data, assume the digit is lost.
|
||||
const int assumeLostAfterFrameCount = 10;
|
||||
|
||||
// Increment our frame data counters
|
||||
for (size_t i = 0; i < hand.getNumPalms(); ++i) {
|
||||
PalmData& palm = hand.getPalms()[i];
|
||||
palm.incrementFramesWithoutData();
|
||||
if (palm.getFramesWithoutData() > assumeLostAfterFrameCount) {
|
||||
palm.setActive(false);
|
||||
}
|
||||
for (size_t f = 0; f < palm.getNumFingers(); ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
finger.incrementFramesWithoutData();
|
||||
if (finger.getFramesWithoutData() > assumeLostAfterFrameCount) {
|
||||
finger.setActive(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t numLeapHands = frame.hands().count();
|
||||
std::vector<PalmData*> palmAssignment(numLeapHands);
|
||||
|
||||
// Look for matches
|
||||
for (size_t index = 0; index < numLeapHands; ++index) {
|
||||
PalmData* takeoverCandidate = NULL;
|
||||
palmAssignment[index] = NULL;
|
||||
Leap::Hand leapHand = frame.hands()[index];
|
||||
int id = leapHand.id();
|
||||
if (leapHand.isValid()) {
|
||||
for (size_t i = 0; i < hand.getNumPalms() && palmAssignment[index] == NULL; ++i) {
|
||||
PalmData& palm = hand.getPalms()[i];
|
||||
if (palm.getLeapID() == id) {
|
||||
// Found hand with the same ID. We're set!
|
||||
palmAssignment[index] = &palm;
|
||||
palm.resetFramesWithoutData();
|
||||
}
|
||||
else if (palm.getFramesWithoutData() > assumeLostAfterFrameCount) {
|
||||
takeoverCandidate = &palm;
|
||||
}
|
||||
}
|
||||
if (palmAssignment[index] == NULL) {
|
||||
palmAssignment[index] = takeoverCandidate;
|
||||
}
|
||||
if (palmAssignment[index] == NULL) {
|
||||
palmAssignment[index] = &hand.addNewPalm();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Apply the assignments
|
||||
for (size_t index = 0; index < numLeapHands; ++index) {
|
||||
if (palmAssignment[index]) {
|
||||
Leap::Hand leapHand = frame.hands()[index];
|
||||
PalmData& palm = *(palmAssignment[index]);
|
||||
|
||||
palm.resetFramesWithoutData();
|
||||
palm.setLeapID(leapHand.id());
|
||||
palm.setActive(true);
|
||||
const Leap::Vector pos = leapHand.palmPosition();
|
||||
const Leap::Vector normal = leapHand.palmNormal();
|
||||
palm.setRawPosition(glm::vec3(pos.x, pos.y, pos.z));
|
||||
palm.setRawNormal(glm::vec3(normal.x, normal.y, normal.z));
|
||||
}
|
||||
}
|
||||
|
||||
// Look for fingers per palm
|
||||
for (size_t i = 0; i < hand.getNumPalms(); ++i) {
|
||||
PalmData& palm = hand.getPalms()[i];
|
||||
if (palm.isActive()) {
|
||||
Leap::Hand leapHand = frame.hand(palm.getLeapID());
|
||||
if (leapHand.isValid()) {
|
||||
int numLeapFingers = leapHand.fingers().count();
|
||||
std::vector<FingerData*> fingerAssignment(numLeapFingers);
|
||||
|
||||
|
||||
// Look for matches
|
||||
for (size_t index = 0; index < numLeapFingers; ++index) {
|
||||
FingerData* takeoverCandidate = NULL;
|
||||
fingerAssignment[index] = NULL;
|
||||
Leap::Finger leapFinger = leapHand.fingers()[index];
|
||||
int id = leapFinger.id();
|
||||
if (leapFinger.isValid()) {
|
||||
for (size_t f = 0; f < palm.getNumFingers() && fingerAssignment[index] == NULL; ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
if (finger.getLeapID() == id) {
|
||||
// Found hand with the same ID. We're set!
|
||||
fingerAssignment[index] = &finger;
|
||||
}
|
||||
else if (finger.getFramesWithoutData() > assumeLostAfterFrameCount) {
|
||||
takeoverCandidate = &finger;
|
||||
}
|
||||
}
|
||||
// If we didn't find a match, but we found an unused finger, us it.
|
||||
if (fingerAssignment[index] == NULL) {
|
||||
fingerAssignment[index] = takeoverCandidate;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Apply the assignments
|
||||
for (size_t index = 0; index < numLeapFingers; ++index) {
|
||||
if (fingerAssignment[index]) {
|
||||
Leap::Finger leapFinger = leapHand.fingers()[index];
|
||||
FingerData& finger = *(fingerAssignment[index]);
|
||||
|
||||
finger.resetFramesWithoutData();
|
||||
finger.setLeapID(leapFinger.id());
|
||||
finger.setActive(true);
|
||||
#ifdef USE_STABILIZED_DATA
|
||||
const Leap::Vector tip = leapFinger.stabilizedTipPosition();
|
||||
#else
|
||||
const Leap::Vector tip = leapFinger.tipPosition();
|
||||
#endif
|
||||
const Leap::Vector root = tip - leapFinger.direction() * leapFinger.length();
|
||||
finger.setRawTipPosition(glm::vec3(tip.x, tip.y, tip.z));
|
||||
finger.setRawRootPosition(glm::vec3(root.x, root.y, root.z));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (!gotRealData) {
|
||||
if (_doFakeFingers) {
|
||||
// There's no real Leap data and we need to fake it.
|
||||
for (size_t i = 0; i < hand.getNumPalms(); ++i) {
|
||||
static const glm::vec3 fakeHandOffsets[] = {
|
||||
glm::vec3( -500.0f, 50.0f, 50.0f),
|
||||
glm::vec3( 0.0f, 50.0f, 50.0f)
|
||||
};
|
||||
static const glm::vec3 fakeHandFingerMirrors[] = {
|
||||
glm::vec3( -1.0f, 1.0f, 1.0f),
|
||||
glm::vec3( 1.0f, 1.0f, 1.0f)
|
||||
};
|
||||
static const glm::vec3 fakeFingerPositions[] = {
|
||||
glm::vec3( -60.0f, 0.0f, -40.0f),
|
||||
glm::vec3( -20.0f, 0.0f, -60.0f),
|
||||
glm::vec3( 20.0f, 0.0f, -60.0f),
|
||||
glm::vec3( 60.0f, 0.0f, -40.0f),
|
||||
glm::vec3( -50.0f, 0.0f, 30.0f)
|
||||
};
|
||||
|
||||
PalmData& palm = hand.getPalms()[i];
|
||||
palm.setActive(true);
|
||||
// Simulated data
|
||||
|
||||
palm.setRawPosition(glm::vec3( 0.0f, 0.0f, 0.0f) + fakeHandOffsets[i]);
|
||||
palm.setRawNormal(glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
|
||||
for (size_t f = 0; f < palm.getNumFingers(); ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
finger.setActive(true);
|
||||
const float tipScale = 1.5f;
|
||||
const float rootScale = 0.75f;
|
||||
glm::vec3 fingerPos = fakeFingerPositions[f] * fakeHandFingerMirrors[i];
|
||||
finger.setRawTipPosition(fingerPos * tipScale + fakeHandOffsets[i]);
|
||||
finger.setRawRootPosition(fingerPos * rootScale + fakeHandOffsets[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Just deactivate everything.
|
||||
for (size_t i = 0; i < hand.getNumPalms(); ++i) {
|
||||
PalmData& palm = hand.getPalms()[i];
|
||||
palm.setActive(false);
|
||||
for (size_t f = 0; f < palm.getNumFingers(); ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
finger.setActive(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
hand.updateFingerTrails();
|
||||
}
|
||||
|
||||
void LeapManager::enableFakeFingers(bool enable) {
|
||||
|
|
@ -98,77 +258,6 @@ bool LeapManager::controllersExist() {
|
|||
#endif
|
||||
}
|
||||
|
||||
const std::vector<glm::vec3>& LeapManager::getFingerTips() {
|
||||
if (controllersExist()) {
|
||||
return _listener->fingerTips;
|
||||
}
|
||||
else {
|
||||
static std::vector<glm::vec3> stubData;
|
||||
stubData.clear();
|
||||
if (_doFakeFingers) {
|
||||
// Simulated data
|
||||
float scale = 1.5f;
|
||||
stubData.push_back(glm::vec3( -60.0f, 0.0f, -40.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( -20.0f, 0.0f, -60.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( 20.0f, 0.0f, -60.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( 60.0f, 0.0f, -40.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( -50.0f, 0.0f, 30.0f) * scale + fakeHandOffset);
|
||||
}
|
||||
return stubData;
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<glm::vec3>& LeapManager::getFingerRoots() {
|
||||
if (controllersExist()) {
|
||||
return _listener->fingerRoots;
|
||||
}
|
||||
else {
|
||||
static std::vector<glm::vec3> stubData;
|
||||
stubData.clear();
|
||||
if (_doFakeFingers) {
|
||||
// Simulated data
|
||||
float scale = 0.75f;
|
||||
stubData.push_back(glm::vec3( -60.0f, 0.0f, -40.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( -20.0f, 0.0f, -60.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( 20.0f, 0.0f, -60.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( 60.0f, 0.0f, -40.0f) * scale + fakeHandOffset);
|
||||
stubData.push_back(glm::vec3( -50.0f, 0.0f, 30.0f) * scale + fakeHandOffset);
|
||||
}
|
||||
return stubData;
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<glm::vec3>& LeapManager::getHandPositions() {
|
||||
if (controllersExist()) {
|
||||
return _listener->handPositions;
|
||||
}
|
||||
else {
|
||||
static std::vector<glm::vec3> stubData;
|
||||
stubData.clear();
|
||||
if (_doFakeFingers) {
|
||||
// Simulated data
|
||||
glm::vec3 handOffset(0.0f, 50.0f, 50.0f);
|
||||
stubData.push_back(glm::vec3( 0.0f, 0.0f, 0.0f) + fakeHandOffset);
|
||||
}
|
||||
return stubData;
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<glm::vec3>& LeapManager::getHandNormals() {
|
||||
if (controllersExist()) {
|
||||
return _listener->handNormals;
|
||||
}
|
||||
else {
|
||||
static std::vector<glm::vec3> stubData;
|
||||
stubData.clear();
|
||||
if (_doFakeFingers) {
|
||||
// Simulated data
|
||||
stubData.push_back(glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
}
|
||||
return stubData;
|
||||
}
|
||||
}
|
||||
|
||||
std::string LeapManager::statusString() {
|
||||
std::stringstream leapString;
|
||||
#ifndef LEAP_STUBS
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@
|
|||
#include <glm/glm.hpp>
|
||||
#include <string>
|
||||
|
||||
class Avatar;
|
||||
class HifiLeapListener;
|
||||
namespace Leap {
|
||||
class Controller;
|
||||
|
|
@ -20,7 +21,7 @@ namespace Leap {
|
|||
|
||||
class LeapManager {
|
||||
public:
|
||||
static void nextFrame(); // called once per frame to get new Leap data
|
||||
static void nextFrame(Avatar& avatar); // called once per frame to get new Leap data
|
||||
static bool controllersExist(); // Returns true if there's at least one active Leap plugged in
|
||||
static void enableFakeFingers(bool enable); // put fake data in if there's no Leap plugged in
|
||||
static const std::vector<glm::vec3>& getFingerTips();
|
||||
|
|
|
|||
|
|
@ -830,13 +830,14 @@ void Avatar::updateHandMovementAndTouching(float deltaTime, bool enableHandMovem
|
|||
}
|
||||
|
||||
// If there's a leap-interaction hand visible, use that as the endpoint
|
||||
if (!getHand().isRaveGloveActive()) {
|
||||
for (size_t i = 0; i < getHand().getPalms().size(); ++i) {
|
||||
PalmData& palm = getHand().getPalms()[i];
|
||||
if (palm.isActive()) {
|
||||
_skeleton.joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].position = palm.getPosition();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}//if (_isMine)
|
||||
|
||||
//constrain right arm length and re-adjust elbow position as it bends
|
||||
|
|
|
|||
|
|
@ -164,6 +164,10 @@ public:
|
|||
glm::quat getOrientation () const;
|
||||
glm::quat getWorldAlignedOrientation() const;
|
||||
|
||||
const glm::vec3& getMouseRayOrigin() const { return _mouseRayOrigin; }
|
||||
const glm::vec3& getMouseRayDirection() const { return _mouseRayDirection; }
|
||||
|
||||
|
||||
glm::vec3 getGravity () const { return _gravity; }
|
||||
|
||||
glm::vec3 getUprightHeadPosition() const;
|
||||
|
|
|
|||
|
|
@ -95,6 +95,7 @@ void Hand::render(bool lookingInMirror) {
|
|||
glEnable(GL_DEPTH_TEST);
|
||||
glEnable(GL_RESCALE_NORMAL);
|
||||
|
||||
renderFingerTrails();
|
||||
renderHandSpheres();
|
||||
}
|
||||
|
||||
|
|
@ -173,43 +174,34 @@ void Hand::renderHandSpheres() {
|
|||
glPopMatrix();
|
||||
}
|
||||
|
||||
void Hand::setLeapFingers(const std::vector<glm::vec3>& fingerTips,
|
||||
const std::vector<glm::vec3>& fingerRoots) {
|
||||
// TODO: add id-checking here to increase finger stability
|
||||
|
||||
size_t fingerIndex = 0;
|
||||
void Hand::renderFingerTrails() {
|
||||
// Draw the finger root cones
|
||||
for (size_t i = 0; i < getNumPalms(); ++i) {
|
||||
PalmData& palm = getPalms()[i];
|
||||
if (palm.isActive()) {
|
||||
for (size_t f = 0; f < palm.getNumFingers(); ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
if (fingerIndex < fingerTips.size()) {
|
||||
finger.setActive(true);
|
||||
finger.setRawTipPosition(fingerTips[fingerIndex]);
|
||||
finger.setRawRootPosition(fingerRoots[fingerIndex]);
|
||||
fingerIndex++;
|
||||
int numPositions = finger.getTrailNumPositions();
|
||||
if (numPositions > 0) {
|
||||
glBegin(GL_TRIANGLE_STRIP);
|
||||
for (int t = 0; t < numPositions; ++t)
|
||||
{
|
||||
const glm::vec3& center = finger.getTrailPosition(t);
|
||||
const float halfWidth = 0.001f;
|
||||
const glm::vec3 edgeDirection(1.0f, 0.0f, 0.0f);
|
||||
glm::vec3 edge0 = center + edgeDirection * halfWidth;
|
||||
glm::vec3 edge1 = center - edgeDirection * halfWidth;
|
||||
float alpha = 1.0f - ((float)t / (float)(numPositions - 1));
|
||||
glColor4f(1.0f, 0.0f, 0.0f, alpha);
|
||||
glVertex3fv((float*)&edge0);
|
||||
glVertex3fv((float*)&edge1);
|
||||
}
|
||||
else {
|
||||
finger.setActive(false);
|
||||
glEnd();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Hand::setLeapHands(const std::vector<glm::vec3>& handPositions,
|
||||
const std::vector<glm::vec3>& handNormals) {
|
||||
for (size_t i = 0; i < getNumPalms(); ++i) {
|
||||
PalmData& palm = getPalms()[i];
|
||||
if (i < handPositions.size()) {
|
||||
palm.setActive(true);
|
||||
palm.setRawPosition(handPositions[i]);
|
||||
palm.setRawNormal(handNormals[i]);
|
||||
}
|
||||
else {
|
||||
palm.setActive(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Hand::updateFingerParticles(float deltaTime) {
|
||||
|
||||
|
|
|
|||
|
|
@ -42,10 +42,6 @@ public:
|
|||
void render(bool lookingInMirror);
|
||||
|
||||
void setBallColor (glm::vec3 ballColor ) { _ballColor = ballColor; }
|
||||
void setLeapFingers (const std::vector<glm::vec3>& fingerTips,
|
||||
const std::vector<glm::vec3>& fingerRoots);
|
||||
void setLeapHands (const std::vector<glm::vec3>& handPositions,
|
||||
const std::vector<glm::vec3>& handNormals);
|
||||
void updateFingerParticles(float deltaTime);
|
||||
void setRaveGloveActive(bool active) { _isRaveGloveActive = active; }
|
||||
|
||||
|
|
@ -74,6 +70,7 @@ private:
|
|||
// private methods
|
||||
void renderRaveGloveStage();
|
||||
void renderHandSpheres();
|
||||
void renderFingerTrails();
|
||||
void calculateGeometry();
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -272,7 +272,7 @@ void Head::calculateGeometry() {
|
|||
+ up * _scale * BODY_BALL_RADIUS_HEAD_BASE * EYE_UP_OFFSET
|
||||
+ front * _scale * BODY_BALL_RADIUS_HEAD_BASE * EYE_FRONT_OFFSET;
|
||||
|
||||
_eyeLevelPosition = _position + up * _scale * BODY_BALL_RADIUS_HEAD_BASE * EYE_UP_OFFSET;
|
||||
_eyeLevelPosition = _rightEyePosition - right * _scale * BODY_BALL_RADIUS_HEAD_BASE * EYE_RIGHT_OFFSET;
|
||||
|
||||
//calculate the eyebrow positions
|
||||
_leftEyeBrowPosition = _leftEyePosition;
|
||||
|
|
|
|||
79
interface/src/ui/VoxelStatsDialog.cpp
Normal file
79
interface/src/ui/VoxelStatsDialog.cpp
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
//
|
||||
// VoxelStatsDialog.cpp
|
||||
// interface
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 7/19/13.
|
||||
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
|
||||
//
|
||||
|
||||
#include <QFormLayout>
|
||||
#include <QDialogButtonBox>
|
||||
|
||||
#include <QPalette>
|
||||
#include <QColor>
|
||||
|
||||
#include <VoxelSceneStats.h>
|
||||
|
||||
#include "ui/VoxelStatsDialog.h"
|
||||
|
||||
|
||||
VoxelStatsDialog::VoxelStatsDialog(QWidget* parent, VoxelSceneStats* model) :
|
||||
QDialog(parent, Qt::Window | Qt::WindowCloseButtonHint | Qt::WindowStaysOnTopHint),
|
||||
_model(model) {
|
||||
|
||||
char strBuf[64];
|
||||
|
||||
this->setWindowTitle("Voxel Statistics");
|
||||
|
||||
// Create layouter
|
||||
QFormLayout* form = new QFormLayout();
|
||||
this->QDialog::setLayout(form);
|
||||
|
||||
// Setup labels
|
||||
for (int i = 0; i < VoxelSceneStats::ITEM_COUNT; ++i) {
|
||||
VoxelSceneStats::ItemInfo& itemInfo = _model->getItemInfo(i);
|
||||
QLabel* label = _labels[i] = new QLabel();
|
||||
label->setAlignment(Qt::AlignRight);
|
||||
|
||||
// Set foreground color to 62.5% brightness of the meter (otherwise will be hard to read on the bright background)
|
||||
QPalette palette = label->palette();
|
||||
unsigned rgb = itemInfo.colorRGBA >> 8;
|
||||
const unsigned colorpart1 = 0xfefefeu;
|
||||
const unsigned colorpart2 = 0xf8f8f8;
|
||||
rgb = ((rgb & colorpart1) >> 1) + ((rgb & colorpart2) >> 3);
|
||||
palette.setColor(QPalette::WindowText, QColor::fromRgb(rgb));
|
||||
label->setPalette(palette);
|
||||
|
||||
// This is my hackery attempt at making QDialog auto-size to a width that will hold our info. It kinda works.
|
||||
label->setText("123456789012345678901234567890123456789012345678901234567890");
|
||||
|
||||
snprintf(strBuf, sizeof(strBuf), " %s:", itemInfo.caption);
|
||||
form->addRow(strBuf, label);
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelStatsDialog::paintEvent(QPaintEvent* event) {
|
||||
|
||||
// Update labels
|
||||
char strBuf[256];
|
||||
for (int i = 0; i < VoxelSceneStats::ITEM_COUNT; ++i) {
|
||||
QLabel* label = _labels[i];
|
||||
snprintf(strBuf, sizeof(strBuf), "%s", _model->getItemValue(i));
|
||||
label->setText(strBuf);
|
||||
}
|
||||
|
||||
this->QDialog::paintEvent(event);
|
||||
this->setFixedSize(this->width(), this->height());
|
||||
}
|
||||
|
||||
void VoxelStatsDialog::reject() {
|
||||
// Just regularly close upon ESC
|
||||
this->QDialog::close();
|
||||
}
|
||||
|
||||
void VoxelStatsDialog::closeEvent(QCloseEvent* event) {
|
||||
this->QDialog::closeEvent(event);
|
||||
emit closed();
|
||||
}
|
||||
|
||||
|
||||
42
interface/src/ui/VoxelStatsDialog.h
Normal file
42
interface/src/ui/VoxelStatsDialog.h
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
//
|
||||
// VoxelStatsDialog.h
|
||||
// interface
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 7/19/13.
|
||||
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
|
||||
//
|
||||
|
||||
#ifndef __hifi__VoxelStatsDialog__
|
||||
#define __hifi__VoxelStatsDialog__
|
||||
|
||||
#include <QDialog>
|
||||
#include <QLabel>
|
||||
|
||||
#include <VoxelSceneStats.h>
|
||||
|
||||
class VoxelStatsDialog : public QDialog {
|
||||
Q_OBJECT
|
||||
public:
|
||||
// Sets up the UI
|
||||
VoxelStatsDialog(QWidget* parent, VoxelSceneStats* model);
|
||||
|
||||
signals:
|
||||
void closed();
|
||||
|
||||
public slots:
|
||||
void reject();
|
||||
|
||||
protected:
|
||||
// State <- data model held by BandwidthMeter
|
||||
void paintEvent(QPaintEvent*);
|
||||
|
||||
// Emits a 'closed' signal when this dialog is closed.
|
||||
void closeEvent(QCloseEvent*);
|
||||
|
||||
private:
|
||||
QLabel* _labels[VoxelSceneStats::ITEM_COUNT];
|
||||
VoxelSceneStats* _model;
|
||||
};
|
||||
|
||||
#endif /* defined(__interface__VoxelStatsDialog__) */
|
||||
|
||||
|
|
@ -27,6 +27,14 @@ const short RING_BUFFER_LENGTH_SAMPLES = RING_BUFFER_LENGTH_FRAMES * BUFFER_LENG
|
|||
|
||||
class AudioRingBuffer : public NodeData {
|
||||
public:
|
||||
|
||||
static int const DEFAULT_LISTEN_LIST_SIZE = 100;
|
||||
typedef enum {
|
||||
NORMAL,
|
||||
OMNI_DIRECTIONAL_POINT,
|
||||
SELECTED_SOURCES
|
||||
} ListenMode;
|
||||
|
||||
AudioRingBuffer(bool isStereo);
|
||||
~AudioRingBuffer();
|
||||
|
||||
|
|
|
|||
|
|
@ -13,15 +13,22 @@ HandData::HandData(AvatarData* owningAvatar) :
|
|||
_baseOrientation(0.0f, 0.0f, 0.0f, 1.0f),
|
||||
_owningAvatarData(owningAvatar)
|
||||
{
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
_palms.push_back(PalmData(this));
|
||||
// Start with two palms
|
||||
addNewPalm();
|
||||
addNewPalm();
|
||||
}
|
||||
|
||||
PalmData& HandData::addNewPalm() {
|
||||
_palms.push_back(PalmData(this));
|
||||
return _palms.back();
|
||||
}
|
||||
|
||||
PalmData::PalmData(HandData* owningHandData) :
|
||||
_rawPosition(0, 0, 0),
|
||||
_rawNormal(0, 1, 0),
|
||||
_isActive(false),
|
||||
_leapID(LEAPID_INVALID),
|
||||
_numFramesWithoutData(0),
|
||||
_owningHandData(owningHandData)
|
||||
{
|
||||
for (int i = 0; i < NUM_FINGERS_PER_HAND; ++i) {
|
||||
|
|
@ -33,9 +40,13 @@ FingerData::FingerData(PalmData* owningPalmData, HandData* owningHandData) :
|
|||
_tipRawPosition(0, 0, 0),
|
||||
_rootRawPosition(0, 0, 0),
|
||||
_isActive(false),
|
||||
_leapID(LEAPID_INVALID),
|
||||
_numFramesWithoutData(0),
|
||||
_owningPalmData(owningPalmData),
|
||||
_owningHandData(owningHandData)
|
||||
{
|
||||
const int standardTrailLength = 30;
|
||||
setTrailLength(standardTrailLength);
|
||||
}
|
||||
|
||||
void HandData::encodeRemoteData(std::vector<glm::vec3>& fingerVectors) {
|
||||
|
|
@ -80,3 +91,66 @@ void HandData::decodeRemoteData(const std::vector<glm::vec3>& fingerVectors) {
|
|||
}
|
||||
}
|
||||
|
||||
void HandData::setFingerTrailLength(unsigned int length) {
|
||||
for (size_t i = 0; i < getNumPalms(); ++i) {
|
||||
PalmData& palm = getPalms()[i];
|
||||
for (size_t f = 0; f < palm.getNumFingers(); ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
finger.setTrailLength(length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void HandData::updateFingerTrails() {
|
||||
for (size_t i = 0; i < getNumPalms(); ++i) {
|
||||
PalmData& palm = getPalms()[i];
|
||||
for (size_t f = 0; f < palm.getNumFingers(); ++f) {
|
||||
FingerData& finger = palm.getFingers()[f];
|
||||
finger.updateTrail();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void FingerData::setTrailLength(unsigned int length) {
|
||||
_tipTrailPositions.resize(length);
|
||||
_tipTrailCurrentStartIndex = 0;
|
||||
_tipTrailCurrentValidLength = 0;
|
||||
}
|
||||
|
||||
void FingerData::updateTrail() {
|
||||
if (_tipTrailPositions.size() == 0)
|
||||
return;
|
||||
|
||||
if (_isActive) {
|
||||
// Add the next point in the trail.
|
||||
_tipTrailCurrentStartIndex--;
|
||||
if (_tipTrailCurrentStartIndex < 0)
|
||||
_tipTrailCurrentStartIndex = _tipTrailPositions.size() - 1;
|
||||
|
||||
_tipTrailPositions[_tipTrailCurrentStartIndex] = getTipPosition();
|
||||
|
||||
if (_tipTrailCurrentValidLength < _tipTrailPositions.size())
|
||||
_tipTrailCurrentValidLength++;
|
||||
}
|
||||
else {
|
||||
// It's not active, so just shorten the trail.
|
||||
if (_tipTrailCurrentValidLength > 0)
|
||||
_tipTrailCurrentValidLength--;
|
||||
}
|
||||
}
|
||||
|
||||
int FingerData::getTrailNumPositions() {
|
||||
return _tipTrailCurrentValidLength;
|
||||
}
|
||||
|
||||
const glm::vec3& FingerData::getTrailPosition(int index) {
|
||||
if (index >= _tipTrailCurrentValidLength) {
|
||||
static glm::vec3 zero(0,0,0);
|
||||
return zero;
|
||||
}
|
||||
int posIndex = (index + _tipTrailCurrentStartIndex) % _tipTrailCurrentValidLength;
|
||||
return _tipTrailPositions[posIndex];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class FingerData;
|
|||
class PalmData;
|
||||
|
||||
const int NUM_FINGERS_PER_HAND = 5;
|
||||
const int LEAPID_INVALID = -1;
|
||||
|
||||
class HandData {
|
||||
public:
|
||||
|
|
@ -39,6 +40,10 @@ public:
|
|||
|
||||
std::vector<PalmData>& getPalms() { return _palms; }
|
||||
size_t getNumPalms() { return _palms.size(); }
|
||||
PalmData& addNewPalm();
|
||||
|
||||
void setFingerTrailLength(unsigned int length);
|
||||
void updateFingerTrails();
|
||||
|
||||
// Use these for sending and receiving hand data
|
||||
void encodeRemoteData(std::vector<glm::vec3>& fingerVectors);
|
||||
|
|
@ -65,15 +70,31 @@ public:
|
|||
const glm::vec3& getTipRawPosition() const { return _tipRawPosition; }
|
||||
const glm::vec3& getRootRawPosition() const { return _rootRawPosition; }
|
||||
bool isActive() const { return _isActive; }
|
||||
int getLeapID() const { return _leapID; }
|
||||
|
||||
void setActive(bool active) { _isActive = active; }
|
||||
void setLeapID(int id) { _leapID = id; }
|
||||
void setRawTipPosition(const glm::vec3& pos) { _tipRawPosition = pos; }
|
||||
void setRawRootPosition(const glm::vec3& pos) { _rootRawPosition = pos; }
|
||||
void setTrailLength(unsigned int length);
|
||||
void updateTrail();
|
||||
|
||||
int getTrailNumPositions();
|
||||
const glm::vec3& getTrailPosition(int index);
|
||||
|
||||
void incrementFramesWithoutData() { _numFramesWithoutData++; }
|
||||
void resetFramesWithoutData() { _numFramesWithoutData = 0; }
|
||||
int getFramesWithoutData() const { return _numFramesWithoutData; }
|
||||
|
||||
private:
|
||||
glm::vec3 _tipRawPosition;
|
||||
glm::vec3 _rootRawPosition;
|
||||
bool _isActive; // This has current valid data
|
||||
int _leapID; // the Leap's serial id for this tracked object
|
||||
int _numFramesWithoutData; // after too many frames without data, this tracked object assumed lost.
|
||||
std::vector<glm::vec3> _tipTrailPositions;
|
||||
int _tipTrailCurrentStartIndex;
|
||||
int _tipTrailCurrentValidLength;
|
||||
PalmData* _owningPalmData;
|
||||
HandData* _owningHandData;
|
||||
};
|
||||
|
|
@ -86,19 +107,27 @@ public:
|
|||
const glm::vec3& getRawPosition() const { return _rawPosition; }
|
||||
const glm::vec3& getRawNormal() const { return _rawNormal; }
|
||||
bool isActive() const { return _isActive; }
|
||||
int getLeapID() const { return _leapID; }
|
||||
|
||||
std::vector<FingerData>& getFingers() { return _fingers; }
|
||||
size_t getNumFingers() { return _fingers.size(); }
|
||||
|
||||
void setActive(bool active) { _isActive = active; }
|
||||
void setLeapID(int id) { _leapID = id; }
|
||||
void setRawPosition(const glm::vec3& pos) { _rawPosition = pos; }
|
||||
void setRawNormal(const glm::vec3& normal) { _rawNormal = normal; }
|
||||
|
||||
void incrementFramesWithoutData() { _numFramesWithoutData++; }
|
||||
void resetFramesWithoutData() { _numFramesWithoutData = 0; }
|
||||
int getFramesWithoutData() const { return _numFramesWithoutData; }
|
||||
|
||||
private:
|
||||
std::vector<FingerData> _fingers;
|
||||
glm::vec3 _rawPosition;
|
||||
glm::vec3 _rawNormal;
|
||||
bool _isActive; // This has current valid data
|
||||
int _leapID; // the Leap's serial id for this tracked object
|
||||
int _numFramesWithoutData; // after too many frames without data, this tracked object assumed lost.
|
||||
HandData* _owningHandData;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -14,6 +14,12 @@
|
|||
|
||||
PACKET_VERSION versionForPacketType(PACKET_TYPE type) {
|
||||
switch (type) {
|
||||
|
||||
case PACKET_TYPE_MICROPHONE_AUDIO_NO_ECHO:
|
||||
case PACKET_TYPE_MICROPHONE_AUDIO_WITH_ECHO:
|
||||
return 1;
|
||||
break;
|
||||
|
||||
case PACKET_TYPE_HEAD_DATA:
|
||||
return 2;
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -34,6 +34,7 @@ const PACKET_TYPE PACKET_TYPE_TRANSMITTER_DATA_V2 = 'T';
|
|||
const PACKET_TYPE PACKET_TYPE_ENVIRONMENT_DATA = 'e';
|
||||
const PACKET_TYPE PACKET_TYPE_DOMAIN_LIST_REQUEST = 'L';
|
||||
const PACKET_TYPE PACKET_TYPE_DOMAIN_REPORT_FOR_DUTY = 'C';
|
||||
const PACKET_TYPE PACKET_TYPE_VOXEL_STATS = '#';
|
||||
|
||||
typedef char PACKET_VERSION;
|
||||
|
||||
|
|
|
|||
|
|
@ -44,6 +44,8 @@ void VoxelNode::init(unsigned char * octalCode) {
|
|||
_children[i] = NULL;
|
||||
}
|
||||
_childCount = 0;
|
||||
_subtreeNodeCount = 1; // that's me
|
||||
_subtreeLeafNodeCount = 0; // that's me
|
||||
|
||||
_glBufferIndex = GLBUFFER_INDEX_UNKNOWN;
|
||||
_isDirty = true;
|
||||
|
|
@ -79,6 +81,24 @@ void VoxelNode::handleSubtreeChanged(VoxelTree* myTree) {
|
|||
if (myTree->getShouldReaverage()) {
|
||||
setColorFromAverageOfChildren();
|
||||
}
|
||||
|
||||
recalculateSubTreeNodeCount();
|
||||
}
|
||||
|
||||
void VoxelNode::recalculateSubTreeNodeCount() {
|
||||
// Assuming the tree below me as changed, I need to recalculate my node count
|
||||
_subtreeNodeCount = 1; // that's me
|
||||
if (isLeaf()) {
|
||||
_subtreeLeafNodeCount = 1;
|
||||
} else {
|
||||
_subtreeLeafNodeCount = 0;
|
||||
for (int i = 0; i < NUMBER_OF_CHILDREN; i++) {
|
||||
if (_children[i]) {
|
||||
_subtreeNodeCount += _children[i]->_subtreeNodeCount;
|
||||
_subtreeLeafNodeCount += _children[i]->_subtreeLeafNodeCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -107,6 +107,12 @@ public:
|
|||
|
||||
static int addDeleteHook(VoxelNodeDeleteHook hook, void* extraData = NULL);
|
||||
static void removeDeleteHook(int hookID);
|
||||
|
||||
void recalculateSubTreeNodeCount();
|
||||
unsigned long getSubTreeNodeCount() const { return _subtreeNodeCount; };
|
||||
unsigned long getSubTreeInternalNodeCount() const { return _subtreeNodeCount - _subtreeLeafNodeCount; };
|
||||
unsigned long getSubTreeLeafNodeCount() const { return _subtreeLeafNodeCount; };
|
||||
|
||||
private:
|
||||
void calculateAABox();
|
||||
void init(unsigned char * octalCode);
|
||||
|
|
@ -126,6 +132,8 @@ private:
|
|||
unsigned char* _octalCode;
|
||||
VoxelNode* _children[8];
|
||||
int _childCount;
|
||||
unsigned long _subtreeNodeCount;
|
||||
unsigned long _subtreeLeafNodeCount;
|
||||
float _density; // If leaf: density = 1, if internal node: 0-1 density of voxels inside
|
||||
|
||||
static VoxelNodeDeleteHook _hooks[VOXEL_NODE_MAX_DELETE_HOOKS];
|
||||
|
|
|
|||
556
libraries/voxels/src/VoxelSceneStats.cpp
Normal file
556
libraries/voxels/src/VoxelSceneStats.cpp
Normal file
|
|
@ -0,0 +1,556 @@
|
|||
//
|
||||
// VoxelSceneStats.cpp
|
||||
// hifi
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 7/18/13.
|
||||
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
|
||||
//
|
||||
//
|
||||
|
||||
#include <PacketHeaders.h>
|
||||
#include <SharedUtil.h>
|
||||
|
||||
#include "VoxelNode.h"
|
||||
#include "VoxelSceneStats.h"
|
||||
|
||||
|
||||
const int samples = 100;
|
||||
VoxelSceneStats::VoxelSceneStats() :
|
||||
_elapsedAverage(samples),
|
||||
_bitsPerVoxelAverage(samples)
|
||||
{
|
||||
reset();
|
||||
_isReadyToSend = false;
|
||||
_isStarted = false;
|
||||
}
|
||||
|
||||
void VoxelSceneStats::sceneStarted(bool isFullScene, bool isMoving, VoxelNode* root) {
|
||||
reset(); // resets packet and voxel stats
|
||||
_isStarted = true;
|
||||
_start = usecTimestampNow();
|
||||
_totalVoxels = root->getSubTreeNodeCount();
|
||||
_totalInternal = root->getSubTreeInternalNodeCount();
|
||||
_totalLeaves = root->getSubTreeLeafNodeCount();
|
||||
|
||||
_isFullScene = isFullScene;
|
||||
_isMoving = isMoving;
|
||||
}
|
||||
|
||||
void VoxelSceneStats::sceneCompleted() {
|
||||
if (_isStarted) {
|
||||
_end = usecTimestampNow();
|
||||
_elapsed = _end - _start;
|
||||
_elapsedAverage.updateAverage((float)_elapsed);
|
||||
|
||||
_statsMessageLength = packIntoMessage(_statsMessage, sizeof(_statsMessage));
|
||||
_isReadyToSend = true;
|
||||
_isStarted = false;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::encodeStarted() {
|
||||
_encodeStart = usecTimestampNow();
|
||||
}
|
||||
|
||||
void VoxelSceneStats::encodeStopped() {
|
||||
_totalEncodeTime += (usecTimestampNow() - _encodeStart);
|
||||
}
|
||||
|
||||
void VoxelSceneStats::reset() {
|
||||
_totalEncodeTime = 0;
|
||||
_encodeStart = 0;
|
||||
|
||||
_packets = 0;
|
||||
_bytes = 0;
|
||||
_passes = 0;
|
||||
|
||||
_totalVoxels = 0;
|
||||
_totalInternal = 0;
|
||||
_totalLeaves = 0;
|
||||
|
||||
_traversed = 0;
|
||||
_internal = 0;
|
||||
_leaves = 0;
|
||||
|
||||
_skippedDistance = 0;
|
||||
_internalSkippedDistance = 0;
|
||||
_leavesSkippedDistance = 0;
|
||||
|
||||
_skippedOutOfView = 0;
|
||||
_internalSkippedOutOfView = 0;
|
||||
_leavesSkippedOutOfView = 0;
|
||||
|
||||
_skippedWasInView = 0;
|
||||
_internalSkippedWasInView = 0;
|
||||
_leavesSkippedWasInView = 0;
|
||||
|
||||
_skippedNoChange = 0;
|
||||
_internalSkippedNoChange = 0;
|
||||
_leavesSkippedNoChange = 0;
|
||||
|
||||
_skippedOccluded = 0;
|
||||
_internalSkippedOccluded = 0;
|
||||
_leavesSkippedOccluded = 0;
|
||||
|
||||
_colorSent = 0;
|
||||
_internalColorSent = 0;
|
||||
_leavesColorSent = 0;
|
||||
|
||||
_didntFit = 0;
|
||||
_internalDidntFit = 0;
|
||||
_leavesDidntFit = 0;
|
||||
|
||||
_colorBitsWritten = 0;
|
||||
_existsBitsWritten = 0;
|
||||
_existsInPacketBitsWritten = 0;
|
||||
_treesRemoved = 0;
|
||||
}
|
||||
|
||||
void VoxelSceneStats::packetSent(int bytes) {
|
||||
_packets++;
|
||||
_bytes += bytes;
|
||||
}
|
||||
|
||||
void VoxelSceneStats::traversed(const VoxelNode* node) {
|
||||
_traversed++;
|
||||
if (node->isLeaf()) {
|
||||
_leaves++;
|
||||
} else {
|
||||
_internal++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::skippedDistance(const VoxelNode* node) {
|
||||
_skippedDistance++;
|
||||
if (node->isLeaf()) {
|
||||
_leavesSkippedDistance++;
|
||||
} else {
|
||||
_internalSkippedDistance++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::skippedOutOfView(const VoxelNode* node) {
|
||||
_skippedOutOfView++;
|
||||
if (node->isLeaf()) {
|
||||
_leavesSkippedOutOfView++;
|
||||
} else {
|
||||
_internalSkippedOutOfView++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::skippedWasInView(const VoxelNode* node) {
|
||||
_skippedWasInView++;
|
||||
if (node->isLeaf()) {
|
||||
_leavesSkippedWasInView++;
|
||||
} else {
|
||||
_internalSkippedWasInView++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::skippedNoChange(const VoxelNode* node) {
|
||||
_skippedNoChange++;
|
||||
if (node->isLeaf()) {
|
||||
_leavesSkippedNoChange++;
|
||||
} else {
|
||||
_internalSkippedNoChange++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::skippedOccluded(const VoxelNode* node) {
|
||||
_skippedOccluded++;
|
||||
if (node->isLeaf()) {
|
||||
_leavesSkippedOccluded++;
|
||||
} else {
|
||||
_internalSkippedOccluded++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::colorSent(const VoxelNode* node) {
|
||||
_colorSent++;
|
||||
if (node->isLeaf()) {
|
||||
_leavesColorSent++;
|
||||
} else {
|
||||
_internalColorSent++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::didntFit(const VoxelNode* node) {
|
||||
_didntFit++;
|
||||
if (node->isLeaf()) {
|
||||
_leavesDidntFit++;
|
||||
} else {
|
||||
_internalDidntFit++;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelSceneStats::colorBitsWritten() {
|
||||
_colorBitsWritten++;
|
||||
}
|
||||
|
||||
void VoxelSceneStats::existsBitsWritten() {
|
||||
_existsBitsWritten++;
|
||||
}
|
||||
|
||||
void VoxelSceneStats::existsInPacketBitsWritten() {
|
||||
_existsInPacketBitsWritten++;
|
||||
}
|
||||
|
||||
void VoxelSceneStats::childBitsRemoved(bool includesExistsBits, bool includesColors) {
|
||||
_existsInPacketBitsWritten--;
|
||||
if (includesExistsBits) {
|
||||
_existsBitsWritten--;
|
||||
}
|
||||
if (includesColors) {
|
||||
_colorBitsWritten--;
|
||||
}
|
||||
_treesRemoved++;
|
||||
}
|
||||
|
||||
int VoxelSceneStats::packIntoMessage(unsigned char* destinationBuffer, int availableBytes) {
|
||||
unsigned char* bufferStart = destinationBuffer;
|
||||
|
||||
int headerLength = populateTypeAndVersion(destinationBuffer, PACKET_TYPE_VOXEL_STATS);
|
||||
destinationBuffer += headerLength;
|
||||
|
||||
memcpy(destinationBuffer, &_start, sizeof(_start));
|
||||
destinationBuffer += sizeof(_start);
|
||||
memcpy(destinationBuffer, &_end, sizeof(_end));
|
||||
destinationBuffer += sizeof(_end);
|
||||
memcpy(destinationBuffer, &_elapsed, sizeof(_elapsed));
|
||||
destinationBuffer += sizeof(_elapsed);
|
||||
memcpy(destinationBuffer, &_totalEncodeTime, sizeof(_totalEncodeTime));
|
||||
destinationBuffer += sizeof(_totalEncodeTime);
|
||||
memcpy(destinationBuffer, &_isFullScene, sizeof(_isFullScene));
|
||||
destinationBuffer += sizeof(_isFullScene);
|
||||
memcpy(destinationBuffer, &_isMoving, sizeof(_isMoving));
|
||||
destinationBuffer += sizeof(_isMoving);
|
||||
memcpy(destinationBuffer, &_packets, sizeof(_packets));
|
||||
destinationBuffer += sizeof(_packets);
|
||||
memcpy(destinationBuffer, &_bytes, sizeof(_bytes));
|
||||
destinationBuffer += sizeof(_bytes);
|
||||
|
||||
memcpy(destinationBuffer, &_totalInternal, sizeof(_totalInternal));
|
||||
destinationBuffer += sizeof(_totalInternal);
|
||||
memcpy(destinationBuffer, &_totalLeaves, sizeof(_totalLeaves));
|
||||
destinationBuffer += sizeof(_totalLeaves);
|
||||
memcpy(destinationBuffer, &_internal, sizeof(_internal));
|
||||
destinationBuffer += sizeof(_internal);
|
||||
memcpy(destinationBuffer, &_leaves, sizeof(_leaves));
|
||||
destinationBuffer += sizeof(_leaves);
|
||||
memcpy(destinationBuffer, &_internalSkippedDistance, sizeof(_internalSkippedDistance));
|
||||
destinationBuffer += sizeof(_internalSkippedDistance);
|
||||
memcpy(destinationBuffer, &_leavesSkippedDistance, sizeof(_leavesSkippedDistance));
|
||||
destinationBuffer += sizeof(_leavesSkippedDistance);
|
||||
memcpy(destinationBuffer, &_internalSkippedOutOfView, sizeof(_internalSkippedOutOfView));
|
||||
destinationBuffer += sizeof(_internalSkippedOutOfView);
|
||||
memcpy(destinationBuffer, &_leavesSkippedOutOfView, sizeof(_leavesSkippedOutOfView));
|
||||
destinationBuffer += sizeof(_leavesSkippedOutOfView);
|
||||
memcpy(destinationBuffer, &_internalSkippedWasInView, sizeof(_internalSkippedWasInView));
|
||||
destinationBuffer += sizeof(_internalSkippedWasInView);
|
||||
memcpy(destinationBuffer, &_leavesSkippedWasInView, sizeof(_leavesSkippedWasInView));
|
||||
destinationBuffer += sizeof(_leavesSkippedWasInView);
|
||||
memcpy(destinationBuffer, &_internalSkippedNoChange, sizeof(_internalSkippedNoChange));
|
||||
destinationBuffer += sizeof(_internalSkippedNoChange);
|
||||
memcpy(destinationBuffer, &_leavesSkippedNoChange, sizeof(_leavesSkippedNoChange));
|
||||
destinationBuffer += sizeof(_leavesSkippedNoChange);
|
||||
memcpy(destinationBuffer, &_internalSkippedOccluded, sizeof(_internalSkippedOccluded));
|
||||
destinationBuffer += sizeof(_internalSkippedOccluded);
|
||||
memcpy(destinationBuffer, &_leavesSkippedOccluded, sizeof(_leavesSkippedOccluded));
|
||||
destinationBuffer += sizeof(_leavesSkippedOccluded);
|
||||
memcpy(destinationBuffer, &_internalColorSent, sizeof(_internalColorSent));
|
||||
destinationBuffer += sizeof(_internalColorSent);
|
||||
memcpy(destinationBuffer, &_leavesColorSent, sizeof(_leavesColorSent));
|
||||
destinationBuffer += sizeof(_leavesColorSent);
|
||||
memcpy(destinationBuffer, &_internalDidntFit, sizeof(_internalDidntFit));
|
||||
destinationBuffer += sizeof(_internalDidntFit);
|
||||
memcpy(destinationBuffer, &_leavesDidntFit, sizeof(_leavesDidntFit));
|
||||
destinationBuffer += sizeof(_leavesDidntFit);
|
||||
memcpy(destinationBuffer, &_colorBitsWritten, sizeof(_colorBitsWritten));
|
||||
destinationBuffer += sizeof(_colorBitsWritten);
|
||||
memcpy(destinationBuffer, &_existsBitsWritten, sizeof(_existsBitsWritten));
|
||||
destinationBuffer += sizeof(_existsBitsWritten);
|
||||
memcpy(destinationBuffer, &_existsInPacketBitsWritten, sizeof(_existsInPacketBitsWritten));
|
||||
destinationBuffer += sizeof(_existsInPacketBitsWritten);
|
||||
memcpy(destinationBuffer, &_treesRemoved, sizeof(_treesRemoved));
|
||||
destinationBuffer += sizeof(_treesRemoved);
|
||||
|
||||
return destinationBuffer - bufferStart; // includes header!
|
||||
}
|
||||
|
||||
int VoxelSceneStats::unpackFromMessage(unsigned char* sourceBuffer, int availableBytes) {
|
||||
unsigned char* startPosition = sourceBuffer;
|
||||
|
||||
// increment to push past the packet header
|
||||
int numBytesPacketHeader = numBytesForPacketHeader(sourceBuffer);
|
||||
sourceBuffer += numBytesPacketHeader;
|
||||
|
||||
memcpy(&_start, sourceBuffer, sizeof(_start));
|
||||
sourceBuffer += sizeof(_start);
|
||||
memcpy(&_end, sourceBuffer, sizeof(_end));
|
||||
sourceBuffer += sizeof(_end);
|
||||
memcpy(&_elapsed, sourceBuffer, sizeof(_elapsed));
|
||||
sourceBuffer += sizeof(_elapsed);
|
||||
memcpy(&_totalEncodeTime, sourceBuffer, sizeof(_totalEncodeTime));
|
||||
sourceBuffer += sizeof(_totalEncodeTime);
|
||||
memcpy(&_isFullScene, sourceBuffer, sizeof(_isFullScene));
|
||||
sourceBuffer += sizeof(_isFullScene);
|
||||
memcpy(&_isMoving, sourceBuffer, sizeof(_isMoving));
|
||||
sourceBuffer += sizeof(_isMoving);
|
||||
memcpy(&_packets, sourceBuffer, sizeof(_packets));
|
||||
sourceBuffer += sizeof(_packets);
|
||||
memcpy(&_bytes, sourceBuffer, sizeof(_bytes));
|
||||
sourceBuffer += sizeof(_bytes);
|
||||
|
||||
memcpy(&_totalInternal, sourceBuffer, sizeof(_totalInternal));
|
||||
sourceBuffer += sizeof(_totalInternal);
|
||||
memcpy(&_totalLeaves, sourceBuffer, sizeof(_totalLeaves));
|
||||
sourceBuffer += sizeof(_totalLeaves);
|
||||
_totalVoxels = _totalInternal + _totalLeaves;
|
||||
|
||||
memcpy(&_internal, sourceBuffer, sizeof(_internal));
|
||||
sourceBuffer += sizeof(_internal);
|
||||
memcpy(&_leaves, sourceBuffer, sizeof(_leaves));
|
||||
sourceBuffer += sizeof(_leaves);
|
||||
_traversed = _internal + _leaves;
|
||||
|
||||
memcpy(&_internalSkippedDistance, sourceBuffer, sizeof(_internalSkippedDistance));
|
||||
sourceBuffer += sizeof(_internalSkippedDistance);
|
||||
memcpy(&_leavesSkippedDistance, sourceBuffer, sizeof(_leavesSkippedDistance));
|
||||
sourceBuffer += sizeof(_leavesSkippedDistance);
|
||||
_skippedDistance = _internalSkippedDistance + _leavesSkippedDistance;
|
||||
|
||||
memcpy(&_internalSkippedOutOfView, sourceBuffer, sizeof(_internalSkippedOutOfView));
|
||||
sourceBuffer += sizeof(_internalSkippedOutOfView);
|
||||
memcpy(&_leavesSkippedOutOfView, sourceBuffer, sizeof(_leavesSkippedOutOfView));
|
||||
sourceBuffer += sizeof(_leavesSkippedOutOfView);
|
||||
_skippedOutOfView = _internalSkippedOutOfView + _leavesSkippedOutOfView;
|
||||
|
||||
memcpy(&_internalSkippedWasInView, sourceBuffer, sizeof(_internalSkippedWasInView));
|
||||
sourceBuffer += sizeof(_internalSkippedWasInView);
|
||||
memcpy(&_leavesSkippedWasInView, sourceBuffer, sizeof(_leavesSkippedWasInView));
|
||||
sourceBuffer += sizeof(_leavesSkippedWasInView);
|
||||
_skippedWasInView = _internalSkippedWasInView + _leavesSkippedWasInView;
|
||||
|
||||
memcpy(&_internalSkippedNoChange, sourceBuffer, sizeof(_internalSkippedNoChange));
|
||||
sourceBuffer += sizeof(_internalSkippedNoChange);
|
||||
memcpy(&_leavesSkippedNoChange, sourceBuffer, sizeof(_leavesSkippedNoChange));
|
||||
sourceBuffer += sizeof(_leavesSkippedNoChange);
|
||||
_skippedNoChange = _internalSkippedNoChange + _leavesSkippedNoChange;
|
||||
|
||||
memcpy(&_internalSkippedOccluded, sourceBuffer, sizeof(_internalSkippedOccluded));
|
||||
sourceBuffer += sizeof(_internalSkippedOccluded);
|
||||
memcpy(&_leavesSkippedOccluded, sourceBuffer, sizeof(_leavesSkippedOccluded));
|
||||
sourceBuffer += sizeof(_leavesSkippedOccluded);
|
||||
_skippedOccluded = _internalSkippedOccluded + _leavesSkippedOccluded;
|
||||
|
||||
memcpy(&_internalColorSent, sourceBuffer, sizeof(_internalColorSent));
|
||||
sourceBuffer += sizeof(_internalColorSent);
|
||||
memcpy(&_leavesColorSent, sourceBuffer, sizeof(_leavesColorSent));
|
||||
sourceBuffer += sizeof(_leavesColorSent);
|
||||
_colorSent = _internalColorSent + _leavesColorSent;
|
||||
|
||||
memcpy(&_internalDidntFit, sourceBuffer, sizeof(_internalDidntFit));
|
||||
sourceBuffer += sizeof(_internalDidntFit);
|
||||
memcpy(&_leavesDidntFit, sourceBuffer, sizeof(_leavesDidntFit));
|
||||
sourceBuffer += sizeof(_leavesDidntFit);
|
||||
_didntFit = _internalDidntFit + _leavesDidntFit;
|
||||
|
||||
memcpy(&_colorBitsWritten, sourceBuffer, sizeof(_colorBitsWritten));
|
||||
sourceBuffer += sizeof(_colorBitsWritten);
|
||||
memcpy(&_existsBitsWritten, sourceBuffer, sizeof(_existsBitsWritten));
|
||||
sourceBuffer += sizeof(_existsBitsWritten);
|
||||
memcpy(&_existsInPacketBitsWritten, sourceBuffer, sizeof(_existsInPacketBitsWritten));
|
||||
sourceBuffer += sizeof(_existsInPacketBitsWritten);
|
||||
memcpy(&_treesRemoved, sourceBuffer, sizeof(_treesRemoved));
|
||||
sourceBuffer += sizeof(_treesRemoved);
|
||||
|
||||
// running averages
|
||||
_elapsedAverage.updateAverage((float)_elapsed);
|
||||
unsigned long total = _existsInPacketBitsWritten + _colorSent;
|
||||
float calculatedBPV = total == 0 ? 0 : (_bytes * 8) / total;
|
||||
_bitsPerVoxelAverage.updateAverage(calculatedBPV);
|
||||
|
||||
|
||||
return sourceBuffer - startPosition; // includes header!
|
||||
}
|
||||
|
||||
|
||||
void VoxelSceneStats::printDebugDetails() {
|
||||
qDebug("\n------------------------------\n");
|
||||
qDebug("VoxelSceneStats:\n");
|
||||
qDebug(" start : %llu \n", _start);
|
||||
qDebug(" end : %llu \n", _end);
|
||||
qDebug(" elapsed : %llu \n", _elapsed);
|
||||
qDebug(" encoding : %llu \n", _totalEncodeTime);
|
||||
qDebug("\n");
|
||||
qDebug(" full scene: %s\n", debug::valueOf(_isFullScene));
|
||||
qDebug(" moving: %s\n", debug::valueOf(_isMoving));
|
||||
qDebug("\n");
|
||||
qDebug(" packets: %d\n", _packets);
|
||||
qDebug(" bytes : %ld\n", _bytes);
|
||||
qDebug("\n");
|
||||
qDebug(" total voxels : %lu\n", _totalVoxels );
|
||||
qDebug(" internal : %lu\n", _totalInternal );
|
||||
qDebug(" leaves : %lu\n", _totalLeaves );
|
||||
qDebug(" traversed : %lu\n", _traversed );
|
||||
qDebug(" internal : %lu\n", _internal );
|
||||
qDebug(" leaves : %lu\n", _leaves );
|
||||
qDebug(" skipped distance : %lu\n", _skippedDistance );
|
||||
qDebug(" internal : %lu\n", _internalSkippedDistance );
|
||||
qDebug(" leaves : %lu\n", _leavesSkippedDistance );
|
||||
qDebug(" skipped out of view : %lu\n", _skippedOutOfView );
|
||||
qDebug(" internal : %lu\n", _internalSkippedOutOfView );
|
||||
qDebug(" leaves : %lu\n", _leavesSkippedOutOfView );
|
||||
qDebug(" skipped was in view : %lu\n", _skippedWasInView );
|
||||
qDebug(" internal : %lu\n", _internalSkippedWasInView );
|
||||
qDebug(" leaves : %lu\n", _leavesSkippedWasInView );
|
||||
qDebug(" skipped no change : %lu\n", _skippedNoChange );
|
||||
qDebug(" internal : %lu\n", _internalSkippedNoChange );
|
||||
qDebug(" leaves : %lu\n", _leavesSkippedNoChange );
|
||||
qDebug(" skipped occluded : %lu\n", _skippedOccluded );
|
||||
qDebug(" internal : %lu\n", _internalSkippedOccluded );
|
||||
qDebug(" leaves : %lu\n", _leavesSkippedOccluded );
|
||||
|
||||
qDebug("\n");
|
||||
qDebug(" color sent : %lu\n", _colorSent );
|
||||
qDebug(" internal : %lu\n", _internalColorSent );
|
||||
qDebug(" leaves : %lu\n", _leavesColorSent );
|
||||
qDebug(" Didn't Fit : %lu\n", _didntFit );
|
||||
qDebug(" internal : %lu\n", _internalDidntFit );
|
||||
qDebug(" leaves : %lu\n", _leavesDidntFit );
|
||||
qDebug(" color bits : %lu\n", _colorBitsWritten );
|
||||
qDebug(" exists bits : %lu\n", _existsBitsWritten );
|
||||
qDebug(" in packet bit : %lu\n", _existsInPacketBitsWritten);
|
||||
qDebug(" trees removed : %lu\n", _treesRemoved );
|
||||
}
|
||||
|
||||
const unsigned greenish = 0x40ff40d0;
|
||||
const unsigned yellowish = 0xffef40c0;
|
||||
const unsigned greyish = 0xd0d0d0a0;
|
||||
|
||||
VoxelSceneStats::ItemInfo VoxelSceneStats::_ITEMS[] = {
|
||||
{ "Elapsed" , greenish },
|
||||
{ "Encode" , yellowish },
|
||||
{ "Network" , greyish },
|
||||
{ "Voxels on Server" , greenish },
|
||||
{ "Voxels Sent" , yellowish },
|
||||
{ "Colors Sent" , greyish },
|
||||
{ "Bitmasks Sent" , greenish },
|
||||
{ "Traversed" , yellowish },
|
||||
{ "Skipped - Total" , greyish },
|
||||
{ "Skipped - Distance" , greenish },
|
||||
{ "Skipped - Out of View", yellowish },
|
||||
{ "Skipped - Was in View", greyish },
|
||||
{ "Skipped - No Change" , greenish },
|
||||
{ "Skipped - Occluded" , yellowish },
|
||||
{ "Didn't fit in packet" , greyish },
|
||||
{ "Mode" , greenish },
|
||||
};
|
||||
|
||||
char* VoxelSceneStats::getItemValue(int item) {
|
||||
const uint64_t USECS_PER_SECOND = 1000 * 1000;
|
||||
int calcFPS, calcAverageFPS, calculatedKBPS;
|
||||
switch(item) {
|
||||
case ITEM_ELAPSED: {
|
||||
calcFPS = (float)USECS_PER_SECOND / (float)_elapsed;
|
||||
float elapsedAverage = _elapsedAverage.getAverage();
|
||||
calcAverageFPS = (float)USECS_PER_SECOND / (float)elapsedAverage;
|
||||
|
||||
sprintf(_itemValueBuffer, "%llu usecs (%d fps) Average: %.0f usecs (%d fps)",
|
||||
_elapsed, calcFPS, elapsedAverage, calcAverageFPS);
|
||||
break;
|
||||
}
|
||||
case ITEM_ENCODE:
|
||||
calcFPS = (float)USECS_PER_SECOND / (float)_totalEncodeTime;
|
||||
sprintf(_itemValueBuffer, "%llu usecs (%d fps)", _totalEncodeTime, calcFPS);
|
||||
break;
|
||||
case ITEM_PACKETS: {
|
||||
float elapsedSecs = ((float)_elapsed / (float)USECS_PER_SECOND);
|
||||
calculatedKBPS = elapsedSecs == 0 ? 0 : ((_bytes * 8) / elapsedSecs) / 1000;
|
||||
sprintf(_itemValueBuffer, "%d packets %lu bytes (%d kbps)", _packets, _bytes, calculatedKBPS);
|
||||
break;
|
||||
}
|
||||
case ITEM_VOXELS_SERVER: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_totalVoxels, _totalInternal, _totalLeaves);
|
||||
break;
|
||||
}
|
||||
case ITEM_VOXELS: {
|
||||
unsigned long total = _existsInPacketBitsWritten + _colorSent;
|
||||
float calculatedBPV = total == 0 ? 0 : (_bytes * 8) / total;
|
||||
float averageBPV = _bitsPerVoxelAverage.getAverage();
|
||||
sprintf(_itemValueBuffer, "%lu (%.2f bits/voxel Average: %.2f bits/voxel) %lu internal %lu leaves",
|
||||
total, calculatedBPV, averageBPV, _existsInPacketBitsWritten, _colorSent);
|
||||
break;
|
||||
}
|
||||
case ITEM_TRAVERSED: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_traversed, _internal, _leaves);
|
||||
break;
|
||||
}
|
||||
case ITEM_SKIPPED: {
|
||||
unsigned long total = _skippedDistance + _skippedOutOfView +
|
||||
_skippedWasInView + _skippedNoChange + _skippedOccluded;
|
||||
|
||||
unsigned long internal = _internalSkippedDistance + _internalSkippedOutOfView +
|
||||
_internalSkippedWasInView + _internalSkippedNoChange + _internalSkippedOccluded;
|
||||
|
||||
unsigned long leaves = _leavesSkippedDistance + _leavesSkippedOutOfView +
|
||||
_leavesSkippedWasInView + _leavesSkippedNoChange + _leavesSkippedOccluded;
|
||||
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
total, internal, leaves);
|
||||
break;
|
||||
}
|
||||
case ITEM_SKIPPED_DISTANCE: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_skippedDistance, _internalSkippedDistance, _leavesSkippedDistance);
|
||||
break;
|
||||
}
|
||||
case ITEM_SKIPPED_OUT_OF_VIEW: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_skippedOutOfView, _internalSkippedOutOfView, _leavesSkippedOutOfView);
|
||||
break;
|
||||
}
|
||||
case ITEM_SKIPPED_WAS_IN_VIEW: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_skippedWasInView, _internalSkippedWasInView, _leavesSkippedWasInView);
|
||||
break;
|
||||
}
|
||||
case ITEM_SKIPPED_NO_CHANGE: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_skippedNoChange, _internalSkippedNoChange, _leavesSkippedNoChange);
|
||||
break;
|
||||
}
|
||||
case ITEM_SKIPPED_OCCLUDED: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_skippedOccluded, _internalSkippedOccluded, _leavesSkippedOccluded);
|
||||
break;
|
||||
}
|
||||
case ITEM_COLORS: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves",
|
||||
_colorSent, _internalColorSent, _leavesColorSent);
|
||||
break;
|
||||
}
|
||||
case ITEM_DIDNT_FIT: {
|
||||
sprintf(_itemValueBuffer, "%lu total %lu internal %lu leaves (removed: %lu)",
|
||||
_didntFit, _internalDidntFit, _leavesDidntFit, _treesRemoved);
|
||||
break;
|
||||
}
|
||||
case ITEM_BITS: {
|
||||
sprintf(_itemValueBuffer, "colors: %lu, exists: %lu, in packets: %lu",
|
||||
_colorBitsWritten, _existsBitsWritten, _existsInPacketBitsWritten);
|
||||
break;
|
||||
}
|
||||
case ITEM_MODE: {
|
||||
sprintf(_itemValueBuffer, "%s - %s", (_isFullScene ? "Full Scene" : "Partial Scene"),
|
||||
(_isMoving ? "Moving" : "Stationary"));
|
||||
break;
|
||||
}
|
||||
default:
|
||||
sprintf(_itemValueBuffer, "");
|
||||
break;
|
||||
}
|
||||
return _itemValueBuffer;
|
||||
}
|
||||
|
||||
170
libraries/voxels/src/VoxelSceneStats.h
Normal file
170
libraries/voxels/src/VoxelSceneStats.h
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
//
|
||||
// VoxelSceneStats.h
|
||||
// hifi
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 7/18/13.
|
||||
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
|
||||
//
|
||||
//
|
||||
|
||||
#ifndef __hifi__VoxelSceneStats__
|
||||
#define __hifi__VoxelSceneStats__
|
||||
|
||||
#include <stdint.h>
|
||||
#include <NodeList.h>
|
||||
|
||||
class VoxelNode;
|
||||
|
||||
class VoxelSceneStats {
|
||||
public:
|
||||
VoxelSceneStats();
|
||||
void reset();
|
||||
void sceneStarted(bool fullScene, bool moving, VoxelNode* root);
|
||||
void sceneCompleted();
|
||||
|
||||
void printDebugDetails();
|
||||
void packetSent(int bytes);
|
||||
|
||||
void encodeStarted();
|
||||
void encodeStopped();
|
||||
|
||||
void traversed(const VoxelNode* node);
|
||||
void skippedDistance(const VoxelNode* node);
|
||||
void skippedOutOfView(const VoxelNode* node);
|
||||
void skippedWasInView(const VoxelNode* node);
|
||||
void skippedNoChange(const VoxelNode* node);
|
||||
void skippedOccluded(const VoxelNode* node);
|
||||
void colorSent(const VoxelNode* node);
|
||||
void didntFit(const VoxelNode* node);
|
||||
void colorBitsWritten();
|
||||
void existsBitsWritten();
|
||||
void existsInPacketBitsWritten();
|
||||
void childBitsRemoved(bool includesExistsBits, bool includesColors);
|
||||
|
||||
int packIntoMessage(unsigned char* destinationBuffer, int availableBytes);
|
||||
int unpackFromMessage(unsigned char* sourceBuffer, int availableBytes);
|
||||
|
||||
bool isReadyToSend() const { return _isReadyToSend; }
|
||||
void markAsSent() { _isReadyToSend = false; }
|
||||
unsigned char* getStatsMessage() { return &_statsMessage[0]; }
|
||||
int getStatsMessageLength() const { return _statsMessageLength; }
|
||||
|
||||
enum {
|
||||
ITEM_ELAPSED,
|
||||
ITEM_ENCODE,
|
||||
ITEM_PACKETS,
|
||||
ITEM_VOXELS_SERVER,
|
||||
ITEM_VOXELS,
|
||||
ITEM_COLORS,
|
||||
ITEM_BITS,
|
||||
ITEM_TRAVERSED,
|
||||
ITEM_SKIPPED,
|
||||
ITEM_SKIPPED_DISTANCE,
|
||||
ITEM_SKIPPED_OUT_OF_VIEW,
|
||||
ITEM_SKIPPED_WAS_IN_VIEW,
|
||||
ITEM_SKIPPED_NO_CHANGE,
|
||||
ITEM_SKIPPED_OCCLUDED,
|
||||
ITEM_DIDNT_FIT,
|
||||
ITEM_MODE,
|
||||
ITEM_COUNT
|
||||
};
|
||||
|
||||
// Meta information about each stats item
|
||||
struct ItemInfo {
|
||||
char const* const caption;
|
||||
unsigned colorRGBA;
|
||||
};
|
||||
|
||||
ItemInfo& getItemInfo(int item) { return _ITEMS[item]; };
|
||||
char* getItemValue(int item);
|
||||
|
||||
private:
|
||||
bool _isReadyToSend;
|
||||
unsigned char _statsMessage[MAX_PACKET_SIZE];
|
||||
int _statsMessageLength;
|
||||
|
||||
// scene timing data in usecs
|
||||
bool _isStarted;
|
||||
uint64_t _start;
|
||||
uint64_t _end;
|
||||
uint64_t _elapsed;
|
||||
|
||||
SimpleMovingAverage _elapsedAverage;
|
||||
SimpleMovingAverage _bitsPerVoxelAverage;
|
||||
|
||||
uint64_t _totalEncodeTime;
|
||||
uint64_t _encodeStart;
|
||||
|
||||
// scene voxel related data
|
||||
unsigned long _totalVoxels;
|
||||
unsigned long _totalInternal;
|
||||
unsigned long _totalLeaves;
|
||||
|
||||
unsigned long _traversed;
|
||||
unsigned long _internal;
|
||||
unsigned long _leaves;
|
||||
|
||||
unsigned long _skippedDistance;
|
||||
unsigned long _internalSkippedDistance;
|
||||
unsigned long _leavesSkippedDistance;
|
||||
|
||||
unsigned long _skippedOutOfView;
|
||||
unsigned long _internalSkippedOutOfView;
|
||||
unsigned long _leavesSkippedOutOfView;
|
||||
|
||||
unsigned long _skippedWasInView;
|
||||
unsigned long _internalSkippedWasInView;
|
||||
unsigned long _leavesSkippedWasInView;
|
||||
|
||||
unsigned long _skippedNoChange;
|
||||
unsigned long _internalSkippedNoChange;
|
||||
unsigned long _leavesSkippedNoChange;
|
||||
|
||||
unsigned long _skippedOccluded;
|
||||
unsigned long _internalSkippedOccluded;
|
||||
unsigned long _leavesSkippedOccluded;
|
||||
|
||||
unsigned long _colorSent;
|
||||
unsigned long _internalColorSent;
|
||||
unsigned long _leavesColorSent;
|
||||
|
||||
unsigned long _didntFit;
|
||||
unsigned long _internalDidntFit;
|
||||
unsigned long _leavesDidntFit;
|
||||
|
||||
unsigned long _colorBitsWritten;
|
||||
unsigned long _existsBitsWritten;
|
||||
unsigned long _existsInPacketBitsWritten;
|
||||
unsigned long _treesRemoved;
|
||||
|
||||
// Accounting Notes:
|
||||
//
|
||||
// 1) number of voxels sent can be calculated as _colorSent + _colorBitsWritten. This works because each internal
|
||||
// node in a packet will have a _colorBitsWritten included for it and each "leaf" in the packet will have a
|
||||
// _colorSent written for it. Note that these "leaf" nodes in the packets may not be actual leaves in the full
|
||||
// tree, because LOD may cause us to send an average color for an internal node instead of recursing deeper to
|
||||
// the leaves.
|
||||
//
|
||||
// 2) the stats balance if: (working assumption)
|
||||
// if _colorSent > 0
|
||||
// _traversed = all skipped + _colorSent + _colorBitsWritten
|
||||
// else
|
||||
// _traversed = all skipped + _colorSent + _colorBitsWritten + _treesRemoved
|
||||
//
|
||||
|
||||
// scene network related data
|
||||
unsigned int _packets;
|
||||
unsigned long _bytes;
|
||||
unsigned int _passes;
|
||||
|
||||
// features related items
|
||||
bool _isMoving;
|
||||
bool _isFullScene;
|
||||
|
||||
|
||||
static ItemInfo _ITEMS[];
|
||||
static int const MAX_ITEM_VALUE_LENGTH = 128;
|
||||
char _itemValueBuffer[MAX_ITEM_VALUE_LENGTH];
|
||||
};
|
||||
|
||||
#endif /* defined(__hifi__VoxelSceneStats__) */
|
||||
|
|
@ -673,6 +673,9 @@ void VoxelTree::reaverageVoxelColors(VoxelNode *startNode) {
|
|||
if (hasChildren && !startNode->collapseIdenticalLeaves()) {
|
||||
startNode->setColorFromAverageOfChildren();
|
||||
}
|
||||
|
||||
// this is also a good time to recalculateSubTreeNodeCount()
|
||||
startNode->recalculateSubTreeNodeCount();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1037,6 +1040,13 @@ int VoxelTree::encodeTreeBitstream(VoxelNode* node, unsigned char* outputBuffer,
|
|||
availableBytes -= codeLength; // keep track or remaining space
|
||||
|
||||
int currentEncodeLevel = 0;
|
||||
|
||||
// record some stats, this is the one node that we won't record below in the recursion function, so we need to
|
||||
// track it here
|
||||
if (params.stats) {
|
||||
params.stats->traversed(node);
|
||||
}
|
||||
|
||||
int childBytesWritten = encodeTreeBitstreamRecursion(node, outputBuffer, availableBytes, bag, params, currentEncodeLevel);
|
||||
|
||||
// if childBytesWritten == 1 then something went wrong... that's not possible
|
||||
|
|
@ -1061,6 +1071,9 @@ int VoxelTree::encodeTreeBitstream(VoxelNode* node, unsigned char* outputBuffer,
|
|||
int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outputBuffer, int availableBytes, VoxelNodeBag& bag,
|
||||
EncodeBitstreamParams& params, int& currentEncodeLevel) const {
|
||||
|
||||
// you can't call this without a valid node
|
||||
assert(node);
|
||||
|
||||
// How many bytes have we written so far at this level;
|
||||
int bytesAtThisLevel = 0;
|
||||
|
||||
|
|
@ -1081,6 +1094,9 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
|
||||
// If we're too far away for our render level, then just return
|
||||
if (distance >= boundaryDistance) {
|
||||
if (params.stats) {
|
||||
params.stats->skippedDistance(node);
|
||||
}
|
||||
return bytesAtThisLevel;
|
||||
}
|
||||
|
||||
|
|
@ -1088,6 +1104,9 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
// although technically, we really shouldn't ever be here, because our callers shouldn't be calling us if
|
||||
// we're out of view
|
||||
if (!node->isInView(*params.viewFrustum)) {
|
||||
if (params.stats) {
|
||||
params.stats->skippedOutOfView(node);
|
||||
}
|
||||
return bytesAtThisLevel;
|
||||
}
|
||||
|
||||
|
|
@ -1110,6 +1129,9 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
// if we're in deltaViewFrustum mode, and this node has changed since it was last sent, then we do
|
||||
// need to send it.
|
||||
if (wasInView && !(params.deltaViewFrustum && node->hasChangedSince(params.lastViewFrustumSent - CHANGE_FUDGE))) {
|
||||
if (params.stats) {
|
||||
params.stats->skippedWasInView(node);
|
||||
}
|
||||
return bytesAtThisLevel;
|
||||
}
|
||||
|
||||
|
|
@ -1117,6 +1139,9 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
// then we can also bail early and save bits
|
||||
if (!params.forceSendScene && !params.deltaViewFrustum &&
|
||||
!node->hasChangedSince(params.lastViewFrustumSent - CHANGE_FUDGE)) {
|
||||
if (params.stats) {
|
||||
params.stats->skippedNoChange(node);
|
||||
}
|
||||
return bytesAtThisLevel;
|
||||
}
|
||||
|
||||
|
|
@ -1136,6 +1161,9 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
CoverageMapStorageResult result = params.map->checkMap(voxelPolygon, false);
|
||||
delete voxelPolygon; // cleanup
|
||||
if (result == OCCLUDED) {
|
||||
if (params.stats) {
|
||||
params.stats->skippedOccluded(node);
|
||||
}
|
||||
return bytesAtThisLevel;
|
||||
}
|
||||
} else {
|
||||
|
|
@ -1201,6 +1229,13 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
distancesToChildren[i] = 0.0f;
|
||||
currentCount++;
|
||||
}
|
||||
|
||||
// track stats
|
||||
// must check childNode here, because it could be we got here with no childNode
|
||||
if (params.stats && childNode) {
|
||||
params.stats->traversed(childNode);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// for each child node in Distance sorted order..., check to see if they exist, are colored, and in view, and if so
|
||||
|
|
@ -1211,13 +1246,23 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
|
||||
bool childIsInView = (childNode && (!params.viewFrustum || childNode->isInView(*params.viewFrustum)));
|
||||
|
||||
if (childIsInView) {
|
||||
if (!childIsInView) {
|
||||
// must check childNode here, because it could be we got here because there was no childNode
|
||||
if (params.stats && childNode) {
|
||||
params.stats->skippedOutOfView(childNode);
|
||||
}
|
||||
} else {
|
||||
// Before we determine consider this further, let's see if it's in our LOD scope...
|
||||
float distance = distancesToChildren[i]; // params.viewFrustum ? childNode->distanceToCamera(*params.viewFrustum) : 0;
|
||||
float boundaryDistance = !params.viewFrustum ? 1 :
|
||||
boundaryDistanceForRenderLevel(childNode->getLevel() + params.boundaryLevelAdjust);
|
||||
|
||||
if (distance < boundaryDistance) {
|
||||
if (!(distance < boundaryDistance)) {
|
||||
// don't need to check childNode here, because we can't get here with no childNode
|
||||
if (params.stats) {
|
||||
params.stats->skippedDistance(childNode);
|
||||
}
|
||||
} else {
|
||||
inViewCount++;
|
||||
|
||||
// track children in view as existing and not a leaf, if they're a leaf,
|
||||
|
|
@ -1261,7 +1306,21 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
} // wants occlusion culling & isLeaf()
|
||||
|
||||
|
||||
bool shouldRender = !params.viewFrustum ? true : childNode->calculateShouldRender(params.viewFrustum, params.boundaryLevelAdjust);
|
||||
bool shouldRender = !params.viewFrustum
|
||||
? true
|
||||
: childNode->calculateShouldRender(params.viewFrustum, params.boundaryLevelAdjust);
|
||||
|
||||
// track some stats
|
||||
if (params.stats) {
|
||||
// don't need to check childNode here, because we can't get here with no childNode
|
||||
if (!shouldRender && childNode->isLeaf()) {
|
||||
params.stats->skippedDistance(childNode);
|
||||
}
|
||||
// don't need to check childNode here, because we can't get here with no childNode
|
||||
if (childIsOccluded) {
|
||||
params.stats->skippedOccluded(childNode);
|
||||
}
|
||||
}
|
||||
|
||||
// track children with actual color, only if the child wasn't previously in view!
|
||||
if (shouldRender && !childIsOccluded) {
|
||||
|
|
@ -1288,7 +1347,15 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
inViewWithColorCount++;
|
||||
} else {
|
||||
// otherwise just track stats of the items we discarded
|
||||
params.childWasInViewDiscarded++;
|
||||
// don't need to check childNode here, because we can't get here with no childNode
|
||||
if (params.stats) {
|
||||
if (childWasInView) {
|
||||
params.stats->skippedWasInView(childNode);
|
||||
} else {
|
||||
params.stats->skippedNoChange(childNode);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1297,14 +1364,24 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
*writeToThisLevelBuffer = childrenColoredBits;
|
||||
writeToThisLevelBuffer += sizeof(childrenColoredBits); // move the pointer
|
||||
bytesAtThisLevel += sizeof(childrenColoredBits); // keep track of byte count
|
||||
if (params.stats) {
|
||||
params.stats->colorBitsWritten();
|
||||
}
|
||||
|
||||
// write the color data...
|
||||
if (params.includeColor) {
|
||||
for (int i = 0; i < NUMBER_OF_CHILDREN; i++) {
|
||||
if (oneAtBit(childrenColoredBits, i)) {
|
||||
memcpy(writeToThisLevelBuffer, &node->getChildAtIndex(i)->getColor(), BYTES_PER_COLOR);
|
||||
VoxelNode* childNode = node->getChildAtIndex(i);
|
||||
memcpy(writeToThisLevelBuffer, &childNode->getColor(), BYTES_PER_COLOR);
|
||||
writeToThisLevelBuffer += BYTES_PER_COLOR; // move the pointer for color
|
||||
bytesAtThisLevel += BYTES_PER_COLOR; // keep track of byte count for color
|
||||
|
||||
// don't need to check childNode here, because we can't get here with no childNode
|
||||
if (params.stats) {
|
||||
params.stats->colorSent(childNode);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1315,12 +1392,18 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
*writeToThisLevelBuffer = childrenExistInTreeBits;
|
||||
writeToThisLevelBuffer += sizeof(childrenExistInTreeBits); // move the pointer
|
||||
bytesAtThisLevel += sizeof(childrenExistInTreeBits); // keep track of byte count
|
||||
if (params.stats) {
|
||||
params.stats->existsBitsWritten();
|
||||
}
|
||||
}
|
||||
|
||||
// write the child exist bits
|
||||
*writeToThisLevelBuffer = childrenExistInPacketBits;
|
||||
writeToThisLevelBuffer += sizeof(childrenExistInPacketBits); // move the pointer
|
||||
bytesAtThisLevel += sizeof(childrenExistInPacketBits); // keep track of byte count
|
||||
if (params.stats) {
|
||||
params.stats->existsInPacketBitsWritten();
|
||||
}
|
||||
|
||||
// We only need to keep digging, if there is at least one child that is inView, and not a leaf.
|
||||
keepDiggingDeeper = (inViewNotLeafCount > 0);
|
||||
|
|
@ -1333,6 +1416,12 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
availableBytes -= bytesAtThisLevel;
|
||||
} else {
|
||||
bag.insert(node);
|
||||
|
||||
// don't need to check node here, because we can't get here with no node
|
||||
if (params.stats) {
|
||||
params.stats->didntFit(node);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1393,7 +1482,12 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
// so, if the child returns 2 bytes out, we can actually consider that an empty tree also!!
|
||||
//
|
||||
// we can make this act like no bytes out, by just resetting the bytes out in this case
|
||||
if (params.includeColor && childTreeBytesOut == 2) {
|
||||
if (params.includeColor && !params.includeExistsBits && childTreeBytesOut == 2) {
|
||||
childTreeBytesOut = 0; // this is the degenerate case of a tree with no colors and no child trees
|
||||
}
|
||||
// If we've asked for existBits, this is also true, except that the tree will output 3 bytes
|
||||
// NOTE: does this introduce a problem with detecting deletion??
|
||||
if (params.includeColor && params.includeExistsBits && childTreeBytesOut == 3) {
|
||||
childTreeBytesOut = 0; // this is the degenerate case of a tree with no colors and no child trees
|
||||
}
|
||||
|
||||
|
|
@ -1408,6 +1502,12 @@ int VoxelTree::encodeTreeBitstreamRecursion(VoxelNode* node, unsigned char* outp
|
|||
childrenExistInPacketBits -= (1 << (7 - originalIndex));
|
||||
// repair the child exists mask
|
||||
*childExistsPlaceHolder = childrenExistInPacketBits;
|
||||
|
||||
// If this is the last of the child exists bits, then we're actually be rolling out the entire tree
|
||||
if (params.stats && childrenExistInPacketBits == 0) {
|
||||
params.stats->childBitsRemoved(params.includeExistsBits, params.includeColor);
|
||||
}
|
||||
|
||||
// Note: no need to move the pointer, cause we already stored this
|
||||
} // end if (childTreeBytesOut == 0)
|
||||
} // end if (oneAtBit(childrenExistInPacketBits, originalIndex))
|
||||
|
|
|
|||
|
|
@ -9,12 +9,14 @@
|
|||
#ifndef __hifi__VoxelTree__
|
||||
#define __hifi__VoxelTree__
|
||||
|
||||
#include "SimpleMovingAverage.h"
|
||||
#include <PointerStack.h>
|
||||
#include <SimpleMovingAverage.h>
|
||||
|
||||
#include "CoverageMap.h"
|
||||
#include "ViewFrustum.h"
|
||||
#include "VoxelNode.h"
|
||||
#include "VoxelNodeBag.h"
|
||||
#include "CoverageMap.h"
|
||||
#include "PointerStack.h"
|
||||
#include "VoxelSceneStats.h"
|
||||
|
||||
// Callback function, for recuseTreeWithOperation
|
||||
typedef bool (*RecurseVoxelTreeOperation)(VoxelNode* node, void* extraData);
|
||||
|
|
@ -36,6 +38,7 @@ typedef enum {GRADIENT, RANDOM, NATURAL} creationMode;
|
|||
#define NO_BOUNDARY_ADJUST 0
|
||||
#define LOW_RES_MOVING_ADJUST 1
|
||||
#define IGNORE_LAST_SENT 0
|
||||
#define IGNORE_SCENE_STATS NULL
|
||||
|
||||
class EncodeBitstreamParams {
|
||||
public:
|
||||
|
|
@ -48,10 +51,10 @@ public:
|
|||
bool deltaViewFrustum;
|
||||
const ViewFrustum* lastViewFrustum;
|
||||
bool wantOcclusionCulling;
|
||||
long childWasInViewDiscarded;
|
||||
int boundaryLevelAdjust;
|
||||
uint64_t lastViewFrustumSent;
|
||||
bool forceSendScene;
|
||||
VoxelSceneStats* stats;
|
||||
CoverageMap* map;
|
||||
|
||||
EncodeBitstreamParams(
|
||||
|
|
@ -66,7 +69,8 @@ public:
|
|||
CoverageMap* map = IGNORE_COVERAGE_MAP,
|
||||
int boundaryLevelAdjust = NO_BOUNDARY_ADJUST,
|
||||
uint64_t lastViewFrustumSent = IGNORE_LAST_SENT,
|
||||
bool forceSendScene = true) :
|
||||
bool forceSendScene = true,
|
||||
VoxelSceneStats* stats = IGNORE_SCENE_STATS) :
|
||||
maxEncodeLevel (maxEncodeLevel),
|
||||
maxLevelReached (0),
|
||||
viewFrustum (viewFrustum),
|
||||
|
|
@ -76,10 +80,10 @@ public:
|
|||
deltaViewFrustum (deltaViewFrustum),
|
||||
lastViewFrustum (lastViewFrustum),
|
||||
wantOcclusionCulling (wantOcclusionCulling),
|
||||
childWasInViewDiscarded (0),
|
||||
boundaryLevelAdjust (boundaryLevelAdjust),
|
||||
lastViewFrustumSent (lastViewFrustumSent),
|
||||
forceSendScene (forceSendScene),
|
||||
stats (stats),
|
||||
map (map)
|
||||
{}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -12,9 +12,11 @@
|
|||
#include <iostream>
|
||||
#include <NodeData.h>
|
||||
#include <AvatarData.h>
|
||||
#include "VoxelNodeBag.h"
|
||||
#include "VoxelConstants.h"
|
||||
#include "CoverageMap.h"
|
||||
|
||||
#include <CoverageMap.h>
|
||||
#include <VoxelConstants.h>
|
||||
#include <VoxelNodeBag.h>
|
||||
#include <VoxelSceneStats.h>
|
||||
|
||||
class VoxelNodeData : public AvatarData {
|
||||
public:
|
||||
|
|
@ -58,6 +60,9 @@ public:
|
|||
void setLastTimeBagEmpty(uint64_t lastTimeBagEmpty) { _lastTimeBagEmpty = lastTimeBagEmpty; };
|
||||
|
||||
bool getCurrentPacketIsColor() const { return _currentPacketIsColor; };
|
||||
|
||||
VoxelSceneStats stats;
|
||||
|
||||
private:
|
||||
VoxelNodeData(const VoxelNodeData &);
|
||||
VoxelNodeData& operator= (const VoxelNodeData&);
|
||||
|
|
|
|||
|
|
@ -60,6 +60,7 @@ bool wantLocalDomain = false;
|
|||
bool wantColorRandomizer = false;
|
||||
bool debugVoxelSending = false;
|
||||
bool shouldShowAnimationDebug = false;
|
||||
bool displayVoxelStats = false;
|
||||
|
||||
EnvironmentData environmentData[3];
|
||||
|
||||
|
|
@ -111,6 +112,44 @@ void eraseVoxelTreeAndCleanupNodeVisitData() {
|
|||
|
||||
pthread_mutex_t treeLock;
|
||||
|
||||
void handlePacketSend(NodeList* nodeList,
|
||||
NodeList::iterator& node,
|
||||
VoxelNodeData* nodeData,
|
||||
int& trueBytesSent, int& truePacketsSent) {
|
||||
// If we've got a stats message ready to send, then see if we can piggyback them together
|
||||
if (nodeData->stats.isReadyToSend()) {
|
||||
// Send the stats message to the client
|
||||
unsigned char* statsMessage = nodeData->stats.getStatsMessage();
|
||||
int statsMessageLength = nodeData->stats.getStatsMessageLength();
|
||||
|
||||
// If the size of the stats message and the voxel message will fit in a packet, then piggyback them
|
||||
if (nodeData->getPacketLength() + statsMessageLength < MAX_PACKET_SIZE) {
|
||||
|
||||
// copy voxel message to back of stats message
|
||||
memcpy(statsMessage + statsMessageLength, nodeData->getPacket(), nodeData->getPacketLength());
|
||||
statsMessageLength += nodeData->getPacketLength();
|
||||
|
||||
// actually send it
|
||||
nodeList->getNodeSocket()->send(node->getActiveSocket(), statsMessage, statsMessageLength);
|
||||
} else {
|
||||
// not enough room in the packet, send two packets
|
||||
nodeList->getNodeSocket()->send(node->getActiveSocket(), statsMessage, statsMessageLength);
|
||||
nodeList->getNodeSocket()->send(node->getActiveSocket(),
|
||||
nodeData->getPacket(), nodeData->getPacketLength());
|
||||
}
|
||||
} else {
|
||||
// just send the voxel packet
|
||||
nodeList->getNodeSocket()->send(node->getActiveSocket(),
|
||||
nodeData->getPacket(), nodeData->getPacketLength());
|
||||
}
|
||||
// remember to track our stats
|
||||
nodeData->stats.packetSent(nodeData->getPacketLength());
|
||||
trueBytesSent += nodeData->getPacketLength();
|
||||
truePacketsSent++;
|
||||
nodeData->resetVoxelPacket();
|
||||
}
|
||||
|
||||
|
||||
// Version of voxel distributor that sends the deepest LOD level at once
|
||||
void deepestLevelVoxelDistributor(NodeList* nodeList,
|
||||
NodeList::iterator& node,
|
||||
|
|
@ -141,11 +180,9 @@ void deepestLevelVoxelDistributor(NodeList* nodeList,
|
|||
printf("wantColor=%s --- SENDING PARTIAL PACKET! nodeData->getCurrentPacketIsColor()=%s\n",
|
||||
debug::valueOf(wantColor), debug::valueOf(nodeData->getCurrentPacketIsColor()));
|
||||
}
|
||||
nodeList->getNodeSocket()->send(node->getActiveSocket(),
|
||||
nodeData->getPacket(), nodeData->getPacketLength());
|
||||
trueBytesSent += nodeData->getPacketLength();
|
||||
truePacketsSent++;
|
||||
nodeData->resetVoxelPacket();
|
||||
|
||||
handlePacketSend(nodeList, node, nodeData, trueBytesSent, truePacketsSent);
|
||||
|
||||
} else {
|
||||
if (::debugVoxelSending) {
|
||||
printf("wantColor=%s --- FIXING HEADER! nodeData->getCurrentPacketIsColor()=%s\n",
|
||||
|
|
@ -200,13 +237,20 @@ void deepestLevelVoxelDistributor(NodeList* nodeList,
|
|||
// only set our last sent time if we weren't resetting due to frustum change
|
||||
uint64_t now = usecTimestampNow();
|
||||
nodeData->setLastTimeBagEmpty(now);
|
||||
if (::debugVoxelSending) {
|
||||
printf("ENTIRE SCENE SENT! nodeData->setLastTimeBagEmpty(now=[%lld])\n", now);
|
||||
}
|
||||
|
||||
nodeData->stats.sceneCompleted();
|
||||
|
||||
if (::displayVoxelStats) {
|
||||
nodeData->stats.printDebugDetails();
|
||||
}
|
||||
|
||||
// This is the start of "resending" the scene.
|
||||
nodeData->nodeBag.insert(serverTree.rootNode);
|
||||
|
||||
// start tracking our stats
|
||||
bool isFullScene = (!viewFrustumChanged || !nodeData->getWantDelta()) && nodeData->getViewFrustumJustStoppedChanging();
|
||||
nodeData->stats.sceneStarted(isFullScene, viewFrustumChanged, ::serverTree.rootNode);
|
||||
}
|
||||
|
||||
// If we have something in our nodeBag, then turn them into packets and send them out...
|
||||
|
|
@ -240,32 +284,31 @@ void deepestLevelVoxelDistributor(NodeList* nodeList,
|
|||
int boundaryLevelAdjust = viewFrustumChanged && nodeData->getWantLowResMoving()
|
||||
? LOW_RES_MOVING_ADJUST : NO_BOUNDARY_ADJUST;
|
||||
|
||||
bool isFullScene = (!viewFrustumChanged || !nodeData->getWantDelta()) &&
|
||||
nodeData->getViewFrustumJustStoppedChanging();
|
||||
|
||||
EncodeBitstreamParams params(INT_MAX, &nodeData->getCurrentViewFrustum(), wantColor,
|
||||
WANT_EXISTS_BITS, DONT_CHOP, wantDelta, lastViewFrustum,
|
||||
wantOcclusionCulling, coverageMap, boundaryLevelAdjust,
|
||||
nodeData->getLastTimeBagEmpty(),
|
||||
nodeData->getViewFrustumJustStoppedChanging());
|
||||
isFullScene, &nodeData->stats);
|
||||
|
||||
nodeData->stats.encodeStarted();
|
||||
bytesWritten = serverTree.encodeTreeBitstream(subTree, &tempOutputBuffer[0], MAX_VOXEL_PACKET_SIZE - 1,
|
||||
nodeData->nodeBag, params);
|
||||
nodeData->stats.encodeStopped();
|
||||
|
||||
if (nodeData->getAvailable() >= bytesWritten) {
|
||||
nodeData->writeToPacket(&tempOutputBuffer[0], bytesWritten);
|
||||
} else {
|
||||
nodeList->getNodeSocket()->send(node->getActiveSocket(),
|
||||
nodeData->getPacket(), nodeData->getPacketLength());
|
||||
trueBytesSent += nodeData->getPacketLength();
|
||||
truePacketsSent++;
|
||||
handlePacketSend(nodeList, node, nodeData, trueBytesSent, truePacketsSent);
|
||||
packetsSentThisInterval++;
|
||||
nodeData->resetVoxelPacket();
|
||||
nodeData->writeToPacket(&tempOutputBuffer[0], bytesWritten);
|
||||
}
|
||||
} else {
|
||||
if (nodeData->isPacketWaiting()) {
|
||||
nodeList->getNodeSocket()->send(node->getActiveSocket(),
|
||||
nodeData->getPacket(), nodeData->getPacketLength());
|
||||
trueBytesSent += nodeData->getPacketLength();
|
||||
truePacketsSent++;
|
||||
handlePacketSend(nodeList, node, nodeData, trueBytesSent, truePacketsSent);
|
||||
nodeData->resetVoxelPacket();
|
||||
}
|
||||
packetsSentThisInterval = PACKETS_PER_CLIENT_PER_INTERVAL; // done for now, no nodes left
|
||||
|
|
@ -368,9 +411,11 @@ void *distributeVoxelsToListeners(void *args) {
|
|||
if (usecToSleep > 0) {
|
||||
usleep(usecToSleep);
|
||||
} else {
|
||||
if (::debugVoxelSending) {
|
||||
std::cout << "Last send took too much time, not sleeping!\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pthread_exit(0);
|
||||
}
|
||||
|
|
@ -402,6 +447,10 @@ int main(int argc, const char * argv[]) {
|
|||
|
||||
srand((unsigned)time(0));
|
||||
|
||||
const char* DISPLAY_VOXEL_STATS = "--displayVoxelStats";
|
||||
::displayVoxelStats = cmdOptionExists(argc, argv, DISPLAY_VOXEL_STATS);
|
||||
printf("displayVoxelStats=%s\n", debug::valueOf(::displayVoxelStats));
|
||||
|
||||
const char* DEBUG_VOXEL_SENDING = "--debugVoxelSending";
|
||||
::debugVoxelSending = cmdOptionExists(argc, argv, DEBUG_VOXEL_SENDING);
|
||||
printf("debugVoxelSending=%s\n", debug::valueOf(::debugVoxelSending));
|
||||
|
|
@ -437,8 +486,10 @@ int main(int argc, const char * argv[]) {
|
|||
|
||||
::serverTree.clearDirtyBit(); // the tree is clean since we just loaded it
|
||||
printf("DONE loading voxels from file... fileRead=%s\n", debug::valueOf(persistantFileRead));
|
||||
unsigned long nodeCount = ::serverTree.getVoxelCount();
|
||||
printf("Nodes after loading scene %ld nodes\n", nodeCount);
|
||||
unsigned long nodeCount = ::serverTree.rootNode->getSubTreeNodeCount();
|
||||
unsigned long internalNodeCount = ::serverTree.rootNode->getSubTreeInternalNodeCount();
|
||||
unsigned long leafNodeCount = ::serverTree.rootNode->getSubTreeLeafNodeCount();
|
||||
printf("Nodes after loading scene %lu nodes %lu internal %lu leaves\n", nodeCount, internalNodeCount, leafNodeCount);
|
||||
}
|
||||
|
||||
// Check to see if the user passed in a command line option for loading an old style local
|
||||
|
|
|
|||
Loading…
Reference in a new issue