Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-23 09:33:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixing the outside the octree bug

Browse source
This commit is contained in:
samcake 2016-03-10 18:14:11 -08:00
commit 58b84b67ea
18 changed files with 1283 additions and 363 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
examples/defaultScripts.js
View file

@ -13,7 +13,6 @@ Script.load("progress.js");
Script.load("edit.js");
Script.load("marketplace.js");
Script.load("selectAudioDevice.js");
Script.load("inspect.js");
Script.load("notifications.js");
Script.load("users.js");
Script.load("controllers/handControllerGrab.js");

285
examples/hmdControls.js
View file

@ -1,285 +0,0 @@
//
// hmdControls.js
// examples
//
// Created by Sam Gondelman on 6/17/15
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
var MOVE_DISTANCE = 2.0;
var PITCH_INCREMENT = 0.5; // degrees
var pitchChange = 0; // degrees
var YAW_INCREMENT = 0.5; // degrees
var VR_YAW_INCREMENT = 15.0; // degrees
var yawChange = 0;
var BOOM_SPEED = 0.5;
var THRESHOLD = 0.2;
var CAMERA_UPDATE_TIME = 0.5;
var yawTimer = CAMERA_UPDATE_TIME;
var shifted = false;
var SHIFT_UPDATE_TIME = 0.5;
var shiftTimer = SHIFT_UPDATE_TIME;
var SHIFT_MAG = 4.0;
var warpActive = false;
var WARP_UPDATE_TIME = .5;
var warpTimer = WARP_UPDATE_TIME;
var warpPosition = { x: 0, y: 0, z: 0 };
var WARP_SPHERE_SIZE = 1;
var warpSphere = Overlays.addOverlay("sphere", {
position: { x: 0, y: 0, z: 0 },
size: WARP_SPHERE_SIZE,
color: { red: 0, green: 255, blue: 0 },
alpha: 1.0,
solid: true,
visible: false,
});
var WARP_LINE_HEIGHT = 10;
var warpLine = Overlays.addOverlay("line3d", {
start: { x: 0, y: 0, z:0 },
end: { x: 0, y: 0, z: 0 },
color: { red: 0, green: 255, blue: 255},
alpha: 1,
lineWidth: 5,
visible: false,
});
var velocity = { x: 0, y: 0, z: 0 };
var VERY_LONG_TIME = 1000000.0;
var active = HMD.active;
var prevVRMode = HMD.active;
var hmdControls = (function () {
function onKeyPressEvent(event) {
if (event.text == 'g' && event.isMeta) {
active = !active;
}
}
function findAction(name) {
var actions = Controller.getAllActions();
for (var i = 0; i < actions.length; i++) {
if (actions[i].actionName == name) {
return i;
}
}
// If the action isn't found, it will default to the first available action
return 0;
}
function onActionEvent(action, state) {
if (!active) {
return;
}
if (state < THRESHOLD) {
if (action == findAction("YAW_LEFT") || action == findAction("YAW_RIGHT")) {
yawTimer = CAMERA_UPDATE_TIME;
} else if (action == findAction("PITCH_UP") || action == findAction("PITCH_DOWN")) {
pitchTimer = CAMERA_UPDATE_TIME;
}
return;
}
switch (action) {
case findAction("LONGITUDINAL_BACKWARD"):
var direction = {x: 0.0, y: 0.0, z:1.0};
direction = Vec3.multiply(Vec3.normalize(direction), shifted ? SHIFT_MAG * MOVE_DISTANCE : MOVE_DISTANCE);
velocity = Vec3.sum(velocity, direction);
break;
case findAction("LONGITUDINAL_FORWARD"):
var direction = {x: 0.0, y: 0.0, z:-1.0};
direction = Vec3.multiply(Vec3.normalize(direction), shifted ? SHIFT_MAG * MOVE_DISTANCE : MOVE_DISTANCE);
velocity = Vec3.sum(velocity, direction);
break;
case findAction("LATERAL_LEFT"):
var direction = {x:-1.0, y: 0.0, z: 0.0}
direction = Vec3.multiply(Vec3.normalize(direction), shifted ? SHIFT_MAG * MOVE_DISTANCE : MOVE_DISTANCE);
velocity = Vec3.sum(velocity, direction);
break;
case findAction("LATERAL_RIGHT"):
var direction = {x:1.0, y: 0.0, z: 0.0};
direction = Vec3.multiply(Vec3.normalize(direction), shifted ? SHIFT_MAG * MOVE_DISTANCE : MOVE_DISTANCE);
velocity = Vec3.sum(velocity, direction);
break;
case findAction("VERTICAL_DOWN"):
var direction = {x: 0.0, y: -1.0, z: 0.0};
direction = Vec3.multiply(Vec3.normalize(direction), shifted ? SHIFT_MAG * MOVE_DISTANCE : MOVE_DISTANCE);
velocity = Vec3.sum(velocity, direction);
break;
case findAction("VERTICAL_UP"):
var direction = {x: 0.0, y: 1.0, z: 0.0};
direction = Vec3.multiply(Vec3.normalize(direction), shifted ? SHIFT_MAG * MOVE_DISTANCE : MOVE_DISTANCE);
velocity = Vec3.sum(velocity, direction);
break;
case findAction("YAW_LEFT"):
if (yawTimer < 0.0 && HMD.active) {
yawChange = yawChange + (shifted ? SHIFT_MAG * VR_YAW_INCREMENT : VR_YAW_INCREMENT);
yawTimer = CAMERA_UPDATE_TIME;
} else if (!HMD.active) {
yawChange = yawChange + (shifted ? SHIFT_MAG * YAW_INCREMENT : YAW_INCREMENT);
}
break;
case findAction("YAW_RIGHT"):
if (yawTimer < 0.0 && HMD.active) {
yawChange = yawChange - (shifted ? SHIFT_MAG * VR_YAW_INCREMENT : VR_YAW_INCREMENT);
yawTimer = CAMERA_UPDATE_TIME;
} else if (!HMD.active) {
yawChange = yawChange - (shifted ? SHIFT_MAG * YAW_INCREMENT : YAW_INCREMENT);
}
break;
case findAction("PITCH_DOWN"):
if (!HMD.active) {
pitchChange = pitchChange - (shifted ? SHIFT_MAG * PITCH_INCREMENT : PITCH_INCREMENT);
}
break;
case findAction("PITCH_UP"):
if (!HMD.active) {
pitchChange = pitchChange + (shifted ? SHIFT_MAG * PITCH_INCREMENT : PITCH_INCREMENT);
}
break;
case findAction("SHIFT"): // speed up
if (shiftTimer < 0.0) {
shifted = !shifted;
shiftTimer = SHIFT_UPDATE_TIME;
}
break;
case findAction("ACTION1"): // start/end warp
if (warpTimer < 0.0) {
warpActive = !warpActive;
if (!warpActive) {
finishWarp();
}
warpTimer = WARP_UPDATE_TIME;
}
break;
case findAction("ACTION2"): // cancel warp
warpActive = false;
Overlays.editOverlay(warpSphere, {
visible: false,
});
Overlays.editOverlay(warpLine, {
visible: false,
});
default:
break;
}
}
function update(dt) {
if (prevVRMode != HMD.active) {
active = HMD.active;
prevVRMode = HMD.active;
}
if (yawTimer >= 0.0) {
yawTimer = yawTimer - dt;
}
if (shiftTimer >= 0.0) {
shiftTimer = shiftTimer - dt;
}
if (warpTimer >= 0.0) {
warpTimer = warpTimer - dt;
}
if (warpActive) {
updateWarp();
}
if (active) {
Controller.captureActionEvents();
MyAvatar.bodyYaw = MyAvatar.bodyYaw + yawChange;
MyAvatar.headPitch = Math.max(-180, Math.min(180, MyAvatar.headPitch + pitchChange));
yawChange = 0;
pitchChange = 0;
MyAvatar.motorVelocity = velocity;
MyAvatar.motorTimescale = 0.0;
velocity = { x: 0, y: 0, z: 0 };
} else {
Controller.releaseActionEvents();
yawChange = 0;
pitchChange = 0;
MyAvatar.motorVelocity = {x:0.0, y:0.0, z:0.0}
MyAvatar.motorTimescale = VERY_LONG_TIME;
}
}
function updateWarp() {
var look = Quat.getFront(Camera.getOrientation());
var pitch = Math.asin(look.y);
// Get relative to looking straight down
pitch += Math.PI / 2;
// Scale up
pitch *= 2;
var distance = pitch * pitch * pitch;
var warpDirection = Vec3.normalize({ x: look.x, y: 0, z: look.z });
warpPosition = Vec3.multiply(warpDirection, distance);
warpPosition = Vec3.sum(MyAvatar.position, warpPosition);
// Commented out until ray picking can be fixed
// var pickRay = {
// origin: Vec3.sum(warpPosition, WARP_PICK_OFFSET),
// direction: { x: 0, y: -1, z: 0 }
// };
// var intersection = Entities.findRayIntersection(pickRay);
// if (intersection.intersects && intersection.distance < WARP_PICK_MAX_DISTANCE) {
// // Warp 1 meter above the object - this is an approximation
// // TODO Get the actual offset to the Avatar's feet and plant them to
// // the object.
// warpPosition = Vec3.sum(intersection.intersection, { x: 0, y: 1, z:0 });
// }
// Adjust overlays to match warp position
Overlays.editOverlay(warpSphere, {
position: warpPosition,
visible: true,
});
Overlays.editOverlay(warpLine, {
start: warpPosition,
end: Vec3.sum(warpPosition, { x: 0, y: WARP_LINE_HEIGHT, z: 0 }),
visible: true,
});
}
function finishWarp() {
Overlays.editOverlay(warpSphere, {
visible: false,
});
Overlays.editOverlay(warpLine, {
visible: false,
});
MyAvatar.position = warpPosition;
}
function setUp() {
Controller.keyPressEvent.connect(onKeyPressEvent);
Controller.actionEvent.connect(onActionEvent);
Script.update.connect(update);
}
function tearDown() {
Controller.releaseActionEvents();
MyAvatar.motorVelocity = {x:0.0, y:0.0, z:0.0}
MyAvatar.motorTimescale = VERY_LONG_TIME;
}
setUp();
Script.scriptEnding.connect(tearDown);
}());

17
examples/hmdDefaults.js
View file

@ -1,17 +0,0 @@
//
// hmdDefaults.js
// examples
//
// Created by David Rowe on 6 Mar 2015.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
Script.load("progress.js");
Script.load("lobby.js");
Script.load("notifications.js");
Script.load("controllers/oculus/goTo.js");
Script.load("hmdControls.js");
//Script.load("scripts.js"); // Not created yet

11
examples/libraries/entitySelectionTool.js
View file

@ -4316,16 +4316,23 @@ SelectionDisplay = (function() {
return false;
};
that.updateHandleSizes = function() {
if (selectionManager.hasSelection()) {
var diff = Vec3.subtract(selectionManager.worldPosition, Camera.getPosition());
var grabberSize = Vec3.length(diff) * GRABBER_DISTANCE_TO_SIZE_RATIO;
var dimensions = SelectionManager.worldDimensions;
var avgDimension = (dimensions.x + dimensions.y + dimensions.z) / 3;
grabberSize = Math.min(grabberSize, avgDimension / 10);
for (var i = 0; i < stretchHandles.length; i++) {
Overlays.editOverlay(stretchHandles[i], {
size: grabberSize,
});
}
var handleSize = Vec3.length(diff) * GRABBER_DISTANCE_TO_SIZE_RATIO * 10;
var handleSize = Vec3.length(diff) * GRABBER_DISTANCE_TO_SIZE_RATIO * 7;
handleSize = Math.min(handleSize, avgDimension / 3);
Overlays.editOverlay(yawHandle, {
scale: handleSize,
});
@ -4342,7 +4349,7 @@ SelectionDisplay = (function() {
});
Overlays.editOverlay(grabberMoveUp, {
position: pos,
scale: handleSize / 2,
scale: handleSize / 1.25,
});
}
}

BIN
interface/resources/fonts/hifi-glyphs.ttf
View file

Binary file not shown.

3
interface/src/avatar/SkeletonModel.cpp
View file

@ -144,7 +144,10 @@ void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
} else {
handParams.isRightEnabled = false;
}
handParams.bodyCapsuleRadius = myAvatar->getCharacterController()->getCapsuleRadius();
handParams.bodyCapsuleHalfHeight = myAvatar->getCharacterController()->getCapsuleHalfHeight();
handParams.bodyCapsuleLocalOffset = myAvatar->getCharacterController()->getCapsuleLocalOffset();
_rig->updateFromHandParameters(handParams, deltaTime);

5
interface/src/ui/overlays/Base3DOverlay.cpp
View file

@ -14,6 +14,7 @@
#include "Application.h"
#include <RegisteredMetaTypes.h>
#include <SharedUtil.h>
#include "Application.h"
const float DEFAULT_LINE_WIDTH = 1.0f;
@ -39,7 +40,6 @@ Base3DOverlay::Base3DOverlay(const Base3DOverlay* base3DOverlay) :
_drawInFront(base3DOverlay->_drawInFront)
{
}
void Base3DOverlay::setProperties(const QVariantMap& properties) {
Overlay::setProperties(properties);
@ -108,8 +108,7 @@ void Base3DOverlay::setProperties(const QVariantMap& properties) {
setIgnoreRayIntersection(properties["ignoreRayIntersection"].toBool());
}
// Communicate changes to the renderItem if needed
if (needRenderItemUpdate) {
auto itemID = getRenderItemID();
if (render::Item::isValidID(itemID)) {

44
libraries/animation/src/Rig.cpp
View file

@ -17,6 +17,7 @@
#include <QWriteLocker>
#include <QReadLocker>
#include <GeometryUtil.h>
#include <NumericalConstants.h>
#include <DebugDraw.h>
@ -1073,32 +1074,27 @@ void Rig::updateFromHandParameters(const HandParameters& params, float dt) {
if (_animSkeleton && _animNode) {
const float HAND_RADIUS = 0.05f;
const float BODY_RADIUS = params.bodyCapsuleRadius;
const float MIN_LENGTH = 1.0e-4f;
// project the hips onto the xz plane.
int hipsIndex = indexOfJoint("Hips");
glm::vec3 hipsTrans;
if (hipsIndex >= 0) {
hipsTrans = _internalPoseSet._absolutePoses[hipsIndex].trans;
}
const glm::vec2 bodyCircleCenter(hipsTrans.x, hipsTrans.z);
// Use this capsule to represent the avatar body.
const float bodyCapsuleRadius = params.bodyCapsuleRadius;
const glm::vec3 bodyCapsuleCenter = hipsTrans - params.bodyCapsuleLocalOffset;
const glm::vec3 bodyCapsuleStart = bodyCapsuleCenter - glm::vec3(0, params.bodyCapsuleHalfHeight, 0);
const glm::vec3 bodyCapsuleEnd = bodyCapsuleCenter + glm::vec3(0, params.bodyCapsuleHalfHeight, 0);
if (params.isLeftEnabled) {
// project the hand position onto the xz plane.
glm::vec2 handCircleCenter(params.leftPosition.x, params.leftPosition.z);
// check for 2d overlap of the hand and body circles.
auto circleToCircle = handCircleCenter - bodyCircleCenter;
const float circleToCircleLength = glm::length(circleToCircle);
const float penetrationDistance = HAND_RADIUS + BODY_RADIUS - circleToCircleLength;
if (penetrationDistance > 0.0f && circleToCircleLength > MIN_LENGTH) {
// push the hands out of the body
handCircleCenter += penetrationDistance * glm::normalize(circleToCircle);
// prevent the hand IK targets from intersecting the body capsule
glm::vec3 handPosition = params.leftPosition;
glm::vec3 displacement(glm::vec3::_null);
if (findSphereCapsulePenetration(handPosition, HAND_RADIUS, bodyCapsuleStart, bodyCapsuleEnd, bodyCapsuleRadius, displacement)) {
handPosition -= displacement;
}
glm::vec3 handPosition(handCircleCenter.x, params.leftPosition.y, handCircleCenter.y);
_animVars.set("leftHandPosition", handPosition);
_animVars.set("leftHandRotation", params.leftOrientation);
_animVars.set("leftHandType", (int)IKTarget::Type::RotationAndPosition);
@ -1110,19 +1106,13 @@ void Rig::updateFromHandParameters(const HandParameters& params, float dt) {
if (params.isRightEnabled) {
// project the hand position onto the xz plane.
glm::vec2 handCircleCenter(params.rightPosition.x, params.rightPosition.z);
// check for 2d overlap of the hand and body circles.
auto circleToCircle = handCircleCenter - bodyCircleCenter;
const float circleToCircleLength = glm::length(circleToCircle);
const float penetrationDistance = HAND_RADIUS + BODY_RADIUS - circleToCircleLength;
if (penetrationDistance > 0.0f && circleToCircleLength > MIN_LENGTH) {
// push the hands out of the body
handCircleCenter += penetrationDistance * glm::normalize(circleToCircle);
// prevent the hand IK targets from intersecting the body capsule
glm::vec3 handPosition = params.rightPosition;
glm::vec3 displacement(glm::vec3::_null);
if (findSphereCapsulePenetration(handPosition, HAND_RADIUS, bodyCapsuleStart, bodyCapsuleEnd, bodyCapsuleRadius, displacement)) {
handPosition -= displacement;
}
glm::vec3 handPosition(handCircleCenter.x, params.rightPosition.y, handCircleCenter.y);
_animVars.set("rightHandPosition", handPosition);
_animVars.set("rightHandRotation", params.rightOrientation);
_animVars.set("rightHandType", (int)IKTarget::Type::RotationAndPosition);

2
libraries/animation/src/Rig.h
View file

@ -68,6 +68,8 @@ public:
bool isLeftEnabled;
bool isRightEnabled;
float bodyCapsuleRadius;
float bodyCapsuleHalfHeight;
glm::vec3 bodyCapsuleLocalOffset;
glm::vec3 leftPosition = glm::vec3(); // rig space
glm::quat leftOrientation = glm::quat(); // rig space (z forward)
glm::vec3 rightPosition = glm::vec3(); // rig space

2
libraries/physics/src/CharacterController.h
View file

@ -79,6 +79,8 @@ public:
glm::vec3 getLinearVelocity() const;
float getCapsuleRadius() const { return _radius; }
float getCapsuleHalfHeight() const { return _halfHeight; }
glm::vec3 getCapsuleLocalOffset() const { return _shapeLocalOffset; }
enum class State {
Ground = 0,

9
libraries/render/src/render/Scene.cpp
View file

@ -83,8 +83,17 @@ void Scene::processPendingChangesQueue() {
}
// Now we know for sure that we have enough items in the array to
// capture anything coming from the pendingChanges
// resets and potential NEW items
resetItems(consolidatedPendingChanges._resetItems, consolidatedPendingChanges._resetPayloads);
// Update the numItemsAtomic counter AFTER the reset changes went through
_numAllocatedItems.exchange(maxID);
// updates
updateItems(consolidatedPendingChanges._updatedItems, consolidatedPendingChanges._updateFunctors);
// removes
removeItems(consolidatedPendingChanges._removedItems);
// Update the numItemsAtomic counter AFTER the pending changes went through

10
libraries/render/src/render/Scene.h
View file

@ -63,19 +63,22 @@ public:
// Check that the ID is valid and allocated for this scene, this a threadsafe call
bool isAllocatedID(const ItemID& id);
// THis is the total number of allocated items, this a threadsafe call
size_t getNumItems() const { return _numAllocatedItems.load(); }
// Enqueue change batch to the scene
void enqueuePendingChanges(const PendingChanges& pendingChanges);
// Process the penging changes equeued
void processPendingChangesQueue();
// This next call are NOT threadsafe, you have to call them from the correct thread to avoid any potential issues
// Access a particular item form its ID
// WARNING, There is No check on the validity of the ID, so this could return a bad Item
const Item& getItem(const ItemID& id) const { return _items[id]; }
size_t getNumItems() const { return _items.size(); }
// Access the spatialized items
// Access the spatialized items
const ItemSpatialTree& getSpatialTree() const { return _masterSpatialTree; }
// Access non-spatialized items (overlays, backgrounds)
@ -85,7 +88,6 @@ protected:
// Thread safe elements that can be accessed from anywhere
std::atomic<unsigned int> _IDAllocator{ 1 }; // first valid itemID will be One
std::atomic<unsigned int> _numAllocatedItems{ 1 }; // num of allocated items, matching the _items.size()
std::mutex _changeQueueMutex;
PendingChangesQueue _changeQueue;

51
libraries/render/src/render/SpatialTree.cpp
View file

@ -264,12 +264,33 @@ Octree::Index Octree::accessCellBrick(Index cellID, const CellBrickAccessor& acc
return brickID;
}
Octree::Location ItemSpatialTree::evalLocation(const AABox& bound, Coord3f& minCoordf, Coord3f& maxCoordf) const {
minCoordf = evalCoordf(bound.getMinimumPoint());
maxCoordf = evalCoordf(bound.getMaximumPoint());
// If the bound crosses any of the octree volume limit, then return root cell
if ( (minCoordf.x < 0.0f)
|| (minCoordf.y < 0.0f)
|| (minCoordf.z < 0.0f)
|| (maxCoordf.x >= _size)
|| (maxCoordf.y >= _size)
|| (maxCoordf.z >= _size)) {
return Location();
}
Coord3 minCoord(minCoordf);
Coord3 maxCoord(maxCoordf);
return Location::evalFromRange(minCoord, maxCoord);
}
Octree::Locations ItemSpatialTree::evalLocations(const ItemBounds& bounds) const {
Locations locations;
Coord3f minCoordf, maxCoordf;
locations.reserve(bounds.size());
for (auto& bound : bounds) {
if (!bound.bound.isNull()) {
locations.emplace_back(evalLocation(bound.bound));
locations.emplace_back(evalLocation(bound.bound, minCoordf, maxCoordf));
} else {
locations.emplace_back(Location());
}
@ -344,11 +365,8 @@ bool ItemSpatialTree::removeItem(Index cellIdx, const ItemKey& key, const ItemID
ItemSpatialTree::Index ItemSpatialTree::resetItem(Index oldCell, const ItemKey& oldKey, const AABox& bound, const ItemID& item, ItemKey& newKey) {
auto newCell = INVALID_CELL;
if (!newKey.isViewSpace()) {
auto minCoordf = evalCoordf(bound.getMinimumPoint());
auto maxCoordf = evalCoordf(bound.getMaximumPoint());
Coord3 minCoord(minCoordf);
Coord3 maxCoord(maxCoordf);
auto location = Location::evalFromRange(minCoord, maxCoord);
Coord3f minCoordf, maxCoordf;
auto location = evalLocation(bound, minCoordf, maxCoordf);
// Compare range size vs cell location size and tag itemKey accordingly
// If Item bound fits in sub cell then tag as small
@ -403,7 +421,22 @@ ItemSpatialTree::Index ItemSpatialTree::resetItem(Index oldCell, const ItemKey&
int Octree::select(CellSelection& selection, const FrustumSelector& selector) const {
Index cellID = ROOT_CELL;
return selectTraverse(cellID, selection, selector);
auto cell = getConcreteCell(cellID);
auto cellLocation = cell.getlocation();
int numSelectedsIn = (int)selection.size();
// Always include the root cell partially containing potentially outer objects
selectCellBrick(cellID, selection, false);
// then traverse deeper
for (int i = 0; i < NUM_OCTANTS; i++) {
Index subCellID = cell.child((Link)i);
if (subCellID != INVALID_CELL) {
selectTraverse(subCellID, selection, selector);
}
}
return (int)selection.size() - numSelectedsIn;
}
@ -554,11 +587,11 @@ int ItemSpatialTree::selectCells(CellSelection& selection, const ViewFrustum& fr
FrustumSelector selector;
for (int i = 0; i < ViewFrustum::NUM_PLANES; i++) {
::Plane octPlane;
octPlane.setNormalAndPoint(worldPlanes[i].getNormal(), evalCoordNoClampf(worldPlanes[i].getPoint(), ROOT_DEPTH));
octPlane.setNormalAndPoint(worldPlanes[i].getNormal(), evalCoordf(worldPlanes[i].getPoint(), ROOT_DEPTH));
selector.frustum[i] = Coord4f(octPlane.getNormal(), octPlane.getDCoefficient());
}
selector.eyePos = evalCoordNoClampf(frustum.getPosition(), ROOT_DEPTH);
selector.eyePos = evalCoordf(frustum.getPosition(), ROOT_DEPTH);
selector.setAngle(glm::radians(lodAngle));
return Octree::select(selection, selector);

32
libraries/render/src/render/SpatialTree.h
View file

@ -367,7 +367,7 @@ namespace render {
// An octree of Items organizing them efficiently for culling
// The octree only cares about the bound & the key of an item to store it a the right cell location
class ItemSpatialTree : public Octree {
float _size { 32768.0f };
float _size{ 32768.0f };
float _invSize { 1.0f / _size };
glm::vec3 _origin { -16384.0f };
@ -399,24 +399,27 @@ namespace render {
}
// Clamp a position expressed in a depth space to make sure it is in the valid space for that Depth
// Clamp a 3D relative position to make sure it is in the valid range space of the octree
glm::vec3 clampRelPosToTreeRange(const glm::vec3& pos) const {
const float EPSILON = 0.0001f;
return glm::vec3(
std::min(std::max(pos.x, 1.0f), _size - 1.0f),
std::min(std::max(pos.y, 1.0f), _size - 1.0f),
std::min(std::max(pos.z, 1.0f), _size - 1.0f));
std::min(std::max(pos.x, 0.0f), _size - EPSILON),
std::min(std::max(pos.y, 0.0f), _size - EPSILON),
std::min(std::max(pos.z, 0.0f), _size - EPSILON));
}
// Eval an integer cell coordinate (at the specified deepth) from a given 3d position
// If the 3D position is out of the octree volume, then the position is clamped
// so the integer coordinate is meaningfull
Coord3 evalCoord(const glm::vec3& pos, Depth depth = Octree::METRIC_COORD_DEPTH) const {
auto npos = clampRelPosToTreeRange((pos - getOrigin()));
return Coord3(npos * getInvCellWidth(depth)); // Truncate fractional part
}
// Eval a real cell coordinate (at the specified deepth) from a given 3d position
// Position is NOT clamped to the boundaries of the octree so beware of conversion to a Coord3!
Coord3f evalCoordf(const glm::vec3& pos, Depth depth = Octree::METRIC_COORD_DEPTH) const {
auto npos = clampRelPosToTreeRange((pos - getOrigin()));
return Coord3f(npos * getInvCellWidth(depth));
}
Coord3f evalCoordNoClampf(const glm::vec3& pos, Depth depth = Octree::METRIC_COORD_DEPTH) const {
auto npos = ((pos - getOrigin()));
auto npos = (pos - getOrigin());
return Coord3f(npos * getInvCellWidth(depth));
}
@ -426,10 +429,9 @@ namespace render {
return AABox(evalPos(loc.pos, cellWidth), cellWidth);
}
Location evalLocation(const AABox& bound) const {
return Location::evalFromRange(evalCoord(bound.getMinimumPoint()), evalCoord(bound.getMaximumPoint()));
}
// Eval the cell location for a given arbitrary Bound,
// if the Bound crosses any of the Octree planes then the root cell is returned
Location evalLocation(const AABox& bound, Coord3f& minCoordf, Coord3f& maxCoordf) const;
Locations evalLocations(const ItemBounds& bounds) const;
// Managing itemsInserting items in cells

12
tests/shared/src/GeometryUtilTests.cpp
View file

@ -212,3 +212,15 @@ void GeometryUtilTests::testTwistSwingDecomposition() {
}
void GeometryUtilTests::testSphereCapsulePenetration() {
glm::vec3 sphereCenter(1.5, 0.0, 0.0);
float sphereRadius = 1.0f;
glm::vec3 capsuleStart(0.0f, -10.0f, 0.0f);
glm::vec3 capsuleEnd(0.0f, 10.0f, 0.0f);
float capsuleRadius = 1.0f;
glm::vec3 penetration(glm::vec3::_null);
bool hit = findSphereCapsulePenetration(sphereCenter, sphereRadius, capsuleStart, capsuleEnd, capsuleRadius, penetration);
QCOMPARE(hit, true);
QCOMPARE_WITH_ABS_ERROR(penetration, glm::vec3(-0.5f, 0.0f, 0.0f), EPSILON);
}

1
tests/shared/src/GeometryUtilTests.h
View file

@ -21,6 +21,7 @@ private slots:
void testLocalRayRectangleIntersection();
void testWorldRayRectangleIntersection();
void testTwistSwingDecomposition();
void testSphereCapsulePenetration();
};
float getErrorDifference(const float& a, const float& b);

452
unpublishedScripts/DomainContent/Home/fishTank/createFishTank.js Normal file
View file

@ -0,0 +1,452 @@
//
// createTank.js
//
//
// created by James b. Pollack @imgntn on 3/9/2016
// Copyright 2016 High Fidelity, Inc.
//
// Adds a fish tank and base, decorations, particle bubble systems, and a bubble sound. Attaches a script that does fish swimming.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
var fishTank, tankBase, bubbleSystem, secondBubbleSystem, thirdBubbleSystem, innerContainer, bubbleInjector, lowerCorner, upperCorner, urchin, treasure, rocks;
var CLEANUP = true;
var TANK_DIMENSIONS = {
x: 0.8212,
y: 0.8116,
z: 2.1404
};
var INNER_TANK_SCALE = 0.7;
var INNER_TANK_DIMENSIONS = Vec3.multiply(INNER_TANK_SCALE, TANK_DIMENSIONS);
INNER_TANK_DIMENSIONS.y = INNER_TANK_DIMENSIONS.y - 0.4;
var TANK_WIDTH = TANK_DIMENSIONS.z;
var TANK_HEIGHT = TANK_DIMENSIONS.y;
var DEBUG_COLOR = {
red: 255,
green: 0,
blue: 255
}
var center = Vec3.sum(MyAvatar.position, Vec3.multiply(Quat.getFront(MyAvatar.orientation), 1 * TANK_WIDTH));
var TANK_POSITION = center;
var TANK_SCRIPT = Script.resolvePath('tank.js?' + Math.random())
var TANK_MODEL_URL = "http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/aquariumTank.fbx";
var TANK_BASE_MODEL_URL = 'http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/aquariumBase.fbx';
var TANK_BASE_COLLISION_HULL = 'http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/aquariumBase.obj'
var TANK_BASE_DIMENSIONS = {
x: 0.8599,
y: 1.8450,
z: 2.1936
};
var BASE_VERTICAL_OFFSET = 0.42;
var BUBBLE_SYSTEM_FORWARD_OFFSET = TANK_DIMENSIONS.x + 0.06;
var BUBBLE_SYSTEM_LATERAL_OFFSET = 0.025;
var BUBBLE_SYSTEM_VERTICAL_OFFSET = -0.30;
var BUBBLE_SYSTEM_DIMENSIONS = {
x: TANK_DIMENSIONS.x / 8,
y: TANK_DIMENSIONS.y,
z: TANK_DIMENSIONS.z / 8
}
var BUBBLE_SOUND_URL = "http://hifi-content.s3.amazonaws.com/DomainContent/Home/Sounds/aquarium_small.L.wav";
var bubbleSound = SoundCache.getSound(BUBBLE_SOUND_URL);
var URCHIN_FORWARD_OFFSET = TANK_DIMENSIONS.x - 0.35;
var URCHIN_LATERAL_OFFSET = -0.05;
var URCHIN_VERTICAL_OFFSET = -0.12;
var URCHIN_MODEL_URL = 'http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/Urchin.fbx';
var URCHIN_DIMENSIONS = {
x: 0.4,
y: 0.4,
z: 0.4
}
var ROCKS_FORWARD_OFFSET = 0;
var ROCKS_LATERAL_OFFSET = 0.0;
var ROCKS_VERTICAL_OFFSET = (-TANK_DIMENSIONS.y / 2) + 0.25;
var ROCK_MODEL_URL = 'http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/Aquarium-Rocks-2.fbx';
var ROCK_DIMENSIONS = {
x: 0.707,
y: 0.33,
z: 1.64
}
var TREASURE_FORWARD_OFFSET = -TANK_DIMENSIONS.x;
var TREASURE_LATERAL_OFFSET = -0.15;
var TREASURE_VERTICAL_OFFSET = -0.23;
var TREASURE_MODEL_URL = 'http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/Treasure-Chest2-SM.fbx';
var TREASURE_DIMENSIONS = {
x: 0.1199,
y: 0.1105,
z: 0.1020
}
function createFishTank() {
var tankProperties = {
name: 'hifi-home-fishtank',
type: 'Model',
modelURL: TANK_MODEL_URL,
dimensions: TANK_DIMENSIONS,
position: TANK_POSITION,
color: DEBUG_COLOR,
collisionless: true,
script: TANK_SCRIPT,
visible: true
}
fishTank = Entities.addEntity(tankProperties);
}
function createBubbleSystems() {
var tankProperties = Entities.getEntityProperties(fishTank);
var bubbleProperties = {
"name": 'hifi-home-fishtank-bubbles',
"isEmitting": 1,
"maxParticles": 1880,
"lifespan": 1.6,
"emitRate": 10,
"emitSpeed": 0.025,
"speedSpread": 0.025,
"emitOrientation": {
"x": 0,
"y": 0.5,
"z": 0.5,
"w": 0
},
"emitDimensions": {
"x": -0.2,
"y": TANK_DIMENSIONS.y,
"z": 0
},
"polarStart": 0,
"polarFinish": 0,
"azimuthStart": 0.2,
"azimuthFinish": 0.1,
"emitAcceleration": {
"x": 0,
"y": 0.3,
"z": 0
},
"accelerationSpread": {
"x": 0.01,
"y": 0.01,
"z": 0.01
},
"particleRadius": 0.005,
"radiusSpread": 0,
"radiusStart": 0.01,
"radiusFinish": 0.01,
"alpha": 0.2,
"alphaSpread": 0,
"alphaStart": 0.3,
"alphaFinish": 0,
"emitterShouldTrail": 0,
"textures": "http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/bubble-white.png"
};
bubbleProperties.type = "ParticleEffect";
bubbleProperties.parentID = fishTank;
bubbleProperties.dimensions = BUBBLE_SYSTEM_DIMENSIONS;
var finalOffset = getOffsetFromTankCenter(BUBBLE_SYSTEM_VERTICAL_OFFSET, BUBBLE_SYSTEM_FORWARD_OFFSET, BUBBLE_SYSTEM_LATERAL_OFFSET);
bubbleProperties.position = finalOffset;
bubbleSystem = Entities.addEntity(bubbleProperties);
bubbleProperties.position.x += -0.076;
secondBubbleSystem = Entities.addEntity(bubbleProperties)
bubbleProperties.position.x += -0.076;
thirdBubbleSystem = Entities.addEntity(bubbleProperties)
createBubbleSound(finalOffset);
}
function getOffsetFromTankCenter(VERTICAL_OFFSET, FORWARD_OFFSET, LATERAL_OFFSET) {
var tankProperties = Entities.getEntityProperties(fishTank);
var upVector = Quat.getUp(tankProperties.rotation);
var frontVector = Quat.getFront(tankProperties.rotation);
var rightVector = Quat.getRight(tankProperties.rotation);
var upOffset = Vec3.multiply(upVector, VERTICAL_OFFSET);
var frontOffset = Vec3.multiply(frontVector, FORWARD_OFFSET);
var rightOffset = Vec3.multiply(rightVector, LATERAL_OFFSET);
var finalOffset = Vec3.sum(tankProperties.position, upOffset);
finalOffset = Vec3.sum(finalOffset, frontOffset);
finalOffset = Vec3.sum(finalOffset, rightOffset);
return finalOffset
}
function createBubbleSound(position) {
var audioProperties = {
volume: 0.05,
position: position,
loop: true
};
bubbleInjector = Audio.playSound(bubbleSound, audioProperties);
}
function createInnerContainer(position) {
var tankProperties = Entities.getEntityProperties(fishTank);
var containerProps = {
name: "hifi-home-fishtank-inner-container",
type: 'Box',
color: {
red: 0,
green: 0,
blue: 255
},
parentID: fishTank,
dimensions: INNER_TANK_DIMENSIONS,
position: tankProperties.position,
visible: false,
collisionless: true,
dynamic: false
};
innerContainer = Entities.addEntity(containerProps);
}
function createEntitiesAtCorners() {
var bounds = Entities.getEntityProperties(innerContainer, "boundingBox").boundingBox;
var lowerProps = {
name: 'hifi-home-fishtank-lower-corner',
type: "Box",
parentID: fishTank,
dimensions: {
x: 0.2,
y: 0.2,
z: 0.2
},
color: {
red: 255,
green: 0,
blue: 0
},
collisionless: true,
position: bounds.brn,
visible: false
}
var upperProps = {
name: 'hifi-home-fishtank-upper-corner',
type: "Box",
parentID: fishTank,
dimensions: {
x: 0.2,
y: 0.2,
z: 0.2
},
color: {
red: 0,
green: 255,
blue: 0
},
collisionless: true,
position: bounds.tfl,
visible: false
}
lowerCorner = Entities.addEntity(lowerProps);
upperCorner = Entities.addEntity(upperProps);
}
function createRocks() {
var finalPosition = getOffsetFromTankCenter(ROCKS_VERTICAL_OFFSET, ROCKS_FORWARD_OFFSET, ROCKS_LATERAL_OFFSET);
var properties = {
name: 'hifi-home-fishtank-rock',
type: 'Model',
parentID: fishTank,
modelURL: ROCK_MODEL_URL,
position: finalPosition,
dimensions: ROCK_DIMENSIONS
}
rocks = Entities.addEntity(properties);
}
function createUrchin() {
var finalPosition = getOffsetFromTankCenter(URCHIN_VERTICAL_OFFSET, URCHIN_FORWARD_OFFSET, URCHIN_LATERAL_OFFSET);
var properties = {
name: 'hifi-home-fishtank-urchin',
type: 'Model',
parentID: fishTank,
modelURL: URCHIN_MODEL_URL,
position: finalPosition,
shapeType: 'Sphere',
dimensions: URCHIN_DIMENSIONS
}
urchin = Entities.addEntity(properties);
}
function createTreasureChest() {
var finalPosition = getOffsetFromTankCenter(TREASURE_VERTICAL_OFFSET, TREASURE_FORWARD_OFFSET, TREASURE_LATERAL_OFFSET);
var properties = {
name: 'hifi-home-fishtank-treasure-chest',
type: 'Model',
parentID: fishTank,
modelURL: TREASURE_MODEL_URL,
position: finalPosition,
dimensions: TREASURE_DIMENSIONS,
rotation: Quat.fromPitchYawRollDegrees(10, -45, 10)
}
treasure = Entities.addEntity(properties);
}
function createTankBase() {
var properties = {
name: 'hifi-home-fishtank-base',
type: 'Model',
modelURL: TANK_BASE_MODEL_URL,
parentID: fishTank,
shapeType: 'compound',
compoundShapeURL: TANK_BASE_COLLISION_HULL,
position: {
x: TANK_POSITION.x,
y: TANK_POSITION.y - BASE_VERTICAL_OFFSET,
z: TANK_POSITION.z
},
dimensions: TANK_BASE_DIMENSIONS
}
tankBase = Entities.addEntity(properties);
}
createFishTank();
createInnerContainer();
createBubbleSystems();
createEntitiesAtCorners();
createUrchin();
createRocks();
createTankBase();
createTreasureChest();
var customKey = 'hifi-home-fishtank';
var data = {
fishLoaded: false,
bubbleSystem: bubbleSystem,
bubbleSound: bubbleSound,
corners: {
brn: lowerCorner,
tfl: upperCorner
},
innerContainer: innerContainer,
}
Script.setTimeout(function() {
setEntityCustomData(customKey, fishTank, data);
}, 2000)
function cleanup() {
Entities.deleteEntity(fishTank);
Entities.deleteEntity(tankBase);
Entities.deleteEntity(bubbleSystem);
Entities.deleteEntity(secondBubbleSystem);
Entities.deleteEntity(thirdBubbleSystem);
Entities.deleteEntity(innerContainer);
Entities.deleteEntity(lowerCorner);
Entities.deleteEntity(upperCorner);
Entities.deleteEntity(urchin);
Entities.deleteEntity(rocks);
bubbleInjector.stop();
bubbleInjector = null;
}
if (CLEANUP === true) {
Script.scriptEnding.connect(cleanup);
}
function setEntityUserData(id, data) {
var json = JSON.stringify(data)
Entities.editEntity(id, {
userData: json
});
}
function getEntityUserData(id) {
var results = null;
var properties = Entities.getEntityProperties(id, "userData");
if (properties.userData) {
try {
results = JSON.parse(properties.userData);
} catch (err) {
// print('error parsing json');
// print('properties are:'+ properties.userData);
}
}
return results ? results : {};
}
// Non-destructively modify the user data of an entity.
function setEntityCustomData(customKey, id, data) {
var userData = getEntityUserData(id);
if (data == null) {
delete userData[customKey];
} else {
userData[customKey] = data;
}
setEntityUserData(id, userData);
}
function getEntityCustomData(customKey, id, defaultValue) {
var userData = getEntityUserData(id);
if (undefined != userData[customKey]) {
return userData[customKey];
} else {
return defaultValue;
}
}

709
unpublishedScripts/DomainContent/Home/fishTank/tank.js Normal file
View file

@ -0,0 +1,709 @@
//
// tank.js
//
//
// created by James b. Pollack @imgntn on 3/9/2016
// Copyright 2016 High Fidelity, Inc.
//
// looks for fish to swim around, if there are none it makes some. adds an attractor where the person simulating it is looking.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
(function() {
Script.include('../../../../examples/libraries/virtualBaton.js');
//only one person should simulate the tank at a time -- we pass around a virtual baton
var baton;
var iOwn = false;
var _entityID;
var _this;
var connected = false;
var TANK_SEARCH_RADIUS = 5;
var WANT_LOOK_DEBUG_LINE = false;
var WANT_LOOK_DEBUG_SPHERE = false;
var INTERSECT_COLOR = {
red: 255,
green: 0,
blue: 255
}
function FishTank() {
_this = this;
}
function startUpdate() {
//when the baton is claimed;
// print('trying to claim the object' + _entityID)
iOwn = true;
connected = true;
Script.update.connect(_this.update);
}
function stopUpdateAndReclaim() {
//when the baton is released;
// print('i released the object ' + _entityID)
iOwn = false;
if (connected === true) {
connected = false;
Script.update.disconnect(_this.update);
_this.clearLookAttractor();
}
//hook up callbacks to the baton
baton.claim(startUpdate, stopUpdateAndReclaim);
}
FishTank.prototype = {
fish: null,
tankLocked: false,
hasLookAttractor: false,
lookAttractor: null,
overlayLine: null,
overlayLineDistance: 3,
debugSphere: null,
findFishInTank: function() {
// print('looking for a fish in the tank')
var results = Entities.findEntities(_this.currentProperties.position, TANK_SEARCH_RADIUS);
var fishList = [];
results.forEach(function(fish) {
var properties = Entities.getEntityProperties(fish, 'name');
if (properties.name.indexOf('hifi-fishtank-fish' + _this.entityID) > -1) {
fishList.push(fish);
}
})
// print('fish? ' + fishList.length)
return fishList;
},
initialize: function(entityID) {
var properties = Entities.getEntityProperties(entityID)
if (properties.hasOwnProperty('userData') === false || properties.userData.length === 0) {
_this.initTimeout = Script.setTimeout(function() {
if (properties.hasOwnProperty('userData')) {
// print('has user data property')
}
if (properties.userData.length === 0) {
// print('user data length is zero')
}
// print('try again in one second')
_this.initialize(entityID);
}, 1000)
} else {
// print('userdata before parse attempt' + properties.userData)
_this.userData = null;
try {
_this.userData = JSON.parse(properties.userData);
} catch (err) {
// print('error parsing json');
// print('properties are:' + properties.userData);
return;
}
// print('after parse')
_this.currentProperties = Entities.getEntityProperties(entityID);
baton = virtualBaton({
batonName: 'io.highfidelity.fishtank:' + entityID, // One winner for each entity
});
stopUpdateAndReclaim();
}
},
preload: function(entityID) {
// print("preload");
this.entityID = entityID;
_entityID = entityID;
this.initialize(entityID);
this.initTimeout = null;
},
unload: function() {
// print(' UNLOAD')
if (connected === true) {
Script.update.disconnect(_this.update);
}
if (WANT_LOOK_DEBUG_LINE === true) {
_this.overlayLineOff();
}
if (baton) {
// print('BATON RELEASE ')
baton.release(function() {});
}
},
update: function(deltaTime) {
if (iOwn === false) {
// print('i dont own')
//exit if we're not supposed to be simulating the fish
return
}
// print('i am the owner!')
//do stuff
updateFish(deltaTime);
_this.seeIfOwnerIsLookingAtTheTank();
},
debugSphereOn: function(position) {
if (_this.debugSphere !== null) {
Entities.editEntity(_this.debugSphere, {
visible: true
})
return;
}
var sphereProperties = {
type: 'Sphere',
parentID: _this.entityID,
dimensions: {
x: 0.1,
y: 0.1,
z: 0.1,
},
color: INTERSECT_COLOR,
position: position,
collisionless: true
}
_this.debugSphere = Entities.addEntity(sphereProperties);
},
updateDebugSphere: function(position) {
Entities.editEntity(_this.debugSphere, {
visible: true,
position: position
})
},
debugSphereOff: function() {
Entities.editEntity(_this.debugSphere, {
visible: false
})
},
overlayLineOn: function(closePoint, farPoint, color) {
if (_this.overlayLine === null) {
var lineProperties = {
lineWidth: 5,
start: closePoint,
end: farPoint,
color: color,
ignoreRayIntersection: true, // always ignore this
visible: true,
alpha: 1
};
this.overlayLine = Overlays.addOverlay("line3d", lineProperties);
} else {
var success = Overlays.editOverlay(_this.overlayLine, {
lineWidth: 5,
start: closePoint,
end: farPoint,
color: color,
visible: true,
ignoreRayIntersection: true, // always ignore this
alpha: 1
});
}
},
overlayLineOff: function() {
if (_this.overlayLine !== null) {
Overlays.deleteOverlay(this.overlayLine);
}
_this.overlayLine = null;
},
seeIfOwnerIsLookingAtTheTank: function() {
var cameraPosition = Camera.getPosition();
var cameraOrientation = Camera.getOrientation();
var front = Quat.getFront(cameraOrientation);
var pickRay = {
origin: cameraPosition,
direction: front
};
if (WANT_LOOK_DEBUG_LINE === true) {
_this.overlayLineOn(pickRay.origin, Vec3.sum(pickRay.origin, Vec3.multiply(front, _this.overlayLineDistance)), INTERSECT_COLOR);
};
var brn = _this.userData['hifi-home-fishtank']['corners'].brn;
var tfl = _this.userData['hifi-home-fishtank']['corners'].tfl;
var innerContainer = _this.userData['hifi-home-fishtank'].innerContainer;
var intersection = Entities.findRayIntersection(pickRay, true, [innerContainer], [_this.entityID, brn, tfl]);
if (intersection.intersects && intersection.entityID === innerContainer) {
//print('intersecting a tank')
if (WANT_LOOK_DEBUG_SPHERE === true) {
if (_this.debugSphere === null) {
_this.debugSphereOn(intersection.intersection);
} else {
_this.updateDebugSphere(intersection.intersection);
}
}
if (intersection.distance > LOOK_ATTRACTOR_DISTANCE) {
if (WANT_LOOK_DEBUG_SPHERE === true) {
_this.debugSphereOff();
}
return
}
// print('intersection:: ' + JSON.stringify(intersection));
if (_this.hasLookAttractor === false) {
_this.createLookAttractor(intersection.intersection, intersection.distance);
} else if (_this.hasLookAttractor === true) {
_this.updateLookAttractor(intersection.intersection, intersection.distance);
}
} else {
if (_this.hasLookAttractor === true) {
_this.clearLookAttractor();
}
}
},
createLookAttractor: function(position, distance) {
_this.lookAttractor = {
position: position,
distance: distance
};
_this.hasLookAttractor = true;
},
updateLookAttractor: function(position, distance) {
_this.lookAttractor = {
position: position,
distance: distance
};
},
clearLookAttractor: function() {
_this.hasLookAttractor = false;
_this.lookAttractor = null;
},
createLookAttractorEntity: function() {
},
findLookAttractorEntities: function() {
},
seeIfAnyoneIsLookingAtTheTank: function() {
// get avatars
// get their positions
// get their gazes
// check for intersection
// add attractor for closest person (?)
}
};
//
// flockOfFish.js
// examples
//
// Philip Rosedale
// Copyright 2016 High Fidelity, Inc.
// Fish smimming around in a space in front of you
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
var FISHTANK_USERDATA_KEY = 'hifi-home-fishtank'
var LIFETIME = 300; // Fish live for 5 minutes
var NUM_FISH = 8;
var TANK_DIMENSIONS = {
x: 1.3393,
y: 1.3515,
z: 3.5914
};
var TANK_WIDTH = TANK_DIMENSIONS.z / 2;
var TANK_HEIGHT = TANK_DIMENSIONS.y / 2;
var FISH_DIMENSIONS = {
x: 0.0149,
y: 0.02546,
z: 0.0823
}
var MAX_SIGHT_DISTANCE = 1.5;
var MIN_SEPARATION = 0.15;
var AVOIDANCE_FORCE = 0.032;
var COHESION_FORCE = 0.025;
var ALIGNMENT_FORCE = 0.025;
var LOOK_ATTRACTOR_FORCE = 0.02;
var LOOK_ATTRACTOR_DISTANCE = 1.75;
var SWIMMING_FORCE = 0.025;
var SWIMMING_SPEED = 0.5;
var FISH_DAMPING = 0.55;
var FISH_ANGULAR_DAMPING = 0.55;
var THROTTLE = false;
var THROTTLE_RATE = 100;
var sinceLastUpdate = 0;
// var FISH_MODEL_URL = "http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/Fish-1.fbx";
// var FISH_MODEL_TWO_URL = "http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/Fish-2.fbx";
var FISH_MODEL_URL = "http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/goodfish5.fbx";
var FISH_MODEL_TWO_URL = "http://hifi-content.s3.amazonaws.com/DomainContent/Home/fishTank/goodfish5.fbx";
var fishLoaded = false;
function randomVector(scale) {
return {
x: Math.random() * scale - scale / 2.0,
y: Math.random() * scale - scale / 2.0,
z: Math.random() * scale - scale / 2.0
};
}
function updateFish(deltaTime) {
// print('update loop')
if (_this.tankLocked === true) {
return;
}
if (!Entities.serversExist() || !Entities.canRez()) {
return;
}
if (THROTTLE === true) {
sinceLastUpdate = sinceLastUpdate + deltaTime * 100;
if (sinceLastUpdate > THROTTLE_RATE) {
sinceLastUpdate = 0;
} else {
return;
}
}
// print('has userdata fish??' + _this.userData['hifi-home-fishtank'].fishLoaded)
if (_this.userData['hifi-home-fishtank'].fishLoaded === false) {
//no fish in the user data
_this.tankLocked = true;
print('NO FISH YET SO LOAD EM!!!')
loadFish(NUM_FISH);
var data = {
fishLoaded: true,
bubbleSystem: _this.userData['hifi-home-fishtank'].bubbleSystem,
bubbleSound: _this.userData['hifi-home-fishtank'].bubbleSound,
corners: {
brn: _this.userData['hifi-home-fishtank'].lowerCorner,
tfl: _this.userData['hifi-home-fishtank'].upperCorner
},
innerContainer: _this.userData['hifi-home-fishtank'].innerContainer,
}
setEntityCustomData(FISHTANK_USERDATA_KEY, _this.entityID, data);
_this.userData['hifi-home-fishtank'].fishLoaded = true;
Script.setTimeout(function() {
_this.fish = _this.findFishInTank();
}, 2000)
return;
} else {
//fish in userdata already
if (_this.fish === null) {
_this.fish = _this.findFishInTank();
}
}
var fish = _this.fish;
// print('how many fish do i find?' + fish.length)
if (fish.length === 0) {
// print('no fish...')
return
};
var averageVelocity = {
x: 0,
y: 0,
z: 0
};
var averagePosition = {
x: 0,
y: 0,
z: 0
};
var userData = JSON.parse(_this.currentProperties.userData);
var innerContainer = userData['hifi-home-fishtank']['innerContainer'];
var bounds = Entities.getEntityProperties(innerContainer, "boundingBox").boundingBox;
lowerCorner = bounds.brn;
upperCorner = bounds.tfl;
// First pre-load an array with properties on all the other fish so our per-fish loop
// isn't doing it.
var flockProperties = [];
for (var i = 0; i < fish.length; i++) {
var otherProps = Entities.getEntityProperties(fish[i], ["position", "velocity", "rotation"]);
flockProperties.push(otherProps);
}
for (var i = 0; i < fish.length; i++) {
if (fish[i]) {
// Get only the properties we need, because that is faster
var properties = flockProperties[i];
// If fish has been deleted, bail
if (properties.id != fish[i]) {
fish[i] = false;
return;
}
// Store old values so we can check if they have changed enough to update
var velocity = {
x: properties.velocity.x,
y: properties.velocity.y,
z: properties.velocity.z
};
var position = {
x: properties.position.x,
y: properties.position.y,
z: properties.position.z
};
averageVelocity = {
x: 0,
y: 0,
z: 0
};
averagePosition = {
x: 0,
y: 0,
z: 0
};
var othersCounted = 0;
for (var j = 0; j < fish.length; j++) {
if (i != j) {
// Get only the properties we need, because that is faster
var otherProps = flockProperties[j];
var separation = Vec3.distance(properties.position, otherProps.position);
if (separation < MAX_SIGHT_DISTANCE) {
averageVelocity = Vec3.sum(averageVelocity, otherProps.velocity);
averagePosition = Vec3.sum(averagePosition, otherProps.position);
othersCounted++;
}
if (separation < MIN_SEPARATION) {
var pushAway = Vec3.multiply(Vec3.normalize(Vec3.subtract(properties.position, otherProps.position)), AVOIDANCE_FORCE);
velocity = Vec3.sum(velocity, pushAway);
}
}
}
if (othersCounted > 0) {
averageVelocity = Vec3.multiply(averageVelocity, 1.0 / othersCounted);
averagePosition = Vec3.multiply(averagePosition, 1.0 / othersCounted);
// Alignment: Follow group's direction and speed
velocity = Vec3.mix(velocity, Vec3.multiply(Vec3.normalize(averageVelocity), Vec3.length(velocity)), ALIGNMENT_FORCE);
// Cohesion: Steer towards center of flock
var towardCenter = Vec3.subtract(averagePosition, position);
velocity = Vec3.mix(velocity, Vec3.multiply(Vec3.normalize(towardCenter), Vec3.length(velocity)), COHESION_FORCE);
//attractors
//[position, radius, force]
}
if (_this.hasLookAttractor === true) {
//print('has a look attractor, so use it')
var attractorPosition = _this.lookAttractor.position;
var towardAttractor = Vec3.subtract(attractorPosition, position);
velocity = Vec3.mix(velocity, Vec3.multiply(Vec3.normalize(towardAttractor), Vec3.length(velocity)), LOOK_ATTRACTOR_FORCE);
}
// Try to swim at a constant speed
velocity = Vec3.mix(velocity, Vec3.multiply(Vec3.normalize(velocity), SWIMMING_SPEED), SWIMMING_FORCE);
// Keep fish in their 'tank'
if (position.x < lowerCorner.x) {
position.x = lowerCorner.x;
velocity.x *= -0.15
} else if (position.x > upperCorner.x) {
position.x = upperCorner.x;
velocity.x *= -0.15
}
if (position.y < lowerCorner.y) {
position.y = lowerCorner.y;
velocity.y *= -0.15
} else if (position.y > upperCorner.y) {
position.y = upperCorner.y;
velocity.y *= -0.15
}
if (position.z < lowerCorner.z) {
position.z = lowerCorner.z;
velocity.z *= -0.15
} else if (position.z > upperCorner.z) {
position.z = upperCorner.z;
velocity.z *= -0.15
}
// Orient in direction of velocity
var rotation = Quat.rotationBetween(Vec3.UNIT_NEG_Z, velocity);
var mixedRotation = Quat.mix(properties.rotation, rotation, VELOCITY_FOLLOW_RATE);
var VELOCITY_FOLLOW_RATE = 0.30;
var slerpedRotation = Quat.slerp(properties.rotation, rotation, VELOCITY_FOLLOW_RATE);
var safeEuler = Quat.safeEulerAngles(rotation);
safeEuler.z = safeEuler.z *= 0.925;
//note: a we want the fish to both rotate toward its velocity and not roll over, and also not pitch more than 30 degrees positive or negative (not doing that last bit right quite yet)
var newQuat = Quat.fromPitchYawRollDegrees(safeEuler.x, safeEuler.y, safeEuler.z);
var finalQuat = Quat.slerp(slerpedRotation, newQuat, 0.5);
// Only update properties if they have changed, to save bandwidth
var MIN_POSITION_CHANGE_FOR_UPDATE = 0.001;
if (Vec3.distance(properties.position, position) < MIN_POSITION_CHANGE_FOR_UPDATE) {
Entities.editEntity(fish[i], {
velocity: velocity,
rotation: finalQuat
});
} else {
Entities.editEntity(fish[i], {
position: position,
velocity: velocity,
rotation: finalQuat
});
}
}
}
}
var STARTING_FRACTION = 0.25;
function loadFish(howMany) {
// print('LOADING FISH: ' + howMany)
var center = _this.currentProperties.position;
lowerCorner = {
x: center.x - (_this.currentProperties.dimensions.z / 2),
y: center.y,
z: center.z - (_this.currentProperties.dimensions.z / 2)
};
upperCorner = {
x: center.x + (_this.currentProperties.dimensions.z / 2),
y: center.y + _this.currentProperties.dimensions.y,
z: center.z + (_this.currentProperties.dimensions.z / 2)
};
var fish = [];
for (var i = 0; i < howMany; i++) {
var position = {
x: lowerCorner.x + (upperCorner.x - lowerCorner.x) / 2.0 + (Math.random() - 0.5) * (upperCorner.x - lowerCorner.x) * STARTING_FRACTION,
y: lowerCorner.y + (upperCorner.y - lowerCorner.y) / 2.0 + (Math.random() - 0.5) * (upperCorner.y - lowerCorner.y) * STARTING_FRACTION,
z: lowerCorner.z + (upperCorner.z - lowerCorner.z) / 2.0 + (Math.random() - 0.5) * (upperCorner.z - lowerCorner.z) * STARTING_FRACTION
};
fish.push(
Entities.addEntity({
name: 'hifi-fishtank-fish' + _this.entityID,
type: "Model",
modelURL: fish.length % 2 === 0 ? FISH_MODEL_URL : FISH_MODEL_TWO_URL,
position: position,
parentID: _this.entityID,
// rotation: {
// x: 0,
// y: 0,
// z: 0,
// w: 1
// },
// type: "Box",
dimensions: FISH_DIMENSIONS,
velocity: {
x: SWIMMING_SPEED,
y: SWIMMING_SPEED,
z: SWIMMING_SPEED
},
damping: FISH_DAMPING,
angularDamping: FISH_ANGULAR_DAMPING,
dynamic: false,
// lifetime: LIFETIME,
color: {
red: 0,
green: 255,
blue: 255
}
})
);
}
// print('initial fish::' + fish.length)
_this.tankLocked = false;
}
Script.scriptEnding.connect(function() {
Script.update.disconnect(_this.update);
})
function setEntityUserData(id, data) {
var json = JSON.stringify(data)
Entities.editEntity(id, {
userData: json
});
}
// FIXME do non-destructive modification of the existing user data
function getEntityUserData(id) {
var results = null;
var properties = Entities.getEntityProperties(id, "userData");
if (properties.userData) {
try {
results = JSON.parse(properties.userData);
} catch (err) {
// print('error parsing json');
// print('properties are:'+ properties.userData);
}
}
return results ? results : {};
}
// Non-destructively modify the user data of an entity.
function setEntityCustomData(customKey, id, data) {
var userData = getEntityUserData(id);
if (data == null) {
delete userData[customKey];
} else {
userData[customKey] = data;
}
setEntityUserData(id, userData);
}
function getEntityCustomData(customKey, id, defaultValue) {
var userData = getEntityUserData(id);
if (undefined != userData[customKey]) {
return userData[customKey];
} else {
return defaultValue;
}
}
return new FishTank();
});