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

more renaming to entity from model where we're really talking about an entity

Browse source
This commit is contained in:
ZappoMan 2014-07-01 17:07:16 -07:00
parent 865566414c
commit fe30d3807c
7 changed files with 236 additions and 236 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

180
libraries/entities/src/EntityItem.cpp
View file

@ -55,7 +55,7 @@ uint32_t EntityItem::getIDfromCreatorTokenID(uint32_t creatorTokenID) {
if (_tokenIDsToIDs.find(creatorTokenID) != _tokenIDsToIDs.end()) {
return _tokenIDsToIDs[creatorTokenID];
}
return UNKNOWN_MODEL_ID;
return UNKNOWN_ENTITY_ID;
}
uint32_t EntityItem::getNextCreatorTokenID() {
@ -84,7 +84,7 @@ void EntityItem::handleAddEntityResponse(const QByteArray& packet) {
EntityItem::EntityItem() {
_type = EntityTypes::Base;
rgbColor noColor = { 0, 0, 0 };
init(glm::vec3(0,0,0), 0, noColor, NEW_MODEL);
init(glm::vec3(0,0,0), 0, noColor, NEW_ENTITY);
}
void EntityItem::initFromEntityItemID(const EntityItemID& entityItemID) {
@ -101,14 +101,14 @@ void EntityItem::initFromEntityItemID(const EntityItemID& entityItemID) {
rgbColor noColor = { 0, 0, 0 };
memcpy(_color, noColor, sizeof(_color));
_shouldBeDeleted = false;
_modelURL = MODEL_DEFAULT_MODEL_URL;
_rotation = MODEL_DEFAULT_MODEL_ROTATION;
_modelURL = ENTITY_DEFAULT_MODEL_URL;
_rotation = ENTITY_DEFAULT_ROTATION;
// animation related
_animationURL = MODEL_DEFAULT_ANIMATION_URL;
_animationURL = ENTITY_DEFAULT_ANIMATION_URL;
_animationIsPlaying = false;
_animationFrameIndex = 0.0f;
_animationFPS = MODEL_DEFAULT_ANIMATION_FPS;
_animationFPS = ENTITY_DEFAULT_ANIMATION_FPS;
_glowLevel = 0.0f;
_jointMappingCompleted = false;
@ -130,7 +130,7 @@ EntityItem::~EntityItem() {
}
void EntityItem::init(glm::vec3 position, float radius, rgbColor color, uint32_t id) {
if (id == NEW_MODEL) {
if (id == NEW_ENTITY) {
_id = _nextID;
_nextID++;
} else {
@ -144,14 +144,14 @@ void EntityItem::init(glm::vec3 position, float radius, rgbColor color, uint32_t
_radius = radius;
memcpy(_color, color, sizeof(_color));
_shouldBeDeleted = false;
_modelURL = MODEL_DEFAULT_MODEL_URL;
_rotation = MODEL_DEFAULT_MODEL_ROTATION;
_modelURL = ENTITY_DEFAULT_MODEL_URL;
_rotation = ENTITY_DEFAULT_ROTATION;
// animation related
_animationURL = MODEL_DEFAULT_ANIMATION_URL;
_animationURL = ENTITY_DEFAULT_ANIMATION_URL;
_animationIsPlaying = false;
_animationFrameIndex = 0.0f;
_animationFPS = MODEL_DEFAULT_ANIMATION_FPS;
_animationFPS = ENTITY_DEFAULT_ANIMATION_FPS;
_glowLevel = 0.0f;
_jointMappingCompleted = false;
_lastAnimated = now;
@ -554,7 +554,7 @@ int EntityItem::oldVersionReadEntityDataFromBuffer(const unsigned char* data, in
dataAt += bytes;
bytesRead += bytes;
if (args.bitstreamVersion >= VERSION_MODELS_HAVE_ANIMATION) {
if (args.bitstreamVersion >= VERSION_ENTITIES_HAVE_ANIMATION) {
// animationURL
uint16_t animationURLLength;
memcpy(&animationURLLength, dataAt, sizeof(animationURLLength));
@ -594,14 +594,14 @@ EntityItemID EntityItem::readEntityItemIDFromBuffer(const unsigned char* data, i
quint32 id = idCoder;
result.id = id;
result.isKnownID = true;
result.creatorTokenID = UNKNOWN_MODEL_TOKEN;
result.creatorTokenID = UNKNOWN_ENTITY_TOKEN;
}
return result;
}
int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLeftToRead, ReadBitstreamToTreeParams& args) {
if (args.bitstreamVersion < VERSION_MODELS_SUPPORT_SPLIT_MTU) {
if (args.bitstreamVersion < VERSION_ENTITIES_SUPPORT_SPLIT_MTU) {
return oldVersionReadEntityDataFromBuffer(data, bytesLeftToRead, args);
}
@ -631,7 +631,7 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
dataAt += encodedID.size();
bytesRead += encodedID.size();
_id = idCoder;
_creatorTokenID = UNKNOWN_MODEL_TOKEN; // if we know the id, then we don't care about the creator token
_creatorTokenID = UNKNOWN_ENTITY_TOKEN; // if we know the id, then we don't care about the creator token
_newlyCreated = false;
// type
@ -786,11 +786,11 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
qDebug() << "EntityItem EntityItem::fromEditPacket() editID=" << editID;
}
bool isNewEntityItem = (editID == NEW_MODEL);
bool isNewEntityItem = (editID == NEW_ENTITY);
// special case for handling "new" modelItems
if (isNewEntityItem) {
// If this is a NEW_MODEL, then we assume that there's an additional uint32_t creatorToken, that
// If this is a NEW_ENTITY, then we assume that there's an additional uint32_t creatorToken, that
// we want to send back to the creator as an map to the actual id
uint32_t creatorTokenID;
memcpy(&creatorTokenID, dataAt, sizeof(creatorTokenID));
@ -801,7 +801,7 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
newEntityItem._newlyCreated = true;
valid = true;
} else {
// look up the existing modelItem
// look up the existing entityItem
const EntityItem* existingEntityItem = tree->findEntityByID(editID, true);
// copy existing properties before over-writing with new properties
@ -809,8 +809,8 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
newEntityItem = *existingEntityItem;
valid = true;
} else {
// the user attempted to edit a modelItem that doesn't exist
qDebug() << "user attempted to edit a modelItem that doesn't exist... editID=" << editID;
// the user attempted to edit a entityItem that doesn't exist
qDebug() << "user attempted to edit a entityItem that doesn't exist... editID=" << editID;
tree->debugDumpMap();
valid = false;
@ -844,35 +844,35 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
}
// radius
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_RADIUS) == MODEL_PACKET_CONTAINS_RADIUS)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_RADIUS) == ENTITY_PACKET_CONTAINS_RADIUS)) {
memcpy(&newEntityItem._radius, dataAt, sizeof(newEntityItem._radius));
dataAt += sizeof(newEntityItem._radius);
processedBytes += sizeof(newEntityItem._radius);
}
// position
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_POSITION) == MODEL_PACKET_CONTAINS_POSITION)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_POSITION) == ENTITY_PACKET_CONTAINS_POSITION)) {
memcpy(&newEntityItem._position, dataAt, sizeof(newEntityItem._position));
dataAt += sizeof(newEntityItem._position);
processedBytes += sizeof(newEntityItem._position);
}
// color
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_COLOR) == MODEL_PACKET_CONTAINS_COLOR)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_COLOR) == ENTITY_PACKET_CONTAINS_COLOR)) {
memcpy(newEntityItem._color, dataAt, sizeof(newEntityItem._color));
dataAt += sizeof(newEntityItem._color);
processedBytes += sizeof(newEntityItem._color);
}
// shouldBeDeleted
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_SHOULDDIE) == MODEL_PACKET_CONTAINS_SHOULDDIE)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_SHOULDDIE) == ENTITY_PACKET_CONTAINS_SHOULDDIE)) {
memcpy(&newEntityItem._shouldBeDeleted, dataAt, sizeof(newEntityItem._shouldBeDeleted));
dataAt += sizeof(newEntityItem._shouldBeDeleted);
processedBytes += sizeof(newEntityItem._shouldBeDeleted);
}
// modelURL
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_MODEL_URL) == MODEL_PACKET_CONTAINS_MODEL_URL)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_MODEL_URL) == ENTITY_PACKET_CONTAINS_MODEL_URL)) {
uint16_t modelURLLength;
memcpy(&modelURLLength, dataAt, sizeof(modelURLLength));
dataAt += sizeof(modelURLLength);
@ -885,14 +885,14 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
// modelRotation
if (isNewEntityItem || ((packetContainsBits &
MODEL_PACKET_CONTAINS_MODEL_ROTATION) == MODEL_PACKET_CONTAINS_MODEL_ROTATION)) {
ENTITY_PACKET_CONTAINS_ROTATION) == ENTITY_PACKET_CONTAINS_ROTATION)) {
int bytes = unpackOrientationQuatFromBytes(dataAt, newEntityItem._rotation);
dataAt += bytes;
processedBytes += bytes;
}
// animationURL
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_ANIMATION_URL) == MODEL_PACKET_CONTAINS_ANIMATION_URL)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_ANIMATION_URL) == ENTITY_PACKET_CONTAINS_ANIMATION_URL)) {
uint16_t animationURLLength;
memcpy(&animationURLLength, dataAt, sizeof(animationURLLength));
dataAt += sizeof(animationURLLength);
@ -905,7 +905,7 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
// animationIsPlaying
if (isNewEntityItem || ((packetContainsBits &
MODEL_PACKET_CONTAINS_ANIMATION_PLAYING) == MODEL_PACKET_CONTAINS_ANIMATION_PLAYING)) {
ENTITY_PACKET_CONTAINS_ANIMATION_PLAYING) == ENTITY_PACKET_CONTAINS_ANIMATION_PLAYING)) {
memcpy(&newEntityItem._animationIsPlaying, dataAt, sizeof(newEntityItem._animationIsPlaying));
dataAt += sizeof(newEntityItem._animationIsPlaying);
@ -914,7 +914,7 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
// animationFrameIndex
if (isNewEntityItem || ((packetContainsBits &
MODEL_PACKET_CONTAINS_ANIMATION_FRAME) == MODEL_PACKET_CONTAINS_ANIMATION_FRAME)) {
ENTITY_PACKET_CONTAINS_ANIMATION_FRAME) == ENTITY_PACKET_CONTAINS_ANIMATION_FRAME)) {
memcpy(&newEntityItem._animationFrameIndex, dataAt, sizeof(newEntityItem._animationFrameIndex));
dataAt += sizeof(newEntityItem._animationFrameIndex);
@ -923,7 +923,7 @@ EntityItem EntityItem::fromEditPacket(const unsigned char* data, int length, int
// animationFPS
if (isNewEntityItem || ((packetContainsBits &
MODEL_PACKET_CONTAINS_ANIMATION_FPS) == MODEL_PACKET_CONTAINS_ANIMATION_FPS)) {
ENTITY_PACKET_CONTAINS_ANIMATION_FPS) == ENTITY_PACKET_CONTAINS_ANIMATION_FPS)) {
memcpy(&newEntityItem._animationFPS, dataAt, sizeof(newEntityItem._animationFPS));
dataAt += sizeof(newEntityItem._animationFPS);
@ -957,15 +957,15 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
unsigned char* copyAt = bufferOut;
sizeOut = 0;
// get the octal code for the modelItem
// get the octal code for the entityItem
// this could be a problem if the caller doesn't include position....
glm::vec3 rootPosition(0);
float rootScale = 0.5f;
unsigned char* octcode = pointToOctalCode(rootPosition.x, rootPosition.y, rootPosition.z, rootScale);
// TODO: Consider this old code... including the correct octree for where the modelItem will go matters for
// modelItem servers with different jurisdictions, but for now, we'll send everything to the root, since the
// TODO: Consider this old code... including the correct octree for where the entityItem will go matters for
// entityItem servers with different jurisdictions, but for now, we'll send everything to the root, since the
// tree does the right thing...
//
//unsigned char* octcode = pointToOctalCode(details[i].position.x, details[i].position.y,
@ -980,7 +980,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
sizeOut += lengthOfOctcode;
// Now add our edit content details...
bool isNewEntityItem = (id.id == NEW_MODEL);
bool isNewEntityItem = (id.id == NEW_ENTITY);
// id
memcpy(copyAt, &id.id, sizeof(id.id));
@ -989,7 +989,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
// special case for handling "new" modelItems
if (isNewEntityItem) {
// If this is a NEW_MODEL, then we assume that there's an additional uint32_t creatorToken, that
// If this is a NEW_ENTITY, then we assume that there's an additional uint32_t creatorToken, that
// we want to send back to the creator as an map to the actual id
memcpy(copyAt, &id.creatorTokenID, sizeof(id.creatorTokenID));
copyAt += sizeof(id.creatorTokenID);
@ -1002,7 +1002,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
copyAt += sizeof(lastEdited);
sizeOut += sizeof(lastEdited);
// For new modelItems, all remaining items are mandatory, for an edited modelItem, All of the remaining items are
// For new modelItems, all remaining items are mandatory, for an edited entityItem, All of the remaining items are
// optional, and may or may not be included based on their included values in the properties included bits
uint16_t packetContainsBits = properties.getChangedBits();
if (!isNewEntityItem) {
@ -1012,7 +1012,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
}
// radius
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_RADIUS) == MODEL_PACKET_CONTAINS_RADIUS)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_RADIUS) == ENTITY_PACKET_CONTAINS_RADIUS)) {
float radius = properties.getRadius() / (float) TREE_SCALE;
memcpy(copyAt, &radius, sizeof(radius));
copyAt += sizeof(radius);
@ -1020,7 +1020,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
}
// position
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_POSITION) == MODEL_PACKET_CONTAINS_POSITION)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_POSITION) == ENTITY_PACKET_CONTAINS_POSITION)) {
glm::vec3 position = properties.getPosition() / (float)TREE_SCALE;
memcpy(copyAt, &position, sizeof(position));
copyAt += sizeof(position);
@ -1028,7 +1028,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
}
// color
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_COLOR) == MODEL_PACKET_CONTAINS_COLOR)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_COLOR) == ENTITY_PACKET_CONTAINS_COLOR)) {
rgbColor color = { properties.getColor().red, properties.getColor().green, properties.getColor().blue };
memcpy(copyAt, color, sizeof(color));
copyAt += sizeof(color);
@ -1036,7 +1036,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
}
// shoulDie
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_SHOULDDIE) == MODEL_PACKET_CONTAINS_SHOULDDIE)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_SHOULDDIE) == ENTITY_PACKET_CONTAINS_SHOULDDIE)) {
bool shouldBeDeleted = properties.getShouldBeDeleted();
memcpy(copyAt, &shouldBeDeleted, sizeof(shouldBeDeleted));
copyAt += sizeof(shouldBeDeleted);
@ -1044,7 +1044,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
}
// modelURL
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_MODEL_URL) == MODEL_PACKET_CONTAINS_MODEL_URL)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_MODEL_URL) == ENTITY_PACKET_CONTAINS_MODEL_URL)) {
uint16_t urlLength = properties.getModelURL().size() + 1;
memcpy(copyAt, &urlLength, sizeof(urlLength));
copyAt += sizeof(urlLength);
@ -1055,14 +1055,14 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
}
// modelRotation
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_MODEL_ROTATION) == MODEL_PACKET_CONTAINS_MODEL_ROTATION)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_ROTATION) == ENTITY_PACKET_CONTAINS_ROTATION)) {
int bytes = packOrientationQuatToBytes(copyAt, properties.getRotation());
copyAt += bytes;
sizeOut += bytes;
}
// animationURL
if (isNewEntityItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_ANIMATION_URL) == MODEL_PACKET_CONTAINS_ANIMATION_URL)) {
if (isNewEntityItem || ((packetContainsBits & ENTITY_PACKET_CONTAINS_ANIMATION_URL) == ENTITY_PACKET_CONTAINS_ANIMATION_URL)) {
uint16_t urlLength = properties.getAnimationURL().size() + 1;
memcpy(copyAt, &urlLength, sizeof(urlLength));
copyAt += sizeof(urlLength);
@ -1074,7 +1074,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
// animationIsPlaying
if (isNewEntityItem || ((packetContainsBits &
MODEL_PACKET_CONTAINS_ANIMATION_PLAYING) == MODEL_PACKET_CONTAINS_ANIMATION_PLAYING)) {
ENTITY_PACKET_CONTAINS_ANIMATION_PLAYING) == ENTITY_PACKET_CONTAINS_ANIMATION_PLAYING)) {
bool animationIsPlaying = properties.getAnimationIsPlaying();
memcpy(copyAt, &animationIsPlaying, sizeof(animationIsPlaying));
@ -1084,7 +1084,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
// animationFrameIndex
if (isNewEntityItem || ((packetContainsBits &
MODEL_PACKET_CONTAINS_ANIMATION_FRAME) == MODEL_PACKET_CONTAINS_ANIMATION_FRAME)) {
ENTITY_PACKET_CONTAINS_ANIMATION_FRAME) == ENTITY_PACKET_CONTAINS_ANIMATION_FRAME)) {
float animationFrameIndex = properties.getAnimationFrameIndex();
memcpy(copyAt, &animationFrameIndex, sizeof(animationFrameIndex));
@ -1094,7 +1094,7 @@ bool EntityItem::encodeEntityEditMessageDetails(PacketType command, EntityItemID
// animationFPS
if (isNewEntityItem || ((packetContainsBits &
MODEL_PACKET_CONTAINS_ANIMATION_FPS) == MODEL_PACKET_CONTAINS_ANIMATION_FPS)) {
ENTITY_PACKET_CONTAINS_ANIMATION_FPS) == ENTITY_PACKET_CONTAINS_ANIMATION_FPS)) {
float animationFPS = properties.getAnimationFPS();
memcpy(copyAt, &animationFPS, sizeof(animationFPS));
@ -1127,8 +1127,8 @@ void EntityItem::adjustEditPacketForClockSkew(unsigned char* codeColorBuffer, ss
memcpy(&id, dataAt, sizeof(id));
dataAt += sizeof(id);
// special case for handling "new" modelItems
if (id == NEW_MODEL) {
// If this is a NEW_MODEL, then we assume that there's an additional uint32_t creatorToken, that
if (id == NEW_ENTITY) {
// If this is a NEW_ENTITY, then we assume that there's an additional uint32_t creatorToken, that
// we want to send back to the creator as an map to the actual id
dataAt += sizeof(uint32_t);
}
@ -1271,17 +1271,17 @@ void EntityItem::setProperties(const EntityItemProperties& properties, bool forc
EntityItemProperties::EntityItemProperties() :
_position(0),
_color(),
_radius(MODEL_DEFAULT_RADIUS),
_radius(ENTITY_DEFAULT_RADIUS),
_shouldBeDeleted(false),
_modelURL(""),
_rotation(MODEL_DEFAULT_MODEL_ROTATION),
_rotation(ENTITY_DEFAULT_ROTATION),
_animationURL(""),
_animationIsPlaying(false),
_animationFrameIndex(0.0),
_animationFPS(MODEL_DEFAULT_ANIMATION_FPS),
_animationFPS(ENTITY_DEFAULT_ANIMATION_FPS),
_glowLevel(0.0f),
_id(UNKNOWN_MODEL_ID),
_id(UNKNOWN_ENTITY_ID),
_idSet(false),
_lastEdited(usecTimestampNow()),
@ -1314,43 +1314,43 @@ void EntityItemProperties::debugDump() const {
uint16_t EntityItemProperties::getChangedBits() const {
uint16_t changedBits = 0;
if (_radiusChanged) {
changedBits += MODEL_PACKET_CONTAINS_RADIUS;
changedBits += ENTITY_PACKET_CONTAINS_RADIUS;
}
if (_positionChanged) {
changedBits += MODEL_PACKET_CONTAINS_POSITION;
changedBits += ENTITY_PACKET_CONTAINS_POSITION;
}
if (_colorChanged) {
changedBits += MODEL_PACKET_CONTAINS_COLOR;
changedBits += ENTITY_PACKET_CONTAINS_COLOR;
}
if (_shouldBeDeletedChanged) {
changedBits += MODEL_PACKET_CONTAINS_SHOULDDIE;
changedBits += ENTITY_PACKET_CONTAINS_SHOULDDIE;
}
if (_modelURLChanged) {
changedBits += MODEL_PACKET_CONTAINS_MODEL_URL;
changedBits += ENTITY_PACKET_CONTAINS_MODEL_URL;
}
if (_rotationChanged) {
changedBits += MODEL_PACKET_CONTAINS_MODEL_ROTATION;
changedBits += ENTITY_PACKET_CONTAINS_ROTATION;
}
if (_animationURLChanged) {
changedBits += MODEL_PACKET_CONTAINS_ANIMATION_URL;
changedBits += ENTITY_PACKET_CONTAINS_ANIMATION_URL;
}
if (_animationIsPlayingChanged) {
changedBits += MODEL_PACKET_CONTAINS_ANIMATION_PLAYING;
changedBits += ENTITY_PACKET_CONTAINS_ANIMATION_PLAYING;
}
if (_animationFrameIndexChanged) {
changedBits += MODEL_PACKET_CONTAINS_ANIMATION_FRAME;
changedBits += ENTITY_PACKET_CONTAINS_ANIMATION_FRAME;
}
if (_animationFPSChanged) {
changedBits += MODEL_PACKET_CONTAINS_ANIMATION_FPS;
changedBits += ENTITY_PACKET_CONTAINS_ANIMATION_FPS;
}
return changedBits;
@ -1383,7 +1383,7 @@ QScriptValue EntityItemProperties::copyToScriptValue(QScriptEngine* engine) cons
if (_idSet) {
properties.setProperty("id", _id);
properties.setProperty("isKnownID", (_id != UNKNOWN_MODEL_ID));
properties.setProperty("isKnownID", (_id != UNKNOWN_ENTITY_ID));
}
// Sitting properties support
@ -1541,60 +1541,60 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue &object) {
_lastEdited = usecTimestampNow();
}
void EntityItemProperties::copyToEntityItem(EntityItem& modelItem, bool forceCopy) const {
void EntityItemProperties::copyToEntityItem(EntityItem& entityItem, bool forceCopy) const {
bool somethingChanged = false;
if (_positionChanged || forceCopy) {
modelItem.setPosition(_position / (float) TREE_SCALE);
entityItem.setPosition(_position / (float) TREE_SCALE);
somethingChanged = true;
}
if (_colorChanged || forceCopy) {
modelItem.setColor(_color);
entityItem.setColor(_color);
somethingChanged = true;
}
if (_radiusChanged || forceCopy) {
modelItem.setRadius(_radius / (float) TREE_SCALE);
entityItem.setRadius(_radius / (float) TREE_SCALE);
somethingChanged = true;
}
if (_shouldBeDeletedChanged || forceCopy) {
modelItem.setShouldBeDeleted(_shouldBeDeleted);
entityItem.setShouldBeDeleted(_shouldBeDeleted);
somethingChanged = true;
}
if (_modelURLChanged || forceCopy) {
modelItem.setModelURL(_modelURL);
entityItem.setModelURL(_modelURL);
somethingChanged = true;
}
if (_rotationChanged || forceCopy) {
modelItem.setRotation(_rotation);
entityItem.setRotation(_rotation);
somethingChanged = true;
}
if (_animationURLChanged || forceCopy) {
modelItem.setAnimationURL(_animationURL);
entityItem.setAnimationURL(_animationURL);
somethingChanged = true;
}
if (_animationIsPlayingChanged || forceCopy) {
modelItem.setAnimationIsPlaying(_animationIsPlaying);
entityItem.setAnimationIsPlaying(_animationIsPlaying);
somethingChanged = true;
}
if (_animationFrameIndexChanged || forceCopy) {
modelItem.setAnimationFrameIndex(_animationFrameIndex);
entityItem.setAnimationFrameIndex(_animationFrameIndex);
somethingChanged = true;
}
if (_animationFPSChanged || forceCopy) {
modelItem.setAnimationFPS(_animationFPS);
entityItem.setAnimationFPS(_animationFPS);
somethingChanged = true;
}
if (_glowLevelChanged || forceCopy) {
modelItem.setGlowLevel(_glowLevel);
entityItem.setGlowLevel(_glowLevel);
somethingChanged = true;
}
@ -1606,25 +1606,25 @@ void EntityItemProperties::copyToEntityItem(EntityItem& modelItem, bool forceCop
qDebug() << "EntityItemProperties::copyToEntityItem() AFTER update... edited AGO=" << elapsed <<
"now=" << now << " _lastEdited=" << _lastEdited;
}
modelItem.setLastEdited(_lastEdited);
entityItem.setLastEdited(_lastEdited);
}
}
void EntityItemProperties::copyFromEntityItem(const EntityItem& modelItem) {
_position = modelItem.getPosition() * (float) TREE_SCALE;
_color = modelItem.getXColor();
_radius = modelItem.getRadius() * (float) TREE_SCALE;
_shouldBeDeleted = modelItem.getShouldBeDeleted();
_modelURL = modelItem.getModelURL();
_rotation = modelItem.getRotation();
_animationURL = modelItem.getAnimationURL();
_animationIsPlaying = modelItem.getAnimationIsPlaying();
_animationFrameIndex = modelItem.getAnimationFrameIndex();
_animationFPS = modelItem.getAnimationFPS();
_glowLevel = modelItem.getGlowLevel();
_sittingPoints = modelItem.getSittingPoints(); // sitting support
void EntityItemProperties::copyFromEntityItem(const EntityItem& entityItem) {
_position = entityItem.getPosition() * (float) TREE_SCALE;
_color = entityItem.getXColor();
_radius = entityItem.getRadius() * (float) TREE_SCALE;
_shouldBeDeleted = entityItem.getShouldBeDeleted();
_modelURL = entityItem.getModelURL();
_rotation = entityItem.getRotation();
_animationURL = entityItem.getAnimationURL();
_animationIsPlaying = entityItem.getAnimationIsPlaying();
_animationFrameIndex = entityItem.getAnimationFrameIndex();
_animationFPS = entityItem.getAnimationFPS();
_glowLevel = entityItem.getGlowLevel();
_sittingPoints = entityItem.getSittingPoints(); // sitting support
_id = modelItem.getID();
_id = entityItem.getID();
_idSet = true;
_positionChanged = false;

64
libraries/entities/src/EntityItem.h
View file

@ -38,27 +38,27 @@ class VoxelEditPacketSender;
class VoxelsScriptingInterface;
struct VoxelDetail;
const uint32_t NEW_MODEL = 0xFFFFFFFF;
const uint32_t UNKNOWN_MODEL_TOKEN = 0xFFFFFFFF;
const uint32_t UNKNOWN_MODEL_ID = 0xFFFFFFFF;
const uint32_t NEW_ENTITY = 0xFFFFFFFF;
const uint32_t UNKNOWN_ENTITY_TOKEN = 0xFFFFFFFF;
const uint32_t UNKNOWN_ENTITY_ID = 0xFFFFFFFF;
const uint16_t MODEL_PACKET_CONTAINS_RADIUS = 1;
const uint16_t MODEL_PACKET_CONTAINS_POSITION = 2;
const uint16_t MODEL_PACKET_CONTAINS_COLOR = 4;
const uint16_t MODEL_PACKET_CONTAINS_SHOULDDIE = 8;
const uint16_t MODEL_PACKET_CONTAINS_MODEL_URL = 16;
const uint16_t MODEL_PACKET_CONTAINS_MODEL_ROTATION = 32;
const uint16_t MODEL_PACKET_CONTAINS_ANIMATION_URL = 64;
const uint16_t MODEL_PACKET_CONTAINS_ANIMATION_PLAYING = 128;
const uint16_t MODEL_PACKET_CONTAINS_ANIMATION_FRAME = 256;
const uint16_t MODEL_PACKET_CONTAINS_ANIMATION_FPS = 512;
const uint16_t ENTITY_PACKET_CONTAINS_RADIUS = 1;
const uint16_t ENTITY_PACKET_CONTAINS_POSITION = 2;
const uint16_t ENTITY_PACKET_CONTAINS_COLOR = 4;
const uint16_t ENTITY_PACKET_CONTAINS_SHOULDDIE = 8;
const uint16_t ENTITY_PACKET_CONTAINS_MODEL_URL = 16;
const uint16_t ENTITY_PACKET_CONTAINS_ROTATION = 32;
const uint16_t ENTITY_PACKET_CONTAINS_ANIMATION_URL = 64;
const uint16_t ENTITY_PACKET_CONTAINS_ANIMATION_PLAYING = 128;
const uint16_t ENTITY_PACKET_CONTAINS_ANIMATION_FRAME = 256;
const uint16_t ENTITY_PACKET_CONTAINS_ANIMATION_FPS = 512;
const float MODEL_DEFAULT_RADIUS = 0.1f / TREE_SCALE;
const float MINIMUM_MODEL_ELEMENT_SIZE = (1.0f / 100000.0f) / TREE_SCALE; // smallest size container
const QString MODEL_DEFAULT_MODEL_URL("");
const glm::quat MODEL_DEFAULT_MODEL_ROTATION;
const QString MODEL_DEFAULT_ANIMATION_URL("");
const float MODEL_DEFAULT_ANIMATION_FPS = 30.0f;
const float ENTITY_DEFAULT_RADIUS = 0.1f / TREE_SCALE;
const float ENTITY_MINIMUM_ELEMENT_SIZE = (1.0f / 100000.0f) / TREE_SCALE; // smallest size container
const QString ENTITY_DEFAULT_MODEL_URL("");
const glm::quat ENTITY_DEFAULT_ROTATION;
const QString ENTITY_DEFAULT_ANIMATION_URL("");
const float ENTITY_DEFAULT_ANIMATION_FPS = 30.0f;
// PropertyFlags support
@ -98,9 +98,9 @@ enum EntityPropertyList {
typedef PropertyFlags<EntityPropertyList> EntityPropertyFlags;
/// A collection of properties of a model item used in the scripting API. Translates between the actual properties of a model
/// and a JavaScript style hash/QScriptValue storing a set of properties. Used in scripting to set/get the complete set of
/// model item properties via JavaScript hashes/QScriptValues
/// A collection of properties of an entity item used in the scripting API. Translates between the actual properties of an
/// entity and a JavaScript style hash/QScriptValue storing a set of properties. Used in scripting to set/get the complete
/// set of entity item properties via JavaScript hashes/QScriptValues
/// all units for position, radius, etc are in meter units
class EntityItemProperties {
public:
@ -109,8 +109,8 @@ public:
QScriptValue copyToScriptValue(QScriptEngine* engine) const;
void copyFromScriptValue(const QScriptValue& object);
void copyToEntityItem(EntityItem& modelItem, bool forceCopy = false) const;
void copyFromEntityItem(const EntityItem& modelItem);
void copyToEntityItem(EntityItem& entityItem, bool forceCopy = false) const;
void copyFromEntityItem(const EntityItem& entityItem);
const glm::vec3& getPosition() const { return _position; }
xColor getColor() const { return _color; }
@ -144,7 +144,7 @@ public:
void setGlowLevel(float value) { _glowLevel = value; _glowLevelChanged = true; }
/// used by EntityScriptingInterface to return EntityItemProperties for unknown models
void setIsUnknownID() { _id = UNKNOWN_MODEL_ID; _idSet = true; }
void setIsUnknownID() { _id = UNKNOWN_ENTITY_ID; _idSet = true; }
glm::vec3 getMinimumPoint() const { return _position - glm::vec3(_radius, _radius, _radius); }
glm::vec3 getMaximumPoint() const { return _position + glm::vec3(_radius, _radius, _radius); }
@ -195,13 +195,13 @@ void EntityItemPropertiesFromScriptValue(const QScriptValue &object, EntityItemP
class EntityItemID {
public:
EntityItemID() :
id(NEW_MODEL), creatorTokenID(UNKNOWN_MODEL_TOKEN), isKnownID(false) { };
id(NEW_ENTITY), creatorTokenID(UNKNOWN_ENTITY_TOKEN), isKnownID(false) { };
EntityItemID(uint32_t id, uint32_t creatorTokenID, bool isKnownID) :
id(id), creatorTokenID(creatorTokenID), isKnownID(isKnownID) { };
EntityItemID(uint32_t id) :
id(id), creatorTokenID(UNKNOWN_MODEL_TOKEN), isKnownID(true) { };
id(id), creatorTokenID(UNKNOWN_ENTITY_TOKEN), isKnownID(true) { };
uint32_t id;
uint32_t creatorTokenID;
@ -213,7 +213,7 @@ inline bool operator<(const EntityItemID& a, const EntityItemID& b) {
}
inline bool operator==(const EntityItemID& a, const EntityItemID& b) {
if (a.id == UNKNOWN_MODEL_ID && b.id == UNKNOWN_MODEL_ID) {
if (a.id == UNKNOWN_ENTITY_ID && b.id == UNKNOWN_ENTITY_ID) {
return a.creatorTokenID == b.creatorTokenID;
}
return a.id == b.id;
@ -221,7 +221,7 @@ inline bool operator==(const EntityItemID& a, const EntityItemID& b) {
inline uint qHash(const EntityItemID& a, uint seed) {
qint64 temp;
if (a.id == UNKNOWN_MODEL_ID) {
if (a.id == UNKNOWN_ENTITY_ID) {
temp = -a.creatorTokenID;
} else {
temp = a.id;
@ -283,7 +283,7 @@ public:
float getGlowLevel() const { return _glowLevel; }
QVector<SittingPoint> getSittingPoints() const { return _sittingPoints; }
EntityItemID getEntityItemID() const { return EntityItemID(getID(), getCreatorTokenID(), getID() != UNKNOWN_MODEL_ID); }
EntityItemID getEntityItemID() const { return EntityItemID(getID(), getCreatorTokenID(), getID() != UNKNOWN_ENTITY_ID); }
EntityItemProperties getProperties() const;
/// The last updated/simulated time of this model from the time perspective of the authoritative server/source
@ -300,7 +300,7 @@ public:
bool getShouldBeDeleted() const { return _shouldBeDeleted; }
uint32_t getCreatorTokenID() const { return _creatorTokenID; }
bool isNewlyCreated() const { return _newlyCreated; }
bool isKnownID() const { return getID() != UNKNOWN_MODEL_ID; }
bool isKnownID() const { return getID() != UNKNOWN_ENTITY_ID; }
/// set position in domain scale units (0.0 - 1.0)
void setPosition(const glm::vec3& value) { _position = value; }
@ -369,7 +369,7 @@ public:
protected:
void initFromEntityItemID(const EntityItemID& entityItemID);
virtual void init(glm::vec3 position, float radius, rgbColor color, uint32_t id = NEW_MODEL);
virtual void init(glm::vec3 position, float radius, rgbColor color, uint32_t id = NEW_ENTITY);
glm::vec3 _position;
rgbColor _color;

16
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -29,7 +29,7 @@ EntityItemID EntityScriptingInterface::addEntity(const EntityItemProperties& pro
// The application will keep track of creatorTokenID
uint32_t creatorTokenID = EntityItem::getNextCreatorTokenID();
EntityItemID id(NEW_MODEL, creatorTokenID, false );
EntityItemID id(NEW_ENTITY, creatorTokenID, false );
// queue the packet
queueEntityMessage(PacketTypeEntityAddOrEdit, id, properties);
@ -49,7 +49,7 @@ EntityItemID EntityScriptingInterface::identifyEntity(EntityItemID entityID) {
if (!entityID.isKnownID) {
actualID = EntityItem::getIDfromCreatorTokenID(entityID.creatorTokenID);
if (actualID == UNKNOWN_MODEL_ID) {
if (actualID == UNKNOWN_ENTITY_ID) {
return entityID; // bailing early
}
@ -92,7 +92,7 @@ EntityItemID EntityScriptingInterface::editEntity(EntityItemID entityID, const E
}
// if at this point, we know the id, send the update to the model server
if (actualID != UNKNOWN_MODEL_ID) {
if (actualID != UNKNOWN_ENTITY_ID) {
entityID.id = actualID;
entityID.isKnownID = true;
queueEntityMessage(PacketTypeEntityAddOrEdit, entityID, properties);
@ -109,9 +109,9 @@ EntityItemID EntityScriptingInterface::editEntity(EntityItemID entityID, const E
}
// TODO: This deleteEntity() method uses the PacketType_MODEL_ADD_OR_EDIT message to send
// TODO: This deleteEntity() method uses the PacketTypeEntityAddOrEdit message to send
// a changed model with a shouldDie() property set to true. This works and is currently the only
// way to tell the model server to delete a model. But we should change this to use the PacketType_MODEL_ERASE
// way to tell the model server to delete a model. But we should change this to use the PacketTypeEntityErase
// message which takes a list of model id's to delete.
void EntityScriptingInterface::deleteEntity(EntityItemID entityID) {
@ -127,7 +127,7 @@ void EntityScriptingInterface::deleteEntity(EntityItemID entityID) {
}
// if at this point, we know the id, send the update to the model server
if (actualID != UNKNOWN_MODEL_ID) {
if (actualID != UNKNOWN_ENTITY_ID) {
entityID.id = actualID;
entityID.isKnownID = true;
queueEntityMessage(PacketTypeEntityAddOrEdit, entityID, properties);
@ -142,7 +142,7 @@ void EntityScriptingInterface::deleteEntity(EntityItemID entityID) {
}
EntityItemID EntityScriptingInterface::findClosestEntity(const glm::vec3& center, float radius) const {
EntityItemID result(UNKNOWN_MODEL_ID, UNKNOWN_MODEL_TOKEN, false);
EntityItemID result(UNKNOWN_ENTITY_ID, UNKNOWN_ENTITY_TOKEN, false);
if (_entityTree) {
_entityTree->lockForRead();
const EntityItem* closestEntity = _entityTree->findClosestEntity(center/(float)TREE_SCALE,
@ -166,7 +166,7 @@ QVector<EntityItemID> EntityScriptingInterface::findEntities(const glm::vec3& ce
_entityTree->unlock();
foreach (const EntityItem* model, models) {
EntityItemID thisEntityItemID(model->getID(), UNKNOWN_MODEL_TOKEN, true);
EntityItemID thisEntityItemID(model->getID(), UNKNOWN_ENTITY_TOKEN, true);
result << thisEntityItemID;
}
}

84
libraries/entities/src/EntityTree.cpp
View file

@ -218,59 +218,59 @@ void EntityTree::storeEntity(const EntityItem& model, const SharedNodePointer& s
}
void EntityTree::updateEntity(const EntityItemID& modelID, const EntityItemProperties& properties) {
EntityItem updateItem(modelID);
void EntityTree::updateEntity(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem updateItem(entityID);
bool wantDebug = false;
if (wantDebug) {
qDebug() << "EntityTree::updateEntity(modelID, properties) line:" << __LINE__ << "updateItem:";
qDebug() << "EntityTree::updateEntity(entityID, properties) line:" << __LINE__ << "updateItem:";
updateItem.debugDump();
}
// since the properties might not be complete, they may only contain some values,
// we need to first see if we already have the model in our tree, and make a copy of
// its existing properties first
EntityTreeElement* containingElement = getContainingElement(modelID);
EntityTreeElement* containingElement = getContainingElement(entityID);
if (wantDebug) {
qDebug() << "EntityTree::updateEntity(modelID, properties) containingElement=" << containingElement;
qDebug() << "EntityTree::updateEntity(entityID, properties) containingElement=" << containingElement;
}
if (containingElement) {
const EntityItem* oldEntity = containingElement->getEntityWithEntityItemID(modelID);
const EntityItem* oldEntity = containingElement->getEntityWithEntityItemID(entityID);
if (oldEntity) {
EntityItemProperties oldProps = oldEntity->getProperties();
if (wantDebug) {
qDebug() << "EntityTree::updateEntity(modelID, properties) ********** COPY PROPERTIES FROM oldEntity=" << oldEntity << "*******************";
qDebug() << "EntityTree::updateEntity(modelID, properties) oldEntity=" << oldEntity;
qDebug() << "EntityTree::updateEntity(entityID, properties) ********** COPY PROPERTIES FROM oldEntity=" << oldEntity << "*******************";
qDebug() << "EntityTree::updateEntity(entityID, properties) oldEntity=" << oldEntity;
oldProps.debugDump();
qDebug() << "EntityTree::updateEntity(modelID, properties) line:" << __LINE__ << "about to call updateItem.setProperties(oldProps);";
qDebug() << "EntityTree::updateEntity(entityID, properties) line:" << __LINE__ << "about to call updateItem.setProperties(oldProps);";
}
updateItem.setProperties(oldProps, true); // force copy
if (wantDebug) {
qDebug() << "EntityTree::updateEntity(modelID, properties) line:" << __LINE__ << "updateItem:";
qDebug() << "EntityTree::updateEntity(entityID, properties) line:" << __LINE__ << "updateItem:";
updateItem.debugDump();
}
} else {
if (wantDebug) {
qDebug() << "EntityTree::updateEntity(modelID, properties) WAIT WHAT!!! COULDN'T FIND oldEntity=" << oldEntity;
qDebug() << "EntityTree::updateEntity(entityID, properties) WAIT WHAT!!! COULDN'T FIND oldEntity=" << oldEntity;
}
}
}
updateItem.setProperties(properties);
if (wantDebug) {
qDebug() << "EntityTree::updateEntity(modelID, properties) line:" << __LINE__ << "updateItem:";
qDebug() << "EntityTree::updateEntity(entityID, properties) line:" << __LINE__ << "updateItem:";
updateItem.debugDump();
}
storeEntity(updateItem);
}
void EntityTree::addEntity(const EntityItemID& modelID, const EntityItemProperties& properties) {
EntityItem updateItem(modelID, properties);
void EntityTree::addEntity(const EntityItemID& entityID, const EntityItemProperties& properties) {
EntityItem updateItem(entityID, properties);
storeEntity(updateItem);
}
@ -413,18 +413,18 @@ bool DeleteEntityOperator::PostRecursion(OctreeElement* element) {
return keepSearching; // if we haven't yet found it, keep looking
}
void EntityTree::deleteEntity(const EntityItemID& modelID) {
void EntityTree::deleteEntity(const EntityItemID& entityID) {
// NOTE: callers must lock the tree before using this method
// First, look for the existing model in the tree..
DeleteEntityOperator theOperator(this, modelID);
DeleteEntityOperator theOperator(this, entityID);
recurseTreeWithOperator(&theOperator);
_isDirty = true;
bool wantDebug = false;
if (wantDebug) {
EntityTreeElement* containingElement = getContainingElement(modelID);
EntityTreeElement* containingElement = getContainingElement(entityID);
qDebug() << "EntityTree::storeEntity().... after store... containingElement=" << containingElement;
}
}
@ -433,9 +433,9 @@ void EntityTree::deleteEntitys(QSet<EntityItemID> modelIDs) {
// NOTE: callers must lock the tree before using this method
DeleteEntityOperator theOperator(this);
foreach(const EntityItemID& modelID, modelIDs) {
foreach(const EntityItemID& entityID, modelIDs) {
// First, look for the existing model in the tree..
theOperator.modelToDelete(modelID);
theOperator.modelToDelete(entityID);
}
recurseTreeWithOperator(&theOperator);
@ -443,8 +443,8 @@ void EntityTree::deleteEntitys(QSet<EntityItemID> modelIDs) {
bool wantDebug = false;
if (wantDebug) {
foreach(const EntityItemID& modelID, modelIDs) {
EntityTreeElement* containingElement = getContainingElement(modelID);
foreach(const EntityItemID& entityID, modelIDs) {
EntityTreeElement* containingElement = getContainingElement(entityID);
qDebug() << "EntityTree::storeEntity().... after store... containingElement=" << containingElement;
}
}
@ -487,19 +487,19 @@ void EntityTree::handleAddEntityResponse(const QByteArray& packet) {
memcpy(&creatorTokenID, dataAt, sizeof(creatorTokenID));
dataAt += sizeof(creatorTokenID);
uint32_t modelID;
memcpy(&modelID, dataAt, sizeof(modelID));
dataAt += sizeof(modelID);
uint32_t entityID;
memcpy(&entityID, dataAt, sizeof(entityID));
dataAt += sizeof(entityID);
if (wantDebug) {
qDebug() << " creatorTokenID=" << creatorTokenID;
qDebug() << " modelID=" << modelID;
qDebug() << " entityID=" << entityID;
}
// update models in our tree
bool assumeEntityFound = !getIsViewing(); // if we're not a viewing tree, then we don't have to find the actual model
FindAndUpdateEntityItemIDArgs args = {
modelID,
entityID,
creatorTokenID,
false,
assumeEntityFound,
@ -507,7 +507,7 @@ void EntityTree::handleAddEntityResponse(const QByteArray& packet) {
};
if (wantDebug) {
qDebug() << "looking for creatorTokenID=" << creatorTokenID << " modelID=" << modelID
qDebug() << "looking for creatorTokenID=" << creatorTokenID << " entityID=" << entityID
<< " getIsViewing()=" << getIsViewing();
}
lockForWrite();
@ -638,24 +638,24 @@ void EntityTree::findEntities(const AACube& cube, QVector<EntityItem*> foundEnti
}
const EntityItem* EntityTree::findEntityByID(uint32_t id, bool alreadyLocked) const {
EntityItemID modelID(id);
EntityItemID entityID(id);
bool wantDebug = false;
if (wantDebug) {
qDebug() << "EntityTree::findEntityByID()...";
qDebug() << " id=" << id;
qDebug() << " modelID=" << modelID;
qDebug() << " entityID=" << entityID;
qDebug() << "_modelToElementMap=" << _modelToElementMap;
}
return findEntityByEntityItemID(modelID);
return findEntityByEntityItemID(entityID);
}
const EntityItem* EntityTree::findEntityByEntityItemID(const EntityItemID& modelID) const {
const EntityItem* EntityTree::findEntityByEntityItemID(const EntityItemID& entityID) const {
const EntityItem* foundEntity = NULL;
EntityTreeElement* containingElement = getContainingElement(modelID);
EntityTreeElement* containingElement = getContainingElement(entityID);
if (containingElement) {
foundEntity = containingElement->getEntityWithEntityItemID(modelID);
foundEntity = containingElement->getEntityWithEntityItemID(entityID);
}
return foundEntity;
}
@ -829,10 +829,10 @@ bool EntityTree::encodeEntitysDeletedSince(OCTREE_PACKET_SEQUENCE sequenceNumber
// if the timestamp is more recent then out last sent time, include it
if (iterator.key() > sinceTime) {
uint32_t modelID = values.at(valueItem);
memcpy(copyAt, &modelID, sizeof(modelID));
copyAt += sizeof(modelID);
outputLength += sizeof(modelID);
uint32_t entityID = values.at(valueItem);
memcpy(copyAt, &entityID, sizeof(entityID));
copyAt += sizeof(entityID);
outputLength += sizeof(entityID);
numberOfIds++;
// check to make sure we have room for one more id...
@ -916,12 +916,12 @@ void EntityTree::processEraseMessage(const QByteArray& dataByteArray, const Shar
break; // bail to prevent buffer overflow
}
uint32_t modelID = 0; // placeholder for now
memcpy(&modelID, dataAt, sizeof(modelID));
dataAt += sizeof(modelID);
processedBytes += sizeof(modelID);
uint32_t entityID = 0; // placeholder for now
memcpy(&entityID, dataAt, sizeof(entityID));
dataAt += sizeof(entityID);
processedBytes += sizeof(entityID);
EntityItemID entityItemID(modelID);
EntityItemID entityItemID(entityID);
modelItemIDsToDelete << entityItemID;
}
deleteEntitys(modelItemIDsToDelete);

122
libraries/entities/src/EntityTreeElement.cpp
View file

@ -1,6 +1,6 @@
//
// EntityTreeElement.cpp
// libraries/models/src
// libraries/entities/src
//
// Created by Brad Hefta-Gaub on 12/4/13.
// Copyright 2013 High Fidelity, Inc.
@ -51,8 +51,8 @@ EntityTreeElement* EntityTreeElement::addChildAtIndex(int index) {
}
// TODO: This will attempt to store as many models as will fit in the packetData, if an individual model won't
// fit, but some models did fit, then the element outputs what can fit. Once the general Octree::encodeXXX()
// TODO: This will attempt to store as many entities as will fit in the packetData, if an individual entity won't
// fit, but some entities did fit, then the element outputs what can fit. Once the general Octree::encodeXXX()
// process supports partial encoding of an octree element, this will need to be updated to handle spanning its
// contents across multiple packets.
OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData* packetData,
@ -62,35 +62,35 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
// first, check the params.extraEncodeData to see if there's any partial re-encode data for this element
OctreeElementExtraEncodeData* extraEncodeData = params.extraEncodeData;
EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData = NULL;
EntityTreeElementExtraEncodeData* entityTreeElementExtraEncodeData = NULL;
bool hadElementExtraData = false;
if (extraEncodeData && extraEncodeData->contains(this)) {
modelTreeElementExtraEncodeData = static_cast<EntityTreeElementExtraEncodeData*>(extraEncodeData->value(this));
entityTreeElementExtraEncodeData = static_cast<EntityTreeElementExtraEncodeData*>(extraEncodeData->value(this));
hadElementExtraData = true;
} else {
// if there wasn't one already, then create one
modelTreeElementExtraEncodeData = new EntityTreeElementExtraEncodeData();
entityTreeElementExtraEncodeData = new EntityTreeElementExtraEncodeData();
}
LevelDetails elementLevel = packetData->startLevel();
// write our models out... first determine which of the models are in view based on our params
// write our entities out... first determine which of the entities are in view based on our params
uint16_t numberOfEntities = 0;
uint16_t actualNumberOfEntities = 0;
QVector<uint16_t> indexesOfEntitiesToInclude;
for (uint16_t i = 0; i < _entityItems->size(); i++) {
const EntityItem& model = (*_entityItems)[i];
const EntityItem& entity = (*_entityItems)[i];
bool includeThisEntity = true;
if (hadElementExtraData) {
includeThisEntity = modelTreeElementExtraEncodeData->includedItems.contains(model.getEntityItemID());
includeThisEntity = entityTreeElementExtraEncodeData->includedItems.contains(entity.getEntityItemID());
}
if (includeThisEntity && params.viewFrustum) {
AACube modelCube = model.getAACube();
modelCube.scale(TREE_SCALE);
if (params.viewFrustum->cubeInFrustum(modelCube) == ViewFrustum::OUTSIDE) {
AACube entityCube = entity.getAACube();
entityCube.scale(TREE_SCALE);
if (params.viewFrustum->cubeInFrustum(entityCube) == ViewFrustum::OUTSIDE) {
includeThisEntity = false; // out of view, don't include it
}
}
@ -106,30 +106,30 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
if (successAppendEntityCount) {
foreach (uint16_t i, indexesOfEntitiesToInclude) {
const EntityItem& model = (*_entityItems)[i];
const EntityItem& entity = (*_entityItems)[i];
LevelDetails modelLevel = packetData->startLevel();
LevelDetails entityLevel = packetData->startLevel();
OctreeElement::AppendState appendEntityState = model.appendEntityData(packetData, params, modelTreeElementExtraEncodeData);
OctreeElement::AppendState appendEntityState = entity.appendEntityData(packetData, params, entityTreeElementExtraEncodeData);
// If none of this model data was able to be appended, then discard it
// and don't include it in our model count
// If none of this entity data was able to be appended, then discard it
// and don't include it in our entity count
if (appendEntityState == OctreeElement::NONE) {
packetData->discardLevel(modelLevel);
packetData->discardLevel(entityLevel);
} else {
// If either ALL or some of it got appended, then end the level (commit it)
// and include the model in our final count of models
packetData->endLevel(modelLevel);
// and include the entity in our final count of entities
packetData->endLevel(entityLevel);
actualNumberOfEntities++;
}
// If the model item got completely appended, then we can remove it from the extra encode data
// If the entity item got completely appended, then we can remove it from the extra encode data
if (appendEntityState == OctreeElement::COMPLETED) {
modelTreeElementExtraEncodeData->includedItems.remove(model.getEntityItemID());
entityTreeElementExtraEncodeData->includedItems.remove(entity.getEntityItemID());
}
// If any part of the model items didn't fit, then the element is considered partial
// NOTE: if the model item didn't fit or only partially fit, then the model item should have
// If any part of the entity items didn't fit, then the element is considered partial
// NOTE: if the entity item didn't fit or only partially fit, then the entity item should have
// added itself to the extra encode data.
if (appendEntityState != OctreeElement::COMPLETED) {
appendElementState = OctreeElement::PARTIAL;
@ -137,32 +137,32 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
}
}
// If we were provided with extraEncodeData, and we allocated and/or got modelTreeElementExtraEncodeData
// If we were provided with extraEncodeData, and we allocated and/or got entityTreeElementExtraEncodeData
// then we need to do some additional processing, namely make sure our extraEncodeData is up to date for
// this octree element.
if (extraEncodeData && modelTreeElementExtraEncodeData) {
if (extraEncodeData && entityTreeElementExtraEncodeData) {
// If after processing we have some includedItems left in it, then make sure we re-add it back to our map
if (modelTreeElementExtraEncodeData->includedItems.size()) {
extraEncodeData->insert(this, modelTreeElementExtraEncodeData);
if (entityTreeElementExtraEncodeData->includedItems.size()) {
extraEncodeData->insert(this, entityTreeElementExtraEncodeData);
} else {
// otherwise, clean things up...
extraEncodeData->remove(this);
delete modelTreeElementExtraEncodeData;
delete entityTreeElementExtraEncodeData;
}
}
// Determine if no models at all were able to fit
// Determine if no entities at all were able to fit
bool noEntitiesFit = (numberOfEntities > 0 && actualNumberOfEntities == 0);
// If we wrote fewer models than we expected, update the number of models in our packet
// If we wrote fewer entities than we expected, update the number of entities in our packet
bool successUpdateEntityCount = true;
if (!noEntitiesFit && numberOfEntities != actualNumberOfEntities) {
successUpdateEntityCount = packetData->updatePriorBytes(numberOfEntitiesOffset,
(const unsigned char*)&actualNumberOfEntities, sizeof(actualNumberOfEntities));
}
// If we weren't able to update our model count, or we couldn't fit any models, then
// If we weren't able to update our entity count, or we couldn't fit any entities, then
// we should discard our element and return a result of NONE
if (!successUpdateEntityCount || noEntitiesFit) {
packetData->discardLevel(elementLevel);
@ -174,15 +174,15 @@ OctreeElement::AppendState EntityTreeElement::appendElementData(OctreePacketData
return appendElementState;
}
bool EntityTreeElement::containsEntityBounds(const EntityItem& model) const {
glm::vec3 clampedMin = glm::clamp(model.getMinimumPoint(), 0.0f, 1.0f);
glm::vec3 clampedMax = glm::clamp(model.getMaximumPoint(), 0.0f, 1.0f);
bool EntityTreeElement::containsEntityBounds(const EntityItem& entity) const {
glm::vec3 clampedMin = glm::clamp(entity.getMinimumPoint(), 0.0f, 1.0f);
glm::vec3 clampedMax = glm::clamp(entity.getMaximumPoint(), 0.0f, 1.0f);
return _cube.contains(clampedMin) && _cube.contains(clampedMax);
}
bool EntityTreeElement::bestFitEntityBounds(const EntityItem& model) const {
glm::vec3 clampedMin = glm::clamp(model.getMinimumPoint(), 0.0f, 1.0f);
glm::vec3 clampedMax = glm::clamp(model.getMaximumPoint(), 0.0f, 1.0f);
bool EntityTreeElement::bestFitEntityBounds(const EntityItem& entity) const {
glm::vec3 clampedMin = glm::clamp(entity.getMinimumPoint(), 0.0f, 1.0f);
glm::vec3 clampedMax = glm::clamp(entity.getMaximumPoint(), 0.0f, 1.0f);
if (_cube.contains(clampedMin) && _cube.contains(clampedMax)) {
int childForMinimumPoint = getMyChildContainingPoint(clampedMin);
int childForMaximumPoint = getMyChildContainingPoint(clampedMax);
@ -192,7 +192,7 @@ bool EntityTreeElement::bestFitEntityBounds(const EntityItem& model) const {
return true;
}
// If I contain both the minimum and maximum point, but two different children of mine
// contain those points, then I am the best fit for that model
// contain those points, then I am the best fit for that entity
if (childForMinimumPoint != childForMaximumPoint) {
return true;
}
@ -202,24 +202,24 @@ bool EntityTreeElement::bestFitEntityBounds(const EntityItem& model) const {
void EntityTreeElement::update(EntityTreeUpdateArgs& args) {
args._totalElements++;
// update our contained models
QList<EntityItem>::iterator modelItr = _entityItems->begin();
while(modelItr != _entityItems->end()) {
EntityItem& model = (*modelItr);
// update our contained entities
QList<EntityItem>::iterator entityItr = _entityItems->begin();
while(entityItr != _entityItems->end()) {
EntityItem& entity = (*entityItr);
args._totalItems++;
// TODO: this _lastChanged isn't actually changing because we're not marking this element as changed.
// how do we want to handle this??? We really only want to consider an element changed when it is
// edited... not just animated...
model.update(_lastChanged);
entity.update(_lastChanged);
// If the model wants to die, or if it's left our bounding box, then move it
// into the arguments moving models. These will be added back or deleted completely
if (model.getShouldBeDeleted() || !bestFitEntityBounds(model)) {
args._movingEntities.push_back(model);
// If the entity wants to die, or if it's left our bounding box, then move it
// into the arguments moving entities. These will be added back or deleted completely
if (entity.getShouldBeDeleted() || !bestFitEntityBounds(entity)) {
args._movingEntities.push_back(entity);
// erase this model
modelItr = _entityItems->erase(modelItr);
// erase this entity
entityItr = _entityItems->erase(entityItr);
args._movingItems++;
@ -227,11 +227,11 @@ void EntityTreeElement::update(EntityTreeUpdateArgs& args) {
markWithChangedTime();
// TODO: is this a good place to change the containing element map???
qDebug() << "EntityTreeElement::update()... calling _myTree->setContainingElement(model.getEntityItemID(), NULL); ********";
_myTree->setContainingElement(model.getEntityItemID(), NULL);
qDebug() << "EntityTreeElement::update()... calling _myTree->setContainingElement(entity.getEntityItemID(), NULL); ********";
_myTree->setContainingElement(entity.getEntityItemID(), NULL);
} else {
++modelItr;
++entityItr;
}
}
}
@ -240,7 +240,7 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face,
void** intersectedObject) {
// only called if we do intersect our bounding cube, but find if we actually intersect with models...
// only called if we do intersect our bounding cube, but find if we actually intersect with entities...
QList<EntityItem>::iterator entityItr = _entityItems->begin();
QList<EntityItem>::const_iterator entityEnd = _entityItems->end();
@ -350,7 +350,7 @@ bool EntityTreeElement::findSpherePenetration(const glm::vec3& center, float rad
return false;
}
// TODO: the old model code has support for sittingPoints... need to determine how to handle this...
// TODO: the old entity code has support for sittingPoints... need to determine how to handle this...
// for local editors, the old updateModels(id, properties) had this code...
// if (found) {
// thisModel.setProperties(properties);
@ -368,7 +368,7 @@ bool EntityTreeElement::updateEntity(const EntityItem& entity) {
// NOTE: this method must first lookup the entity by ID, hence it is O(N)
// and "entity is not found" is worst-case (full N) but maybe we don't care?
// (guaranteed that num entitys per elemen is small?)
// (guaranteed that num entities per elemen is small?)
uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) {
EntityItem& thisEntity = (*_entityItems)[i];
@ -437,9 +437,9 @@ void EntityTreeElement::updateEntityItemID(FindAndUpdateEntityItemIDArgs* args)
}
}
// if we're in an isViewing tree, we also need to look for an kill any viewed entitys
// if we're in an isViewing tree, we also need to look for an kill any viewed entities
if (!args->viewedEntityFound && args->isViewing) {
if (thisEntity.getCreatorTokenID() == UNKNOWN_MODEL_TOKEN && thisEntity.getID() == args->entityID) {
if (thisEntity.getCreatorTokenID() == UNKNOWN_ENTITY_TOKEN && thisEntity.getID() == args->entityID) {
if (wantDebug) {
qDebug() << "EntityTreeElement::updateEntityItemID()... VIEWED entity FOUND??? "
@ -502,7 +502,7 @@ void EntityTreeElement::getEntities(const AACube& box, QVector<EntityItem*>& fou
}
const EntityItem* EntityTreeElement::getEntityWithID(uint32_t id) const {
// NOTE: this lookup is O(N) but maybe we don't care? (guaranteed that num entitys per elemen is small?)
// NOTE: this lookup is O(N) but maybe we don't care? (guaranteed that num entities per elemen is small?)
const EntityItem* foundEntity = NULL;
uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) {
@ -515,7 +515,7 @@ const EntityItem* EntityTreeElement::getEntityWithID(uint32_t id) const {
}
const EntityItem* EntityTreeElement::getEntityWithEntityItemID(const EntityItemID& id) const {
// NOTE: this lookup is O(N) but maybe we don't care? (guaranteed that num entitys per elemen is small?)
// NOTE: this lookup is O(N) but maybe we don't care? (guaranteed that num entities per elemen is small?)
const EntityItem* foundEntity = NULL;
uint16_t numberOfEntities = _entityItems->size();
for (uint16_t i = 0; i < numberOfEntities; i++) {
@ -571,7 +571,7 @@ int EntityTreeElement::readElementDataFromBuffer(const unsigned char* data, int
int expectedBytesPerEntity = EntityItem::expectedBytes();
if (bytesLeftToRead >= (int)sizeof(numberOfEntities)) {
// read our entitys in....
// read our entities in....
numberOfEntities = *(uint16_t*)dataAt;
dataAt += sizeof(numberOfEntities);

2
libraries/networking/src/PacketHeaders.cpp
View file

@ -75,7 +75,7 @@ PacketVersion versionForPacketType(PacketType type) {
case PacketTypeParticleErase:
return 1;
case PacketTypeEntityData:
return VERSION_MODELS_SUPPORT_SPLIT_MTU;
return VERSION_ENTITIES_SUPPORT_SPLIT_MTU;
case PacketTypeEntityErase:
return 1;
default:

4
libraries/networking/src/PacketHeaders.h
View file

@ -111,8 +111,8 @@ PacketType packetTypeForPacket(const char* packet);
int arithmeticCodingValueFromBuffer(const char* checkValue);
int numBytesArithmeticCodingFromBuffer(const char* checkValue);
const PacketVersion VERSION_MODELS_HAVE_ANIMATION = 1;
const PacketVersion VERSION_ENTITIES_HAVE_ANIMATION = 1;
const PacketVersion VERSION_ROOT_ELEMENT_HAS_DATA = 2;
const PacketVersion VERSION_MODELS_SUPPORT_SPLIT_MTU = 3;
const PacketVersion VERSION_ENTITIES_SUPPORT_SPLIT_MTU = 3;
#endif // hifi_PacketHeaders_h