Qt::ItemFlags VirtualSystemModel::flags(const QModelIndex &idx) const { if (!idx.isValid()) return 0; ModelItem *item = static_cast<ModelItem*>(idx.internalPointer()); return Qt::ItemIsEnabled | Qt::ItemIsSelectable | item->itemFlags(idx.column()); }
bool VirtualSystemSortProxyModel::lessThan(const QModelIndex &leftIdx, const QModelIndex &rightIdx) const { if (!leftIdx.isValid() || !rightIdx.isValid()) return false; ModelItem *pLeftItem = static_cast<ModelItem*>(leftIdx.internalPointer()); ModelItem *pRightItem = static_cast<ModelItem*>(rightIdx.internalPointer()); /* We sort hardware types only */ if (!(pLeftItem->type() == HardwareType && pRightItem->type() == HardwareType)) return false; HardwareItem *pHwLeft = static_cast<HardwareItem*>(pLeftItem); HardwareItem *pHwRight = static_cast<HardwareItem*>(pRightItem); for (unsigned int i = 0; i < RT_ELEMENTS(m_sortList); ++i) if (pHwLeft->m_type == m_sortList[i]) { for (unsigned int a = 0; a <= i; ++a) if (pHwRight->m_type == m_sortList[a]) return true; return false; } return true; }
void TransfersView::slotItemActivated(const QModelIndex & index) { if (!index.isValid()) return; TransferTreeModel * transferTreeModel = KGet::model(); ModelItem * item = transferTreeModel->itemFromIndex(index); TransfersViewDelegate *view_delegate = static_cast <TransfersViewDelegate *> (itemDelegate()); if(!item) return; if(!item->isGroup() && index.column() == 0) { if(!view_delegate->isExtended(index)) { TransferHandler *handler = item->asTransfer()->transferHandler(); QWidget *widget = getDetailsWidgetForTransfer(handler); m_editingIndexes.append(index); view_delegate->extendItem(widget, index); } else { m_editingIndexes.removeAll(index); view_delegate->contractItem(index); } KGet::actionCollection()->action("transfer_show_details")->setChecked(view_delegate->isExtended(index)); } else if (!item->isGroup() && static_cast<TransferModelItem*>(item)->transferHandler()->status() == Job::Finished) { new KRun(static_cast<TransferModelItem*>(item)->transferHandler()->dest(), this); } }
int ModelTreeElement::readElementDataFromBuffer(const unsigned char* data, int bytesLeftToRead, ReadBitstreamToTreeParams& args) { const unsigned char* dataAt = data; int bytesRead = 0; uint16_t numberOfModels = 0; int expectedBytesPerModel = ModelItem::expectedBytes(); if (bytesLeftToRead >= (int)sizeof(numberOfModels)) { // read our models in.... numberOfModels = *(uint16_t*)dataAt; dataAt += sizeof(numberOfModels); bytesLeftToRead -= (int)sizeof(numberOfModels); bytesRead += sizeof(numberOfModels); if (bytesLeftToRead >= (int)(numberOfModels * expectedBytesPerModel)) { for (uint16_t i = 0; i < numberOfModels; i++) { ModelItem tempModel; int bytesForThisModel = tempModel.readModelDataFromBuffer(dataAt, bytesLeftToRead, args); _myTree->storeModel(tempModel); dataAt += bytesForThisModel; bytesLeftToRead -= bytesForThisModel; bytesRead += bytesForThisModel; } } } return bytesRead; }
QVariant VirtualSystemModel::data(const QModelIndex &idx, int role /* = Qt::DisplayRole */) const { if (!idx.isValid()) return QVariant(); ModelItem *item = static_cast<ModelItem*>(idx.internalPointer()); return item->data(idx.column(), role); }
bool VirtualSystemModel::setData(const QModelIndex &idx, const QVariant &value, int role) { if (!idx.isValid()) return false; ModelItem *item = static_cast<ModelItem*>(idx.internalPointer()); return item->setData(idx.column(), value, role); }
void RenameCommand::unexecute ( void ) { ModelItem* item = model_->lookup( new_db_url_ ); if ( item == 0 ) { cerr << "Yikes, item did not exist!" << endl; return; } item->setName( old_db_url_.name() ); }
int VirtualSystemModel::rowCount(const QModelIndex &parentIdx /* = QModelIndex() */) const { ModelItem *parentItem; if (parentIdx.column() > 0) return 0; if (!parentIdx.isValid()) parentItem = m_pRootItem; else parentItem = static_cast<ModelItem*>(parentIdx.internalPointer()); return parentItem->childCount(); }
void VirtualSystemDelegate::setModelData(QWidget *pEditor, QAbstractItemModel *pModel, const QModelIndex &idx) const { if (!idx.isValid()) return QItemDelegate::setModelData(pEditor, pModel, idx); QModelIndex index = pModel->index(idx.row(), idx.column()); if (mProxy) index = mProxy->mapToSource(idx); ModelItem *item = static_cast<ModelItem*>(index.internalPointer()); if (!item->setModelData(pEditor, pModel, idx)) QItemDelegate::setModelData(pEditor, pModel, idx); }
bool ModelTreeElement::bestFitModelBounds(const ModelItem& model) const { if (_box.contains(model.getMinimumPoint()) && _box.contains(model.getMaximumPoint())) { int childForMinimumPoint = getMyChildContainingPoint(model.getMinimumPoint()); int childForMaximumPoint = getMyChildContainingPoint(model.getMaximumPoint()); // 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 if (childForMinimumPoint != childForMaximumPoint) { return true; } } return false; }
QModelIndex VirtualSystemModel::parent(const QModelIndex &idx) const { if (!idx.isValid()) return QModelIndex(); ModelItem *childItem = static_cast<ModelItem*>(idx.internalPointer()); ModelItem *parentItem = childItem->parent(); if (parentItem == m_pRootItem) return QModelIndex(); return createIndex(parentItem->row(), 0, parentItem); }
void VirtualSystemDelegate::setEditorData(QWidget *pEditor, const QModelIndex &idx) const { if (!idx.isValid()) return QItemDelegate::setEditorData(pEditor, idx); QModelIndex index(idx); if (mProxy) index = mProxy->mapToSource(idx); ModelItem *item = static_cast<ModelItem*>(index.internalPointer()); if (!item->setEditorData(pEditor, index)) QItemDelegate::setEditorData(pEditor, index); }
void AutoMateUi::tweakContextMenu(const QPoint &p) { QModelIndex index = tweaks_view->indexAt(p); if (!index.isValid()) return; index = tweaksProxyModel->mapToSource(index); QMenu *menu = new QMenu(this); ModelItem *item = static_cast<ModelItem*>(index.internalPointer()); selectedTweakFileName = item->data(1).toString(); if (selectedTweakFileName.size() ==0) return; QAction *action = menu->addAction(QString("Edit %1").arg(selectedTweakFileName)); connect(action, SIGNAL(triggered()), SLOT(editSelectedTweak())); menu->exec(tweaks_view->viewport()->mapToGlobal(p)); }
void VirtualSystemModel::restoreDefaults(const QModelIndex &parentIdx /* = QModelIndex() */) { ModelItem *parentItem; if (!parentIdx.isValid()) parentItem = m_pRootItem; else parentItem = static_cast<ModelItem*>(parentIdx.internalPointer()); for (int i = 0; i < parentItem->childCount(); ++i) { parentItem->child(i)->restoreDefaults(); restoreDefaults(index(i, 0, parentIdx)); } emit dataChanged(index(0, 0, parentIdx), index(parentItem->childCount()-1, 0, parentIdx)); }
QWidget *VirtualSystemDelegate::createEditor(QWidget *pParent, const QStyleOptionViewItem &styleOption, const QModelIndex &idx) const { if (!idx.isValid()) return QItemDelegate::createEditor(pParent, styleOption, idx); QModelIndex index(idx); if (mProxy) index = mProxy->mapToSource(idx); ModelItem *item = static_cast<ModelItem*>(index.internalPointer()); QWidget *editor = item->createEditor(pParent, styleOption, index); if (editor == NULL) return QItemDelegate::createEditor(pParent, styleOption, index); else return editor; }
void ModelTreeElement::getModelsForUpdate(const AABox& box, QVector<ModelItem*>& foundModels) { QList<ModelItem>::iterator modelItr = _modelItems->begin(); QList<ModelItem>::iterator modelEnd = _modelItems->end(); AABox modelBox; while(modelItr != modelEnd) { ModelItem* model = &(*modelItr); float radius = model->getRadius(); // NOTE: we actually do box-box collision queries here, which is sloppy but good enough for now // TODO: decide whether to replace modelBox-box query with sphere-box (requires a square root // but will be slightly more accurate). modelBox.setBox(model->getPosition() - glm::vec3(radius), 2.f * radius); if (modelBox.touches(_box)) { foundModels.push_back(model); } ++modelItr; } }
Command *Command::opActivateTexture(const ResourceReference &textureRef) { TextureSet *texture = textureRef.resolve<TextureSet>(); Item *item = texture->findParent<Item>(); if (!item || (item->getSubType() != Item::kItemGlobalTemplate && item->getSubType() != Item::kItemLevelTemplate && item->getSubType() != Item::kItemModel)) { return nextCommand(); } if (item->getSubType() == Item::kItemModel) { ModelItem *modelItem = Object::cast<ModelItem>(item); modelItem->setTexture(texture->getIndex(), texture->getSubType()); } else { ItemTemplate *templateItem = Object::cast<ItemTemplate>(item); templateItem->setTexture(texture->getIndex(), texture->getSubType()); } return nextCommand(); }
Command *Command::opActivateMesh(const ResourceReference &meshRef) { BonesMesh *mesh = meshRef.resolve<BonesMesh>(); Item *item = mesh->findParent<Item>(); if (!item || (item->getSubType() != Item::kItemGlobalTemplate && item->getSubType() != Item::kItemLevelTemplate && item->getSubType() != Item::kItemModel)) { return nextCommand(); } if (item->getSubType() == Item::kItemModel) { ModelItem *modelItem = Object::cast<ModelItem>(item); modelItem->setBonesMesh(mesh->getIndex()); } else { ItemTemplate *templateItem = Object::cast<ItemTemplate>(item); templateItem->setBonesMesh(mesh->getIndex()); } return nextCommand(); }
QModelIndex VirtualSystemModel::index(int row, int column, const QModelIndex &parentIdx /* = QModelIndex() */) const { if (!hasIndex(row, column, parentIdx)) return QModelIndex(); ModelItem *parentItem; if (!parentIdx.isValid()) parentItem = m_pRootItem; else parentItem = static_cast<ModelItem*>(parentIdx.internalPointer()); ModelItem *childItem = parentItem->child(row); if (childItem) return createIndex(row, column, childItem); else return QModelIndex(); }
bool ModelTreeElement::bestFitModelBounds(const ModelItem& model) const { glm::vec3 clampedMin = glm::clamp(model.getMinimumPoint(), 0.0f, 1.0f); glm::vec3 clampedMax = glm::clamp(model.getMaximumPoint(), 0.0f, 1.0f); if (_box.contains(clampedMin) && _box.contains(clampedMax)) { int childForMinimumPoint = getMyChildContainingPoint(clampedMin); int childForMaximumPoint = getMyChildContainingPoint(clampedMax); // if this is a really small box, then it's close enough! if (_box.getScale() <= SMALLEST_REASONABLE_OCTREE_ELEMENT_SCALE) { 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 if (childForMinimumPoint != childForMaximumPoint) { return true; } } return false; }
void MainWindow::setupDockWindows() { // Try to read JSBSim legacy files. JSBSimReader reader; reader.addAircraftPath("/home/flightgear/sw/share/FlightGear/Aircraft/FA-18/"); reader.addEnginePath("/home/flightgear/sw/share/FlightGear/Aircraft/FA-18/Engines/"); reader.loadAircraft("FA-18-cross.xml"); if (reader.getErrorState()) { const ReaderWriter::StringList errors = reader.getErrors(); ReaderWriter::StringList::const_iterator it; for (it = errors.begin(); it != errors.end(); ++it) std::cerr << *it << std::endl; return; } // Ok, now the Vehicle here contains the imported data // When the reflection stuff is ready, we can dump that data to a // native format ... reader.getVehicle()->getSystem()->init(); ModelItem* model = new ModelItem; model->setSystem(reader.getVehicle()->getSystem()); QDockWidget* dockWidget = new QDockWidget(this); QTreeView* treeView = new QTreeView(dockWidget); treeView->setModel(model); dockWidget->setWidget(treeView); addDockWidget(Qt::LeftDockWidgetArea, dockWidget); FrameItem* frameModel = new FrameItem; frameModel->setRootFrame(reader.getVehicle()->getSystem()->getEnvironment()->getRootFrame()); dockWidget = new QDockWidget(this); treeView = new QTreeView(dockWidget); treeView->setModel(frameModel); dockWidget->setWidget(treeView); addDockWidget(Qt::RightDockWidgetArea, dockWidget); }
void TransfersView::slotItemCollapsed(const QModelIndex & index) { if (!index.isValid()) return; TransferTreeModel * transferTreeModel = KGet::model(); ModelItem * item = transferTreeModel->itemFromIndex(index); TransfersViewDelegate *view_delegate = static_cast <TransfersViewDelegate *> (itemDelegate()); if(!item) return; if(item->isGroup()) { TransferGroupHandler * groupHandler = item->asGroup()->groupHandler(); QList<TransferHandler *> transfers = groupHandler->transfers(); foreach(TransferHandler * transfer, transfers) { kDebug(5001) << "Transfer = " << transfer->source().prettyUrl(); view_delegate->contractItem(KGet::model()->itemFromTransferHandler(transfer)->index()); }
void AnimSkeleton::applyToItem(Item *item) { Anim::applyToItem(item); if (!_loop) { _currentTime = 0; } if (_currentTime > _totalTime) { _currentTime = 0; } ModelItem *modelItem = Object::cast<ModelItem>(item); BonesMesh *mesh = modelItem->findBonesMesh(); TextureSet *texture = modelItem->findTextureSet(TextureSet::kTextureNormal); _visual->setModel(mesh->getModel()); _visual->setTexture(texture->getTexture()); _visual->setAnim(_seletonAnim); _visual->setTime(_currentTime); }
bool VirtualSystemSortProxyModel::filterAcceptsRow(int srcRow, const QModelIndex & srcParenIdx) const { /* By default enable all, we will explicitly filter out below */ if (srcParenIdx.isValid()) { QModelIndex i = srcParenIdx.child(srcRow, 0); if (i.isValid()) { ModelItem *item = static_cast<ModelItem*>(i.internalPointer()); /* We filter hardware types only */ if (item->type() == HardwareType) { HardwareItem *hwItem = static_cast<HardwareItem*>(item); /* The license type shouldn't be displayed */ if (m_filterList.contains(hwItem->m_type)) return false; } } } return true; }
void ModelServer::modelCreated(const ModelItem& newModel, const SharedNodePointer& senderNode) { unsigned char outputBuffer[MAX_PACKET_SIZE]; unsigned char* copyAt = outputBuffer; int numBytesPacketHeader = populatePacketHeader(reinterpret_cast<char*>(outputBuffer), PacketTypeModelAddResponse); int packetLength = numBytesPacketHeader; copyAt += numBytesPacketHeader; // encode the creatorTokenID uint32_t creatorTokenID = newModel.getCreatorTokenID(); memcpy(copyAt, &creatorTokenID, sizeof(creatorTokenID)); copyAt += sizeof(creatorTokenID); packetLength += sizeof(creatorTokenID); // encode the model ID uint32_t modelID = newModel.getID(); memcpy(copyAt, &modelID, sizeof(modelID)); copyAt += sizeof(modelID); packetLength += sizeof(modelID); NodeList::getInstance()->writeDatagram((char*) outputBuffer, packetLength, senderNode); }
int ModelTreeElement::readElementDataFromBuffer(const unsigned char* data, int bytesLeftToRead, ReadBitstreamToTreeParams& args) { // If we're the root, but this bitstream doesn't support root elements with data, then // return without reading any bytes if (this == _myTree->getRoot() && args.bitstreamVersion < VERSION_ROOT_ELEMENT_HAS_DATA) { qDebug() << "ROOT ELEMENT: no root data for " "bitstreamVersion=" << (int)args.bitstreamVersion << " bytesLeftToRead=" << bytesLeftToRead; return 0; } const unsigned char* dataAt = data; int bytesRead = 0; uint16_t numberOfModels = 0; int expectedBytesPerModel = ModelItem::expectedBytes(); if (bytesLeftToRead >= (int)sizeof(numberOfModels)) { // read our models in.... numberOfModels = *(uint16_t*)dataAt; dataAt += sizeof(numberOfModels); bytesLeftToRead -= (int)sizeof(numberOfModels); bytesRead += sizeof(numberOfModels); if (bytesLeftToRead >= (int)(numberOfModels * expectedBytesPerModel)) { for (uint16_t i = 0; i < numberOfModels; i++) { ModelItem tempModel; int bytesForThisModel = tempModel.readModelDataFromBuffer(dataAt, bytesLeftToRead, args); _myTree->storeModel(tempModel); dataAt += bytesForThisModel; bytesLeftToRead -= bytesForThisModel; bytesRead += bytesForThisModel; } } } return bytesRead; }
void ModelItemProperties::copyToModelItem(ModelItem& modelItem) const { bool somethingChanged = false; if (_positionChanged) { modelItem.setPosition(_position / (float) TREE_SCALE); somethingChanged = true; } if (_colorChanged) { modelItem.setColor(_color); somethingChanged = true; } if (_radiusChanged) { modelItem.setRadius(_radius / (float) TREE_SCALE); somethingChanged = true; } if (_shouldDieChanged) { modelItem.setShouldDie(_shouldDie); somethingChanged = true; } if (_modelURLChanged) { modelItem.setModelURL(_modelURL); somethingChanged = true; } if (_modelRotationChanged) { modelItem.setModelRotation(_modelRotation); somethingChanged = true; } if (somethingChanged) { bool wantDebug = false; if (wantDebug) { uint64_t now = usecTimestampNow(); int elapsed = now - _lastEdited; qDebug() << "ModelItemProperties::copyToModelItem() AFTER update... edited AGO=" << elapsed << "now=" << now << " _lastEdited=" << _lastEdited; } modelItem.setLastEdited(_lastEdited); } }
void ModelItemProperties::copyFromModelItem(const ModelItem& modelItem) { _position = modelItem.getPosition() * (float) TREE_SCALE; _color = modelItem.getXColor(); _radius = modelItem.getRadius() * (float) TREE_SCALE; _shouldDie = modelItem.getShouldDie(); _modelURL = modelItem.getModelURL(); _modelRotation = modelItem.getModelRotation(); _id = modelItem.getID(); _idSet = true; _positionChanged = false; _colorChanged = false; _radiusChanged = false; _shouldDieChanged = false; _modelURLChanged = false; _modelRotationChanged = false; _defaultSettings = false; }
bool ModelTreeElement::updateModel(const ModelItem& model) { // NOTE: this method must first lookup the model by ID, hence it is O(N) // and "model is not found" is worst-case (full N) but maybe we don't care? // (guaranteed that num models per elemen is small?) const bool wantDebug = false; uint16_t numberOfModels = _modelItems->size(); for (uint16_t i = 0; i < numberOfModels; i++) { ModelItem& thisModel = (*_modelItems)[i]; if (thisModel.getID() == model.getID()) { int difference = thisModel.getLastUpdated() - model.getLastUpdated(); bool changedOnServer = thisModel.getLastEdited() < model.getLastEdited(); bool localOlder = thisModel.getLastUpdated() < model.getLastUpdated(); if (changedOnServer || localOlder) { if (wantDebug) { qDebug("local model [id:%d] %s and %s than server model by %d, model.isNewlyCreated()=%s", model.getID(), (changedOnServer ? "CHANGED" : "same"), (localOlder ? "OLDER" : "NEWER"), difference, debug::valueOf(model.isNewlyCreated()) ); } thisModel.copyChangedProperties(model); markWithChangedTime(); } else { if (wantDebug) { qDebug(">>> IGNORING SERVER!!! Would've caused jutter! <<< " "local model [id:%d] %s and %s than server model by %d, model.isNewlyCreated()=%s", model.getID(), (changedOnServer ? "CHANGED" : "same"), (localOlder ? "OLDER" : "NEWER"), difference, debug::valueOf(model.isNewlyCreated()) ); } } return true; } } return false; }
ModelItem ModelItem::fromEditPacket(const unsigned char* data, int length, int& processedBytes, ModelTree* tree, bool& valid) { ModelItem newModelItem; // id and _lastUpdated will get set here... const unsigned char* dataAt = data; processedBytes = 0; // the first part of the data is our octcode... int octets = numberOfThreeBitSectionsInCode(data); int lengthOfOctcode = bytesRequiredForCodeLength(octets); // we don't actually do anything with this octcode... dataAt += lengthOfOctcode; processedBytes += lengthOfOctcode; // id uint32_t editID; memcpy(&editID, dataAt, sizeof(editID)); dataAt += sizeof(editID); processedBytes += sizeof(editID); bool isNewModelItem = (editID == NEW_MODEL); // special case for handling "new" modelItems if (isNewModelItem) { // If this is a NEW_MODEL, 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)); dataAt += sizeof(creatorTokenID); processedBytes += sizeof(creatorTokenID); newModelItem.setCreatorTokenID(creatorTokenID); newModelItem._newlyCreated = true; valid = true; } else { // look up the existing modelItem const ModelItem* existingModelItem = tree->findModelByID(editID, true); // copy existing properties before over-writing with new properties if (existingModelItem) { newModelItem = *existingModelItem; 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; // NOTE: even though this is a bad editID, we have to consume the edit details, so that // the buffer doesn't get corrupted for further processing... valid = false; } newModelItem._id = editID; newModelItem._newlyCreated = false; } // lastEdited memcpy(&newModelItem._lastEdited, dataAt, sizeof(newModelItem._lastEdited)); dataAt += sizeof(newModelItem._lastEdited); processedBytes += sizeof(newModelItem._lastEdited); // 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 = 0; if (!isNewModelItem) { memcpy(&packetContainsBits, dataAt, sizeof(packetContainsBits)); dataAt += sizeof(packetContainsBits); processedBytes += sizeof(packetContainsBits); } // radius if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_RADIUS) == MODEL_PACKET_CONTAINS_RADIUS)) { memcpy(&newModelItem._radius, dataAt, sizeof(newModelItem._radius)); dataAt += sizeof(newModelItem._radius); processedBytes += sizeof(newModelItem._radius); } // position if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_POSITION) == MODEL_PACKET_CONTAINS_POSITION)) { memcpy(&newModelItem._position, dataAt, sizeof(newModelItem._position)); dataAt += sizeof(newModelItem._position); processedBytes += sizeof(newModelItem._position); } // color if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_COLOR) == MODEL_PACKET_CONTAINS_COLOR)) { memcpy(newModelItem._color, dataAt, sizeof(newModelItem._color)); dataAt += sizeof(newModelItem._color); processedBytes += sizeof(newModelItem._color); } // shouldDie if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_SHOULDDIE) == MODEL_PACKET_CONTAINS_SHOULDDIE)) { memcpy(&newModelItem._shouldDie, dataAt, sizeof(newModelItem._shouldDie)); dataAt += sizeof(newModelItem._shouldDie); processedBytes += sizeof(newModelItem._shouldDie); } // modelURL if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_MODEL_URL) == MODEL_PACKET_CONTAINS_MODEL_URL)) { uint16_t modelURLLength; memcpy(&modelURLLength, dataAt, sizeof(modelURLLength)); dataAt += sizeof(modelURLLength); processedBytes += sizeof(modelURLLength); QString tempString((const char*)dataAt); newModelItem._modelURL = tempString; dataAt += modelURLLength; processedBytes += modelURLLength; } // modelRotation if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_MODEL_ROTATION) == MODEL_PACKET_CONTAINS_MODEL_ROTATION)) { int bytes = unpackOrientationQuatFromBytes(dataAt, newModelItem._modelRotation); dataAt += bytes; processedBytes += bytes; } // animationURL if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_ANIMATION_URL) == MODEL_PACKET_CONTAINS_ANIMATION_URL)) { uint16_t animationURLLength; memcpy(&animationURLLength, dataAt, sizeof(animationURLLength)); dataAt += sizeof(animationURLLength); processedBytes += sizeof(animationURLLength); QString tempString((const char*)dataAt); newModelItem._animationURL = tempString; dataAt += animationURLLength; processedBytes += animationURLLength; } // animationIsPlaying if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_ANIMATION_PLAYING) == MODEL_PACKET_CONTAINS_ANIMATION_PLAYING)) { memcpy(&newModelItem._animationIsPlaying, dataAt, sizeof(newModelItem._animationIsPlaying)); dataAt += sizeof(newModelItem._animationIsPlaying); processedBytes += sizeof(newModelItem._animationIsPlaying); } // animationFrameIndex if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_ANIMATION_FRAME) == MODEL_PACKET_CONTAINS_ANIMATION_FRAME)) { memcpy(&newModelItem._animationFrameIndex, dataAt, sizeof(newModelItem._animationFrameIndex)); dataAt += sizeof(newModelItem._animationFrameIndex); processedBytes += sizeof(newModelItem._animationFrameIndex); } // animationFPS if (isNewModelItem || ((packetContainsBits & MODEL_PACKET_CONTAINS_ANIMATION_FPS) == MODEL_PACKET_CONTAINS_ANIMATION_FPS)) { memcpy(&newModelItem._animationFPS, dataAt, sizeof(newModelItem._animationFPS)); dataAt += sizeof(newModelItem._animationFPS); processedBytes += sizeof(newModelItem._animationFPS); } const bool wantDebugging = false; if (wantDebugging) { qDebug("ModelItem::fromEditPacket()..."); qDebug() << " ModelItem id in packet:" << editID; newModelItem.debugDump(); } return newModelItem; }