dmz::Boolean dmz::NetModulePacketCodecBasic::register_object ( const Handle ObjectHandle, const ObjectType &Type, Marshal &outData) { Boolean result (False); _objTable.remove (ObjectHandle); ObjectType current (Type); EncodeObjectStruct *eos (0); do { eos = _objTypeTable.lookup (current.get_handle ()); current.become_parent (); } while (current && !eos); if (ObjectHandle && eos && _objTable.store (ObjectHandle, eos)) { result = _write_object (ObjectHandle, NetObjectActivate, outData); } return result; }
int CJSONValue::GetCount (void) const // GetCount // // Returns the number of elements { switch (m_iType) { case typeNull: return 0; case typeArray: { ArrayType *pArray = (ArrayType *)m_pValue; return pArray->GetCount(); } case typeObject: { ObjectType *pObj = (ObjectType *)m_pValue; return pObj->GetCount(); } default: return 1; } }
inline ObjectType* ObjectHeap< ObjectType >::AllocateFresh( void ) { ObjectType* object = Allocate(); if( object ) object->Reset(); return object; }
bool CJSONValue::FindElement (const CString &sKey, CJSONValue *retValue) const // FindElement // // Finds a field in a structure { switch (m_iType) { case typeObject: { ObjectType *pObj = (ObjectType *)m_pValue; CJSONValue *pValue = pObj->GetAt(sKey); if (pValue == NULL) return false; if (retValue) *retValue = *pValue; return true; } default: return false; } }
dmz::Boolean dmz::NetModuleLocalDRBasic::update_object (const Handle ObjectHandle) { Boolean result (False); if (_objMod) { const ObjectType Type (_objMod->lookup_object_type (ObjectHandle)); if (Type) { ObjectUpdate *test (_typeTable.lookup (Type.get_handle ())); if (!test) { test = _create_test_from_type (Type); } Boolean limitRate (False); while (test && !result && !limitRate) { result = test->update_object (ObjectHandle, *_objMod, limitRate); test = test->next; } } } return result; }
dmz::Boolean dmz::QtPluginCanvasObjectBasic::_find_config_from_type ( Config &local, ObjectType &objType) { const String Name (get_plugin_name ()); Boolean found (objType.get_config ().lookup_all_config_merged (Name, local)); if (!found) { ObjectType currentType (objType); currentType.become_parent (); while (currentType && !found) { if (currentType.get_config ().lookup_all_config_merged (Name, local)) { found = True; objType = currentType; } currentType.become_parent (); } } return found; }
dmz::QtPluginCanvasObjectBasic::ModelStruct * dmz::QtPluginCanvasObjectBasic::_get_model_struct (const ObjectType &ObjType) { ModelStruct *retVal (_masterModelTable.lookup (ObjType.get_handle ())); if (!retVal) { Config local; ObjectType currentType (ObjType); if (_find_config_from_type (local, currentType)) { ModelStruct *ms (_modelTable.lookup (currentType.get_handle ())); if (!ms) { ms = _config_to_model_struct (local, currentType); if (ms) { _modelTable.store (ms->ObjType.get_handle (), ms); } } retVal = ms; } } if (retVal) { _masterModelTable.store (ObjType.get_handle (), retVal); } return retVal; }
static Rect worldToScreenCoords(const Point3f &_position, const ObjectType &_type, const Point2f &fov_size, const Size &frame_size, float cameraElevation) { // TODO : replace magic numbers with an object depth property // This constant is half a ball diameter (9.75-ish inches), converted to meters // For example, goals will have 0 depth since we're just shooting at // a plane. 3d objects will have depth, though, so we track the center of the // rather than the front. float r = sqrtf(_position.x * _position.x + _position.y * _position.y + _position.z * _position.z); // - (4.572 * 25.4)/1000.0; float azimuth = asinf(_position.x / sqrt(_position.x * _position.x + _position.y * _position.y)); float inclination = asinf( _position.z / r ) + cameraElevation; //inverse of formula in screenToWorldCoords() Point2f dist_to_center( tan(azimuth) * (0.5 * frame_size.width / tan(fov_size.x / 2)), tan(inclination) * (0.5 * frame_size.height / tan(fov_size.y / 2))); cout << "Distance to center: " << dist_to_center << endl; Point2f rect_center( dist_to_center.x + (frame_size.width / 2.0), -dist_to_center.y + (frame_size.height / 2.0)); Point2f angular_size( 2.0 * atan2f(_type.width(), (2.0*r)), 2.0 * atan2f(_type.height(), (2.0*r))); Point2f screen_size( angular_size.x * (frame_size.width / fov_size.x), angular_size.y * (frame_size.height / fov_size.y)); Point topLeft( cvRound(rect_center.x - (screen_size.x / 2.0)), cvRound(rect_center.y - (screen_size.y / 2.0))); return Rect(topLeft.x, topLeft.y, cvRound(screen_size.x), cvRound(screen_size.y)); }
const CJSONValue &CJSONValue::GetElement (int iIndex) const // GetElement // // Returns the element by index { switch (m_iType) { case typeArray: { ArrayType *pArray = (ArrayType *)m_pValue; if (iIndex < 0 || iIndex >= pArray->GetCount()) return g_NullValue; return pArray->GetAt(iIndex); } case typeObject: { ObjectType *pObj = (ObjectType *)m_pValue; if (iIndex < 0 || iIndex >= pObj->GetCount()) return g_NullValue; return pObj->GetValue(iIndex); } default: return g_NullValue; } }
void ObjectType::setLayout(ObjectTypeLayout* l) { if (!l) { cerr << "[WARNING] ObjectType::setLayout: Cannot set layout to 0." << endl; return; } if (layout()) { if (layout() != l) { cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" << l->objectName().cstring(); cerr << "' on ObjectType '" << objectName().cstring() << "', which already has a layout." << endl; } return; } ObjectType* oldParent = l->parent(); if (oldParent && oldParent != this) { if (oldParent->isLayoutType()) { cerr << "[WARNING] ObjectType::setLayout: Attempting to set ObjectTypeLayout '" << l->objectName().cstring(); cerr << "' on ObjectType '" << objectName().cstring() << "', when the ObjectTypeLayout already has a parent layout." << endl; return; } else { // Steal the layout from an ObjectType parent. oldParent->takeLayout(); } } m_layout = l; if (oldParent != this) { l->setParent(this); l->reparentChildren(this); } }
void Module::setSpecification(const ObjectType& parent, const ObjectType& child) { if (!parent.typeTemplate().isVirtual()) { Log::error("Cannot forward ",parent," to ",child," because ",parent.typeTemplate(), " is not virtual "); } const ObjectType* parentPtr = new ObjectType(parent); _automaticSpecifications.insert(std::make_pair(parentPtr, child)); }
ObjectType* ObjectType::createWithChild() { ObjectType* parent = create(); ObjectType* child = create(); child->setObjectName("child"); child->setParent(parent); return parent; }
void ObjectTypeManager::setupObject(IGObject::Ptr obj, uint32_t type){ if(checkValid(type)){ ObjectType* prototype = typeStore[type]; obj->setType(type); prototype->setupObject(obj); }else{ //TODO throw exception? } }
// QtPluginIconPalletTool Interface void dmz::QtPluginIconPalletTool::_add_type (const ObjectType &Type) { const String IconResource = config_to_string ( get_plugin_name () + ".resource", Type.get_config()); const String IconName = _rc.find_file (IconResource); if (IconName) { const String Name = Type.get_name (); if (Name) { QImage back ( (int)_iconExtent, (int)_iconExtent, QImage::Format_ARGB32_Premultiplied); QPainter painter (&back); painter.setCompositionMode (QPainter::CompositionMode_Source); painter.fillRect (back.rect (), Qt::transparent); painter.setCompositionMode (QPainter::CompositionMode_SourceOver); QSvgRenderer qsr (QString (IconName.get_buffer ())); QRectF size = qsr.viewBoxF (); qreal width = size.width (); qreal height = size.height (); qreal scale = (width > height) ? width : height; if (scale <= 0.0f) { scale = 1.0f; } scale = _iconExtent / scale; width *= scale; height *= scale; size.setWidth (width); size.setHeight (height); if (height < _iconExtent) { size.moveTop ((_iconExtent - height) * 0.5f); } if (width < _iconExtent) { size.moveLeft ((_iconExtent - width) * 0.5f); } qsr.render (&painter, size); painter.end (); QIcon icon; icon.addPixmap (QPixmap::fromImage (back)); QStandardItem *item = new QStandardItem (icon, Name.get_buffer ()); item->setEditable (false); _model.appendRow (item); } } else if (IconResource) { _log.error << "Unable to find icon resource: " << IconResource << " for object type: " << Type.get_name () << endl; } RuntimeIterator it; ObjectType next; while (Type.get_next_child (it, next)) { _add_type (next); } }
void dmz::QtPluginCanvasObject::_init (Config &local, Config &global) { _canvasModuleName = config_to_string ("module.canvas.name", local); Config pluginList; if (local.lookup_all_config ("plugins.plugin", pluginList)) { RuntimeContext *context (get_plugin_runtime_context ()); if (dmz::load_plugins (context, pluginList, local, global, _extensions, &_log)) { _extensions.discover_plugins (); } } _defaultAttributeHandle = activate_default_object_attribute ( ObjectCreateMask | ObjectDestroyMask | ObjectPositionMask | ObjectOrientationMask); _linkAttributeHandle = activate_object_attribute ( ObjectAttributeLayerLinkName, ObjectLinkMask | ObjectUnlinkMask); #if 0 Config preLoadList; if (local.lookup_all_config ("preload", preLoadList)) { Config data; ConfigIterator it; Boolean done (!preLoadList.get_first_config (it, data)); while (!done) { ObjectType objType; Mask objState; if (_defs.lookup_object_type (config_to_string ("type", data), objType)) { _defs.lookup_state (config_to_string ("state", data), objState); _log.info << "Pre-Loading object of type: " << objType.get_name () << endl; _get_model_struct (objType, objState); } done = !preLoadList.get_next_config (it, data); } } #endif }
//------------------------------------------------------------------------------ void ObjectTypeDatabase::unregisterType(const ObjectType & t) { if (t.getID() < m_types.size()) { m_types[t.getID()] = nullptr; } else { SN_ERROR("ObjectTypeDatabase::unregisterType: type not found (" << t.toString() << ")"); } }
void Module::setExtension(const ObjectTypeTemplate &childTemplate, const ObjectType &parent, const std::map<int, int> ¶meterMapping) { setExtension(childTemplate, [parent, parameterMapping](const ObjectType& type) { ObjectType father = parent; for(const auto& binding : parameterMapping) { father.setParameter(binding.second, type.parameterValue(binding.first)); } return father; }); }
void digidoc::dsig::operator<< (DOMElement &e, const ObjectType &i) { e << static_cast<const ObjectTypeBase&>(i); for(ObjectType::QualifyingPropertiesConstIterator b = i.qualifyingProperties().begin(); b != i.qualifyingProperties().end(); ++b) { DOMElement &s( xsd::cxx::xml::dom::create_element("QualifyingProperties", "http://uri.etsi.org/01903/v1.3.2#", e)); s << *b; } }
void CJSONValue::Insert (const CString &sKey, const CJSONValue &Source) // Insert // // Appends to a key to a structure { ASSERT(m_iType == typeObject); ObjectType *pObj = (ObjectType *)m_pValue; pObj->Insert(sKey, Source); }
bool Module::isExtension(const ObjectType& child, const ObjectType& parent) const { if(child.extendsDirectly(parent)) return true; ObjectType father = getFather(child); if(!father.isNull()) return isExtension(father, parent); return false; }
ItemUI::ItemUI(uint16_t id) : ThingUI() { m_id = id; ObjectType* obj = Objects::getInstance()->getItemType(id); if(id < 100 || !obj){ DEBUGPRINT(DEBUGPRINT_ERROR, DEBUGPRINT_LEVEL_OBLIGATORY, "[ItemUI::ItemUI] Invalid item %d\n", id); return; } obj->loadGfx(); obj->instancesOnMap++; }
int64_t StructTypeTemplate::fixedSize(const ObjectType &type) const { int s = 0; for (int i = 1; i < type.numberOfParameters(); i += 2) { int t = type.parameterValue(i).toObjectType().fixedSize(); if (t != -1) { s += t; } else { return -1; } } return s; }
void CJSONValue::InsertHandoff (const CString &sKey, CJSONValue &Source) // InsertHandoff // // Appends to a key to a structure { ASSERT(m_iType == typeObject); ObjectType *pObj = (ObjectType *)m_pValue; CJSONValue *pNewValue = pObj->Insert(sKey); pNewValue->TakeHandoff(Source); }
// RenderPluginEventOSG Interface dmz::RenderPluginEventOSG::TypeStruct * dmz::RenderPluginEventOSG::_get_type ( const Handle EventHandle, const EventType &Type) { TypeStruct *result (0); EventModule *module = get_event_module (); TypeTable *table (0); EventType event (Type); while (event && !result) { TypeTable *table = _get_type_table (Type); if (table) { ObjectType current; if (module) { module->lookup_object_type (EventHandle, table->TypeAttr, current); } const ObjectType Start (current); while (current && !result) { result = table->map.lookup (current.get_handle ()); if (!result) { result = _create_type (EventHandle, event, current, *table); } if (!result) { current.become_parent (); } } if (result && (current != Start)) { table->map.store (Start.get_handle (), result); } } if (!result) { event.become_parent (); } } return result; }
ObjectType Module::specify(const ObjectType &parent) const { ObjectType child = specifyLocally(parent); if(child.isNull()) { for(const Module* module : reverse(_importedModules)) { child = module->specify(parent); if(!child.isNull()) return child; } } return child; }
ItemUI::~ItemUI() { if (!Objects::getInstance()->isLoaded()) { printf("Destroying item %d after dat was unloaded\n", m_id); return; } ObjectType* obj = Objects::getInstance()->getItemType(m_id); if (obj) { if(obj->instancesOnMap){ obj->instancesOnMap--; if (!obj->instancesOnMap) obj->unloadGfx(); } else { } } }
ObjectType Module::specifyLocally(const ObjectType& parent) const { auto it = _specializers.find(const_cast<ObjectTypeTemplate*>(&parent.typeTemplate())); if (it == _specializers.end()) { return ObjectType(); } ObjectType type = it->second.specialize(parent); if (!type.isNull()) { type.importParameters(parent); } return type; }
void Module::setSpecification(const ObjectType& parent, const ObjectType& child) { if (!parent.typeTemplate().isVirtual()) { Log::error("Cannot forward ",parent," to ",child," because ",parent.typeTemplate().name(), " is not virtual "); } const ObjectType* parentPtr = new ObjectType(parent); _automaticSpecifications.insert(std::make_pair(parentPtr, child)); auto it = _specializers.find(const_cast<ObjectTypeTemplate*>(&parent.typeTemplate())); if (it == _specializers.end()) { _specializers.emplace(std::piecewise_construct, std::make_tuple(const_cast<ObjectTypeTemplate* >(&parent.typeTemplate())), std::make_tuple(parent, child)); } else { it->second.forward(parent, child); } }
ObjectType Module::specifyLocally(const ObjectType& parent) const { ObjectType type; ObjectType rangeBegin(parent.typeTemplate()); for(SpecificationMap::const_iterator it = _automaticSpecifications.lower_bound(&rangeBegin); it != _automaticSpecifications.end() && it->first->typeTemplate() == parent.typeTemplate(); ++it) { if(parent.extendsDirectly(*(it->first))) { type = it->second; type.importParameters(parent); break; } } return type; }
Variant StructTypeTemplate::attributeValue(const ObjectType &type, ObjectTypeTemplate::Attribute attribute) const { if (attribute == ObjectTypeTemplate::Attribute::name) { return type.parameterValue(0); } else { return Variant(); } }