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

Merge branch 'master' of https://github.com/highfidelity/hifi into newEntityListView

Browse source
This commit is contained in:
David Back 2018-09-11 17:13:02 -07:00
commit ac04c501cb
9 changed files with 266 additions and 352 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
interface/resources/qml/hifi/AvatarApp.qml
View file

@ -175,7 +175,14 @@ Rectangle {
displayNameInput.text = getAvatarsData.displayName; displayNameInput.text = getAvatarsData.displayName;
currentAvatarSettings = getAvatarsData.currentAvatarSettings; currentAvatarSettings = getAvatarsData.currentAvatarSettings;
updateCurrentAvatarInBookmarks(currentAvatar); var bookmarkAvatarIndex = allAvatars.findAvatarIndexByValue(currentAvatar);
if (bookmarkAvatarIndex === -1) {
currentAvatar.name = '';
} else {
currentAvatar.name = allAvatars.get(bookmarkAvatarIndex).name;
allAvatars.move(bookmarkAvatarIndex, 0, 1);
}
view.setPage(0);
} else if (message.method === 'updateAvatarInBookmarks') { } else if (message.method === 'updateAvatarInBookmarks') {
updateCurrentAvatarInBookmarks(currentAvatar); updateCurrentAvatarInBookmarks(currentAvatar);
} else if (message.method === 'selectAvatarEntity') { } else if (message.method === 'selectAvatarEntity') {

8
interface/src/Application.cpp
View file

@ -1192,7 +1192,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
connect(&domainHandler, SIGNAL(resetting()), SLOT(resettingDomain())); connect(&domainHandler, SIGNAL(resetting()), SLOT(resettingDomain()));
connect(&domainHandler, SIGNAL(connectedToDomain(QUrl)), SLOT(updateWindowTitle())); connect(&domainHandler, SIGNAL(connectedToDomain(QUrl)), SLOT(updateWindowTitle()));
connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(updateWindowTitle())); connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(updateWindowTitle()));
connect(&domainHandler, &DomainHandler::disconnectedFromDomain, this, &Application::clearDomainAvatars);
connect(&domainHandler, &DomainHandler::disconnectedFromDomain, this, [this]() { connect(&domainHandler, &DomainHandler::disconnectedFromDomain, this, [this]() {
getOverlays().deleteOverlay(getTabletScreenID()); getOverlays().deleteOverlay(getTabletScreenID());
getOverlays().deleteOverlay(getTabletHomeButtonID()); getOverlays().deleteOverlay(getTabletHomeButtonID());
@ -6370,10 +6369,6 @@ void Application::clearDomainOctreeDetails() {
getMyAvatar()->setAvatarEntityDataChanged(true); getMyAvatar()->setAvatarEntityDataChanged(true);
} }
void Application::clearDomainAvatars() {
DependencyManager::get<AvatarManager>()->clearOtherAvatars();
}
void Application::domainURLChanged(QUrl domainURL) { void Application::domainURLChanged(QUrl domainURL) {
// disable physics until we have enough information about our new location to not cause craziness. // disable physics until we have enough information about our new location to not cause craziness.
resetPhysicsReadyInformation(); resetPhysicsReadyInformation();
@ -6461,9 +6456,6 @@ void Application::nodeKilled(SharedNodePointer node) {
} else if (node->getType() == NodeType::EntityServer) { } else if (node->getType() == NodeType::EntityServer) {
// we lost an entity server, clear all of the domain octree details // we lost an entity server, clear all of the domain octree details
clearDomainOctreeDetails(); clearDomainOctreeDetails();
} else if (node->getType() == NodeType::AvatarMixer) {
// our avatar mixer has gone away - clear the hash of avatars
DependencyManager::get<AvatarManager>()->clearOtherAvatars();
} else if (node->getType() == NodeType::AssetServer) { } else if (node->getType() == NodeType::AssetServer) {
// asset server going away - check if we have the asset browser showing // asset server going away - check if we have the asset browser showing

1
interface/src/Application.h
View file

@ -437,7 +437,6 @@ private slots:
void onDesktopRootContextCreated(QQmlContext* qmlContext); void onDesktopRootContextCreated(QQmlContext* qmlContext);
void showDesktop(); void showDesktop();
void clearDomainOctreeDetails(); void clearDomainOctreeDetails();
void clearDomainAvatars();
void onAboutToQuit(); void onAboutToQuit();
void onPresent(quint32 frameCount); void onPresent(quint32 frameCount);

2
interface/src/avatar/AvatarManager.h
View file

@ -93,7 +93,7 @@ public:
void postUpdate(float deltaTime, const render::ScenePointer& scene); void postUpdate(float deltaTime, const render::ScenePointer& scene);
void clearOtherAvatars(); void clearOtherAvatars() override;
void deleteAllAvatars(); void deleteAllAvatars();
void getObjectsToRemoveFromPhysics(VectorOfMotionStates& motionStates); void getObjectsToRemoveFromPhysics(VectorOfMotionStates& motionStates);

15
libraries/avatars/src/AvatarHashMap.cpp
View file

@ -113,6 +113,12 @@ AvatarHashMap::AvatarHashMap() {
packetReceiver.registerListener(PacketType::BulkAvatarTraits, this, "processBulkAvatarTraits"); packetReceiver.registerListener(PacketType::BulkAvatarTraits, this, "processBulkAvatarTraits");
connect(nodeList.data(), &NodeList::uuidChanged, this, &AvatarHashMap::sessionUUIDChanged); connect(nodeList.data(), &NodeList::uuidChanged, this, &AvatarHashMap::sessionUUIDChanged);
connect(nodeList.data(), &NodeList::nodeKilled, this, [this](SharedNodePointer killedNode){
if (killedNode->getType() == NodeType::AvatarMixer) {
clearOtherAvatars();
}
});
} }
QVector<QUuid> AvatarHashMap::getAvatarIdentifiers() { QVector<QUuid> AvatarHashMap::getAvatarIdentifiers() {
@ -429,3 +435,12 @@ void AvatarHashMap::sessionUUIDChanged(const QUuid& sessionUUID, const QUuid& ol
emit avatarSessionChangedEvent(sessionUUID, oldUUID); emit avatarSessionChangedEvent(sessionUUID, oldUUID);
} }
void AvatarHashMap::clearOtherAvatars() {
QWriteLocker locker(&_hashLock);
for (auto& av : _avatarHash) {
handleRemovedAvatar(av);
}
_avatarHash.clear();
}

2
libraries/avatars/src/AvatarHashMap.h
View file

@ -101,6 +101,8 @@ public:
void setReplicaCount(int count); void setReplicaCount(int count);
int getReplicaCount() { return _replicas.getReplicaCount(); }; int getReplicaCount() { return _replicas.getReplicaCount(); };
virtual void clearOtherAvatars();
signals: signals:
/**jsdoc /**jsdoc

23
libraries/gpu-gl-common/src/gpu/gl/GLBackendQuery.cpp
View file

@ -25,15 +25,15 @@ static bool timeElapsed = false;
#endif #endif
void GLBackend::do_beginQuery(const Batch& batch, size_t paramOffset) { void GLBackend::do_beginQuery(const Batch& batch, size_t paramOffset) {
#if !defined(USE_GLES)
auto query = batch._queries.get(batch._params[paramOffset]._uint); auto query = batch._queries.get(batch._params[paramOffset]._uint);
GLQuery* glquery = syncGPUObject(*query); GLQuery* glquery = syncGPUObject(*query);
if (glquery) { if (glquery) {
PROFILE_RANGE_BEGIN(render_gpu_gl_detail, glquery->_profileRangeId, query->getName().c_str(), 0xFFFF7F00); PROFILE_RANGE_BEGIN(render_gpu_gl_detail, glquery->_profileRangeId, query->getName().c_str(), 0xFFFF7F00);
++_queryStage._rangeQueryDepth; ++_queryStage._rangeQueryDepth;
glGetInteger64v(GL_TIMESTAMP, (GLint64*)&glquery->_batchElapsedTime); glquery->_batchElapsedTimeBegin = std::chrono::high_resolution_clock::now();
#if !defined(USE_GLES)
if (timeElapsed) { if (timeElapsed) {
if (_queryStage._rangeQueryDepth <= MAX_RANGE_QUERY_DEPTH) { if (_queryStage._rangeQueryDepth <= MAX_RANGE_QUERY_DEPTH) {
glBeginQuery(GL_TIME_ELAPSED, glquery->_endqo); glBeginQuery(GL_TIME_ELAPSED, glquery->_endqo);
@ -41,17 +41,18 @@ void GLBackend::do_beginQuery(const Batch& batch, size_t paramOffset) {
} else { } else {
glQueryCounter(glquery->_beginqo, GL_TIMESTAMP); glQueryCounter(glquery->_beginqo, GL_TIMESTAMP);
} }
#endif
glquery->_rangeQueryDepth = _queryStage._rangeQueryDepth; glquery->_rangeQueryDepth = _queryStage._rangeQueryDepth;
(void)CHECK_GL_ERROR(); (void)CHECK_GL_ERROR();
} }
#endif
} }
void GLBackend::do_endQuery(const Batch& batch, size_t paramOffset) { void GLBackend::do_endQuery(const Batch& batch, size_t paramOffset) {
#if !defined(USE_GLES)
auto query = batch._queries.get(batch._params[paramOffset]._uint); auto query = batch._queries.get(batch._params[paramOffset]._uint);
GLQuery* glquery = syncGPUObject(*query); GLQuery* glquery = syncGPUObject(*query);
if (glquery) { if (glquery) {
#if !defined(USE_GLES)
if (timeElapsed) { if (timeElapsed) {
if (_queryStage._rangeQueryDepth <= MAX_RANGE_QUERY_DEPTH) { if (_queryStage._rangeQueryDepth <= MAX_RANGE_QUERY_DEPTH) {
glEndQuery(GL_TIME_ELAPSED); glEndQuery(GL_TIME_ELAPSED);
@ -59,27 +60,26 @@ void GLBackend::do_endQuery(const Batch& batch, size_t paramOffset) {
} else { } else {
glQueryCounter(glquery->_endqo, GL_TIMESTAMP); glQueryCounter(glquery->_endqo, GL_TIMESTAMP);
} }
#endif
--_queryStage._rangeQueryDepth; --_queryStage._rangeQueryDepth;
GLint64 now; auto duration_ns = (std::chrono::high_resolution_clock::now() - glquery->_batchElapsedTimeBegin);
glGetInteger64v(GL_TIMESTAMP, &now); glquery->_batchElapsedTime = duration_ns.count();
glquery->_batchElapsedTime = now - glquery->_batchElapsedTime;
PROFILE_RANGE_END(render_gpu_gl_detail, glquery->_profileRangeId); PROFILE_RANGE_END(render_gpu_gl_detail, glquery->_profileRangeId);
(void)CHECK_GL_ERROR(); (void)CHECK_GL_ERROR();
} }
#endif
} }
void GLBackend::do_getQuery(const Batch& batch, size_t paramOffset) { void GLBackend::do_getQuery(const Batch& batch, size_t paramOffset) {
#if !defined(USE_GLES)
auto query = batch._queries.get(batch._params[paramOffset]._uint); auto query = batch._queries.get(batch._params[paramOffset]._uint);
GLQuery* glquery = syncGPUObject(*query); GLQuery* glquery = syncGPUObject(*query);
if (glquery) { if (glquery) {
if (glquery->_rangeQueryDepth > MAX_RANGE_QUERY_DEPTH) { if (glquery->_rangeQueryDepth > MAX_RANGE_QUERY_DEPTH) {
query->triggerReturnHandler(glquery->_result, glquery->_batchElapsedTime); query->triggerReturnHandler(glquery->_result, glquery->_batchElapsedTime);
} else { } else {
#if !defined(USE_GLES)
glGetQueryObjectui64v(glquery->_endqo, GL_QUERY_RESULT_AVAILABLE, &glquery->_result); glGetQueryObjectui64v(glquery->_endqo, GL_QUERY_RESULT_AVAILABLE, &glquery->_result);
if (glquery->_result == GL_TRUE) { if (glquery->_result == GL_TRUE) {
if (timeElapsed) { if (timeElapsed) {
@ -92,10 +92,13 @@ void GLBackend::do_getQuery(const Batch& batch, size_t paramOffset) {
} }
query->triggerReturnHandler(glquery->_result, glquery->_batchElapsedTime); query->triggerReturnHandler(glquery->_result, glquery->_batchElapsedTime);
} }
#else
// gles3 is not supporting true time query returns just the batch elapsed time
query->triggerReturnHandler(0, glquery->_batchElapsedTime);
#endif
(void)CHECK_GL_ERROR(); (void)CHECK_GL_ERROR();
} }
} }
#endif
} }
void GLBackend::resetQueryStage() { void GLBackend::resetQueryStage() {

5
libraries/gpu-gl-common/src/gpu/gl/GLQuery.h
View file

@ -47,8 +47,9 @@ public:
const GLuint& _endqo = { _id }; const GLuint& _endqo = { _id };
const GLuint _beginqo = { 0 }; const GLuint _beginqo = { 0 };
GLuint64 _result { (GLuint64)-1 }; GLuint64 _result { (GLuint64)0 };
GLuint64 _batchElapsedTime { (GLuint64) 0 }; GLuint64 _batchElapsedTime{ (GLuint64)0 };
std::chrono::high_resolution_clock::time_point _batchElapsedTimeBegin;
uint64_t _profileRangeId { 0 }; uint64_t _profileRangeId { 0 };
uint32_t _rangeQueryDepth { 0 }; uint32_t _rangeQueryDepth { 0 };

553
scripts/system/libraries/entitySelectionTool.js
View file

@ -410,7 +410,7 @@ SelectionDisplay = (function() {
var COLOR_RED = { red: 226, green: 51, blue: 77 }; var COLOR_RED = { red: 226, green: 51, blue: 77 };
var COLOR_HOVER = { red: 227, green: 227, blue: 227 }; var COLOR_HOVER = { red: 227, green: 227, blue: 227 };
var COLOR_ROTATE_CURRENT_RING = { red: 255, green: 99, blue: 9 }; var COLOR_ROTATE_CURRENT_RING = { red: 255, green: 99, blue: 9 };
var COLOR_SCALE_EDGE = { red: 87, green: 87, blue: 87 }; var COLOR_BOUNDING_EDGE = { red: 87, green: 87, blue: 87 };
var COLOR_SCALE_CUBE = { red: 106, green: 106, blue: 106 }; var COLOR_SCALE_CUBE = { red: 106, green: 106, blue: 106 };
var COLOR_SCALE_CUBE_SELECTED = { red: 18, green: 18, blue: 18 }; var COLOR_SCALE_CUBE_SELECTED = { red: 18, green: 18, blue: 18 };
@ -433,15 +433,15 @@ SelectionDisplay = (function() {
var ROTATE_DISPLAY_SIZE_Y_MULTIPLIER = 0.09; var ROTATE_DISPLAY_SIZE_Y_MULTIPLIER = 0.09;
var ROTATE_DISPLAY_LINE_HEIGHT_MULTIPLIER = 0.07; var ROTATE_DISPLAY_LINE_HEIGHT_MULTIPLIER = 0.07;
var STRETCH_SPHERE_OFFSET = 0.06; var STRETCH_CUBE_OFFSET = 0.06;
var STRETCH_SPHERE_CAMERA_DISTANCE_MULTIPLE = 0.01; var STRETCH_CUBE_CAMERA_DISTANCE_MULTIPLE = 0.02;
var STRETCH_MINIMUM_DIMENSION = 0.001; var STRETCH_MINIMUM_DIMENSION = 0.001;
var STRETCH_ALL_MINIMUM_DIMENSION = 0.01; var STRETCH_ALL_MINIMUM_DIMENSION = 0.01;
var STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE = 6; var STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE = 2;
var STRETCH_PANEL_WIDTH = 0.01; var STRETCH_PANEL_WIDTH = 0.01;
var SCALE_CUBE_OFFSET = 0.5; var BOUNDING_EDGE_OFFSET = 0.5;
var SCALE_CUBE_CAMERA_DISTANCE_MULTIPLE = 0.0125; var SCALE_CUBE_CAMERA_DISTANCE_MULTIPLE = 0.02;
var CLONER_OFFSET = { x: 0.9, y: -0.9, z: 0.9 }; var CLONER_OFFSET = { x: 0.9, y: -0.9, z: 0.9 };
@ -495,6 +495,8 @@ SelectionDisplay = (function() {
var worldRotationX; var worldRotationX;
var worldRotationY; var worldRotationY;
var worldRotationZ; var worldRotationZ;
var activeStretchCubePanelOffset = null;
var previousHandle = null; var previousHandle = null;
var previousHandleHelper = null; var previousHandleHelper = null;
@ -589,20 +591,18 @@ SelectionDisplay = (function() {
leftMargin: 0 leftMargin: 0
}); });
var handlePropertiesStretchSpheres = { var handlePropertiesStretchCubes = {
alpha: 1,
shape: "Sphere",
solid: true, solid: true,
visible: false, visible: false,
ignoreRayIntersection: false, ignoreRayIntersection: false,
drawInFront: true drawInFront: true
}; };
var handleStretchXSphere = Overlays.addOverlay("shape", handlePropertiesStretchSpheres); var handleStretchXCube = Overlays.addOverlay("cube", handlePropertiesStretchCubes);
Overlays.editOverlay(handleStretchXSphere, { color: COLOR_RED }); Overlays.editOverlay(handleStretchXCube, { color: COLOR_RED });
var handleStretchYSphere = Overlays.addOverlay("shape", handlePropertiesStretchSpheres); var handleStretchYCube = Overlays.addOverlay("cube", handlePropertiesStretchCubes);
Overlays.editOverlay(handleStretchYSphere, { color: COLOR_GREEN }); Overlays.editOverlay(handleStretchYCube, { color: COLOR_GREEN });
var handleStretchZSphere = Overlays.addOverlay("shape", handlePropertiesStretchSpheres); var handleStretchZCube = Overlays.addOverlay("cube", handlePropertiesStretchCubes);
Overlays.editOverlay(handleStretchZSphere, { color: COLOR_BLUE }); Overlays.editOverlay(handleStretchZCube, { color: COLOR_BLUE });
var handlePropertiesStretchPanel = { var handlePropertiesStretchPanel = {
shape: "Quad", shape: "Quad",
@ -619,8 +619,7 @@ SelectionDisplay = (function() {
var handleStretchZPanel = Overlays.addOverlay("shape", handlePropertiesStretchPanel); var handleStretchZPanel = Overlays.addOverlay("shape", handlePropertiesStretchPanel);
Overlays.editOverlay(handleStretchZPanel, { color: COLOR_BLUE }); Overlays.editOverlay(handleStretchZPanel, { color: COLOR_BLUE });
var handlePropertiesScaleCubes = { var handleScaleCube = Overlays.addOverlay("cube", {
alpha: 1,
size: 0.025, size: 0.025,
color: COLOR_SCALE_CUBE, color: COLOR_SCALE_CUBE,
solid: true, solid: true,
@ -628,36 +627,28 @@ SelectionDisplay = (function() {
ignoreRayIntersection: false, ignoreRayIntersection: false,
drawInFront: true, drawInFront: true,
borderSize: 1.4 borderSize: 1.4
}; });
var handleScaleLBNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x, -y, -z)
var handleScaleRBNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x, -y, -z)
var handleScaleLBFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x, -y, z)
var handleScaleRBFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x, -y, z)
var handleScaleLTNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x, y, -z)
var handleScaleRTNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x, y, -z)
var handleScaleLTFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x, y, z)
var handleScaleRTFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x, y, z)
var handlePropertiesScaleEdge = { var handlePropertiesBoundingEdge = {
alpha: 1, alpha: 1,
color: COLOR_SCALE_EDGE, color: COLOR_BOUNDING_EDGE,
visible: false, visible: false,
ignoreRayIntersection: true, ignoreRayIntersection: true,
drawInFront: true, drawInFront: true,
lineWidth: 0.2 lineWidth: 0.2
}; };
var handleScaleTREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingTREdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleTLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingTLEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleTFEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingTFEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleTNEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingTNEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleBREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingBREdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleBLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingBLEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleBFEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingBFEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleBNEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingBNEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleNREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingNREdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleNLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingNLEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleFREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingFREdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleScaleFLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge); var handleBoundingFLEdge = Overlays.addOverlay("line3d", handlePropertiesBoundingEdge);
var handleCloner = Overlays.addOverlay("cube", { var handleCloner = Overlays.addOverlay("cube", {
alpha: 1, alpha: 1,
@ -738,32 +729,25 @@ SelectionDisplay = (function() {
handleRotateRollRing, handleRotateRollRing,
handleRotateCurrentRing, handleRotateCurrentRing,
rotationDegreesDisplay, rotationDegreesDisplay,
handleStretchXSphere, handleStretchXCube,
handleStretchYSphere, handleStretchYCube,
handleStretchZSphere, handleStretchZCube,
handleStretchXPanel, handleStretchXPanel,
handleStretchYPanel, handleStretchYPanel,
handleStretchZPanel, handleStretchZPanel,
handleScaleLBNCube, handleScaleCube,
handleScaleRBNCube, handleBoundingTREdge,
handleScaleLBFCube, handleBoundingTLEdge,
handleScaleRBFCube, handleBoundingTFEdge,
handleScaleLTNCube, handleBoundingTNEdge,
handleScaleRTNCube, handleBoundingBREdge,
handleScaleLTFCube, handleBoundingBLEdge,
handleScaleRTFCube, handleBoundingBFEdge,
handleScaleTREdge, handleBoundingBNEdge,
handleScaleTLEdge, handleBoundingNREdge,
handleScaleTFEdge, handleBoundingNLEdge,
handleScaleTNEdge, handleBoundingFREdge,
handleScaleBREdge, handleBoundingFLEdge,
handleScaleBLEdge,
handleScaleBFEdge,
handleScaleBNEdge,
handleScaleNREdge,
handleScaleNLEdge,
handleScaleFREdge,
handleScaleFLEdge,
handleCloner, handleCloner,
selectionBox, selectionBox,
iconSelectionBox, iconSelectionBox,
@ -787,34 +771,27 @@ SelectionDisplay = (function() {
overlayNames[handleRotateCurrentRing] = "handleRotateCurrentRing"; overlayNames[handleRotateCurrentRing] = "handleRotateCurrentRing";
overlayNames[rotationDegreesDisplay] = "rotationDegreesDisplay"; overlayNames[rotationDegreesDisplay] = "rotationDegreesDisplay";
overlayNames[handleStretchXSphere] = "handleStretchXSphere"; overlayNames[handleStretchXCube] = "handleStretchXCube";
overlayNames[handleStretchYSphere] = "handleStretchYSphere"; overlayNames[handleStretchYCube] = "handleStretchYCube";
overlayNames[handleStretchZSphere] = "handleStretchZSphere"; overlayNames[handleStretchZCube] = "handleStretchZCube";
overlayNames[handleStretchXPanel] = "handleStretchXPanel"; overlayNames[handleStretchXPanel] = "handleStretchXPanel";
overlayNames[handleStretchYPanel] = "handleStretchYPanel"; overlayNames[handleStretchYPanel] = "handleStretchYPanel";
overlayNames[handleStretchZPanel] = "handleStretchZPanel"; overlayNames[handleStretchZPanel] = "handleStretchZPanel";
overlayNames[handleScaleLBNCube] = "handleScaleLBNCube"; overlayNames[handleScaleCube] = "handleScaleCube";
overlayNames[handleScaleRBNCube] = "handleScaleRBNCube";
overlayNames[handleScaleLBFCube] = "handleScaleLBFCube";
overlayNames[handleScaleRBFCube] = "handleScaleRBFCube";
overlayNames[handleScaleLTNCube] = "handleScaleLTNCube";
overlayNames[handleScaleRTNCube] = "handleScaleRTNCube";
overlayNames[handleScaleLTFCube] = "handleScaleLTFCube";
overlayNames[handleScaleRTFCube] = "handleScaleRTFCube";
overlayNames[handleScaleTREdge] = "handleScaleTREdge"; overlayNames[handleBoundingTREdge] = "handleBoundingTREdge";
overlayNames[handleScaleTLEdge] = "handleScaleTLEdge"; overlayNames[handleBoundingTLEdge] = "handleBoundingTLEdge";
overlayNames[handleScaleTFEdge] = "handleScaleTFEdge"; overlayNames[handleBoundingTFEdge] = "handleBoundingTFEdge";
overlayNames[handleScaleTNEdge] = "handleScaleTNEdge"; overlayNames[handleBoundingTNEdge] = "handleBoundingTNEdge";
overlayNames[handleScaleBREdge] = "handleScaleBREdge"; overlayNames[handleBoundingBREdge] = "handleBoundingBREdge";
overlayNames[handleScaleBLEdge] = "handleScaleBLEdge"; overlayNames[handleBoundingBLEdge] = "handleBoundingBLEdge";
overlayNames[handleScaleBFEdge] = "handleScaleBFEdge"; overlayNames[handleBoundingBFEdge] = "handleBoundingBFEdge";
overlayNames[handleScaleBNEdge] = "handleScaleBNEdge"; overlayNames[handleBoundingBNEdge] = "handleBoundingBNEdge";
overlayNames[handleScaleNREdge] = "handleScaleNREdge"; overlayNames[handleBoundingNREdge] = "handleBoundingNREdge";
overlayNames[handleScaleNLEdge] = "handleScaleNLEdge"; overlayNames[handleBoundingNLEdge] = "handleBoundingNLEdge";
overlayNames[handleScaleFREdge] = "handleScaleFREdge"; overlayNames[handleBoundingFREdge] = "handleBoundingFREdge";
overlayNames[handleScaleFLEdge] = "handleScaleFLEdge"; overlayNames[handleBoundingFLEdge] = "handleBoundingFLEdge";
overlayNames[handleCloner] = "handleCloner"; overlayNames[handleCloner] = "handleCloner";
overlayNames[selectionBox] = "selectionBox"; overlayNames[selectionBox] = "selectionBox";
@ -1021,32 +998,25 @@ SelectionDisplay = (function() {
case handleTranslateXCone: case handleTranslateXCone:
case handleTranslateXCylinder: case handleTranslateXCylinder:
case handleRotatePitchRing: case handleRotatePitchRing:
case handleStretchXSphere: case handleStretchXCube:
pickedColor = COLOR_RED; pickedColor = COLOR_RED;
highlightNeeded = true; highlightNeeded = true;
break; break;
case handleTranslateYCone: case handleTranslateYCone:
case handleTranslateYCylinder: case handleTranslateYCylinder:
case handleRotateYawRing: case handleRotateYawRing:
case handleStretchYSphere: case handleStretchYCube:
pickedColor = COLOR_GREEN; pickedColor = COLOR_GREEN;
highlightNeeded = true; highlightNeeded = true;
break; break;
case handleTranslateZCone: case handleTranslateZCone:
case handleTranslateZCylinder: case handleTranslateZCylinder:
case handleRotateRollRing: case handleRotateRollRing:
case handleStretchZSphere: case handleStretchZCube:
pickedColor = COLOR_BLUE; pickedColor = COLOR_BLUE;
highlightNeeded = true; highlightNeeded = true;
break; break;
case handleScaleLBNCube: case handleScaleCube:
case handleScaleRBNCube:
case handleScaleLBFCube:
case handleScaleRBFCube:
case handleScaleLTNCube:
case handleScaleRTNCube:
case handleScaleLTFCube:
case handleScaleRTFCube:
pickedColor = COLOR_SCALE_CUBE; pickedColor = COLOR_SCALE_CUBE;
highlightNeeded = true; highlightNeeded = true;
break; break;
@ -1424,127 +1394,56 @@ SelectionDisplay = (function() {
dimensions: arrowConeDimensions dimensions: arrowConeDimensions
}); });
// UPDATE SCALE CUBES // UPDATE SCALE CUBE
var scaleCubeOffsetX = SCALE_CUBE_OFFSET * dimensions.x; var scaleCubeRotation = spaceMode === SPACE_LOCAL ? rotation : Quat.IDENTITY;
var scaleCubeOffsetY = SCALE_CUBE_OFFSET * dimensions.y; var scaleCubeDimension = rotateDimension * SCALE_CUBE_CAMERA_DISTANCE_MULTIPLE /
var scaleCubeOffsetZ = SCALE_CUBE_OFFSET * dimensions.z;
var scaleCubeRotation = spaceMode === SPACE_LOCAL ? rotation : Quat.IDENTITY;
var scaleLBNCubePosition = { x: -scaleCubeOffsetX, y: -scaleCubeOffsetY, z: -scaleCubeOffsetZ };
scaleLBNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLBNCubePosition));
var scaleLBNCubeToCamera = getDistanceToCamera(scaleLBNCubePosition);
var scaleRBNCubePosition = { x: scaleCubeOffsetX, y: -scaleCubeOffsetY, z: -scaleCubeOffsetZ };
scaleRBNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRBNCubePosition));
var scaleRBNCubeToCamera = getDistanceToCamera(scaleRBNCubePosition);
var scaleLBFCubePosition = { x: -scaleCubeOffsetX, y: -scaleCubeOffsetY, z: scaleCubeOffsetZ };
scaleLBFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLBFCubePosition));
var scaleLBFCubeToCamera = getDistanceToCamera(scaleLBFCubePosition);
var scaleRBFCubePosition = { x: scaleCubeOffsetX, y: -scaleCubeOffsetY, z: scaleCubeOffsetZ };
scaleRBFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRBFCubePosition));
var scaleRBFCubeToCamera = getDistanceToCamera(scaleRBFCubePosition);
var scaleLTNCubePosition = { x: -scaleCubeOffsetX, y: scaleCubeOffsetY, z: -scaleCubeOffsetZ };
scaleLTNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLTNCubePosition));
var scaleLTNCubeToCamera = getDistanceToCamera(scaleLTNCubePosition);
var scaleRTNCubePosition = { x: scaleCubeOffsetX, y: scaleCubeOffsetY, z: -scaleCubeOffsetZ };
scaleRTNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRTNCubePosition));
var scaleRTNCubeToCamera = getDistanceToCamera(scaleRTNCubePosition);
var scaleLTFCubePosition = { x: -scaleCubeOffsetX, y: scaleCubeOffsetY, z: scaleCubeOffsetZ };
scaleLTFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLTFCubePosition));
var scaleLTFCubeToCamera = getDistanceToCamera(scaleLTFCubePosition);
var scaleRTFCubePosition = { x: scaleCubeOffsetX, y: scaleCubeOffsetY, z: scaleCubeOffsetZ };
scaleRTFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRTFCubePosition));
var scaleRTFCubeToCamera = getDistanceToCamera(scaleRTFCubePosition);
var scaleCubeToCamera = Math.min(scaleLBNCubeToCamera, scaleRBNCubeToCamera, scaleLBFCubeToCamera,
scaleRBFCubeToCamera, scaleLTNCubeToCamera, scaleRTNCubeToCamera,
scaleLTFCubeToCamera, scaleRTFCubeToCamera);
var scaleCubeDimension = scaleCubeToCamera * SCALE_CUBE_CAMERA_DISTANCE_MULTIPLE;
var scaleCubeDimensions = { x: scaleCubeDimension, y: scaleCubeDimension, z: scaleCubeDimension };
Overlays.editOverlay(handleScaleLBNCube, {
position: scaleLBNCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
Overlays.editOverlay(handleScaleRBNCube, {
position: scaleRBNCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
Overlays.editOverlay(handleScaleLBFCube, {
position: scaleLBFCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
Overlays.editOverlay(handleScaleRBFCube, {
position: scaleRBFCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
Overlays.editOverlay(handleScaleLTNCube, {
position: scaleLTNCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
Overlays.editOverlay(handleScaleRTNCube, {
position: scaleRTNCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
Overlays.editOverlay(handleScaleLTFCube, {
position: scaleLTFCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
Overlays.editOverlay(handleScaleRTFCube, {
position: scaleRTFCubePosition,
rotation: scaleCubeRotation,
dimensions: scaleCubeDimensions
});
// UPDATE SCALE EDGES
Overlays.editOverlay(handleScaleTREdge, { start: scaleRTNCubePosition, end: scaleRTFCubePosition });
Overlays.editOverlay(handleScaleTLEdge, { start: scaleLTNCubePosition, end: scaleLTFCubePosition });
Overlays.editOverlay(handleScaleTFEdge, { start: scaleLTFCubePosition, end: scaleRTFCubePosition });
Overlays.editOverlay(handleScaleTNEdge, { start: scaleLTNCubePosition, end: scaleRTNCubePosition });
Overlays.editOverlay(handleScaleBREdge, { start: scaleRBNCubePosition, end: scaleRBFCubePosition });
Overlays.editOverlay(handleScaleBLEdge, { start: scaleLBNCubePosition, end: scaleLBFCubePosition });
Overlays.editOverlay(handleScaleBFEdge, { start: scaleLBFCubePosition, end: scaleRBFCubePosition });
Overlays.editOverlay(handleScaleBNEdge, { start: scaleLBNCubePosition, end: scaleRBNCubePosition });
Overlays.editOverlay(handleScaleNREdge, { start: scaleRTNCubePosition, end: scaleRBNCubePosition });
Overlays.editOverlay(handleScaleNLEdge, { start: scaleLTNCubePosition, end: scaleLBNCubePosition });
Overlays.editOverlay(handleScaleFREdge, { start: scaleRTFCubePosition, end: scaleRBFCubePosition });
Overlays.editOverlay(handleScaleFLEdge, { start: scaleLTFCubePosition, end: scaleLBFCubePosition });
// UPDATE STRETCH SPHERES
var stretchSphereDimension = rotateDimension * STRETCH_SPHERE_CAMERA_DISTANCE_MULTIPLE /
ROTATE_RING_CAMERA_DISTANCE_MULTIPLE; ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
var stretchSphereDimensions = { x: stretchSphereDimension, y: stretchSphereDimension, z: stretchSphereDimension }; var scaleCubeDimensions = { x: scaleCubeDimension, y: scaleCubeDimension, z: scaleCubeDimension };
var stretchSphereOffset = rotateDimension * STRETCH_SPHERE_OFFSET / ROTATE_RING_CAMERA_DISTANCE_MULTIPLE; Overlays.editOverlay(handleScaleCube, {
var stretchXPosition = { x: stretchSphereOffset, y: 0, z: 0 }; position: position,
stretchXPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchXPosition)); rotation: scaleCubeRotation,
Overlays.editOverlay(handleStretchXSphere, { dimensions: scaleCubeDimensions
position: stretchXPosition,
dimensions: stretchSphereDimensions
});
var stretchYPosition = { x: 0, y: stretchSphereOffset, z: 0 };
stretchYPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchYPosition));
Overlays.editOverlay(handleStretchYSphere, {
position: stretchYPosition,
dimensions: stretchSphereDimensions
});
var stretchZPosition = { x: 0, y: 0, z: stretchSphereOffset };
stretchZPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchZPosition));
Overlays.editOverlay(handleStretchZSphere, {
position: stretchZPosition,
dimensions: stretchSphereDimensions
}); });
// UPDATE BOUNDING BOX EDGES
var edgeOffsetX = BOUNDING_EDGE_OFFSET * dimensions.x;
var edgeOffsetY = BOUNDING_EDGE_OFFSET * dimensions.y;
var edgeOffsetZ = BOUNDING_EDGE_OFFSET * dimensions.z;
var LBNPosition = { x: -edgeOffsetX, y: -edgeOffsetY, z: -edgeOffsetZ };
LBNPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, LBNPosition));
var RBNPosition = { x: edgeOffsetX, y: -edgeOffsetY, z: -edgeOffsetZ };
RBNPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, RBNPosition));
var LBFPosition = { x: -edgeOffsetX, y: -edgeOffsetY, z: edgeOffsetZ };
LBFPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, LBFPosition));
var RBFPosition = { x: edgeOffsetX, y: -edgeOffsetY, z: edgeOffsetZ };
RBFPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, RBFPosition));
var LTNPosition = { x: -edgeOffsetX, y: edgeOffsetY, z: -edgeOffsetZ };
LTNPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, LTNPosition));
var RTNPosition = { x: edgeOffsetX, y: edgeOffsetY, z: -edgeOffsetZ };
RTNPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, RTNPosition));
var LTFPosition = { x: -edgeOffsetX, y: edgeOffsetY, z: edgeOffsetZ };
LTFPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, LTFPosition));
var RTFPosition = { x: edgeOffsetX, y: edgeOffsetY, z: edgeOffsetZ };
RTFPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, RTFPosition));
Overlays.editOverlay(handleBoundingTREdge, { start: RTNPosition, end: RTFPosition });
Overlays.editOverlay(handleBoundingTLEdge, { start: LTNPosition, end: LTFPosition });
Overlays.editOverlay(handleBoundingTFEdge, { start: LTFPosition, end: RTFPosition });
Overlays.editOverlay(handleBoundingTNEdge, { start: LTNPosition, end: RTNPosition });
Overlays.editOverlay(handleBoundingBREdge, { start: RBNPosition, end: RBFPosition });
Overlays.editOverlay(handleBoundingBLEdge, { start: LBNPosition, end: LBFPosition });
Overlays.editOverlay(handleBoundingBFEdge, { start: LBFPosition, end: RBFPosition });
Overlays.editOverlay(handleBoundingBNEdge, { start: LBNPosition, end: RBNPosition });
Overlays.editOverlay(handleBoundingNREdge, { start: RTNPosition, end: RBNPosition });
Overlays.editOverlay(handleBoundingNLEdge, { start: LTNPosition, end: LBNPosition });
Overlays.editOverlay(handleBoundingFREdge, { start: RTFPosition, end: RBFPosition });
Overlays.editOverlay(handleBoundingFLEdge, { start: LTFPosition, end: LBFPosition });
// UPDATE STRETCH HIGHLIGHT PANELS // UPDATE STRETCH HIGHLIGHT PANELS
var scaleRBFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRBFCubePosition); var RBFPositionRotated = Vec3.multiplyQbyV(rotationInverse, RBFPosition);
var scaleRTFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRTFCubePosition); var RTFPositionRotated = Vec3.multiplyQbyV(rotationInverse, RTFPosition);
var scaleLTNCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleLTNCubePosition); var LTNPositionRotated = Vec3.multiplyQbyV(rotationInverse, LTNPosition);
var scaleRTNCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRTNCubePosition); var RTNPositionRotated = Vec3.multiplyQbyV(rotationInverse, RTNPosition);
var stretchPanelXDimensions = Vec3.subtract(scaleRTNCubePositionRotated, scaleRBFCubePositionRotated); var stretchPanelXDimensions = Vec3.subtract(RTNPositionRotated, RBFPositionRotated);
var tempY = Math.abs(stretchPanelXDimensions.y); var tempY = Math.abs(stretchPanelXDimensions.y);
stretchPanelXDimensions.x = STRETCH_PANEL_WIDTH; stretchPanelXDimensions.x = STRETCH_PANEL_WIDTH;
stretchPanelXDimensions.y = Math.abs(stretchPanelXDimensions.z); stretchPanelXDimensions.y = Math.abs(stretchPanelXDimensions.z);
@ -1555,7 +1454,7 @@ SelectionDisplay = (function() {
rotation: rotationZ, rotation: rotationZ,
dimensions: stretchPanelXDimensions dimensions: stretchPanelXDimensions
}); });
var stretchPanelYDimensions = Vec3.subtract(scaleLTNCubePositionRotated, scaleRTFCubePositionRotated); var stretchPanelYDimensions = Vec3.subtract(LTNPositionRotated, RTFPositionRotated);
var tempX = Math.abs(stretchPanelYDimensions.x); var tempX = Math.abs(stretchPanelYDimensions.x);
stretchPanelYDimensions.x = Math.abs(stretchPanelYDimensions.z); stretchPanelYDimensions.x = Math.abs(stretchPanelYDimensions.z);
stretchPanelYDimensions.y = STRETCH_PANEL_WIDTH; stretchPanelYDimensions.y = STRETCH_PANEL_WIDTH;
@ -1566,7 +1465,7 @@ SelectionDisplay = (function() {
rotation: rotationY, rotation: rotationY,
dimensions: stretchPanelYDimensions dimensions: stretchPanelYDimensions
}); });
var stretchPanelZDimensions = Vec3.subtract(scaleLTNCubePositionRotated, scaleRBFCubePositionRotated); var stretchPanelZDimensions = Vec3.subtract(LTNPositionRotated, RBFPositionRotated);
tempX = Math.abs(stretchPanelZDimensions.x); tempX = Math.abs(stretchPanelZDimensions.x);
stretchPanelZDimensions.x = Math.abs(stretchPanelZDimensions.y); stretchPanelZDimensions.x = Math.abs(stretchPanelZDimensions.y);
stretchPanelZDimensions.y = tempX; stretchPanelZDimensions.y = tempX;
@ -1578,6 +1477,46 @@ SelectionDisplay = (function() {
dimensions: stretchPanelZDimensions dimensions: stretchPanelZDimensions
}); });
// UPDATE STRETCH CUBES
var stretchCubeDimension = rotateDimension * STRETCH_CUBE_CAMERA_DISTANCE_MULTIPLE /
ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
var stretchCubeDimensions = { x: stretchCubeDimension, y: stretchCubeDimension, z: stretchCubeDimension };
var stretchCubeOffset = rotateDimension * STRETCH_CUBE_OFFSET / ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
var stretchXPosition, stretchYPosition, stretchZPosition;
if (isActiveTool(handleStretchXCube)) {
stretchXPosition = Vec3.subtract(stretchPanelXPosition, activeStretchCubePanelOffset);
} else {
stretchXPosition = { x: stretchCubeOffset, y: 0, z: 0 };
stretchXPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchXPosition));
}
if (isActiveTool(handleStretchYCube)) {
stretchYPosition = Vec3.subtract(stretchPanelYPosition, activeStretchCubePanelOffset);
} else {
stretchYPosition = { x: 0, y: stretchCubeOffset, z: 0 };
stretchYPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchYPosition));
}
if (isActiveTool(handleStretchZCube)) {
stretchZPosition = Vec3.subtract(stretchPanelZPosition, activeStretchCubePanelOffset);
} else {
stretchZPosition = { x: 0, y: 0, z: stretchCubeOffset };
stretchZPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchZPosition));
}
Overlays.editOverlay(handleStretchXCube, {
position: stretchXPosition,
rotation: rotationX,
dimensions: stretchCubeDimensions
});
Overlays.editOverlay(handleStretchYCube, {
position: stretchYPosition,
rotation: rotationY,
dimensions: stretchCubeDimensions
});
Overlays.editOverlay(handleStretchZCube, {
position: stretchZPosition,
rotation: rotationZ,
dimensions: stretchCubeDimensions
});
// UPDATE SELECTION BOX (CURRENTLY INVISIBLE WITH 0 ALPHA FOR TRANSLATE XZ TOOL) // UPDATE SELECTION BOX (CURRENTLY INVISIBLE WITH 0 ALPHA FOR TRANSLATE XZ TOOL)
var inModeRotate = isActiveTool(handleRotatePitchRing) || var inModeRotate = isActiveTool(handleRotatePitchRing) ||
isActiveTool(handleRotateYawRing) || isActiveTool(handleRotateYawRing) ||
@ -1622,20 +1561,15 @@ SelectionDisplay = (function() {
that.setHandleRotateRollVisible(!activeTool || isActiveTool(handleRotateRollRing)); that.setHandleRotateRollVisible(!activeTool || isActiveTool(handleRotateRollRing));
var showScaleStretch = !activeTool && SelectionManager.selections.length === 1 && spaceMode === SPACE_LOCAL; var showScaleStretch = !activeTool && SelectionManager.selections.length === 1 && spaceMode === SPACE_LOCAL;
that.setHandleStretchXVisible(showScaleStretch || isActiveTool(handleStretchXSphere)); that.setHandleStretchXVisible(showScaleStretch || isActiveTool(handleStretchXCube));
that.setHandleStretchYVisible(showScaleStretch || isActiveTool(handleStretchYSphere)); that.setHandleStretchYVisible(showScaleStretch || isActiveTool(handleStretchYCube));
that.setHandleStretchZVisible(showScaleStretch || isActiveTool(handleStretchZSphere)); that.setHandleStretchZVisible(showScaleStretch || isActiveTool(handleStretchZCube));
that.setHandleScaleCubeVisible(showScaleStretch || isActiveTool(handleScaleLBNCube) || that.setHandleScaleCubeVisible(showScaleStretch || isActiveTool(handleScaleCube));
isActiveTool(handleScaleRBNCube) || isActiveTool(handleScaleLBFCube) ||
isActiveTool(handleScaleRBFCube) || isActiveTool(handleScaleLTNCube) ||
isActiveTool(handleScaleRTNCube) || isActiveTool(handleScaleLTFCube) ||
isActiveTool(handleScaleRTFCube) || isActiveTool(handleStretchXSphere) ||
isActiveTool(handleStretchYSphere) || isActiveTool(handleStretchZSphere));
var showOutlineForZone = (SelectionManager.selections.length === 1 && var showOutlineForZone = (SelectionManager.selections.length === 1 &&
typeof SelectionManager.savedProperties[SelectionManager.selections[0]] !== "undefined" && typeof SelectionManager.savedProperties[SelectionManager.selections[0]] !== "undefined" &&
SelectionManager.savedProperties[SelectionManager.selections[0]].type === "Zone"); SelectionManager.savedProperties[SelectionManager.selections[0]].type === "Zone");
that.setHandleScaleEdgeVisible(showOutlineForZone || (!isActiveTool(handleRotatePitchRing) && that.setHandleBoundingEdgeVisible(showOutlineForZone || (!isActiveTool(handleRotatePitchRing) &&
!isActiveTool(handleRotateYawRing) && !isActiveTool(handleRotateYawRing) &&
!isActiveTool(handleRotateRollRing))); !isActiveTool(handleRotateRollRing)));
@ -1721,47 +1655,40 @@ SelectionDisplay = (function() {
}; };
that.setHandleStretchXVisible = function(isVisible) { that.setHandleStretchXVisible = function(isVisible) {
Overlays.editOverlay(handleStretchXSphere, { visible: isVisible }); Overlays.editOverlay(handleStretchXCube, { visible: isVisible });
}; };
that.setHandleStretchYVisible = function(isVisible) { that.setHandleStretchYVisible = function(isVisible) {
Overlays.editOverlay(handleStretchYSphere, { visible: isVisible }); Overlays.editOverlay(handleStretchYCube, { visible: isVisible });
}; };
that.setHandleStretchZVisible = function(isVisible) { that.setHandleStretchZVisible = function(isVisible) {
Overlays.editOverlay(handleStretchZSphere, { visible: isVisible }); Overlays.editOverlay(handleStretchZCube, { visible: isVisible });
}; };
// FUNCTION: SET HANDLE SCALE VISIBLE // FUNCTION: SET HANDLE SCALE VISIBLE
that.setHandleScaleVisible = function(isVisible) { that.setHandleScaleVisible = function(isVisible) {
that.setHandleScaleCubeVisible(isVisible); that.setHandleScaleCubeVisible(isVisible);
that.setHandleScaleEdgeVisible(isVisible); that.setHandleBoundingEdgeVisible(isVisible);
}; };
that.setHandleScaleCubeVisible = function(isVisible) { that.setHandleScaleCubeVisible = function(isVisible) {
Overlays.editOverlay(handleScaleLBNCube, { visible: isVisible }); Overlays.editOverlay(handleScaleCube, { visible: isVisible });
Overlays.editOverlay(handleScaleRBNCube, { visible: isVisible });
Overlays.editOverlay(handleScaleLBFCube, { visible: isVisible });
Overlays.editOverlay(handleScaleRBFCube, { visible: isVisible });
Overlays.editOverlay(handleScaleLTNCube, { visible: isVisible });
Overlays.editOverlay(handleScaleRTNCube, { visible: isVisible });
Overlays.editOverlay(handleScaleLTFCube, { visible: isVisible });
Overlays.editOverlay(handleScaleRTFCube, { visible: isVisible });
}; };
that.setHandleScaleEdgeVisible = function(isVisible) { that.setHandleBoundingEdgeVisible = function(isVisible) {
Overlays.editOverlay(handleScaleTREdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingTREdge, { visible: isVisible });
Overlays.editOverlay(handleScaleTLEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingTLEdge, { visible: isVisible });
Overlays.editOverlay(handleScaleTFEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingTFEdge, { visible: isVisible });
Overlays.editOverlay(handleScaleTNEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingTNEdge, { visible: isVisible });
Overlays.editOverlay(handleScaleBREdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingBREdge, { visible: isVisible });
Overlays.editOverlay(handleScaleBLEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingBLEdge, { visible: isVisible });
Overlays.editOverlay(handleScaleBFEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingBFEdge, { visible: isVisible });
Overlays.editOverlay(handleScaleBNEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingBNEdge, { visible: isVisible });
Overlays.editOverlay(handleScaleNREdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingNREdge, { visible: isVisible });
Overlays.editOverlay(handleScaleNLEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingNLEdge, { visible: isVisible });
Overlays.editOverlay(handleScaleFREdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingFREdge, { visible: isVisible });
Overlays.editOverlay(handleScaleFLEdge, { visible: isVisible }); Overlays.editOverlay(handleBoundingFLEdge, { visible: isVisible });
}; };
// FUNCTION: SET HANDLE CLONER VISIBLE // FUNCTION: SET HANDLE CLONER VISIBLE
@ -2123,7 +2050,7 @@ SelectionDisplay = (function() {
}; };
// TOOL DEFINITION: HANDLE STRETCH TOOL // TOOL DEFINITION: HANDLE STRETCH TOOL
function makeStretchTool(stretchMode, directionEnum, directionVec, pivot, offset, stretchPanel, scaleHandle) { function makeStretchTool(stretchMode, directionEnum, directionVec, pivot, offset, stretchPanel, cubeHandle) {
var directionFor3DStretch = directionVec; var directionFor3DStretch = directionVec;
var distanceFor3DStretch = 0; var distanceFor3DStretch = 0;
var DISTANCE_INFLUENCE_THRESHOLD = 1.2; var DISTANCE_INFLUENCE_THRESHOLD = 1.2;
@ -2155,8 +2082,11 @@ SelectionDisplay = (function() {
var pickRayPosition3D = null; var pickRayPosition3D = null;
var rotation = null; var rotation = null;
var previousPickRay = null; var previousPickRay = null;
var beginMouseEvent = null;
var onBegin = function(event, pickRay, pickResult) { var onBegin = function(event, pickRay, pickResult) {
var proportional = directionEnum === STRETCH_DIRECTION.ALL;
var properties = Entities.getEntityProperties(SelectionManager.selections[0]); var properties = Entities.getEntityProperties(SelectionManager.selections[0]);
initialProperties = properties; initialProperties = properties;
rotation = (spaceMode === SPACE_LOCAL) ? properties.rotation : Quat.IDENTITY; rotation = (spaceMode === SPACE_LOCAL) ? properties.rotation : Quat.IDENTITY;
@ -2244,9 +2174,7 @@ SelectionDisplay = (function() {
} }
planeNormal = Vec3.multiplyQbyV(rotation, planeNormal); planeNormal = Vec3.multiplyQbyV(rotation, planeNormal);
lastPick = rayPlaneIntersection(pickRay, lastPick = rayPlaneIntersection(pickRay, pickRayPosition, planeNormal);
pickRayPosition,
planeNormal);
var planeNormal3D = { var planeNormal3D = {
x: 0, x: 0,
@ -2274,10 +2202,7 @@ SelectionDisplay = (function() {
if (stretchPanel !== null) { if (stretchPanel !== null) {
Overlays.editOverlay(stretchPanel, { visible: true }); Overlays.editOverlay(stretchPanel, { visible: true });
} }
if (scaleHandle !== null) {
Overlays.editOverlay(scaleHandle, { color: COLOR_SCALE_CUBE_SELECTED });
}
var collisionToRemove = "myAvatar"; var collisionToRemove = "myAvatar";
if (properties.collidesWith.indexOf(collisionToRemove) > -1) { if (properties.collidesWith.indexOf(collisionToRemove) > -1) {
var newCollidesWith = properties.collidesWith.replace(collisionToRemove, ""); var newCollidesWith = properties.collidesWith.replace(collisionToRemove, "");
@ -2285,16 +2210,20 @@ SelectionDisplay = (function() {
that.replaceCollisionsAfterStretch = true; that.replaceCollisionsAfterStretch = true;
} }
if (!proportional) {
var stretchCubePosition = Overlays.getProperty(cubeHandle, "position");
var stretchPanelPosition = Overlays.getProperty(stretchPanel, "position");
activeStretchCubePanelOffset = Vec3.subtract(stretchPanelPosition, stretchCubePosition);
}
previousPickRay = pickRay; previousPickRay = pickRay;
beginMouseEvent = event;
}; };
var onEnd = function(event, reason) { var onEnd = function(event, reason) {
if (stretchPanel !== null) { if (stretchPanel !== null) {
Overlays.editOverlay(stretchPanel, { visible: false }); Overlays.editOverlay(stretchPanel, { visible: false });
} }
if (scaleHandle !== null) {
Overlays.editOverlay(scaleHandle, { color: COLOR_SCALE_CUBE });
}
if (that.replaceCollisionsAfterStretch) { if (that.replaceCollisionsAfterStretch) {
var newCollidesWith = SelectionManager.savedProperties[SelectionManager.selections[0]].collidesWith; var newCollidesWith = SelectionManager.savedProperties[SelectionManager.selections[0]].collidesWith;
@ -2302,6 +2231,8 @@ SelectionDisplay = (function() {
that.replaceCollisionsAfterStretch = false; that.replaceCollisionsAfterStretch = false;
} }
activeStretchCubePanelOffset = null;
pushCommandForSelections(); pushCommandForSelections();
}; };
@ -2351,34 +2282,27 @@ SelectionDisplay = (function() {
vector = grid.snapToSpacing(vector); vector = grid.snapToSpacing(vector);
var changeInDimensions = Vec3.multiply(NEGATE_VECTOR, vec3Mult(localSigns, vector)); var changeInDimensions = Vec3.multiply(NEGATE_VECTOR, vec3Mult(localSigns, vector));
if (directionEnum === STRETCH_DIRECTION.ALL) {
var toCameraDistance = getDistanceToCamera(position);
var dimensionsMultiple = toCameraDistance * STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE;
changeInDimensions = Vec3.multiply(changeInDimensions, dimensionsMultiple);
}
var newDimensions; var newDimensions;
if (proportional) { if (proportional) {
var absoluteX = Math.abs(changeInDimensions.x); var viewportDimensions = Controller.getViewportDimensions();
var absoluteY = Math.abs(changeInDimensions.y); var mouseXDifference = (event.x - beginMouseEvent.x) / viewportDimensions.x;
var absoluteZ = Math.abs(changeInDimensions.z); var mouseYDifference = (beginMouseEvent.y - event.y) / viewportDimensions.y;
var percentChange = 0; var mouseDifference = mouseXDifference + mouseYDifference;
if (absoluteX > absoluteY && absoluteX > absoluteZ) { var toCameraDistance = getDistanceToCamera(position);
percentChange = changeInDimensions.x / initialProperties.dimensions.x; var dimensionsMultiple = toCameraDistance * STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE;
percentChange = changeInDimensions.x / initialDimensions.x; var dimensionChange = mouseDifference * dimensionsMultiple;
} else if (absoluteY > absoluteZ) { var averageInitialDimension = (initialDimensions.x + initialDimensions.y + initialDimensions.z) / 3;
percentChange = changeInDimensions.y / initialProperties.dimensions.y; percentChange = dimensionChange / averageInitialDimension;
percentChange = changeInDimensions.y / initialDimensions.y;
} else {
percentChange = changeInDimensions.z / initialProperties.dimensions.z;
percentChange = changeInDimensions.z / initialDimensions.z;
}
percentChange += 1.0; percentChange += 1.0;
newDimensions = Vec3.multiply(percentChange, initialDimensions); newDimensions = Vec3.multiply(percentChange, initialDimensions);
newDimensions.x = Math.abs(newDimensions.x);
newDimensions.y = Math.abs(newDimensions.y);
newDimensions.z = Math.abs(newDimensions.z);
} else { } else {
newDimensions = Vec3.sum(initialDimensions, changeInDimensions); newDimensions = Vec3.sum(initialDimensions, changeInDimensions);
} }
var minimumDimension = directionEnum === var minimumDimension = directionEnum ===
STRETCH_DIRECTION.ALL ? STRETCH_ALL_MINIMUM_DIMENSION : STRETCH_MINIMUM_DIMENSION; STRETCH_DIRECTION.ALL ? STRETCH_ALL_MINIMUM_DIMENSION : STRETCH_MINIMUM_DIMENSION;
if (newDimensions.x < minimumDimension) { if (newDimensions.x < minimumDimension) {
@ -2393,9 +2317,9 @@ SelectionDisplay = (function() {
newDimensions.z = minimumDimension; newDimensions.z = minimumDimension;
changeInDimensions.z = minimumDimension - initialDimensions.z; changeInDimensions.z = minimumDimension - initialDimensions.z;
} }
var changeInPosition = Vec3.multiplyQbyV(rotation, vec3Mult(localDeltaPivot, changeInDimensions)); var changeInPosition = Vec3.multiplyQbyV(rotation, vec3Mult(localDeltaPivot, changeInDimensions));
if (directionEnum === STRETCH_DIRECTION.ALL) { if (proportional) {
changeInPosition = { x: 0, y: 0, z: 0 }; changeInPosition = { x: 0, y: 0, z: 0 };
} }
var newPosition = Vec3.sum(initialPosition, changeInPosition); var newPosition = Vec3.sum(initialPosition, changeInPosition);
@ -2429,52 +2353,30 @@ SelectionDisplay = (function() {
} }
function addHandleStretchTool(overlay, mode, directionEnum) { function addHandleStretchTool(overlay, mode, directionEnum) {
var directionVector, offset, stretchPanel; var directionVector, offset, stretchPanel, handleStretchCube;
if (directionEnum === STRETCH_DIRECTION.X) { if (directionEnum === STRETCH_DIRECTION.X) {
stretchPanel = handleStretchXPanel; stretchPanel = handleStretchXPanel;
handleStretchCube = handleStretchXCube;
directionVector = { x: -1, y: 0, z: 0 }; directionVector = { x: -1, y: 0, z: 0 };
} else if (directionEnum === STRETCH_DIRECTION.Y) { } else if (directionEnum === STRETCH_DIRECTION.Y) {
stretchPanel = handleStretchYPanel; stretchPanel = handleStretchYPanel;
handleStretchCube = handleStretchYCube;
directionVector = { x: 0, y: -1, z: 0 }; directionVector = { x: 0, y: -1, z: 0 };
} else if (directionEnum === STRETCH_DIRECTION.Z) { } else if (directionEnum === STRETCH_DIRECTION.Z) {
stretchPanel = handleStretchZPanel; stretchPanel = handleStretchZPanel;
handleStretchCube = handleStretchZCube;
directionVector = { x: 0, y: 0, z: -1 }; directionVector = { x: 0, y: 0, z: -1 };
} }
offset = Vec3.multiply(directionVector, NEGATE_VECTOR); offset = Vec3.multiply(directionVector, NEGATE_VECTOR);
var tool = makeStretchTool(mode, directionEnum, directionVector, directionVector, offset, stretchPanel, null); var tool = makeStretchTool(mode, directionEnum, directionVector, directionVector, offset, stretchPanel, handleStretchCube);
return addHandleTool(overlay, tool); return addHandleTool(overlay, tool);
} }
// TOOL DEFINITION: HANDLE SCALE TOOL // TOOL DEFINITION: HANDLE SCALE TOOL
function addHandleScaleTool(overlay, mode, directionEnum) { function addHandleScaleTool(overlay, mode) {
var directionVector, offset, selectedHandle; var directionVector = { x:0, y:0, z:0 };
if (directionEnum === SCALE_DIRECTION.LBN) { var offset = { x:0, y:0, z:0 };
directionVector = { x: 1, y: 1, z: 1 }; var tool = makeStretchTool(mode, STRETCH_DIRECTION.ALL, directionVector, directionVector, offset, null, handleScaleCube);
selectedHandle = handleScaleLBNCube;
} else if (directionEnum === SCALE_DIRECTION.RBN) {
directionVector = { x: -1, y: 1, z: 1 };
selectedHandle = handleScaleRBNCube;
} else if (directionEnum === SCALE_DIRECTION.LBF) {
directionVector = { x: 1, y: 1, z: -1 };
selectedHandle = handleScaleLBFCube;
} else if (directionEnum === SCALE_DIRECTION.RBF) {
directionVector = { x: -1, y: 1, z: -1 };
selectedHandle = handleScaleRBFCube;
} else if (directionEnum === SCALE_DIRECTION.LTN) {
directionVector = { x: 1, y: -1, z: 1 };
selectedHandle = handleScaleLTNCube;
} else if (directionEnum === SCALE_DIRECTION.RTN) {
directionVector = { x: -1, y: -1, z: 1 };
selectedHandle = handleScaleRTNCube;
} else if (directionEnum === SCALE_DIRECTION.LTF) {
directionVector = { x: 1, y: -1, z: -1 };
selectedHandle = handleScaleLTFCube;
} else if (directionEnum === SCALE_DIRECTION.RTF) {
directionVector = { x: -1, y: -1, z: -1 };
selectedHandle = handleScaleRTFCube;
}
offset = Vec3.multiply(directionVector, NEGATE_VECTOR);
var tool = makeStretchTool(mode, STRETCH_DIRECTION.ALL, directionVector, directionVector, offset, null, selectedHandle);
return addHandleTool(overlay, tool); return addHandleTool(overlay, tool);
} }
@ -2747,18 +2649,11 @@ SelectionDisplay = (function() {
addHandleRotateTool(handleRotateYawRing, "ROTATE_YAW", ROTATE_DIRECTION.YAW); addHandleRotateTool(handleRotateYawRing, "ROTATE_YAW", ROTATE_DIRECTION.YAW);
addHandleRotateTool(handleRotateRollRing, "ROTATE_ROLL", ROTATE_DIRECTION.ROLL); addHandleRotateTool(handleRotateRollRing, "ROTATE_ROLL", ROTATE_DIRECTION.ROLL);
addHandleStretchTool(handleStretchXSphere, "STRETCH_X", STRETCH_DIRECTION.X); addHandleStretchTool(handleStretchXCube, "STRETCH_X", STRETCH_DIRECTION.X);
addHandleStretchTool(handleStretchYSphere, "STRETCH_Y", STRETCH_DIRECTION.Y); addHandleStretchTool(handleStretchYCube, "STRETCH_Y", STRETCH_DIRECTION.Y);
addHandleStretchTool(handleStretchZSphere, "STRETCH_Z", STRETCH_DIRECTION.Z); addHandleStretchTool(handleStretchZCube, "STRETCH_Z", STRETCH_DIRECTION.Z);
addHandleScaleTool(handleScaleLBNCube, "SCALE_LBN", SCALE_DIRECTION.LBN);
addHandleScaleTool(handleScaleRBNCube, "SCALE_RBN", SCALE_DIRECTION.RBN);
addHandleScaleTool(handleScaleLBFCube, "SCALE_LBF", SCALE_DIRECTION.LBF);
addHandleScaleTool(handleScaleRBFCube, "SCALE_RBF", SCALE_DIRECTION.RBF);
addHandleScaleTool(handleScaleLTNCube, "SCALE_LTN", SCALE_DIRECTION.LTN);
addHandleScaleTool(handleScaleRTNCube, "SCALE_RTN", SCALE_DIRECTION.RTN);
addHandleScaleTool(handleScaleLTFCube, "SCALE_LTF", SCALE_DIRECTION.LTF);
addHandleScaleTool(handleScaleRTFCube, "SCALE_RTF", SCALE_DIRECTION.RTF);
addHandleScaleTool(handleScaleCube, "SCALE");
return that; return that;
}()); }());