mirror of
https://thingvellir.net/git/overte
synced 2025-03-27 23:52:03 +01:00
Merge branch 'master' of https://github.com/highfidelity/hifi into dk/4036
This commit is contained in:
David Kelly
commit
cd55728490
41 changed files with 1515 additions and 402 deletions
|
|
@ -200,7 +200,7 @@ void AvatarMixer::manageDisplayName(const SharedNodePointer& node) {
|
|||
QString baseName = avatar.getDisplayName().trimmed();
|
||||
const QRegularExpression curses { "fuck|shit|damn|cock|cunt" }; // POC. We may eventually want something much more elaborate (subscription?).
|
||||
baseName = baseName.replace(curses, "*"); // Replace rather than remove, so that people have a clue that the person's a jerk.
|
||||
const QRegularExpression trailingDigits { "\\s*_\\d+$" }; // whitespace "_123"
|
||||
const QRegularExpression trailingDigits { "\\s*(_\\d+\\s*)?(\\s*\\n[^$]*)?$" }; // trailing whitespace "_123" and any subsequent lines
|
||||
baseName = baseName.remove(trailingDigits);
|
||||
if (baseName.isEmpty()) {
|
||||
baseName = "anonymous";
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ Item {
|
|||
id: pingCol
|
||||
spacing: 4; x: 4; y: 4;
|
||||
StatText {
|
||||
text: "Audio ping: " + root.audioPing
|
||||
text: "Audio ping/loss: " + root.audioPing + "/" + root.audioPacketLoss + "%"
|
||||
}
|
||||
StatText {
|
||||
text: "Avatar ping: " + root.avatarPing
|
||||
|
|
|
|||
|
|
@ -104,6 +104,7 @@ Item {
|
|||
|
||||
// Required to support clicking on "hifi://" links
|
||||
if (WebEngineView.LoadStartedStatus == loadRequest.status) {
|
||||
urlAppend(loadRequest.url.toString())
|
||||
var url = loadRequest.url.toString();
|
||||
if (urlHandler.canHandleUrl(url)) {
|
||||
if (urlHandler.handleUrl(url)) {
|
||||
|
|
@ -113,12 +114,6 @@ Item {
|
|||
}
|
||||
}
|
||||
|
||||
onNavigationRequested: {
|
||||
if (request.navigationType == WebEngineNavigationRequest.LinkClickedNavigation) {
|
||||
pagesModel.append({webUrl: request.url.toString()})
|
||||
}
|
||||
}
|
||||
|
||||
onNewViewRequested: {
|
||||
request.openIn(webView);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ Item {
|
|||
}
|
||||
|
||||
function gotoPage(url) {
|
||||
pagesModel.append({webUrl: url})
|
||||
urlAppend(url)
|
||||
}
|
||||
|
||||
function reloadPage() {
|
||||
|
|
@ -126,9 +126,20 @@ Item {
|
|||
view.setEnabled(true);
|
||||
}
|
||||
|
||||
function urlAppend(url) {
|
||||
var lurl = decodeURIComponent(url)
|
||||
if (lurl[lurl.length - 1] !== "/")
|
||||
lurl = lurl + "/"
|
||||
if (currentPage === -1 || pagesModel.get(currentPage).webUrl !== lurl) {
|
||||
pagesModel.append({webUrl: lurl})
|
||||
}
|
||||
}
|
||||
|
||||
onCurrentPageChanged: {
|
||||
if (currentPage >= 0 && currentPage < pagesModel.count && loader.item !== null) {
|
||||
loader.item.url = pagesModel.get(currentPage).webUrl
|
||||
web.url = loader.item.url
|
||||
web.address = loader.item.url
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -160,6 +171,7 @@ Item {
|
|||
if (currentPage >= 0) {
|
||||
//we got something to load already
|
||||
item.url = pagesModel.get(currentPage).webUrl
|
||||
web.address = loader.item.url
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -243,12 +243,7 @@ Rectangle {
|
|||
}
|
||||
}
|
||||
}
|
||||
DropShadow {
|
||||
anchors.fill: actionIcon
|
||||
radius: 8.0
|
||||
color: "#80000000"
|
||||
source: actionIcon
|
||||
}
|
||||
|
||||
MouseArea {
|
||||
id: messageArea;
|
||||
width: rectIcon.width;
|
||||
|
|
|
|||
|
|
@ -33,14 +33,25 @@ StackView {
|
|||
property int cardHeight: 320;
|
||||
property string metaverseBase: addressBarDialog.metaverseServerUrl + "/api/v1/";
|
||||
|
||||
property var tablet: null;
|
||||
property bool isDesktop: false;
|
||||
|
||||
Component { id: tabletStoryCard; TabletStoryCard {} }
|
||||
Component.onCompleted: {
|
||||
root.currentItem.focus = true;
|
||||
root.currentItem.forceActiveFocus();
|
||||
addressLine.focus = true;
|
||||
addressLine.forceActiveFocus();
|
||||
fillDestinations();
|
||||
updateLocationText(false);
|
||||
root.parentChanged.connect(center);
|
||||
center();
|
||||
isDesktop = (typeof desktop !== "undefined");
|
||||
tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
|
||||
|
||||
if (desktop) {
|
||||
root.title = "GOTO";
|
||||
}
|
||||
}
|
||||
Component.onDestruction: {
|
||||
root.parentChanged.disconnect(center);
|
||||
|
|
@ -108,6 +119,8 @@ StackView {
|
|||
onClicked: {
|
||||
addressBarDialog.loadHome();
|
||||
tabletRoot.shown = false;
|
||||
tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
|
||||
tablet.gotoHomeScreen();
|
||||
}
|
||||
anchors {
|
||||
left: parent.left
|
||||
|
|
@ -294,6 +307,7 @@ StackView {
|
|||
right: parent.right
|
||||
leftMargin: 10
|
||||
}
|
||||
|
||||
model: suggestions
|
||||
orientation: ListView.Vertical
|
||||
|
||||
|
|
@ -547,6 +561,13 @@ StackView {
|
|||
if (addressLine.text !== "") {
|
||||
addressBarDialog.loadAddress(addressLine.text, fromSuggestions)
|
||||
}
|
||||
|
||||
if (isDesktop) {
|
||||
tablet.gotoHomeScreen();
|
||||
} else {
|
||||
HMD.closeTablet();
|
||||
}
|
||||
|
||||
tabletRoot.shown = false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,10 @@ Item {
|
|||
property bool pinned: false
|
||||
clip: true
|
||||
|
||||
function updateYOffset() { yOffset = size * buttonState; }
|
||||
function updateYOffset() {
|
||||
//make sure offset not set outside image
|
||||
yOffset = (size * buttonState >= image.height) ? image.height - size : size * buttonState
|
||||
}
|
||||
onButtonStateChanged: updateYOffset();
|
||||
|
||||
Component.onCompleted: {
|
||||
|
|
|
|||
|
|
@ -2013,6 +2013,7 @@ void Application::initializeUi() {
|
|||
rootContext->setContextProperty("SoundCache", DependencyManager::get<SoundCache>().data());
|
||||
|
||||
rootContext->setContextProperty("Account", AccountScriptingInterface::getInstance());
|
||||
rootContext->setContextProperty("Tablet", DependencyManager::get<TabletScriptingInterface>().data());
|
||||
rootContext->setContextProperty("DialogsManager", _dialogsManagerScriptingInterface);
|
||||
rootContext->setContextProperty("GlobalServices", GlobalServicesScriptingInterface::getInstance());
|
||||
rootContext->setContextProperty("FaceTracker", DependencyManager::get<DdeFaceTracker>().data());
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@
|
|||
#include "TabletScriptingInterface.h"
|
||||
#include "scripting/HMDScriptingInterface.h"
|
||||
|
||||
static const QVariant TABLET_ADDRESS_DIALOG = "TabletAddressDialog.qml";
|
||||
template<typename T>
|
||||
void DialogsManager::maybeCreateDialog(QPointer<T>& member) {
|
||||
if (!member) {
|
||||
|
|
@ -46,12 +47,48 @@ void DialogsManager::maybeCreateDialog(QPointer<T>& member) {
|
|||
}
|
||||
|
||||
void DialogsManager::toggleAddressBar() {
|
||||
AddressBarDialog::toggle();
|
||||
emit addressBarToggled();
|
||||
auto hmd = DependencyManager::get<HMDScriptingInterface>();
|
||||
auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
|
||||
auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
|
||||
if (tablet->getToolbarMode()) {
|
||||
if (tablet->isPathLoaded(TABLET_ADDRESS_DIALOG)) {
|
||||
tablet->gotoHomeScreen();
|
||||
emit addressBarToggled();
|
||||
} else {
|
||||
tablet->loadQMLSource(TABLET_ADDRESS_DIALOG);
|
||||
emit addressBarToggled();
|
||||
}
|
||||
} else {
|
||||
if (hmd->getShouldShowTablet()) {
|
||||
if (tablet->isPathLoaded(TABLET_ADDRESS_DIALOG) && _closeAddressBar) {
|
||||
tablet->gotoHomeScreen();
|
||||
hmd->closeTablet();
|
||||
_closeAddressBar = false;
|
||||
emit addressBarToggled();
|
||||
} else {
|
||||
tablet->loadQMLSource(TABLET_ADDRESS_DIALOG);
|
||||
_closeAddressBar = true;
|
||||
emit addressBarToggled();
|
||||
}
|
||||
} else {
|
||||
tablet->loadQMLSource(TABLET_ADDRESS_DIALOG);
|
||||
hmd->openTablet();
|
||||
_closeAddressBar = true;
|
||||
emit addressBarToggled();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void DialogsManager::showAddressBar() {
|
||||
AddressBarDialog::show();
|
||||
auto hmd = DependencyManager::get<HMDScriptingInterface>();
|
||||
auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
|
||||
auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
|
||||
tablet->loadQMLSource(TABLET_ADDRESS_DIALOG);
|
||||
|
||||
if (!hmd->getShouldShowTablet()) {
|
||||
hmd->openTablet();
|
||||
}
|
||||
}
|
||||
|
||||
void DialogsManager::showFeed() {
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@ private:
|
|||
QPointer<OctreeStatsDialog> _octreeStatsDialog;
|
||||
QPointer<TestingDialog> _testingDialog;
|
||||
QPointer<DomainConnectionDialog> _domainConnectionDialog;
|
||||
bool _closeAddressBar { false };
|
||||
};
|
||||
|
||||
#endif // hifi_DialogsManager_h
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ void Stats::updateStats(bool force) {
|
|||
STAT_UPDATE(updatedAvatarCount, avatarManager->getNumAvatarsUpdated());
|
||||
STAT_UPDATE(notUpdatedAvatarCount, avatarManager->getNumAvatarsNotUpdated());
|
||||
STAT_UPDATE(serverCount, (int)nodeList->size());
|
||||
STAT_UPDATE(framerate, qApp->getFps());
|
||||
STAT_UPDATE_FLOAT(framerate, qApp->getFps(), 0.1f);
|
||||
if (qApp->getActiveDisplayPlugin()) {
|
||||
auto displayPlugin = qApp->getActiveDisplayPlugin();
|
||||
auto stats = displayPlugin->getHardwareStats();
|
||||
|
|
@ -134,11 +134,11 @@ void Stats::updateStats(bool force) {
|
|||
STAT_UPDATE(longrenders, stats["long_render_count"].toInt());
|
||||
STAT_UPDATE(longsubmits, stats["long_submit_count"].toInt());
|
||||
STAT_UPDATE(longframes, stats["long_frame_count"].toInt());
|
||||
STAT_UPDATE(renderrate, displayPlugin->renderRate());
|
||||
STAT_UPDATE(presentrate, displayPlugin->presentRate());
|
||||
STAT_UPDATE(presentnewrate, displayPlugin->newFramePresentRate());
|
||||
STAT_UPDATE(presentdroprate, displayPlugin->droppedFrameRate());
|
||||
STAT_UPDATE(stutterrate, displayPlugin->stutterRate());
|
||||
STAT_UPDATE_FLOAT(renderrate, displayPlugin->renderRate(), 0.1f);
|
||||
STAT_UPDATE_FLOAT(presentrate, displayPlugin->presentRate(), 0.1f);
|
||||
STAT_UPDATE_FLOAT(presentnewrate, displayPlugin->newFramePresentRate(), 0.1f);
|
||||
STAT_UPDATE_FLOAT(presentdroprate, displayPlugin->droppedFrameRate(), 0.1f);
|
||||
STAT_UPDATE_FLOAT(stutterrate, displayPlugin->stutterRate(), 0.1f);
|
||||
} else {
|
||||
STAT_UPDATE(appdropped, -1);
|
||||
STAT_UPDATE(longrenders, -1);
|
||||
|
|
@ -151,8 +151,8 @@ void Stats::updateStats(bool force) {
|
|||
STAT_UPDATE(avatarSimrate, (int)qApp->getAvatarSimrate());
|
||||
|
||||
auto bandwidthRecorder = DependencyManager::get<BandwidthRecorder>();
|
||||
STAT_UPDATE(packetInCount, bandwidthRecorder->getCachedTotalAverageInputPacketsPerSecond());
|
||||
STAT_UPDATE(packetOutCount, bandwidthRecorder->getCachedTotalAverageOutputPacketsPerSecond());
|
||||
STAT_UPDATE(packetInCount, (int)bandwidthRecorder->getCachedTotalAverageInputPacketsPerSecond());
|
||||
STAT_UPDATE(packetOutCount, (int)bandwidthRecorder->getCachedTotalAverageOutputPacketsPerSecond());
|
||||
STAT_UPDATE_FLOAT(mbpsIn, (float)bandwidthRecorder->getCachedTotalAverageInputKilobitsPerSecond() / 1000.0f, 0.01f);
|
||||
STAT_UPDATE_FLOAT(mbpsOut, (float)bandwidthRecorder->getCachedTotalAverageOutputKilobitsPerSecond() / 1000.0f, 0.01f);
|
||||
|
||||
|
|
@ -164,7 +164,11 @@ void Stats::updateStats(bool force) {
|
|||
SharedNodePointer avatarMixerNode = nodeList->soloNodeOfType(NodeType::AvatarMixer);
|
||||
SharedNodePointer assetServerNode = nodeList->soloNodeOfType(NodeType::AssetServer);
|
||||
SharedNodePointer messageMixerNode = nodeList->soloNodeOfType(NodeType::MessagesMixer);
|
||||
STAT_UPDATE(audioPing, audioMixerNode ? audioMixerNode->getPingMs() : -1);
|
||||
STAT_UPDATE(audioPing, audioMixerNode ? audioMixerNode->getPingMs() : -1);
|
||||
const int mixerLossRate = (int)roundf(_audioStats->data()->getMixerStream()->lossRateWindow() * 100.0f);
|
||||
const int clientLossRate = (int)roundf(_audioStats->data()->getClientStream()->lossRateWindow() * 100.0f);
|
||||
const int largestLossRate = mixerLossRate > clientLossRate ? mixerLossRate : clientLossRate;
|
||||
STAT_UPDATE(audioPacketLoss, audioMixerNode ? largestLossRate : -1);
|
||||
STAT_UPDATE(avatarPing, avatarMixerNode ? avatarMixerNode->getPingMs() : -1);
|
||||
STAT_UPDATE(assetPing, assetServerNode ? assetServerNode->getPingMs() : -1);
|
||||
STAT_UPDATE(messagePing, messageMixerNode ? messageMixerNode->getPingMs() : -1);
|
||||
|
|
@ -196,36 +200,36 @@ void Stats::updateStats(bool force) {
|
|||
if (_expanded || force) {
|
||||
SharedNodePointer avatarMixer = nodeList->soloNodeOfType(NodeType::AvatarMixer);
|
||||
if (avatarMixer) {
|
||||
STAT_UPDATE(avatarMixerInKbps, roundf(bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AvatarMixer)));
|
||||
STAT_UPDATE(avatarMixerInPps, roundf(bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AvatarMixer)));
|
||||
STAT_UPDATE(avatarMixerOutKbps, roundf(bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AvatarMixer)));
|
||||
STAT_UPDATE(avatarMixerOutPps, roundf(bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AvatarMixer)));
|
||||
STAT_UPDATE(avatarMixerInKbps, (int)roundf(bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AvatarMixer)));
|
||||
STAT_UPDATE(avatarMixerInPps, (int)roundf(bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AvatarMixer)));
|
||||
STAT_UPDATE(avatarMixerOutKbps, (int)roundf(bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AvatarMixer)));
|
||||
STAT_UPDATE(avatarMixerOutPps, (int)roundf(bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AvatarMixer)));
|
||||
} else {
|
||||
STAT_UPDATE(avatarMixerInKbps, -1);
|
||||
STAT_UPDATE(avatarMixerInPps, -1);
|
||||
STAT_UPDATE(avatarMixerOutKbps, -1);
|
||||
STAT_UPDATE(avatarMixerOutPps, -1);
|
||||
}
|
||||
STAT_UPDATE(myAvatarSendRate, avatarManager->getMyAvatarSendRate());
|
||||
STAT_UPDATE_FLOAT(myAvatarSendRate, avatarManager->getMyAvatarSendRate(), 0.1f);
|
||||
|
||||
SharedNodePointer audioMixerNode = nodeList->soloNodeOfType(NodeType::AudioMixer);
|
||||
auto audioClient = DependencyManager::get<AudioClient>();
|
||||
if (audioMixerNode || force) {
|
||||
STAT_UPDATE(audioMixerKbps, roundf(
|
||||
STAT_UPDATE(audioMixerKbps, (int)roundf(
|
||||
bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AudioMixer) +
|
||||
bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioMixerPps, roundf(
|
||||
STAT_UPDATE(audioMixerPps, (int)roundf(
|
||||
bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AudioMixer) +
|
||||
bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AudioMixer)));
|
||||
|
||||
STAT_UPDATE(audioMixerInKbps, roundf(bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioMixerInPps, roundf(bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioMixerOutKbps, roundf(bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioMixerOutPps, roundf(bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioAudioInboundPPS, audioClient->getAudioInboundPPS());
|
||||
STAT_UPDATE(audioSilentInboundPPS, audioClient->getSilentInboundPPS());
|
||||
STAT_UPDATE(audioOutboundPPS, audioClient->getAudioOutboundPPS());
|
||||
STAT_UPDATE(audioSilentOutboundPPS, audioClient->getSilentOutboundPPS());
|
||||
STAT_UPDATE(audioMixerInKbps, (int)roundf(bandwidthRecorder->getAverageInputKilobitsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioMixerInPps, (int)roundf(bandwidthRecorder->getAverageInputPacketsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioMixerOutKbps, (int)roundf(bandwidthRecorder->getAverageOutputKilobitsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioMixerOutPps, (int)roundf(bandwidthRecorder->getAverageOutputPacketsPerSecond(NodeType::AudioMixer)));
|
||||
STAT_UPDATE(audioAudioInboundPPS, (int)audioClient->getAudioInboundPPS());
|
||||
STAT_UPDATE(audioSilentInboundPPS, (int)audioClient->getSilentInboundPPS());
|
||||
STAT_UPDATE(audioOutboundPPS, (int)audioClient->getAudioOutboundPPS());
|
||||
STAT_UPDATE(audioSilentOutboundPPS, (int)audioClient->getSilentOutboundPPS());
|
||||
} else {
|
||||
STAT_UPDATE(audioMixerKbps, -1);
|
||||
STAT_UPDATE(audioMixerPps, -1);
|
||||
|
|
|
|||
|
|
@ -81,6 +81,7 @@ class Stats : public QQuickItem {
|
|||
STATS_PROPERTY(int, audioSilentOutboundPPS, 0)
|
||||
STATS_PROPERTY(int, audioAudioInboundPPS, 0)
|
||||
STATS_PROPERTY(int, audioSilentInboundPPS, 0)
|
||||
STATS_PROPERTY(int, audioPacketLoss, 0)
|
||||
STATS_PROPERTY(QString, audioCodec, QString())
|
||||
STATS_PROPERTY(QString, audioNoiseGate, QString())
|
||||
|
||||
|
|
@ -204,6 +205,7 @@ signals:
|
|||
void audioSilentOutboundPPSChanged();
|
||||
void audioAudioInboundPPSChanged();
|
||||
void audioSilentInboundPPSChanged();
|
||||
void audioPacketLossChanged();
|
||||
void audioCodecChanged();
|
||||
void audioNoiseGateChanged();
|
||||
|
||||
|
|
@ -263,4 +265,3 @@ private:
|
|||
};
|
||||
|
||||
#endif // hifi_Stats_h
|
||||
|
||||
|
|
|
|||
|
|
@ -277,10 +277,11 @@ bool RenderableModelEntityItem::getAnimationFrame() {
|
|||
return false;
|
||||
}
|
||||
|
||||
if (_animation && _animation->isLoaded()) {
|
||||
auto animation = getAnimation();
|
||||
if (animation && animation->isLoaded()) {
|
||||
|
||||
const QVector<FBXAnimationFrame>& frames = _animation->getFramesReference(); // NOTE: getFrames() is too heavy
|
||||
auto& fbxJoints = _animation->getGeometry().joints;
|
||||
const QVector<FBXAnimationFrame>& frames = animation->getFramesReference(); // NOTE: getFrames() is too heavy
|
||||
auto& fbxJoints = animation->getGeometry().joints;
|
||||
|
||||
int frameCount = frames.size();
|
||||
if (frameCount > 0) {
|
||||
|
|
@ -566,7 +567,7 @@ void RenderableModelEntityItem::update(const quint64& now) {
|
|||
}
|
||||
|
||||
// make a copy of the animation properites
|
||||
_renderAnimationProperties = _animationProperties;
|
||||
_renderAnimationProperties = getAnimationProperties();
|
||||
|
||||
ModelEntityItem::update(now);
|
||||
}
|
||||
|
|
@ -608,11 +609,11 @@ bool RenderableModelEntityItem::findDetailedRayIntersection(const glm::vec3& ori
|
|||
|
||||
void RenderableModelEntityItem::setShapeType(ShapeType type) {
|
||||
ModelEntityItem::setShapeType(type);
|
||||
if (_shapeType == SHAPE_TYPE_COMPOUND) {
|
||||
if (!_compoundShapeResource && !_compoundShapeURL.isEmpty()) {
|
||||
if (getShapeType() == SHAPE_TYPE_COMPOUND) {
|
||||
if (!_compoundShapeResource && !getCompoundShapeURL().isEmpty()) {
|
||||
_compoundShapeResource = DependencyManager::get<ModelCache>()->getGeometryResource(getCompoundShapeURL());
|
||||
}
|
||||
} else if (_compoundShapeResource && !_compoundShapeURL.isEmpty()) {
|
||||
} else if (_compoundShapeResource && !getCompoundShapeURL().isEmpty()) {
|
||||
// the compoundURL has been set but the shapeType does not agree
|
||||
_compoundShapeResource.reset();
|
||||
}
|
||||
|
|
@ -627,7 +628,7 @@ void RenderableModelEntityItem::setCompoundShapeURL(const QString& url) {
|
|||
if (tree) {
|
||||
QMetaObject::invokeMethod(tree.get(), "callLoader", Qt::QueuedConnection, Q_ARG(EntityItemID, getID()));
|
||||
}
|
||||
if (_shapeType == SHAPE_TYPE_COMPOUND) {
|
||||
if (getShapeType() == SHAPE_TYPE_COMPOUND) {
|
||||
_compoundShapeResource = DependencyManager::get<ModelCache>()->getGeometryResource(url);
|
||||
}
|
||||
}
|
||||
|
|
@ -637,7 +638,7 @@ bool RenderableModelEntityItem::isReadyToComputeShape() {
|
|||
ShapeType type = getShapeType();
|
||||
|
||||
if (type == SHAPE_TYPE_COMPOUND) {
|
||||
if (!_model || _compoundShapeURL.isEmpty()) {
|
||||
if (!_model || getCompoundShapeURL().isEmpty()) {
|
||||
EntityTreePointer tree = getTree();
|
||||
if (tree) {
|
||||
QMetaObject::invokeMethod(tree.get(), "callLoader", Qt::QueuedConnection, Q_ARG(EntityItemID, getID()));
|
||||
|
|
@ -659,8 +660,8 @@ bool RenderableModelEntityItem::isReadyToComputeShape() {
|
|||
doInitialModelSimulation();
|
||||
}
|
||||
return true;
|
||||
} else if (!_compoundShapeURL.isEmpty()) {
|
||||
_compoundShapeResource = DependencyManager::get<ModelCache>()->getGeometryResource(_compoundShapeURL);
|
||||
} else if (!getCompoundShapeURL().isEmpty()) {
|
||||
_compoundShapeResource = DependencyManager::get<ModelCache>()->getGeometryResource(getCompoundShapeURL());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -775,7 +776,7 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& shapeInfo) {
|
|||
pointCollection[i][j] = scaleToFit * (pointCollection[i][j] + _model->getOffset()) - registrationOffset;
|
||||
}
|
||||
}
|
||||
shapeInfo.setParams(type, dimensions, _compoundShapeURL);
|
||||
shapeInfo.setParams(type, dimensions, getCompoundShapeURL());
|
||||
} else if (type >= SHAPE_TYPE_SIMPLE_HULL && type <= SHAPE_TYPE_STATIC_MESH) {
|
||||
// should never fall in here when model not fully loaded
|
||||
assert(_model && _model->isLoaded());
|
||||
|
|
@ -1001,7 +1002,7 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& shapeInfo) {
|
|||
}
|
||||
}
|
||||
|
||||
shapeInfo.setParams(type, 0.5f * dimensions, _modelURL);
|
||||
shapeInfo.setParams(type, 0.5f * dimensions, getModelURL());
|
||||
} else {
|
||||
ModelEntityItem::computeShapeInfo(shapeInfo);
|
||||
shapeInfo.setParams(type, 0.5f * dimensions);
|
||||
|
|
|
|||
|
|
@ -660,22 +660,22 @@ void RenderablePolyVoxEntityItem::computeShapeInfo(ShapeInfo& info) {
|
|||
});
|
||||
}
|
||||
|
||||
void RenderablePolyVoxEntityItem::setXTextureURL(QString xTextureURL) {
|
||||
if (xTextureURL != _xTextureURL) {
|
||||
void RenderablePolyVoxEntityItem::setXTextureURL(const QString& xTextureURL) {
|
||||
if (xTextureURL != getXTextureURL()) {
|
||||
_xTexture.clear();
|
||||
PolyVoxEntityItem::setXTextureURL(xTextureURL);
|
||||
}
|
||||
}
|
||||
|
||||
void RenderablePolyVoxEntityItem::setYTextureURL(QString yTextureURL) {
|
||||
if (yTextureURL != _yTextureURL) {
|
||||
void RenderablePolyVoxEntityItem::setYTextureURL(const QString& yTextureURL) {
|
||||
if (yTextureURL != getYTextureURL()) {
|
||||
_yTexture.clear();
|
||||
PolyVoxEntityItem::setYTextureURL(yTextureURL);
|
||||
}
|
||||
}
|
||||
|
||||
void RenderablePolyVoxEntityItem::setZTextureURL(QString zTextureURL) {
|
||||
if (zTextureURL != _zTextureURL) {
|
||||
void RenderablePolyVoxEntityItem::setZTextureURL(const QString& zTextureURL) {
|
||||
if (zTextureURL != getZTextureURL()) {
|
||||
_zTexture.clear();
|
||||
PolyVoxEntityItem::setZTextureURL(zTextureURL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -101,9 +101,9 @@ public:
|
|||
virtual bool setAll(uint8_t toValue) override;
|
||||
virtual bool setCuboid(const glm::vec3& lowPosition, const glm::vec3& cuboidSize, int toValue) override;
|
||||
|
||||
virtual void setXTextureURL(QString xTextureURL) override;
|
||||
virtual void setYTextureURL(QString yTextureURL) override;
|
||||
virtual void setZTextureURL(QString zTextureURL) override;
|
||||
virtual void setXTextureURL(const QString& xTextureURL) override;
|
||||
virtual void setYTextureURL(const QString& yTextureURL) override;
|
||||
virtual void setZTextureURL(const QString& zTextureURL) override;
|
||||
|
||||
virtual bool addToScene(EntityItemPointer self,
|
||||
std::shared_ptr<render::Scene> scene,
|
||||
|
|
|
|||
|
|
@ -77,14 +77,16 @@ void RenderableTextEntityItem::render(RenderArgs* args) {
|
|||
geometryCache->bindSimpleProgram(batch, false, transparent, false, false, true);
|
||||
geometryCache->renderQuad(batch, minCorner, maxCorner, backgroundColor, _geometryID);
|
||||
|
||||
float scale = _lineHeight / _textRenderer->getFontSize();
|
||||
float lineheight = getLineHeight();
|
||||
float scale = lineheight / _textRenderer->getFontSize();
|
||||
transformToTopLeft.setScale(scale); // Scale to have the correct line height
|
||||
batch.setModelTransform(transformToTopLeft);
|
||||
|
||||
float leftMargin = 0.1f * _lineHeight, topMargin = 0.1f * _lineHeight;
|
||||
float leftMargin = 0.1f * lineheight, topMargin = 0.1f * lineheight;
|
||||
glm::vec2 bounds = glm::vec2(dimensions.x - 2.0f * leftMargin,
|
||||
dimensions.y - 2.0f * topMargin);
|
||||
_textRenderer->draw(batch, leftMargin / scale, -topMargin / scale, _text, textColor, bounds / scale);
|
||||
auto text = getText();
|
||||
_textRenderer->draw(batch, leftMargin / scale, -topMargin / scale, text, textColor, bounds / scale);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -683,7 +683,7 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
|
|||
// However, for now, when the server uses a newer time than what we sent, listen to what we're told.
|
||||
if (overwriteLocalData) weOwnSimulation = false;
|
||||
} else if (_simulationOwner.set(newSimOwner)) {
|
||||
_dirtyFlags |= Simulation::DIRTY_SIMULATOR_ID;
|
||||
markDirtyFlags(Simulation::DIRTY_SIMULATOR_ID);
|
||||
somethingChanged = true;
|
||||
// recompute weOwnSimulation for later
|
||||
weOwnSimulation = _simulationOwner.matchesValidID(myNodeID);
|
||||
|
|
@ -695,19 +695,19 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
|
|||
weOwnSimulation = true;
|
||||
if (!_simulationOwner.isNull()) {
|
||||
// someone else really did own it
|
||||
_dirtyFlags |= Simulation::DIRTY_SIMULATOR_ID;
|
||||
markDirtyFlags(Simulation::DIRTY_SIMULATOR_ID);
|
||||
somethingChanged = true;
|
||||
_simulationOwner.clearCurrentOwner();
|
||||
}
|
||||
} else if (newSimOwner.matchesValidID(myNodeID) && !_hasBidOnSimulation) {
|
||||
// entity-server tells us that we have simulation ownership while we never requested this for this EntityItem,
|
||||
// this could happen when the user reloads the cache and entity tree.
|
||||
_dirtyFlags |= Simulation::DIRTY_SIMULATOR_ID;
|
||||
markDirtyFlags(Simulation::DIRTY_SIMULATOR_ID);
|
||||
somethingChanged = true;
|
||||
_simulationOwner.clearCurrentOwner();
|
||||
weOwnSimulation = false;
|
||||
} else if (_simulationOwner.set(newSimOwner)) {
|
||||
_dirtyFlags |= Simulation::DIRTY_SIMULATOR_ID;
|
||||
markDirtyFlags(Simulation::DIRTY_SIMULATOR_ID);
|
||||
somethingChanged = true;
|
||||
// recompute weOwnSimulation for later
|
||||
weOwnSimulation = _simulationOwner.matchesValidID(myNodeID);
|
||||
|
|
@ -909,19 +909,23 @@ void EntityItem::adjustEditPacketForClockSkew(QByteArray& buffer, qint64 clockSk
|
|||
|
||||
float EntityItem::computeMass() const {
|
||||
glm::vec3 dimensions = getDimensions();
|
||||
return _density * _volumeMultiplier * dimensions.x * dimensions.y * dimensions.z;
|
||||
return getDensity() * _volumeMultiplier * dimensions.x * dimensions.y * dimensions.z;
|
||||
}
|
||||
|
||||
void EntityItem::setDensity(float density) {
|
||||
_density = glm::max(glm::min(density, ENTITY_ITEM_MAX_DENSITY), ENTITY_ITEM_MIN_DENSITY);
|
||||
withWriteLock([&] {
|
||||
_density = glm::max(glm::min(density, ENTITY_ITEM_MAX_DENSITY), ENTITY_ITEM_MIN_DENSITY);
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::updateDensity(float density) {
|
||||
float clampedDensity = glm::max(glm::min(density, ENTITY_ITEM_MAX_DENSITY), ENTITY_ITEM_MIN_DENSITY);
|
||||
if (_density != clampedDensity) {
|
||||
_density = clampedDensity;
|
||||
_dirtyFlags |= Simulation::DIRTY_MASS;
|
||||
}
|
||||
withWriteLock([&] {
|
||||
if (_density != clampedDensity) {
|
||||
_density = clampedDensity;
|
||||
_dirtyFlags |= Simulation::DIRTY_MASS;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::setMass(float mass) {
|
||||
|
|
@ -941,10 +945,12 @@ void EntityItem::setMass(float mass) {
|
|||
} else {
|
||||
newDensity = glm::max(glm::min(mass / volume, ENTITY_ITEM_MAX_DENSITY), ENTITY_ITEM_MIN_DENSITY);
|
||||
}
|
||||
if (_density != newDensity) {
|
||||
_density = newDensity;
|
||||
_dirtyFlags |= Simulation::DIRTY_MASS;
|
||||
}
|
||||
withWriteLock([&] {
|
||||
if (_density != newDensity) {
|
||||
_density = newDensity;
|
||||
_dirtyFlags |= Simulation::DIRTY_MASS;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::setHref(QString value) {
|
||||
|
|
@ -952,32 +958,47 @@ void EntityItem::setHref(QString value) {
|
|||
if (! (value.toLower().startsWith("hifi://")) ) {
|
||||
return;
|
||||
}
|
||||
_href = value;
|
||||
withWriteLock([&] {
|
||||
_href = value;
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::setCollisionSoundURL(const QString& value) {
|
||||
if (_collisionSoundURL != value) {
|
||||
_collisionSoundURL = value;
|
||||
|
||||
bool modified = false;
|
||||
withWriteLock([&] {
|
||||
if (_collisionSoundURL != value) {
|
||||
_collisionSoundURL = value;
|
||||
modified = true;
|
||||
}
|
||||
});
|
||||
if (modified) {
|
||||
if (auto myTree = getTree()) {
|
||||
myTree->notifyNewCollisionSoundURL(_collisionSoundURL, getEntityItemID());
|
||||
myTree->notifyNewCollisionSoundURL(value, getEntityItemID());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SharedSoundPointer EntityItem::getCollisionSound() {
|
||||
if (!_collisionSound) {
|
||||
_collisionSound = DependencyManager::get<SoundCache>()->getSound(_collisionSoundURL);
|
||||
SharedSoundPointer result;
|
||||
withReadLock([&] {
|
||||
result = _collisionSound;
|
||||
});
|
||||
|
||||
if (!result) {
|
||||
result = DependencyManager::get<SoundCache>()->getSound(_collisionSoundURL);
|
||||
withWriteLock([&] {
|
||||
_collisionSound = result;
|
||||
});
|
||||
}
|
||||
return _collisionSound;
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::simulate(const quint64& now) {
|
||||
if (_lastSimulated == 0) {
|
||||
_lastSimulated = now;
|
||||
if (getLastSimulated() == 0) {
|
||||
setLastSimulated(now);
|
||||
}
|
||||
|
||||
float timeElapsed = (float)(now - _lastSimulated) / (float)(USECS_PER_SECOND);
|
||||
float timeElapsed = (float)(now - getLastSimulated()) / (float)(USECS_PER_SECOND);
|
||||
|
||||
#ifdef WANT_DEBUG
|
||||
qCDebug(entities) << "********** EntityItem::simulate()";
|
||||
|
|
@ -1021,10 +1042,10 @@ void EntityItem::simulate(const quint64& now) {
|
|||
if (!stepKinematicMotion(timeElapsed)) {
|
||||
// this entity is no longer moving
|
||||
// flag it to transition from KINEMATIC to STATIC
|
||||
_dirtyFlags |= Simulation::DIRTY_MOTION_TYPE;
|
||||
markDirtyFlags(Simulation::DIRTY_MOTION_TYPE);
|
||||
setAcceleration(Vectors::ZERO);
|
||||
}
|
||||
_lastSimulated = now;
|
||||
setLastSimulated(now);
|
||||
}
|
||||
|
||||
bool EntityItem::stepKinematicMotion(float timeElapsed) {
|
||||
|
|
@ -1056,9 +1077,10 @@ bool EntityItem::stepKinematicMotion(float timeElapsed) {
|
|||
timeElapsed = glm::min(timeElapsed, MAX_TIME_ELAPSED);
|
||||
|
||||
if (isSpinning) {
|
||||
float angularDamping = getAngularDamping();
|
||||
// angular damping
|
||||
if (_angularDamping > 0.0f) {
|
||||
angularVelocity *= powf(1.0f - _angularDamping, timeElapsed);
|
||||
if (angularDamping > 0.0f) {
|
||||
angularVelocity *= powf(1.0f - angularDamping, timeElapsed);
|
||||
}
|
||||
|
||||
const float MIN_KINEMATIC_ANGULAR_SPEED_SQUARED =
|
||||
|
|
@ -1086,15 +1108,17 @@ bool EntityItem::stepKinematicMotion(float timeElapsed) {
|
|||
glm::vec3 deltaVelocity = Vectors::ZERO;
|
||||
|
||||
// linear damping
|
||||
if (_damping > 0.0f) {
|
||||
deltaVelocity = (powf(1.0f - _damping, timeElapsed) - 1.0f) * linearVelocity;
|
||||
float damping = getDamping();
|
||||
if (damping > 0.0f) {
|
||||
deltaVelocity = (powf(1.0f - damping, timeElapsed) - 1.0f) * linearVelocity;
|
||||
}
|
||||
|
||||
const float MIN_KINEMATIC_LINEAR_ACCELERATION_SQUARED = 1.0e-4f; // 0.01 m/sec^2
|
||||
if (glm::length2(_acceleration) > MIN_KINEMATIC_LINEAR_ACCELERATION_SQUARED) {
|
||||
vec3 acceleration = getAcceleration();
|
||||
if (glm::length2(acceleration) > MIN_KINEMATIC_LINEAR_ACCELERATION_SQUARED) {
|
||||
// yes acceleration
|
||||
// acceleration is in world-frame but we need it in local-frame
|
||||
glm::vec3 linearAcceleration = _acceleration;
|
||||
glm::vec3 linearAcceleration = acceleration;
|
||||
bool success;
|
||||
Transform parentTransform = getParentTransform(success);
|
||||
if (success) {
|
||||
|
|
@ -1180,7 +1204,7 @@ bool EntityItem::lifetimeHasExpired() const {
|
|||
}
|
||||
|
||||
quint64 EntityItem::getExpiry() const {
|
||||
return _created + (quint64)(_lifetime * (float)USECS_PER_SECOND);
|
||||
return getCreated() + (quint64)(getLifetime() * (float)USECS_PER_SECOND);
|
||||
}
|
||||
|
||||
EntityItemProperties EntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
|
||||
|
|
@ -1189,10 +1213,10 @@ EntityItemProperties EntityItem::getProperties(EntityPropertyFlags desiredProper
|
|||
EntityItemProperties properties(propertyFlags);
|
||||
properties._id = getID();
|
||||
properties._idSet = true;
|
||||
properties._created = _created;
|
||||
properties._lastEdited = _lastEdited;
|
||||
properties.setClientOnly(_clientOnly);
|
||||
properties.setOwningAvatarID(_owningAvatarID);
|
||||
properties._created = getCreated();
|
||||
properties._lastEdited = getLastEdited();
|
||||
properties.setClientOnly(getClientOnly());
|
||||
properties.setOwningAvatarID(getOwningAvatarID());
|
||||
|
||||
properties._type = getType();
|
||||
|
||||
|
|
@ -1259,7 +1283,7 @@ void EntityItem::getAllTerseUpdateProperties(EntityItemProperties& properties) c
|
|||
properties._angularVelocity = getLocalAngularVelocity();
|
||||
}
|
||||
if (!properties._accelerationChanged) {
|
||||
properties._acceleration = _acceleration;
|
||||
properties._acceleration = getAcceleration();
|
||||
}
|
||||
|
||||
properties._positionChanged = true;
|
||||
|
|
@ -1270,7 +1294,7 @@ void EntityItem::getAllTerseUpdateProperties(EntityItemProperties& properties) c
|
|||
}
|
||||
|
||||
void EntityItem::pokeSimulationOwnership() {
|
||||
_dirtyFlags |= Simulation::DIRTY_SIMULATION_OWNERSHIP_FOR_POKE;
|
||||
markDirtyFlags(Simulation::DIRTY_SIMULATION_OWNERSHIP_FOR_POKE);
|
||||
auto nodeList = DependencyManager::get<NodeList>();
|
||||
if (_simulationOwner.matchesValidID(nodeList->getSessionUUID())) {
|
||||
// we already own it
|
||||
|
|
@ -1282,7 +1306,7 @@ void EntityItem::pokeSimulationOwnership() {
|
|||
}
|
||||
|
||||
void EntityItem::grabSimulationOwnership() {
|
||||
_dirtyFlags |= Simulation::DIRTY_SIMULATION_OWNERSHIP_FOR_GRAB;
|
||||
markDirtyFlags(Simulation::DIRTY_SIMULATION_OWNERSHIP_FOR_GRAB);
|
||||
auto nodeList = DependencyManager::get<NodeList>();
|
||||
if (_simulationOwner.matchesValidID(nodeList->getSessionUUID())) {
|
||||
// we already own it
|
||||
|
|
@ -1575,18 +1599,18 @@ float EntityItem::getVolumeEstimate() const {
|
|||
void EntityItem::updateRegistrationPoint(const glm::vec3& value) {
|
||||
if (value != _registrationPoint) {
|
||||
setRegistrationPoint(value);
|
||||
_dirtyFlags |= Simulation::DIRTY_SHAPE;
|
||||
markDirtyFlags(Simulation::DIRTY_SHAPE);
|
||||
}
|
||||
}
|
||||
|
||||
void EntityItem::updatePosition(const glm::vec3& value) {
|
||||
if (getLocalPosition() != value) {
|
||||
setLocalPosition(value);
|
||||
_dirtyFlags |= Simulation::DIRTY_POSITION;
|
||||
markDirtyFlags(Simulation::DIRTY_POSITION);
|
||||
forEachDescendant([&](SpatiallyNestablePointer object) {
|
||||
if (object->getNestableType() == NestableType::Entity) {
|
||||
EntityItemPointer entity = std::static_pointer_cast<EntityItem>(object);
|
||||
entity->_dirtyFlags |= Simulation::DIRTY_POSITION;
|
||||
entity->markDirtyFlags(Simulation::DIRTY_POSITION);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
|
@ -1595,8 +1619,9 @@ void EntityItem::updatePosition(const glm::vec3& value) {
|
|||
void EntityItem::updateParentID(const QUuid& value) {
|
||||
if (getParentID() != value) {
|
||||
setParentID(value);
|
||||
_dirtyFlags |= Simulation::DIRTY_MOTION_TYPE; // children are forced to be kinematic
|
||||
_dirtyFlags |= Simulation::DIRTY_COLLISION_GROUP; // may need to not collide with own avatar
|
||||
// children are forced to be kinematic
|
||||
// may need to not collide with own avatar
|
||||
markDirtyFlags(Simulation::DIRTY_MOTION_TYPE | Simulation::DIRTY_COLLISION_GROUP);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1610,7 +1635,7 @@ void EntityItem::updatePositionFromNetwork(const glm::vec3& value) {
|
|||
void EntityItem::updateDimensions(const glm::vec3& value) {
|
||||
if (getDimensions() != value) {
|
||||
setDimensions(value);
|
||||
_dirtyFlags |= (Simulation::DIRTY_SHAPE | Simulation::DIRTY_MASS);
|
||||
markDirtyFlags(Simulation::DIRTY_SHAPE | Simulation::DIRTY_MASS);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1621,8 +1646,7 @@ void EntityItem::updateRotation(const glm::quat& rotation) {
|
|||
forEachDescendant([&](SpatiallyNestablePointer object) {
|
||||
if (object->getNestableType() == NestableType::Entity) {
|
||||
EntityItemPointer entity = std::static_pointer_cast<EntityItem>(object);
|
||||
entity->_dirtyFlags |= Simulation::DIRTY_ROTATION;
|
||||
entity->_dirtyFlags |= Simulation::DIRTY_POSITION;
|
||||
entity->markDirtyFlags(Simulation::DIRTY_ROTATION | Simulation::DIRTY_POSITION);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
|
@ -1777,20 +1801,26 @@ void EntityItem::updateRestitution(float value) {
|
|||
|
||||
void EntityItem::updateFriction(float value) {
|
||||
float clampedValue = glm::max(glm::min(ENTITY_ITEM_MAX_FRICTION, value), ENTITY_ITEM_MIN_FRICTION);
|
||||
if (_friction != clampedValue) {
|
||||
_friction = clampedValue;
|
||||
_dirtyFlags |= Simulation::DIRTY_MATERIAL;
|
||||
}
|
||||
withWriteLock([&] {
|
||||
if (_friction != clampedValue) {
|
||||
_friction = clampedValue;
|
||||
_dirtyFlags |= Simulation::DIRTY_MATERIAL;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::setRestitution(float value) {
|
||||
float clampedValue = glm::max(glm::min(ENTITY_ITEM_MAX_RESTITUTION, value), ENTITY_ITEM_MIN_RESTITUTION);
|
||||
_restitution = clampedValue;
|
||||
withWriteLock([&] {
|
||||
_restitution = clampedValue;
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::setFriction(float value) {
|
||||
float clampedValue = glm::max(glm::min(ENTITY_ITEM_MAX_FRICTION, value), ENTITY_ITEM_MIN_FRICTION);
|
||||
_friction = clampedValue;
|
||||
withWriteLock([&] {
|
||||
_friction = clampedValue;
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::updateLifetime(float value) {
|
||||
|
|
@ -1883,7 +1913,7 @@ void EntityItem::updateSimulationOwner(const SimulationOwner& owner) {
|
|||
}
|
||||
|
||||
if (_simulationOwner.set(owner)) {
|
||||
_dirtyFlags |= Simulation::DIRTY_SIMULATOR_ID;
|
||||
markDirtyFlags(Simulation::DIRTY_SIMULATOR_ID);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1896,7 +1926,7 @@ void EntityItem::clearSimulationOwnership() {
|
|||
// don't bother setting the DIRTY_SIMULATOR_ID flag because:
|
||||
// (a) when entity-server calls clearSimulationOwnership() the dirty-flags are meaningless (only used by interface)
|
||||
// (b) the interface only calls clearSimulationOwnership() in a context that already knows best about dirty flags
|
||||
//_dirtyFlags |= Simulation::DIRTY_SIMULATOR_ID;
|
||||
//markDirtyFlags(Simulation::DIRTY_SIMULATOR_ID);
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -2103,7 +2133,7 @@ void EntityItem::deserializeActionsInternal() {
|
|||
static QString repeatedMessage =
|
||||
LogHandler::getInstance().addRepeatedMessageRegex(".*action creation failed for.*");
|
||||
qCDebug(entities) << "EntityItem::deserializeActionsInternal -- action creation failed for"
|
||||
<< getID() << getName();
|
||||
<< getID() << _name; // getName();
|
||||
removeActionInternal(actionID, nullptr);
|
||||
}
|
||||
}
|
||||
|
|
@ -2327,3 +2357,443 @@ bool EntityItem::matchesJSONFilters(const QJsonObject& jsonFilters) const {
|
|||
// the json filter syntax did not match what we expected, return a match
|
||||
return true;
|
||||
}
|
||||
|
||||
quint64 EntityItem::getLastSimulated() const {
|
||||
quint64 result;
|
||||
withReadLock([&] {
|
||||
result = _lastSimulated;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setLastSimulated(quint64 now) {
|
||||
withWriteLock([&] {
|
||||
_lastSimulated = now;
|
||||
});
|
||||
}
|
||||
|
||||
quint64 EntityItem::getLastEdited() const {
|
||||
quint64 result;
|
||||
withReadLock([&] {
|
||||
result = _lastEdited;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setLastEdited(quint64 lastEdited) {
|
||||
withWriteLock([&] {
|
||||
_lastEdited = _lastUpdated = lastEdited;
|
||||
_changedOnServer = glm::max(lastEdited, _changedOnServer);
|
||||
});
|
||||
}
|
||||
|
||||
quint64 EntityItem::getLastBroadcast() const {
|
||||
quint64 result;
|
||||
withReadLock([&] {
|
||||
result = _lastBroadcast;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setLastBroadcast(quint64 lastBroadcast) {
|
||||
withWriteLock([&] {
|
||||
_lastBroadcast = lastBroadcast;
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::markAsChangedOnServer() {
|
||||
withWriteLock([&] {
|
||||
_changedOnServer = usecTimestampNow();
|
||||
});
|
||||
}
|
||||
|
||||
quint64 EntityItem::getLastChangedOnServer() const {
|
||||
quint64 result;
|
||||
withReadLock([&] {
|
||||
result = _changedOnServer;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::update(const quint64& now) {
|
||||
withWriteLock([&] {
|
||||
_lastUpdated = now;
|
||||
});
|
||||
}
|
||||
|
||||
quint64 EntityItem::getLastUpdated() const {
|
||||
quint64 result;
|
||||
withReadLock([&] {
|
||||
result = _lastUpdated;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::requiresRecalcBoxes() {
|
||||
withWriteLock([&] {
|
||||
_recalcAABox = true;
|
||||
_recalcMinAACube = true;
|
||||
_recalcMaxAACube = true;
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getHref() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _href;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
QString EntityItem::getDescription() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _description;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setDescription(const QString& value) {
|
||||
withWriteLock([&] {
|
||||
_description = value;
|
||||
});
|
||||
}
|
||||
|
||||
float EntityItem::getLocalRenderAlpha() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _localRenderAlpha;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setLocalRenderAlpha(float localRenderAlpha) {
|
||||
withWriteLock([&] {
|
||||
_localRenderAlpha = localRenderAlpha;
|
||||
});
|
||||
}
|
||||
|
||||
glm::vec3 EntityItem::getGravity() const {
|
||||
glm::vec3 result;
|
||||
withReadLock([&] {
|
||||
result = _gravity;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setGravity(const glm::vec3& value) {
|
||||
withWriteLock([&] {
|
||||
_gravity = value;
|
||||
});
|
||||
}
|
||||
|
||||
glm::vec3 EntityItem::getAcceleration() const {
|
||||
glm::vec3 result;
|
||||
withReadLock([&] {
|
||||
result = _acceleration;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setAcceleration(const glm::vec3& value) {
|
||||
withWriteLock([&] {
|
||||
_acceleration = value;
|
||||
});
|
||||
}
|
||||
|
||||
float EntityItem::getDamping() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _damping;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
void EntityItem::setDamping(float value) {
|
||||
withWriteLock([&] {
|
||||
_damping = value;
|
||||
});
|
||||
}
|
||||
|
||||
float EntityItem::getRestitution() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _restitution;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
float EntityItem::getFriction() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _friction;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
// lifetime related properties.
|
||||
float EntityItem::getLifetime() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _lifetime;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setLifetime(float value) {
|
||||
withWriteLock([&] {
|
||||
_lifetime = value;
|
||||
});
|
||||
}
|
||||
|
||||
quint64 EntityItem::getCreated() const {
|
||||
quint64 result;
|
||||
withReadLock([&] {
|
||||
result = _created;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setCreated(quint64 value) {
|
||||
withWriteLock([&] {
|
||||
_created = value;
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getScript() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _script;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setScript(const QString& value) {
|
||||
withWriteLock([&] {
|
||||
_script = value;
|
||||
});
|
||||
}
|
||||
|
||||
quint64 EntityItem::getScriptTimestamp() const {
|
||||
quint64 result;
|
||||
withReadLock([&] {
|
||||
result = _scriptTimestamp;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setScriptTimestamp(const quint64 value) {
|
||||
withWriteLock([&] {
|
||||
_scriptTimestamp = value;
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getServerScripts() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _serverScripts;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setServerScripts(const QString& serverScripts) {
|
||||
withWriteLock([&] {
|
||||
_serverScripts = serverScripts;
|
||||
_serverScriptsChangedTimestamp = usecTimestampNow();
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getCollisionSoundURL() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _collisionSoundURL;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setCollisionSound(SharedSoundPointer sound) {
|
||||
withWriteLock([&] {
|
||||
_collisionSound = sound;
|
||||
});
|
||||
}
|
||||
|
||||
glm::vec3 EntityItem::getRegistrationPoint() const {
|
||||
glm::vec3 result;
|
||||
withReadLock([&] {
|
||||
result = _registrationPoint;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setRegistrationPoint(const glm::vec3& value) {
|
||||
withWriteLock([&] {
|
||||
_registrationPoint = glm::clamp(value, 0.0f, 1.0f);
|
||||
});
|
||||
dimensionsChanged(); // Registration Point affects the bounding box
|
||||
}
|
||||
|
||||
float EntityItem::getAngularDamping() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _angularDamping;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setAngularDamping(float value) {
|
||||
withWriteLock([&] {
|
||||
_angularDamping = value;
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getName() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _name;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setName(const QString& value) {
|
||||
withWriteLock([&] {
|
||||
_name = value;
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getDebugName() {
|
||||
QString result = getName();
|
||||
if (result.isEmpty()) {
|
||||
result = getID().toString();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool EntityItem::getVisible() const {
|
||||
bool result;
|
||||
withReadLock([&] {
|
||||
result = _visible;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setVisible(bool value) {
|
||||
withWriteLock([&] {
|
||||
_visible = value;
|
||||
});
|
||||
}
|
||||
|
||||
bool EntityItem::getCollisionless() const {
|
||||
bool result;
|
||||
withReadLock([&] {
|
||||
result = _collisionless;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setCollisionless(bool value) {
|
||||
withWriteLock([&] {
|
||||
_collisionless = value;
|
||||
});
|
||||
}
|
||||
|
||||
uint8_t EntityItem::getCollisionMask() const {
|
||||
uint8_t result;
|
||||
withReadLock([&] {
|
||||
result = _collisionMask;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setCollisionMask(uint8_t value) {
|
||||
withWriteLock([&] {
|
||||
_collisionMask = value;
|
||||
});
|
||||
}
|
||||
|
||||
bool EntityItem::getDynamic() const {
|
||||
if (SHAPE_TYPE_STATIC_MESH == getShapeType()) {
|
||||
return false;
|
||||
}
|
||||
bool result;
|
||||
withReadLock([&] {
|
||||
result = _dynamic;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setDynamic(bool value) {
|
||||
withWriteLock([&] {
|
||||
_dynamic = value;
|
||||
});
|
||||
}
|
||||
|
||||
bool EntityItem::getLocked() const {
|
||||
bool result;
|
||||
withReadLock([&] {
|
||||
result = _locked;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setLocked(bool value) {
|
||||
withWriteLock([&] {
|
||||
_locked = value;
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getUserData() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _userData;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setUserData(const QString& value) {
|
||||
withWriteLock([&] {
|
||||
_userData = value;
|
||||
});
|
||||
}
|
||||
|
||||
QString EntityItem::getMarketplaceID() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _marketplaceID;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void EntityItem::setMarketplaceID(const QString& value) {
|
||||
withWriteLock([&] {
|
||||
_marketplaceID = value;
|
||||
});
|
||||
}
|
||||
|
||||
uint32_t EntityItem::getDirtyFlags() const {
|
||||
uint32_t result;
|
||||
withReadLock([&] {
|
||||
result = _dirtyFlags;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
void EntityItem::markDirtyFlags(uint32_t mask) {
|
||||
withWriteLock([&] {
|
||||
_dirtyFlags |= mask;
|
||||
});
|
||||
}
|
||||
|
||||
void EntityItem::clearDirtyFlags(uint32_t mask) {
|
||||
withWriteLock([&] {
|
||||
_dirtyFlags &= ~mask;
|
||||
});
|
||||
}
|
||||
|
||||
float EntityItem::getDensity() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _density;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -110,22 +110,21 @@ public:
|
|||
virtual void somethingChangedNotification() { }
|
||||
|
||||
void recordCreationTime(); // set _created to 'now'
|
||||
quint64 getLastSimulated() const { return _lastSimulated; } /// Last simulated time of this entity universal usecs
|
||||
void setLastSimulated(quint64 now) { _lastSimulated = now; }
|
||||
quint64 getLastSimulated() const; /// Last simulated time of this entity universal usecs
|
||||
void setLastSimulated(quint64 now);
|
||||
|
||||
/// Last edited time of this entity universal usecs
|
||||
quint64 getLastEdited() const { return _lastEdited; }
|
||||
void setLastEdited(quint64 lastEdited)
|
||||
{ _lastEdited = _lastUpdated = lastEdited; _changedOnServer = glm::max(lastEdited, _changedOnServer); }
|
||||
quint64 getLastEdited() const;
|
||||
void setLastEdited(quint64 lastEdited);
|
||||
float getEditedAgo() const /// Elapsed seconds since this entity was last edited
|
||||
{ return (float)(usecTimestampNow() - getLastEdited()) / (float)USECS_PER_SECOND; }
|
||||
|
||||
/// Last time we sent out an edit packet for this entity
|
||||
quint64 getLastBroadcast() const { return _lastBroadcast; }
|
||||
void setLastBroadcast(quint64 lastBroadcast) { _lastBroadcast = lastBroadcast; }
|
||||
quint64 getLastBroadcast() const;
|
||||
void setLastBroadcast(quint64 lastBroadcast);
|
||||
|
||||
void markAsChangedOnServer() { _changedOnServer = usecTimestampNow(); }
|
||||
quint64 getLastChangedOnServer() const { return _changedOnServer; }
|
||||
void markAsChangedOnServer();
|
||||
quint64 getLastChangedOnServer() const;
|
||||
|
||||
// TODO: eventually only include properties changed since the params.lastQuerySent time
|
||||
virtual EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const;
|
||||
|
|
@ -163,8 +162,8 @@ public:
|
|||
static void adjustEditPacketForClockSkew(QByteArray& buffer, qint64 clockSkew);
|
||||
|
||||
// perform update
|
||||
virtual void update(const quint64& now) { _lastUpdated = now; }
|
||||
quint64 getLastUpdated() const { return _lastUpdated; }
|
||||
virtual void update(const quint64& now);
|
||||
quint64 getLastUpdated() const;
|
||||
|
||||
// perform linear extrapolation for SimpleEntitySimulation
|
||||
void simulate(const quint64& now);
|
||||
|
|
@ -188,63 +187,63 @@ public:
|
|||
|
||||
const Transform getTransformToCenter(bool& success) const;
|
||||
|
||||
inline void requiresRecalcBoxes() { _recalcAABox = true; _recalcMinAACube = true; _recalcMaxAACube = true; }
|
||||
inline void requiresRecalcBoxes();
|
||||
|
||||
// Hyperlink related getters and setters
|
||||
QString getHref() const { return _href; }
|
||||
QString getHref() const;
|
||||
void setHref(QString value);
|
||||
|
||||
QString getDescription() const { return _description; }
|
||||
void setDescription(QString value) { _description = value; }
|
||||
QString getDescription() const;
|
||||
void setDescription(const QString& value);
|
||||
|
||||
/// Dimensions in meters (0.0 - TREE_SCALE)
|
||||
inline const glm::vec3 getDimensions() const { return getScale(); }
|
||||
virtual void setDimensions(const glm::vec3& value);
|
||||
|
||||
float getLocalRenderAlpha() const { return _localRenderAlpha; }
|
||||
void setLocalRenderAlpha(float localRenderAlpha) { _localRenderAlpha = localRenderAlpha; }
|
||||
float getLocalRenderAlpha() const;
|
||||
void setLocalRenderAlpha(float localRenderAlpha);
|
||||
|
||||
void setDensity(float density);
|
||||
float computeMass() const;
|
||||
void setMass(float mass);
|
||||
|
||||
float getDensity() const { return _density; }
|
||||
float getDensity() const;
|
||||
|
||||
bool hasVelocity() const { return getVelocity() != ENTITY_ITEM_ZERO_VEC3; }
|
||||
bool hasLocalVelocity() const { return getLocalVelocity() != ENTITY_ITEM_ZERO_VEC3; }
|
||||
|
||||
const glm::vec3& getGravity() const { return _gravity; } /// get gravity in meters
|
||||
void setGravity(const glm::vec3& value) { _gravity = value; } /// gravity in meters
|
||||
bool hasGravity() const { return _gravity != ENTITY_ITEM_ZERO_VEC3; }
|
||||
glm::vec3 getGravity() const; /// get gravity in meters
|
||||
void setGravity(const glm::vec3& value); /// gravity in meters
|
||||
bool hasGravity() const { return getGravity() != ENTITY_ITEM_ZERO_VEC3; }
|
||||
|
||||
const glm::vec3& getAcceleration() const { return _acceleration; } /// get acceleration in meters/second/second
|
||||
void setAcceleration(const glm::vec3& value) { _acceleration = value; } /// acceleration in meters/second/second
|
||||
bool hasAcceleration() const { return _acceleration != ENTITY_ITEM_ZERO_VEC3; }
|
||||
glm::vec3 getAcceleration() const; /// get acceleration in meters/second/second
|
||||
void setAcceleration(const glm::vec3& value); /// acceleration in meters/second/second
|
||||
bool hasAcceleration() const { return getAcceleration() != ENTITY_ITEM_ZERO_VEC3; }
|
||||
|
||||
float getDamping() const { return _damping; }
|
||||
void setDamping(float value) { _damping = value; }
|
||||
float getDamping() const;
|
||||
void setDamping(float value);
|
||||
|
||||
float getRestitution() const { return _restitution; }
|
||||
float getRestitution() const;
|
||||
void setRestitution(float value);
|
||||
|
||||
float getFriction() const { return _friction; }
|
||||
float getFriction() const;
|
||||
void setFriction(float value);
|
||||
|
||||
// lifetime related properties.
|
||||
float getLifetime() const { return _lifetime; } /// get the lifetime in seconds for the entity
|
||||
void setLifetime(float value) { _lifetime = value; } /// set the lifetime in seconds for the entity
|
||||
float getLifetime() const; /// get the lifetime in seconds for the entity
|
||||
void setLifetime(float value); /// set the lifetime in seconds for the entity
|
||||
|
||||
quint64 getCreated() const { return _created; } /// get the created-time in useconds for the entity
|
||||
void setCreated(quint64 value) { _created = value; } /// set the created-time in useconds for the entity
|
||||
quint64 getCreated() const; /// get the created-time in useconds for the entity
|
||||
void setCreated(quint64 value); /// set the created-time in useconds for the entity
|
||||
|
||||
/// is this entity immortal, in that it has no lifetime set, and will exist until manually deleted
|
||||
bool isImmortal() const { return _lifetime == ENTITY_ITEM_IMMORTAL_LIFETIME; }
|
||||
bool isImmortal() const { return getLifetime() == ENTITY_ITEM_IMMORTAL_LIFETIME; }
|
||||
|
||||
/// is this entity mortal, in that it has a lifetime set, and will automatically be deleted when that lifetime expires
|
||||
bool isMortal() const { return _lifetime != ENTITY_ITEM_IMMORTAL_LIFETIME; }
|
||||
bool isMortal() const { return getLifetime() != ENTITY_ITEM_IMMORTAL_LIFETIME; }
|
||||
|
||||
/// age of this entity in seconds
|
||||
float getAge() const { return (float)(usecTimestampNow() - _created) / (float)USECS_PER_SECOND; }
|
||||
float getAge() const { return (float)(usecTimestampNow() - getCreated()) / (float)USECS_PER_SECOND; }
|
||||
bool lifetimeHasExpired() const;
|
||||
quint64 getExpiry() const;
|
||||
|
||||
|
|
@ -256,63 +255,61 @@ public:
|
|||
using SpatiallyNestable::getQueryAACube;
|
||||
virtual AACube getQueryAACube(bool& success) const override;
|
||||
|
||||
QString getScript() const { return _script; }
|
||||
void setScript(const QString& value) { _script = value; }
|
||||
QString getScript() const;
|
||||
void setScript(const QString& value);
|
||||
|
||||
quint64 getScriptTimestamp() const { return _scriptTimestamp; }
|
||||
void setScriptTimestamp(const quint64 value) { _scriptTimestamp = value; }
|
||||
quint64 getScriptTimestamp() const;
|
||||
void setScriptTimestamp(const quint64 value);
|
||||
|
||||
QString getServerScripts() const { return _serverScripts; }
|
||||
void setServerScripts(const QString& serverScripts)
|
||||
{ _serverScripts = serverScripts; _serverScriptsChangedTimestamp = usecTimestampNow(); }
|
||||
QString getServerScripts() const;
|
||||
void setServerScripts(const QString& serverScripts);
|
||||
|
||||
const QString& getCollisionSoundURL() const { return _collisionSoundURL; }
|
||||
QString getCollisionSoundURL() const;
|
||||
void setCollisionSoundURL(const QString& value);
|
||||
|
||||
SharedSoundPointer getCollisionSound();
|
||||
void setCollisionSound(SharedSoundPointer sound) { _collisionSound = sound; }
|
||||
void setCollisionSound(SharedSoundPointer sound);
|
||||
|
||||
const glm::vec3& getRegistrationPoint() const { return _registrationPoint; } /// registration point as ratio of entity
|
||||
glm::vec3 getRegistrationPoint() const; /// registration point as ratio of entity
|
||||
|
||||
/// registration point as ratio of entity
|
||||
void setRegistrationPoint(const glm::vec3& value) {
|
||||
_registrationPoint = glm::clamp(value, 0.0f, 1.0f); dimensionsChanged(); // Registration Point affects the bounding box
|
||||
}
|
||||
void setRegistrationPoint(const glm::vec3& value);
|
||||
|
||||
bool hasAngularVelocity() const { return getAngularVelocity() != ENTITY_ITEM_ZERO_VEC3; }
|
||||
bool hasLocalAngularVelocity() const { return getLocalAngularVelocity() != ENTITY_ITEM_ZERO_VEC3; }
|
||||
|
||||
float getAngularDamping() const { return _angularDamping; }
|
||||
void setAngularDamping(float value) { _angularDamping = value; }
|
||||
float getAngularDamping() const;
|
||||
void setAngularDamping(float value);
|
||||
|
||||
QString getName() const { return _name; }
|
||||
void setName(const QString& value) { _name = value; }
|
||||
QString getDebugName() { return _name != "" ? _name : getID().toString(); }
|
||||
QString getName() const;
|
||||
void setName(const QString& value);
|
||||
QString getDebugName();
|
||||
|
||||
bool getVisible() const { return _visible; }
|
||||
void setVisible(bool value) { _visible = value; }
|
||||
bool isVisible() const { return _visible; }
|
||||
bool isInvisible() const { return !_visible; }
|
||||
bool getVisible() const;
|
||||
void setVisible(bool value);
|
||||
inline bool isVisible() const { return getVisible(); }
|
||||
inline bool isInvisible() const { return !getVisible(); }
|
||||
|
||||
bool getCollisionless() const { return _collisionless; }
|
||||
void setCollisionless(bool value) { _collisionless = value; }
|
||||
bool getCollisionless() const;
|
||||
void setCollisionless(bool value);
|
||||
|
||||
uint8_t getCollisionMask() const { return _collisionMask; }
|
||||
void setCollisionMask(uint8_t value) { _collisionMask = value; }
|
||||
uint8_t getCollisionMask() const;
|
||||
void setCollisionMask(uint8_t value);
|
||||
|
||||
void computeCollisionGroupAndFinalMask(int16_t& group, int16_t& mask) const;
|
||||
|
||||
bool getDynamic() const { return SHAPE_TYPE_STATIC_MESH == getShapeType() ? false : _dynamic; }
|
||||
void setDynamic(bool value) { _dynamic = value; }
|
||||
bool getDynamic() const;
|
||||
void setDynamic(bool value);
|
||||
|
||||
virtual bool shouldBePhysical() const { return false; }
|
||||
|
||||
bool getLocked() const { return _locked; }
|
||||
void setLocked(bool value) { _locked = value; }
|
||||
bool getLocked() const;
|
||||
void setLocked(bool value);
|
||||
|
||||
const QString& getUserData() const { return _userData; }
|
||||
virtual void setUserData(const QString& value) { _userData = value; }
|
||||
QString getUserData() const;
|
||||
virtual void setUserData(const QString& value);
|
||||
|
||||
// FIXME not thread safe?
|
||||
const SimulationOwner& getSimulationOwner() const { return _simulationOwner; }
|
||||
void setSimulationOwner(const QUuid& id, quint8 priority);
|
||||
void setSimulationOwner(const SimulationOwner& owner);
|
||||
|
|
@ -325,8 +322,8 @@ public:
|
|||
void setPendingOwnershipPriority(quint8 priority, const quint64& timestamp);
|
||||
void rememberHasSimulationOwnershipBid() const;
|
||||
|
||||
const QString& getMarketplaceID() const { return _marketplaceID; }
|
||||
void setMarketplaceID(const QString& value) { _marketplaceID = value; }
|
||||
QString getMarketplaceID() const;
|
||||
void setMarketplaceID(const QString& value);
|
||||
|
||||
// TODO: get rid of users of getRadius()...
|
||||
float getRadius() const;
|
||||
|
|
@ -369,8 +366,9 @@ public:
|
|||
void updateCreated(uint64_t value);
|
||||
virtual void setShapeType(ShapeType type) { /* do nothing */ }
|
||||
|
||||
uint32_t getDirtyFlags() const { return _dirtyFlags; }
|
||||
void clearDirtyFlags(uint32_t mask = 0xffffffff) { _dirtyFlags &= ~mask; }
|
||||
uint32_t getDirtyFlags() const;
|
||||
void markDirtyFlags(uint32_t mask);
|
||||
void clearDirtyFlags(uint32_t mask = 0xffffffff);
|
||||
|
||||
bool isMoving() const;
|
||||
bool isMovingRelativeToParent() const;
|
||||
|
|
|
|||
|
|
@ -69,38 +69,59 @@ EntityItemProperties LightEntityItem::getProperties(EntityPropertyFlags desiredP
|
|||
}
|
||||
|
||||
void LightEntityItem::setFalloffRadius(float value) {
|
||||
_falloffRadius = glm::max(value, 0.0f);
|
||||
_lightPropertiesChanged = true;
|
||||
value = glm::max(value, 0.0f);
|
||||
if (value == getFalloffRadius()) {
|
||||
return;
|
||||
}
|
||||
withWriteLock([&] {
|
||||
_falloffRadius = value;
|
||||
_lightPropertiesChanged = true;
|
||||
});
|
||||
}
|
||||
|
||||
void LightEntityItem::setIsSpotlight(bool value) {
|
||||
if (value != _isSpotlight) {
|
||||
_isSpotlight = value;
|
||||
|
||||
glm::vec3 dimensions = getDimensions();
|
||||
if (_isSpotlight) {
|
||||
const float length = dimensions.z;
|
||||
const float width = length * glm::sin(glm::radians(_cutoff));
|
||||
setDimensions(glm::vec3(width, width, length));
|
||||
} else {
|
||||
float maxDimension = glm::compMax(dimensions);
|
||||
setDimensions(glm::vec3(maxDimension, maxDimension, maxDimension));
|
||||
}
|
||||
_lightPropertiesChanged = true;
|
||||
if (value == getIsSpotlight()) {
|
||||
return;
|
||||
}
|
||||
|
||||
glm::vec3 dimensions = getDimensions();
|
||||
glm::vec3 newDimensions;
|
||||
if (value) {
|
||||
const float length = dimensions.z;
|
||||
const float width = length * glm::sin(glm::radians(getCutoff()));
|
||||
newDimensions = glm::vec3(width, width, length);
|
||||
} else {
|
||||
newDimensions = glm::vec3(glm::compMax(dimensions));
|
||||
}
|
||||
|
||||
withWriteLock([&] {
|
||||
_isSpotlight = value;
|
||||
_lightPropertiesChanged = true;
|
||||
});
|
||||
setDimensions(newDimensions);
|
||||
}
|
||||
|
||||
void LightEntityItem::setCutoff(float value) {
|
||||
_cutoff = glm::clamp(value, 0.0f, 90.0f);
|
||||
value = glm::clamp(value, 0.0f, 90.0f);
|
||||
if (value == getCutoff()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (_isSpotlight) {
|
||||
withWriteLock([&] {
|
||||
_cutoff = value;
|
||||
});
|
||||
|
||||
if (getIsSpotlight()) {
|
||||
// If we are a spotlight, adjusting the cutoff will affect the area we encapsulate,
|
||||
// so update the dimensions to reflect this.
|
||||
const float length = getDimensions().z;
|
||||
const float width = length * glm::sin(glm::radians(_cutoff));
|
||||
setDimensions(glm::vec3(width, width, length));
|
||||
}
|
||||
_lightPropertiesChanged = true;
|
||||
|
||||
withWriteLock([&] {
|
||||
_lightPropertiesChanged = true;
|
||||
});
|
||||
}
|
||||
|
||||
bool LightEntityItem::setProperties(const EntityItemProperties& properties) {
|
||||
|
|
@ -205,5 +226,86 @@ void LightEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBit
|
|||
|
||||
void LightEntityItem::somethingChangedNotification() {
|
||||
EntityItem::somethingChangedNotification();
|
||||
_lightPropertiesChanged = false;
|
||||
withWriteLock([&] {
|
||||
_lightPropertiesChanged = false;
|
||||
});
|
||||
}
|
||||
|
||||
const rgbColor& LightEntityItem::getColor() const {
|
||||
return _color;
|
||||
}
|
||||
|
||||
xColor LightEntityItem::getXColor() const {
|
||||
xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color;
|
||||
}
|
||||
|
||||
void LightEntityItem::setColor(const rgbColor& value) {
|
||||
withWriteLock([&] {
|
||||
memcpy(_color, value, sizeof(_color));
|
||||
_lightPropertiesChanged = true;
|
||||
});
|
||||
}
|
||||
|
||||
void LightEntityItem::setColor(const xColor& value) {
|
||||
withWriteLock([&] {
|
||||
_color[RED_INDEX] = value.red;
|
||||
_color[GREEN_INDEX] = value.green;
|
||||
_color[BLUE_INDEX] = value.blue;
|
||||
_lightPropertiesChanged = true;
|
||||
});
|
||||
}
|
||||
|
||||
bool LightEntityItem::getIsSpotlight() const {
|
||||
bool result;
|
||||
withReadLock([&] {
|
||||
result = _isSpotlight;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
float LightEntityItem::getIntensity() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _intensity;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void LightEntityItem::setIntensity(float value) {
|
||||
withWriteLock([&] {
|
||||
_intensity = value;
|
||||
_lightPropertiesChanged = true;
|
||||
});
|
||||
}
|
||||
|
||||
float LightEntityItem::getFalloffRadius() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _falloffRadius;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
float LightEntityItem::getExponent() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _exponent;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void LightEntityItem::setExponent(float value) {
|
||||
withWriteLock([&] {
|
||||
_exponent = value;
|
||||
_lightPropertiesChanged = true;
|
||||
});
|
||||
}
|
||||
|
||||
float LightEntityItem::getCutoff() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _cutoff;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -57,47 +57,33 @@ public:
|
|||
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
|
||||
bool& somethingChanged) override;
|
||||
|
||||
const rgbColor& getColor() const { return _color; }
|
||||
xColor getXColor() const {
|
||||
xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color;
|
||||
}
|
||||
const rgbColor& getColor() const;
|
||||
xColor getXColor() const;
|
||||
|
||||
void setColor(const rgbColor& value) { memcpy(_color, value, sizeof(_color)); }
|
||||
void setColor(const xColor& value) {
|
||||
_color[RED_INDEX] = value.red;
|
||||
_color[GREEN_INDEX] = value.green;
|
||||
_color[BLUE_INDEX] = value.blue;
|
||||
_lightPropertiesChanged = true;
|
||||
}
|
||||
void setColor(const rgbColor& value);
|
||||
void setColor(const xColor& value);
|
||||
|
||||
bool getIsSpotlight() const { return _isSpotlight; }
|
||||
bool getIsSpotlight() const;
|
||||
void setIsSpotlight(bool value);
|
||||
|
||||
void setIgnoredColor(const rgbColor& value) { }
|
||||
void setIgnoredAttenuation(float value) { }
|
||||
|
||||
float getIntensity() const { return _intensity; }
|
||||
void setIntensity(float value) {
|
||||
_intensity = value;
|
||||
_lightPropertiesChanged = true;
|
||||
}
|
||||
|
||||
float getFalloffRadius() const { return _falloffRadius; }
|
||||
float getIntensity() const;
|
||||
void setIntensity(float value);
|
||||
float getFalloffRadius() const;
|
||||
void setFalloffRadius(float value);
|
||||
|
||||
float getExponent() const { return _exponent; }
|
||||
void setExponent(float value) {
|
||||
_exponent = value;
|
||||
_lightPropertiesChanged = true;
|
||||
}
|
||||
float getExponent() const;
|
||||
void setExponent(float value);
|
||||
|
||||
float getCutoff() const { return _cutoff; }
|
||||
float getCutoff() const;
|
||||
void setCutoff(float value);
|
||||
|
||||
static bool getLightsArePickable() { return _lightsArePickable; }
|
||||
static void setLightsArePickable(bool value) { _lightsArePickable = value; }
|
||||
|
||||
protected:
|
||||
private:
|
||||
|
||||
|
||||
// properties of a light
|
||||
|
|
@ -108,6 +94,7 @@ protected:
|
|||
float _exponent { DEFAULT_EXPONENT };
|
||||
float _cutoff { DEFAULT_CUTOFF };
|
||||
|
||||
protected:
|
||||
// Dirty flag turn true when either light properties is changing values.
|
||||
// This gets back to false in the somethingChangedNotification() call
|
||||
// Which is called after a setProperties() or a readEntitySubClassFromBUfferCall on the entity.
|
||||
|
|
|
|||
|
|
@ -34,8 +34,8 @@ EntityItemPointer LineEntityItem::factory(const EntityItemID& entityID, const En
|
|||
LineEntityItem::LineEntityItem(const EntityItemID& entityItemID) :
|
||||
EntityItem(entityItemID),
|
||||
_lineWidth(DEFAULT_LINE_WIDTH),
|
||||
_pointsChanged(true),
|
||||
_points(QVector<glm::vec3>(0))
|
||||
_points(QVector<glm::vec3>(0)),
|
||||
_pointsChanged(true)
|
||||
{
|
||||
_type = EntityTypes::Line;
|
||||
}
|
||||
|
|
@ -88,8 +88,10 @@ bool LineEntityItem::appendPoint(const glm::vec3& point) {
|
|||
qCDebug(entities) << "Point is outside entity's bounding box";
|
||||
return false;
|
||||
}
|
||||
_points << point;
|
||||
_pointsChanged = true;
|
||||
withWriteLock([&] {
|
||||
_points << point;
|
||||
_pointsChanged = true;
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -105,8 +107,11 @@ bool LineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
|
|||
return false;
|
||||
}
|
||||
}
|
||||
_points = points;
|
||||
_pointsChanged = true;
|
||||
|
||||
withWriteLock([&] {
|
||||
_points = points;
|
||||
_pointsChanged = true;
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -159,3 +164,51 @@ void LineEntityItem::debugDump() const {
|
|||
qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);
|
||||
}
|
||||
|
||||
|
||||
const rgbColor& LineEntityItem::getColor() const {
|
||||
return _color;
|
||||
}
|
||||
|
||||
xColor LineEntityItem::getXColor() const {
|
||||
xColor result;
|
||||
withReadLock([&] {
|
||||
result = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] };
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void LineEntityItem::setColor(const rgbColor& value) {
|
||||
withWriteLock([&] {
|
||||
memcpy(_color, value, sizeof(_color));
|
||||
});
|
||||
}
|
||||
|
||||
void LineEntityItem::setColor(const xColor& value) {
|
||||
withWriteLock([&] {
|
||||
_color[RED_INDEX] = value.red;
|
||||
_color[GREEN_INDEX] = value.green;
|
||||
_color[BLUE_INDEX] = value.blue;
|
||||
});
|
||||
}
|
||||
|
||||
void LineEntityItem::setLineWidth(float lineWidth) {
|
||||
withWriteLock([&] {
|
||||
_lineWidth = lineWidth;
|
||||
});
|
||||
}
|
||||
|
||||
float LineEntityItem::getLineWidth() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _lineWidth;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
QVector<glm::vec3> LineEntityItem::getLinePoints() const {
|
||||
QVector<glm::vec3> result;
|
||||
withReadLock([&] {
|
||||
result = _points;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,23 +42,19 @@ class LineEntityItem : public EntityItem {
|
|||
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
|
||||
bool& somethingChanged) override;
|
||||
|
||||
const rgbColor& getColor() const { return _color; }
|
||||
xColor getXColor() const { xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color; }
|
||||
const rgbColor& getColor() const;
|
||||
xColor getXColor() const;
|
||||
|
||||
void setColor(const rgbColor& value) { memcpy(_color, value, sizeof(_color)); }
|
||||
void setColor(const xColor& value) {
|
||||
_color[RED_INDEX] = value.red;
|
||||
_color[GREEN_INDEX] = value.green;
|
||||
_color[BLUE_INDEX] = value.blue;
|
||||
}
|
||||
void setColor(const rgbColor& value);
|
||||
void setColor(const xColor& value);
|
||||
|
||||
void setLineWidth(float lineWidth){ _lineWidth = lineWidth; }
|
||||
float getLineWidth() const{ return _lineWidth; }
|
||||
void setLineWidth(float lineWidth);
|
||||
float getLineWidth() const;
|
||||
|
||||
bool setLinePoints(const QVector<glm::vec3>& points);
|
||||
bool appendPoint(const glm::vec3& point);
|
||||
|
||||
const QVector<glm::vec3>& getLinePoints() const{ return _points; }
|
||||
QVector<glm::vec3> getLinePoints() const;
|
||||
|
||||
virtual ShapeType getShapeType() const override { return SHAPE_TYPE_NONE; }
|
||||
|
||||
|
|
@ -74,11 +70,12 @@ class LineEntityItem : public EntityItem {
|
|||
static const float DEFAULT_LINE_WIDTH;
|
||||
static const int MAX_POINTS_PER_LINE;
|
||||
|
||||
protected:
|
||||
private:
|
||||
rgbColor _color;
|
||||
float _lineWidth;
|
||||
bool _pointsChanged;
|
||||
QVector<glm::vec3> _points;
|
||||
protected:
|
||||
bool _pointsChanged;
|
||||
};
|
||||
|
||||
#endif // hifi_LineEntityItem_h
|
||||
|
|
|
|||
|
|
@ -733,3 +733,20 @@ void ParticleEffectEntityItem::setMaxParticles(quint32 maxParticles) {
|
|||
_timeUntilNextEmit = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
QString ParticleEffectEntityItem::getTextures() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _textures;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void ParticleEffectEntityItem::setTextures(const QString& textures) {
|
||||
withWriteLock([&] {
|
||||
if (_textures != textures) {
|
||||
_textures = textures;
|
||||
_texturesChangedFlag = true;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -205,13 +205,8 @@ public:
|
|||
void computeAndUpdateDimensions();
|
||||
|
||||
static const QString DEFAULT_TEXTURES;
|
||||
const QString& getTextures() const { return _textures; }
|
||||
void setTextures(const QString& textures) {
|
||||
if (_textures != textures) {
|
||||
_textures = textures;
|
||||
_texturesChangedFlag = true;
|
||||
}
|
||||
}
|
||||
QString getTextures() const;
|
||||
void setTextures(const QString& textures);
|
||||
|
||||
static const bool DEFAULT_EMITTER_SHOULD_TRAIL;
|
||||
bool getEmitterShouldTrail() const { return _emitterShouldTrail; }
|
||||
|
|
|
|||
|
|
@ -104,14 +104,18 @@ bool PolyLineEntityItem::appendPoint(const glm::vec3& point) {
|
|||
|
||||
|
||||
bool PolyLineEntityItem::setStrokeWidths(const QVector<float>& strokeWidths) {
|
||||
_strokeWidths = strokeWidths;
|
||||
_strokeWidthsChanged = true;
|
||||
withWriteLock([&] {
|
||||
_strokeWidths = strokeWidths;
|
||||
_strokeWidthsChanged = true;
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
bool PolyLineEntityItem::setNormals(const QVector<glm::vec3>& normals) {
|
||||
_normals = normals;
|
||||
_normalsChanged = true;
|
||||
withWriteLock([&] {
|
||||
_normals = normals;
|
||||
_normalsChanged = true;
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -119,35 +123,39 @@ bool PolyLineEntityItem::setLinePoints(const QVector<glm::vec3>& points) {
|
|||
if (points.size() > MAX_POINTS_PER_LINE) {
|
||||
return false;
|
||||
}
|
||||
if (points.size() != _points.size()) {
|
||||
_pointsChanged = true;
|
||||
}
|
||||
//Check to see if points actually changed. If they haven't, return before doing anything else
|
||||
else if (points.size() == _points.size()) {
|
||||
//same number of points, so now compare every point
|
||||
for (int i = 0; i < points.size(); i++) {
|
||||
if (points.at(i) != _points.at(i)){
|
||||
_pointsChanged = true;
|
||||
break;
|
||||
bool result = false;
|
||||
withWriteLock([&] {
|
||||
//Check to see if points actually changed. If they haven't, return before doing anything else
|
||||
if (points.size() != _points.size()) {
|
||||
_pointsChanged = true;
|
||||
} else if (points.size() == _points.size()) {
|
||||
//same number of points, so now compare every point
|
||||
for (int i = 0; i < points.size(); i++) {
|
||||
if (points.at(i) != _points.at(i)) {
|
||||
_pointsChanged = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!_pointsChanged) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int i = 0; i < points.size(); i++) {
|
||||
glm::vec3 point = points.at(i);
|
||||
glm::vec3 halfBox = getDimensions() * 0.5f;
|
||||
if ((point.x < -halfBox.x || point.x > halfBox.x) ||
|
||||
(point.y < -halfBox.y || point.y > halfBox.y) ||
|
||||
(point.z < -halfBox.z || point.z > halfBox.z)) {
|
||||
qCDebug(entities) << "Point is outside entity's bounding box";
|
||||
return false;
|
||||
if (!_pointsChanged) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
_points = points;
|
||||
return true;
|
||||
|
||||
for (int i = 0; i < points.size(); i++) {
|
||||
glm::vec3 point = points.at(i);
|
||||
glm::vec3 halfBox = getDimensions() * 0.5f;
|
||||
if ((point.x < -halfBox.x || point.x > halfBox.x) ||
|
||||
(point.y < -halfBox.y || point.y > halfBox.y) ||
|
||||
(point.z < -halfBox.z || point.z > halfBox.z)) {
|
||||
qCDebug(entities) << "Point is outside entity's bounding box";
|
||||
return;
|
||||
}
|
||||
}
|
||||
_points = points;
|
||||
result = true;
|
||||
});
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int PolyLineEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
|
||||
|
|
@ -210,3 +218,45 @@ void PolyLineEntityItem::debugDump() const {
|
|||
qCDebug(entities) << " getLastEdited:" << debugTime(getLastEdited(), now);
|
||||
}
|
||||
|
||||
|
||||
|
||||
QVector<glm::vec3> PolyLineEntityItem::getLinePoints() const {
|
||||
QVector<glm::vec3> result;
|
||||
withReadLock([&] {
|
||||
result = _points;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
QVector<glm::vec3> PolyLineEntityItem::getNormals() const {
|
||||
QVector<glm::vec3> result;
|
||||
withReadLock([&] {
|
||||
result = _normals;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
QVector<float> PolyLineEntityItem::getStrokeWidths() const {
|
||||
QVector<float> result;
|
||||
withReadLock([&] {
|
||||
result = _strokeWidths;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
QString PolyLineEntityItem::getTextures() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _textures;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyLineEntityItem::setTextures(const QString& textures) {
|
||||
withWriteLock([&] {
|
||||
if (_textures != textures) {
|
||||
_textures = textures;
|
||||
_texturesChangedFlag = true;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -59,21 +59,16 @@ class PolyLineEntityItem : public EntityItem {
|
|||
|
||||
bool setLinePoints(const QVector<glm::vec3>& points);
|
||||
bool appendPoint(const glm::vec3& point);
|
||||
const QVector<glm::vec3>& getLinePoints() const{ return _points; }
|
||||
QVector<glm::vec3> getLinePoints() const;
|
||||
|
||||
bool setNormals(const QVector<glm::vec3>& normals);
|
||||
const QVector<glm::vec3>& getNormals() const{ return _normals; }
|
||||
QVector<glm::vec3> getNormals() const;
|
||||
|
||||
bool setStrokeWidths(const QVector<float>& strokeWidths);
|
||||
const QVector<float>& getStrokeWidths() const{ return _strokeWidths; }
|
||||
QVector<float> getStrokeWidths() const;
|
||||
|
||||
const QString& getTextures() const { return _textures; }
|
||||
void setTextures(const QString& textures) {
|
||||
if (_textures != textures) {
|
||||
_textures = textures;
|
||||
_texturesChangedFlag = true;
|
||||
}
|
||||
}
|
||||
QString getTextures() const;
|
||||
void setTextures(const QString& textures);
|
||||
|
||||
virtual bool needsToCallUpdate() const override { return true; }
|
||||
|
||||
|
|
|
|||
|
|
@ -242,3 +242,129 @@ const QByteArray PolyVoxEntityItem::getVoxelData() const {
|
|||
});
|
||||
return voxelDataCopy;
|
||||
}
|
||||
|
||||
|
||||
void PolyVoxEntityItem::setXTextureURL(const QString& xTextureURL) {
|
||||
withWriteLock([&] {
|
||||
_xTextureURL = xTextureURL;
|
||||
});
|
||||
}
|
||||
|
||||
QString PolyVoxEntityItem::getXTextureURL() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _xTextureURL;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setYTextureURL(const QString& yTextureURL) {
|
||||
withWriteLock([&] {
|
||||
_yTextureURL = yTextureURL;
|
||||
});
|
||||
}
|
||||
|
||||
QString PolyVoxEntityItem::getYTextureURL() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _yTextureURL;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setZTextureURL(const QString& zTextureURL) {
|
||||
withWriteLock([&] {
|
||||
_zTextureURL = zTextureURL;
|
||||
});
|
||||
}
|
||||
QString PolyVoxEntityItem::getZTextureURL() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _zTextureURL;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setXNNeighborID(const EntityItemID& xNNeighborID) {
|
||||
withWriteLock([&] {
|
||||
_xNNeighborID = xNNeighborID;
|
||||
});
|
||||
}
|
||||
|
||||
EntityItemID PolyVoxEntityItem::getXNNeighborID() const {
|
||||
EntityItemID result;
|
||||
withReadLock([&] {
|
||||
result = _xNNeighborID;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setYNNeighborID(const EntityItemID& yNNeighborID) {
|
||||
withWriteLock([&] {
|
||||
_yNNeighborID = yNNeighborID;
|
||||
});
|
||||
}
|
||||
|
||||
EntityItemID PolyVoxEntityItem::getYNNeighborID() const {
|
||||
EntityItemID result;
|
||||
withReadLock([&] {
|
||||
result = _yNNeighborID;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setZNNeighborID(const EntityItemID& zNNeighborID) {
|
||||
withWriteLock([&] {
|
||||
_zNNeighborID = zNNeighborID;
|
||||
});
|
||||
}
|
||||
|
||||
EntityItemID PolyVoxEntityItem::getZNNeighborID() const {
|
||||
EntityItemID result;
|
||||
withReadLock([&] {
|
||||
result = _zNNeighborID;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setXPNeighborID(const EntityItemID& xPNeighborID) {
|
||||
withWriteLock([&] {
|
||||
_xPNeighborID = xPNeighborID;
|
||||
});
|
||||
}
|
||||
|
||||
EntityItemID PolyVoxEntityItem::getXPNeighborID() const {
|
||||
EntityItemID result;
|
||||
withReadLock([&] {
|
||||
result = _xPNeighborID;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setYPNeighborID(const EntityItemID& yPNeighborID) {
|
||||
withWriteLock([&] {
|
||||
_yPNeighborID = yPNeighborID;
|
||||
});
|
||||
}
|
||||
|
||||
EntityItemID PolyVoxEntityItem::getYPNeighborID() const {
|
||||
EntityItemID result;
|
||||
withReadLock([&] {
|
||||
result = _yPNeighborID;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void PolyVoxEntityItem::setZPNeighborID(const EntityItemID& zPNeighborID) {
|
||||
withWriteLock([&] {
|
||||
_zPNeighborID = zPNeighborID;
|
||||
});
|
||||
}
|
||||
|
||||
EntityItemID PolyVoxEntityItem::getZPNeighborID() const {
|
||||
EntityItemID result;
|
||||
withReadLock([&] {
|
||||
result = _zPNeighborID;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -99,36 +99,36 @@ class PolyVoxEntityItem : public EntityItem {
|
|||
static QByteArray makeEmptyVoxelData(quint16 voxelXSize = 16, quint16 voxelYSize = 16, quint16 voxelZSize = 16);
|
||||
|
||||
static const QString DEFAULT_X_TEXTURE_URL;
|
||||
virtual void setXTextureURL(QString xTextureURL) { _xTextureURL = xTextureURL; }
|
||||
virtual const QString& getXTextureURL() const { return _xTextureURL; }
|
||||
virtual void setXTextureURL(const QString& xTextureURL);
|
||||
QString getXTextureURL() const;
|
||||
|
||||
static const QString DEFAULT_Y_TEXTURE_URL;
|
||||
virtual void setYTextureURL(QString yTextureURL) { _yTextureURL = yTextureURL; }
|
||||
virtual const QString& getYTextureURL() const { return _yTextureURL; }
|
||||
virtual void setYTextureURL(const QString& yTextureURL);
|
||||
QString getYTextureURL() const;
|
||||
|
||||
static const QString DEFAULT_Z_TEXTURE_URL;
|
||||
virtual void setZTextureURL(QString zTextureURL) { _zTextureURL = zTextureURL; }
|
||||
virtual const QString& getZTextureURL() const { return _zTextureURL; }
|
||||
virtual void setZTextureURL(const QString& zTextureURL);
|
||||
QString getZTextureURL() const;
|
||||
|
||||
virtual void setXNNeighborID(const EntityItemID& xNNeighborID) { _xNNeighborID = xNNeighborID; }
|
||||
void setXNNeighborID(const QString& xNNeighborID) { setXNNeighborID(QUuid(xNNeighborID)); }
|
||||
virtual const EntityItemID& getXNNeighborID() const { return _xNNeighborID; }
|
||||
virtual void setYNNeighborID(const EntityItemID& yNNeighborID) { _yNNeighborID = yNNeighborID; }
|
||||
void setYNNeighborID(const QString& yNNeighborID) { setYNNeighborID(QUuid(yNNeighborID)); }
|
||||
virtual const EntityItemID& getYNNeighborID() const { return _yNNeighborID; }
|
||||
virtual void setZNNeighborID(const EntityItemID& zNNeighborID) { _zNNeighborID = zNNeighborID; }
|
||||
void setZNNeighborID(const QString& zNNeighborID) { setZNNeighborID(QUuid(zNNeighborID)); }
|
||||
virtual const EntityItemID& getZNNeighborID() const { return _zNNeighborID; }
|
||||
virtual void setXNNeighborID(const EntityItemID& xNNeighborID);
|
||||
void setXNNeighborID(const QString& xNNeighborID);
|
||||
virtual EntityItemID getXNNeighborID() const;
|
||||
virtual void setYNNeighborID(const EntityItemID& yNNeighborID);
|
||||
void setYNNeighborID(const QString& yNNeighborID);
|
||||
virtual EntityItemID getYNNeighborID() const;
|
||||
virtual void setZNNeighborID(const EntityItemID& zNNeighborID);
|
||||
void setZNNeighborID(const QString& zNNeighborID);
|
||||
virtual EntityItemID getZNNeighborID() const;
|
||||
|
||||
virtual void setXPNeighborID(const EntityItemID& xPNeighborID) { _xPNeighborID = xPNeighborID; }
|
||||
void setXPNeighborID(const QString& xPNeighborID) { setXPNeighborID(QUuid(xPNeighborID)); }
|
||||
virtual const EntityItemID& getXPNeighborID() const { return _xPNeighborID; }
|
||||
virtual void setYPNeighborID(const EntityItemID& yPNeighborID) { _yPNeighborID = yPNeighborID; }
|
||||
void setYPNeighborID(const QString& yPNeighborID) { setYPNeighborID(QUuid(yPNeighborID)); }
|
||||
virtual const EntityItemID& getYPNeighborID() const { return _yPNeighborID; }
|
||||
virtual void setZPNeighborID(const EntityItemID& zPNeighborID) { _zPNeighborID = zPNeighborID; }
|
||||
void setZPNeighborID(const QString& zPNeighborID) { setZPNeighborID(QUuid(zPNeighborID)); }
|
||||
virtual const EntityItemID& getZPNeighborID() const { return _zPNeighborID; }
|
||||
virtual void setXPNeighborID(const EntityItemID& xPNeighborID);
|
||||
void setXPNeighborID(const QString& xPNeighborID);
|
||||
virtual EntityItemID getXPNeighborID() const;
|
||||
virtual void setYPNeighborID(const EntityItemID& yPNeighborID);
|
||||
void setYPNeighborID(const QString& yPNeighborID);
|
||||
virtual EntityItemID getYPNeighborID() const;
|
||||
virtual void setZPNeighborID(const EntityItemID& zPNeighborID);
|
||||
void setZPNeighborID(const QString& zPNeighborID);
|
||||
virtual EntityItemID getZPNeighborID() const;
|
||||
|
||||
virtual void rebakeMesh() {};
|
||||
|
||||
|
|
|
|||
|
|
@ -141,3 +141,98 @@ bool TextEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const
|
|||
// FIXME - should set face and surfaceNormal
|
||||
return findRayRectangleIntersection(origin, direction, rotation, position, xyDimensions, distance);
|
||||
}
|
||||
|
||||
void TextEntityItem::setText(const QString& value) {
|
||||
withWriteLock([&] {
|
||||
_text = value;
|
||||
});
|
||||
}
|
||||
|
||||
QString TextEntityItem::getText() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _text;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void TextEntityItem::setLineHeight(float value) {
|
||||
withWriteLock([&] {
|
||||
_lineHeight = value;
|
||||
});
|
||||
}
|
||||
|
||||
float TextEntityItem::getLineHeight() const {
|
||||
float result;
|
||||
withReadLock([&] {
|
||||
result = _lineHeight;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
const rgbColor& TextEntityItem::getTextColor() const {
|
||||
return _textColor;
|
||||
}
|
||||
|
||||
const rgbColor& TextEntityItem::getBackgroundColor() const {
|
||||
return _backgroundColor;
|
||||
}
|
||||
|
||||
xColor TextEntityItem::getTextColorX() const {
|
||||
xColor result;
|
||||
withReadLock([&] {
|
||||
result = { _textColor[RED_INDEX], _textColor[GREEN_INDEX], _textColor[BLUE_INDEX] };
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void TextEntityItem::setTextColor(const rgbColor& value) {
|
||||
withWriteLock([&] {
|
||||
memcpy(_textColor, value, sizeof(_textColor));
|
||||
});
|
||||
}
|
||||
|
||||
void TextEntityItem::setTextColor(const xColor& value) {
|
||||
withWriteLock([&] {
|
||||
_textColor[RED_INDEX] = value.red;
|
||||
_textColor[GREEN_INDEX] = value.green;
|
||||
_textColor[BLUE_INDEX] = value.blue;
|
||||
});
|
||||
}
|
||||
|
||||
xColor TextEntityItem::getBackgroundColorX() const {
|
||||
xColor result;
|
||||
withReadLock([&] {
|
||||
result = { _backgroundColor[RED_INDEX], _backgroundColor[GREEN_INDEX], _backgroundColor[BLUE_INDEX] };
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void TextEntityItem::setBackgroundColor(const rgbColor& value) {
|
||||
withWriteLock([&] {
|
||||
memcpy(_backgroundColor, value, sizeof(_backgroundColor));
|
||||
});
|
||||
}
|
||||
|
||||
void TextEntityItem::setBackgroundColor(const xColor& value) {
|
||||
withWriteLock([&] {
|
||||
_backgroundColor[RED_INDEX] = value.red;
|
||||
_backgroundColor[GREEN_INDEX] = value.green;
|
||||
_backgroundColor[BLUE_INDEX] = value.blue;
|
||||
});
|
||||
}
|
||||
|
||||
bool TextEntityItem::getFaceCamera() const {
|
||||
bool result;
|
||||
withReadLock([&] {
|
||||
result = _faceCamera;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void TextEntityItem::setFaceCamera(bool value) {
|
||||
withWriteLock([&] {
|
||||
_faceCamera = value;
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -53,40 +53,34 @@ public:
|
|||
void** intersectedObject, bool precisionPicking) const override;
|
||||
|
||||
static const QString DEFAULT_TEXT;
|
||||
void setText(const QString& value) { _text = value; }
|
||||
const QString& getText() const { return _text; }
|
||||
void setText(const QString& value);
|
||||
QString getText() const;
|
||||
|
||||
static const float DEFAULT_LINE_HEIGHT;
|
||||
void setLineHeight(float value) { _lineHeight = value; }
|
||||
float getLineHeight() const { return _lineHeight; }
|
||||
void setLineHeight(float value);
|
||||
float getLineHeight() const;
|
||||
|
||||
static const xColor DEFAULT_TEXT_COLOR;
|
||||
const rgbColor& getTextColor() const { return _textColor; }
|
||||
xColor getTextColorX() const { xColor color = { _textColor[RED_INDEX], _textColor[GREEN_INDEX], _textColor[BLUE_INDEX] }; return color; }
|
||||
// FIXME should not return a reference because of thread safety, but can't return an array
|
||||
const rgbColor& getTextColor() const;
|
||||
xColor getTextColorX() const;
|
||||
|
||||
void setTextColor(const rgbColor& value) { memcpy(_textColor, value, sizeof(_textColor)); }
|
||||
void setTextColor(const xColor& value) {
|
||||
_textColor[RED_INDEX] = value.red;
|
||||
_textColor[GREEN_INDEX] = value.green;
|
||||
_textColor[BLUE_INDEX] = value.blue;
|
||||
}
|
||||
void setTextColor(const rgbColor& value);
|
||||
void setTextColor(const xColor& value);
|
||||
|
||||
static const xColor DEFAULT_BACKGROUND_COLOR;
|
||||
const rgbColor& getBackgroundColor() const { return _backgroundColor; }
|
||||
xColor getBackgroundColorX() const { xColor color = { _backgroundColor[RED_INDEX], _backgroundColor[GREEN_INDEX], _backgroundColor[BLUE_INDEX] }; return color; }
|
||||
// FIXME should not return a reference because of thread safety, but can't return an array
|
||||
const rgbColor& getBackgroundColor() const;
|
||||
xColor getBackgroundColorX() const;
|
||||
|
||||
void setBackgroundColor(const rgbColor& value) { memcpy(_backgroundColor, value, sizeof(_backgroundColor)); }
|
||||
void setBackgroundColor(const xColor& value) {
|
||||
_backgroundColor[RED_INDEX] = value.red;
|
||||
_backgroundColor[GREEN_INDEX] = value.green;
|
||||
_backgroundColor[BLUE_INDEX] = value.blue;
|
||||
}
|
||||
void setBackgroundColor(const rgbColor& value);
|
||||
void setBackgroundColor(const xColor& value);
|
||||
|
||||
static const bool DEFAULT_FACE_CAMERA;
|
||||
bool getFaceCamera() const { return _faceCamera; }
|
||||
void setFaceCamera(bool value) { _faceCamera = value; }
|
||||
bool getFaceCamera() const;
|
||||
void setFaceCamera(bool value);
|
||||
|
||||
protected:
|
||||
private:
|
||||
QString _text;
|
||||
float _lineHeight;
|
||||
rgbColor _textColor;
|
||||
|
|
|
|||
|
|
@ -124,18 +124,26 @@ bool WebEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const g
|
|||
}
|
||||
|
||||
void WebEntityItem::setSourceUrl(const QString& value) {
|
||||
if (_sourceUrl != value) {
|
||||
auto newURL = QUrl::fromUserInput(value);
|
||||
withWriteLock([&] {
|
||||
if (_sourceUrl != value) {
|
||||
auto newURL = QUrl::fromUserInput(value);
|
||||
|
||||
if (newURL.isValid()) {
|
||||
_sourceUrl = newURL.toDisplayString();
|
||||
} else {
|
||||
qCDebug(entities) << "Clearing web entity source URL since" << value << "cannot be parsed to a valid URL.";
|
||||
if (newURL.isValid()) {
|
||||
_sourceUrl = newURL.toDisplayString();
|
||||
} else {
|
||||
qCDebug(entities) << "Clearing web entity source URL since" << value << "cannot be parsed to a valid URL.";
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
const QString& WebEntityItem::getSourceUrl() const { return _sourceUrl; }
|
||||
QString WebEntityItem::getSourceUrl() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _sourceUrl;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
void WebEntityItem::setDPI(uint16_t value) {
|
||||
_dpi = value;
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ public:
|
|||
void** intersectedObject, bool precisionPicking) const override;
|
||||
|
||||
virtual void setSourceUrl(const QString& value);
|
||||
const QString& getSourceUrl() const;
|
||||
QString getSourceUrl() const;
|
||||
|
||||
virtual bool wantsHandControllerPointerEvents() const override { return true; }
|
||||
|
||||
|
|
|
|||
|
|
@ -208,10 +208,12 @@ ShapeType ZoneEntityItem::getShapeType() const {
|
|||
}
|
||||
|
||||
void ZoneEntityItem::setCompoundShapeURL(const QString& url) {
|
||||
_compoundShapeURL = url;
|
||||
if (_compoundShapeURL.isEmpty() && _shapeType == SHAPE_TYPE_COMPOUND) {
|
||||
_shapeType = DEFAULT_SHAPE_TYPE;
|
||||
}
|
||||
withWriteLock([&] {
|
||||
_compoundShapeURL = url;
|
||||
if (_compoundShapeURL.isEmpty() && _shapeType == SHAPE_TYPE_COMPOUND) {
|
||||
_shapeType = DEFAULT_SHAPE_TYPE;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
bool ZoneEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
|
||||
|
|
@ -223,7 +225,9 @@ bool ZoneEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const
|
|||
}
|
||||
|
||||
void ZoneEntityItem::setFilterURL(QString url) {
|
||||
_filterURL = url;
|
||||
withWriteLock([&] {
|
||||
_filterURL = url;
|
||||
});
|
||||
if (DependencyManager::isSet<EntityEditFilters>()) {
|
||||
auto entityEditFilters = DependencyManager::get<EntityEditFilters>();
|
||||
qCDebug(entities) << "adding filter " << url << "for zone" << getEntityItemID();
|
||||
|
|
@ -231,3 +235,22 @@ void ZoneEntityItem::setFilterURL(QString url) {
|
|||
}
|
||||
}
|
||||
|
||||
QString ZoneEntityItem::getFilterURL() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _filterURL;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
bool ZoneEntityItem::hasCompoundShapeURL() const {
|
||||
return !getCompoundShapeURL().isEmpty();
|
||||
}
|
||||
|
||||
QString ZoneEntityItem::getCompoundShapeURL() const {
|
||||
QString result;
|
||||
withReadLock([&] {
|
||||
result = _compoundShapeURL;
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,8 +58,8 @@ public:
|
|||
void setShapeType(ShapeType type) override { _shapeType = type; }
|
||||
virtual ShapeType getShapeType() const override;
|
||||
|
||||
virtual bool hasCompoundShapeURL() const { return !_compoundShapeURL.isEmpty(); }
|
||||
const QString getCompoundShapeURL() const { return _compoundShapeURL; }
|
||||
virtual bool hasCompoundShapeURL() const;
|
||||
QString getCompoundShapeURL() const;
|
||||
virtual void setCompoundShapeURL(const QString& url);
|
||||
|
||||
const KeyLightPropertyGroup& getKeyLightProperties() const { return _keyLightProperties; }
|
||||
|
|
@ -74,7 +74,7 @@ public:
|
|||
void setFlyingAllowed(bool value) { _flyingAllowed = value; }
|
||||
bool getGhostingAllowed() const { return _ghostingAllowed; }
|
||||
void setGhostingAllowed(bool value) { _ghostingAllowed = value; }
|
||||
QString getFilterURL() const { return _filterURL; }
|
||||
QString getFilterURL() const;
|
||||
void setFilterURL(const QString url);
|
||||
|
||||
virtual bool supportsDetailedRayIntersection() const override { return true; }
|
||||
|
|
|
|||
|
|
@ -59,8 +59,6 @@ bool OffscreenGLCanvas::create(QOpenGLContext* sharedContext) {
|
|||
|
||||
bool OffscreenGLCanvas::makeCurrent() {
|
||||
bool result = _context->makeCurrent(_offscreenSurface);
|
||||
Q_ASSERT(result);
|
||||
|
||||
std::call_once(_reportOnce, [this]{
|
||||
qCDebug(glLogging) << "GL Version: " << QString((const char*) glGetString(GL_VERSION));
|
||||
qCDebug(glLogging) << "GL Shader Language Version: " << QString((const char*) glGetString(GL_SHADING_LANGUAGE_VERSION));
|
||||
|
|
|
|||
|
|
@ -612,11 +612,7 @@ QObject* OffscreenQmlSurface::finishQmlLoad(std::function<void(QQmlContext*, QOb
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
//check if the item contains sendToScript signal
|
||||
int sendToScriptIndex = newItem->metaObject()->indexOfSignal("sendToScript");
|
||||
if (sendToScriptIndex != -1) {
|
||||
connect(newItem, SIGNAL(sendToScript(QVariant)), this, SIGNAL(fromQml(QVariant)));
|
||||
}
|
||||
connect(newItem, SIGNAL(sendToScript(QVariant)), this, SIGNAL(fromQml(QVariant)));
|
||||
|
||||
// The root item is ready. Associate it with the window.
|
||||
_rootItem = newItem;
|
||||
|
|
|
|||
|
|
@ -275,6 +275,9 @@ void TabletProxy::emitWebEvent(QVariant msg) {
|
|||
emit webEventReceived(msg);
|
||||
}
|
||||
|
||||
bool TabletProxy::isPathLoaded(QVariant path) {
|
||||
return path.toString() == _currentPathLoaded.toString();
|
||||
}
|
||||
void TabletProxy::setQmlTabletRoot(QQuickItem* qmlTabletRoot, QObject* qmlOffscreenSurface) {
|
||||
std::lock_guard<std::mutex> guard(_mutex);
|
||||
_qmlOffscreenSurface = qmlOffscreenSurface;
|
||||
|
|
@ -322,6 +325,7 @@ void TabletProxy::setQmlTabletRoot(QQuickItem* qmlTabletRoot, QObject* qmlOffscr
|
|||
removeButtonsFromHomeScreen();
|
||||
_state = State::Uninitialized;
|
||||
emit screenChanged(QVariant("Closed"), QVariant(""));
|
||||
_currentPathLoaded = "";
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -345,6 +349,7 @@ void TabletProxy::gotoMenuScreen(const QString& submenu) {
|
|||
QMetaObject::invokeMethod(root, "loadSource", Q_ARG(const QVariant&, QVariant(VRMENU_SOURCE_URL)));
|
||||
_state = State::Menu;
|
||||
emit screenChanged(QVariant("Menu"), QVariant(VRMENU_SOURCE_URL));
|
||||
_currentPathLoaded = VRMENU_SOURCE_URL;
|
||||
QMetaObject::invokeMethod(root, "setShown", Q_ARG(const QVariant&, QVariant(true)));
|
||||
}
|
||||
}
|
||||
|
|
@ -364,6 +369,7 @@ void TabletProxy::loadQMLSource(const QVariant& path) {
|
|||
QMetaObject::invokeMethod(root, "loadSource", Q_ARG(const QVariant&, path));
|
||||
_state = State::QML;
|
||||
emit screenChanged(QVariant("QML"), path);
|
||||
_currentPathLoaded = path;
|
||||
QMetaObject::invokeMethod(root, "setShown", Q_ARG(const QVariant&, QVariant(true)));
|
||||
}
|
||||
} else {
|
||||
|
|
@ -426,6 +432,7 @@ void TabletProxy::loadHomeScreen(bool forceOntoHomeScreen) {
|
|||
}
|
||||
_state = State::Home;
|
||||
emit screenChanged(QVariant("Home"), QVariant(TABLET_SOURCE_URL));
|
||||
_currentPathLoaded = TABLET_SOURCE_URL;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -450,6 +457,7 @@ void TabletProxy::gotoWebScreen(const QString& url, const QString& injectedJavaS
|
|||
}
|
||||
_state = State::Web;
|
||||
emit screenChanged(QVariant("Web"), QVariant(url));
|
||||
_currentPathLoaded = QVariant(url);
|
||||
}
|
||||
|
||||
QObject* TabletProxy::addButton(const QVariant& properties) {
|
||||
|
|
|
|||
|
|
@ -183,6 +183,8 @@ public:
|
|||
Q_INVOKABLE void setLandscape(bool landscape) { _landscape = landscape; }
|
||||
Q_INVOKABLE bool getLandscape() { return _landscape; }
|
||||
|
||||
Q_INVOKABLE bool isPathLoaded(QVariant path);
|
||||
|
||||
QQuickItem* getTabletRoot() const { return _qmlTabletRoot; }
|
||||
|
||||
QObject* getTabletSurface();
|
||||
|
|
@ -235,6 +237,7 @@ protected:
|
|||
|
||||
bool _initialScreen { false };
|
||||
QVariant _initialPath { "" };
|
||||
QVariant _currentPathLoaded { "" };
|
||||
QString _name;
|
||||
std::mutex _mutex;
|
||||
std::vector<QSharedPointer<TabletButtonProxy>> _tabletButtonProxies;
|
||||
|
|
|
|||
121
script-archive/selfieStick.js
Normal file
121
script-archive/selfieStick.js
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
// selfieStick.js
|
||||
//
|
||||
// Created by Faye Li on March 23, 2016
|
||||
//
|
||||
// Usage instruction: Spacebar toggles camera control - WASD first person free movement or no movement but allowing others to grab the selfie stick
|
||||
// and control your camera.
|
||||
// For best result, turn off avatar collisions(Developer > Avatar > Uncheck Enable Avatar Collisions)
|
||||
//
|
||||
|
||||
// selfieStick.js
|
||||
//
|
||||
// Created by Faye Li on March 23, 2016
|
||||
//
|
||||
// Usage instruction: Spacebar toggles camera control - WASD first person free movement or no movement but allowing others to grab the selfie stick
|
||||
// and control your camera.
|
||||
//
|
||||
|
||||
(function() { // BEGIN LOCAL_SCOPE
|
||||
var MODEL_URL = "https://hifi-content.s3.amazonaws.com/faye/twitch-stream/selfie_stick.json";
|
||||
var AVATAR_URL = "https://hifi-content.s3.amazonaws.com/jimi/avatar/camera/fst/camera.fst";
|
||||
var originalAvatar = null;
|
||||
var importedEntityIDs = [];
|
||||
var selfieStickEntityID = null;
|
||||
var lensEntityID = null;
|
||||
var freeMovementMode = true;
|
||||
|
||||
turnOffAvatarCollisions();
|
||||
changeAvatar();
|
||||
importModel();
|
||||
processImportedEntities();
|
||||
setupSpaceBarControl();
|
||||
Script.update.connect(update);
|
||||
|
||||
function turnOffAvatarCollisions() {
|
||||
Menu.setIsOptionChecked("Enable avatar collisions", 0);
|
||||
}
|
||||
|
||||
function turnOnAvatarCollisions() {
|
||||
Menu.setIsOptionChecked("Enable avatar collisions", 1);
|
||||
}
|
||||
|
||||
function changeAvatar() {
|
||||
originalAvatar = MyAvatar.skeletonModelURL;
|
||||
MyAvatar.skeletonModelURL = AVATAR_URL;
|
||||
}
|
||||
|
||||
function importModel() {
|
||||
var success = Clipboard.importEntities(MODEL_URL);
|
||||
var spawnLocation = MyAvatar.position;
|
||||
if (success) {
|
||||
importedEntityIDs = Clipboard.pasteEntities(spawnLocation);
|
||||
}
|
||||
}
|
||||
|
||||
function processImportedEntities() {
|
||||
importedEntityIDs.forEach(function(id){
|
||||
var props = Entities.getEntityProperties(id);
|
||||
if (props.name === "Selfie Stick") {
|
||||
selfieStickEntityID = id;
|
||||
} else if (props.name === "Lens") {
|
||||
lensEntityID = id;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function setupSpaceBarControl() {
|
||||
var mappingName = "Handheld-Cam-Space-Bar";
|
||||
var myMapping = Controller.newMapping(mappingName);
|
||||
myMapping.from(Controller.Hardware.Keyboard.Space).to(function(value){
|
||||
if ( value === 0 ) {
|
||||
return;
|
||||
}
|
||||
if (freeMovementMode) {
|
||||
freeMovementMode = false;
|
||||
Camera.mode = "entity";
|
||||
Camera.cameraEntity = lensEntityID;
|
||||
} else {
|
||||
freeMovementMode = true;
|
||||
Camera.mode = "first person";
|
||||
}
|
||||
});
|
||||
Controller.enableMapping(mappingName);
|
||||
}
|
||||
|
||||
function update(deltaTime) {
|
||||
if (freeMovementMode) {
|
||||
var upFactor = 0.1;
|
||||
var upUnitVec = Vec3.normalize(Quat.getUp(MyAvatar.orientation));
|
||||
var upOffset = Vec3.multiply(upUnitVec, upFactor);
|
||||
var forwardFactor = -0.1;
|
||||
var forwardUnitVec = Vec3.normalize(Quat.getFront(MyAvatar.orientation));
|
||||
var forwardOffset = Vec3.multiply(forwardUnitVec, forwardFactor);
|
||||
var newPos = Vec3.sum(Vec3.sum(MyAvatar.position, upOffset), forwardOffset);
|
||||
var newRot = MyAvatar.orientation;
|
||||
Entities.editEntity(selfieStickEntityID, {position: newPos, rotation: newRot});
|
||||
} else {
|
||||
var props = Entities.getEntityProperties(selfieStickEntityID);
|
||||
var upFactor = 0.1;
|
||||
var upUnitVec = Vec3.normalize(Quat.getUp(props.rotation));
|
||||
var upOffset = Vec3.multiply(upUnitVec, -upFactor);
|
||||
var forwardFactor = -0.1;
|
||||
var forwardUnitVec = Vec3.normalize(Quat.getFront(props.rotation));
|
||||
var forwardOffset = Vec3.multiply(forwardUnitVec, -forwardFactor);
|
||||
var newPos = Vec3.sum(Vec3.sum(props.position, upOffset), forwardOffset);
|
||||
MyAvatar.position = newPos;
|
||||
MyAvatar.orientation = props.rotation;
|
||||
}
|
||||
}
|
||||
|
||||
// Removes all entities we imported and reset settings we've changed
|
||||
function cleanup() {
|
||||
importedEntityIDs.forEach(function(id) {
|
||||
Entities.deleteEntity(id);
|
||||
});
|
||||
Camera.mode = "first person";
|
||||
Controller.disableMapping("Handheld-Cam-Space-Bar");
|
||||
MyAvatar.skeletonModelURL = originalAvatar;
|
||||
turnOnAvatarCollisions();
|
||||
}
|
||||
Script.scriptEnding.connect(cleanup);
|
||||
}()); // END LOCAL_SCOPE
|
||||
|
|
@ -1094,7 +1094,6 @@ function MyController(hand) {
|
|||
this.grabbedOverlay = null;
|
||||
this.state = STATE_OFF;
|
||||
this.pointer = null; // entity-id of line object
|
||||
this.entityActivated = false;
|
||||
|
||||
this.triggerValue = 0; // rolling average of trigger value
|
||||
this.triggerClicked = false;
|
||||
|
|
@ -2826,12 +2825,6 @@ function MyController(hand) {
|
|||
|
||||
Controller.triggerHapticPulse(HAPTIC_PULSE_STRENGTH, HAPTIC_PULSE_DURATION, this.hand);
|
||||
|
||||
if (this.entityActivated) {
|
||||
var saveGrabbedID = this.grabbedThingID;
|
||||
this.release();
|
||||
this.grabbedThingID = saveGrabbedID;
|
||||
}
|
||||
|
||||
var grabbedProperties;
|
||||
if (this.grabbedIsOverlay) {
|
||||
grabbedProperties = {
|
||||
|
|
@ -3007,22 +3000,25 @@ function MyController(hand) {
|
|||
* is called correctly, as these just freshly created entity may not have completely initialized.
|
||||
*/
|
||||
var grabEquipCheck = function () {
|
||||
if (_this.state == STATE_NEAR_GRABBING) {
|
||||
_this.callEntityMethodOnGrabbed("startNearGrab");
|
||||
if (_this.state == STATE_NEAR_GRABBING) {
|
||||
_this.callEntityMethodOnGrabbed("startNearGrab");
|
||||
} else { // this.state == STATE_HOLD
|
||||
_this.callEntityMethodOnGrabbed("startEquip");
|
||||
_this.callEntityMethodOnGrabbed("startEquip");
|
||||
}
|
||||
|
||||
_this.currentHandControllerTipPosition =
|
||||
(_this.hand === RIGHT_HAND) ? MyAvatar.rightHandTipPosition : MyAvatar.leftHandTipPosition;
|
||||
_this.currentObjectTime = Date.now();
|
||||
// don't block teleport raypick with equipped entity
|
||||
Messages.sendMessage('Hifi-Teleport-Ignore-Add', _this.grabbedThingID);
|
||||
|
||||
_this.currentObjectPosition = grabbedProperties.position;
|
||||
_this.currentObjectRotation = grabbedProperties.rotation;
|
||||
_this.currentVelocity = ZERO_VEC;
|
||||
_this.currentAngularVelocity = ZERO_VEC;
|
||||
_this.currentHandControllerTipPosition =
|
||||
(_this.hand === RIGHT_HAND) ? MyAvatar.rightHandTipPosition : MyAvatar.leftHandTipPosition;
|
||||
_this.currentObjectTime = Date.now();
|
||||
|
||||
_this.prevDropDetected = false;
|
||||
_this.currentObjectPosition = grabbedProperties.position;
|
||||
_this.currentObjectRotation = grabbedProperties.rotation;
|
||||
_this.currentVelocity = ZERO_VEC;
|
||||
_this.currentAngularVelocity = ZERO_VEC;
|
||||
|
||||
_this.prevDropDetected = false;
|
||||
}
|
||||
|
||||
if (isClone) {
|
||||
|
|
@ -3654,6 +3650,9 @@ function MyController(hand) {
|
|||
this.turnOffVisualizations();
|
||||
|
||||
if (this.grabbedThingID !== null) {
|
||||
|
||||
Messages.sendMessage('Hifi-Teleport-Ignore-Remove', this.grabbedThingID);
|
||||
|
||||
if (this.state === STATE_HOLD) {
|
||||
this.callEntityMethodOnGrabbed("releaseEquip");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,10 +29,15 @@
|
|||
}
|
||||
|
||||
function onScreenChanged(type, url) {
|
||||
// for toolbar mode: change button to active when window is first openend, false otherwise.
|
||||
button.editProperties({isActive: shouldActivateButton});
|
||||
shouldActivateButton = false;
|
||||
onGotoScreen = false;
|
||||
if (url === gotoQmlSource) {
|
||||
onGotoScreen = true;
|
||||
shouldActivateButton = true;
|
||||
button.editProperties({isActive: shouldActivateButton});
|
||||
} else {
|
||||
shouldActivateButton = false;
|
||||
onGotoScreen = false;
|
||||
button.editProperties({isActive: shouldActivateButton});
|
||||
}
|
||||
}
|
||||
|
||||
var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
|
||||
|
|
|
|||
Loading…
Reference in a new issue