void dmz::CyclesPluginWallOSG::_create_object_wall ( const Handle ObjectHandle, const ObjectType &Type) { WallStruct *wall (0); ObjectType current (Type); while (current && !wall) { wall = _wallTable.lookup (Type.get_handle ()); Config wallDef; if (!wall && current.get_config ().lookup_all_config_merged ("wall", wallDef)) { const Float32 Red (config_to_float32 ("color.r", wallDef, 1.0)); const Float32 Green (config_to_float32 ("color.g", wallDef, 1.0)); const Float32 Blue (config_to_float32 ("color.b", wallDef, 1.0)); const Float32 Alpha (config_to_float32 ("color.a", wallDef, 1.0)); const Float32 Height (config_to_float32 ("height.value", wallDef, 1.0)); const Float32 Offset (config_to_float32 ("offset.value", wallDef, 1.0)); _log.info << " " << Type.get_name () << " wall information." << endl << "\t Red : " << Red << endl << "\t Green : " << Green << endl << "\t Blue : " << Blue << endl << "\t Alpha : " << Alpha << endl << "\tHeight : " << Height << endl << "\tOffset : " << Offset << endl; wall = new WallStruct ( True, osg::Vec4 (Red, Green, Blue, Alpha), Height, Offset); if (wall && !_wallTable.store (Type.get_handle (), wall)) { delete wall; wall = 0; } } else { current.become_parent (); } } if (wall && wall->ColorDefined) { _create_wall (ObjectHandle, *wall); } else if (!wall) { wall = new WallStruct (False, osg::Vec4 (0.0f, 0.0f, 0.0f, 0.0f), 0.0f, 0.0f); if (wall && !_wallTable.store (Type.get_handle (), wall)) { delete wall; wall = 0; } } }
void dmz::WeaponPluginGravityBullet::_store_speed ( const Handle ObjectHandle, const ObjectType &Type) { Float64 *ptr (_speedTable.lookup (Type.get_handle ())); if (!ptr) { ptr = new Float64 (_defaultSpeed); if (ptr && !_speedTable.store (Type.get_handle (), ptr)) { delete ptr; ptr = 0; } } if (ptr) { _objectTable.store (ObjectHandle, ptr); ObjectModule *objMod (get_object_module ()); if (objMod) { Matrix ori; objMod->lookup_orientation (ObjectHandle, _defaultHandle, ori); Vector vel (0.0, 0.0, -(*ptr)); ori.transform_vector (vel); objMod->store_velocity (ObjectHandle, _defaultHandle, vel); } } }
dmz::NetModuleLocalDRBasic::ObjectUpdate * dmz::NetModuleLocalDRBasic::_create_test_from_type (const ObjectType &Type) { ObjectUpdate *result (0); ObjectType current (Type); while (current && !result) { result = _typeTable.lookup (current.get_handle ()); if (!result) { result = _baseTable.lookup (current.get_handle ()); if (result) { _typeTable.store (Type.get_handle (), result); } } if (!result) { Config listData; if (current.get_config ().lookup_all_config ( "net.rule", listData)) { _log.info << "Creating network transmission rules for: " << Type.get_name () << endl; result = _create_update_list (listData); if (result) { if (_baseTable.store (current.get_handle (), result)) { _typeTable.store (Type.get_handle (), result); } } } else { current.become_parent (); } } } if (!result) { result = _defaultTest; if (result) { _typeTable.store (Type.get_handle (), result); } } return result; }
// Object Observer Interface void dmz::RenderPluginDisableObjectIsect::create_object ( const UUID &Identity, const Handle ObjectHandle, const ObjectType &Type, const ObjectLocalityEnum Locality) { if (_isect) { Boolean *value (0); ObjectType current (Type); while (current && !value) { value = _isectTable.lookup (current.get_handle ()); if (!value) { Config data; if (current.get_config ().lookup_config ("render.isect", data)) { Boolean disable = config_to_boolean ("disable", data, False); value = new Boolean (disable); if (!_isectTable.store (current.get_handle () , value)) { delete value; value = 0; } } } current.become_parent (); } if (value && *value) { if (_isect->disable_isect (ObjectHandle) == 0) { *value = False; _log.error << "Unable to disable intersection for type: " << Type.get_name () << endl; } } } }
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; }
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::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; }
// 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; }
dmz::AudioPluginObject::SoundDefStruct * dmz::AudioPluginObject::_get_sound_list (const ObjectType &Type) { ObjectType current (Type); SoundDefStruct *result (0); while (!result && current) { result = _soundTable.lookup (current.get_handle ()); if (!result) { result = _object_type_to_sound_list (current); } current.become_parent (); } return result; }
dmz::RenderPluginObjectOSG::DefStruct * dmz::RenderPluginObjectOSG::_lookup_def_struct (const ObjectType &Type) { ObjectType current (Type); DefStruct *result (0); while (!result && current) { result = _typeTable.lookup (current.get_handle ()); if (!result) { result = _create_def_struct (current); if (result) { _typeTable.store (Type.get_handle (), result); } else { current.become_parent (); } } } return result; }
//! Gets root object type. dmz::ObjectType dmz::Definitions::get_root_object_type () const { ObjectType result; if (_state.context && _state.defs) { ObjectType *ptr (_state.defs->objectNameTable.lookup (LocalRootObjectTypeName)); if (!ptr) { TypeContext *rootTypeContext = new TypeContext ( LocalRootObjectTypeName, _state.context, 0, 0); if (rootTypeContext) { ptr = new ObjectType (rootTypeContext); if (ptr && _state.defs->objectNameTable.store (ptr->get_name (), ptr)) { _state.defs->objectHandleTable.store (ptr->get_handle (), ptr); } else if (ptr) { delete ptr; ptr = 0; } rootTypeContext->unref (); } } if (ptr) { result = *ptr; } } return result; }
void dmz::NetModulePacketCodecBasic::_discover_codec (const Plugin *PluginPtr) { const String Name (PluginPtr ? PluginPtr->get_plugin_name () : ""); NetExtPacketCodecObject *objCodec (NetExtPacketCodecObject::cast (PluginPtr)); NetExtPacketCodecEvent *eventCodec (NetExtPacketCodecEvent::cast (PluginPtr)); if (Name && (objCodec || eventCodec)) { PacketStruct *hs (_packetTable.lookup (Name)); if (hs) { DecodeStruct *ds (0); if (objCodec) { ds = new DecodeStruct (hs->PacketID, *objCodec); } else if (eventCodec) { ds = new DecodeStruct (hs->PacketID, *eventCodec); } if (ds && _decodeTable.store (hs->PacketID, ds)) { if (objCodec && hs->objects.get_count ()) { EncodeObjectStruct *eos ( new EncodeObjectStruct (hs->PacketID, *objCodec)); if (eos && _objEncodeTable.store (hs->PacketID, eos)) { ObjectTypeIterator it; ObjectType type; Boolean found (hs->objects.get_first (it, type)); while (found) { _objTypeTable.store (type.get_handle (), eos); found = hs->objects.get_next (it, type); } } else if (eos) { delete eos; eos = 0; } } else if (eventCodec && hs->events.get_count ()) { EncodeEventStruct *ees ( new EncodeEventStruct (hs->PacketID, *eventCodec)); if (ees && _eventEncodeTable.store (hs->PacketID, ees)) { EventTypeIterator it; EventType type; Boolean found (hs->events.get_first (it, type)); while (found) { _eventTypeTable.store (type.get_handle (), ees); found = hs->events.get_next (it, type); } } else if (ees) { delete ees; ees = 0; } } } else if (ds) { delete ds; ds = 0; } } } }
int main (int argc, char *argv[]) { Test test ("dmzRuntimeObjectTypeTest", argc, argv); // test null contructor ObjectType testObjectType; test.validate ( "test default constructor", !testObjectType.get_type_context () && !testObjectType.get_name ().get_length ()); RuntimeContext *context (test.rt.get_context ()); Config config; if (test.validate ( "Looking up runtime table", test.config.lookup_config ("dmz.runtime", config))) { runtime_init (config, test.rt.get_context (), &(test.log)); } Definitions defs (context, &(test.log)); const String CaracalName ("caracal"); const String CatName ("cat"); ObjectType rootObjectType; test.validate ( "Looking up ObjectType: Caracal", defs.lookup_object_type (CaracalName, testObjectType)); test.validate ( "Looking up ObjectType: Cat", defs.lookup_object_type (CatName, rootObjectType)); // ============================================================================ // // <validate constructors> ObjectType copyOfCaracalContext (testObjectType.get_type_context ()); test.validate ( "test (context) constructor", copyOfCaracalContext == testObjectType); ObjectType anotherCaracal (CaracalName, context); ObjectType anotherCat (CatName, context); test.validate ( "test (Name, RuntimeContext) constructor", anotherCat == rootObjectType && anotherCaracal == testObjectType); ObjectType yetAnotherCaracal (anotherCaracal.get_handle (), context); ObjectType yetAnotherCat (anotherCat.get_handle (), context); test.validate ( "test (Handle, RuntimeContext) constructor", yetAnotherCat == rootObjectType && yetAnotherCaracal == testObjectType); ObjectType stillAnotherCaracal (anotherCaracal); ObjectType stillAnotherCat (anotherCat); test.validate ( "test copy constructor", stillAnotherCat == rootObjectType && stillAnotherCaracal == testObjectType); // </validate constructors> // ============================================================================ // // <validate operators> ObjectType shouldBeNothing; ObjectType nothingThatBecomesSomething; test.validate ( "test = operator - (pre state)", (nothingThatBecomesSomething == shouldBeNothing) && !(nothingThatBecomesSomething == anotherCat)); nothingThatBecomesSomething = anotherCat; test.validate ( "test = operator - (equal something)", !(nothingThatBecomesSomething == shouldBeNothing) && (nothingThatBecomesSomething == anotherCat)); nothingThatBecomesSomething = shouldBeNothing; test.validate ( "test = operator - (equal null)", (nothingThatBecomesSomething == shouldBeNothing) && !(nothingThatBecomesSomething == anotherCat)); ObjectType shouldBeACaracal (CaracalName, context); ObjectType shouldBeACat (CatName, context); test.validate ( "test == operator", !(shouldBeNothing == anotherCat) && !(shouldBeNothing == anotherCaracal) && !(shouldBeACaracal == anotherCat) && (shouldBeACaracal == anotherCaracal) && (shouldBeACat == anotherCat) && !(shouldBeACat == anotherCaracal)); test.validate ( "test != operator", (shouldBeNothing != anotherCat) && (shouldBeNothing != anotherCaracal) && (shouldBeACaracal != anotherCat) && !(shouldBeACaracal != anotherCaracal) && !(shouldBeACat != anotherCat) && (shouldBeACat != anotherCaracal)); test.validate ( "test ! operator", !shouldBeNothing && !(!shouldBeACat)); // </validate operators> // ============================================================================ // // <validate accessor functions> ObjectType newTestObject; test.validate ( "test is_of_type operator on a null type object", !newTestObject.is_of_type (shouldBeNothing) && !newTestObject.is_of_type (anotherCat) && !newTestObject.is_of_type (anotherCaracal)); test.validate ( "test is_of_exact_type operator on a null type object", !newTestObject.is_of_exact_type (shouldBeNothing) && !newTestObject.is_of_exact_type (anotherCat) && !newTestObject.is_of_exact_type (anotherCaracal)); newTestObject = anotherCat; test.validate ( "test is_of_type operator on a base type object", !newTestObject.is_of_type (shouldBeNothing) && newTestObject.is_of_type (anotherCat) && !newTestObject.is_of_type (anotherCaracal)); test.validate ( "test is_of_exact_type operator on a base type object", !newTestObject.is_of_exact_type (shouldBeNothing) && newTestObject.is_of_exact_type (anotherCat) && !newTestObject.is_of_exact_type (anotherCaracal)); newTestObject = anotherCaracal; test.validate ( "test is_of_type operator on a child type object", !newTestObject.is_of_type (shouldBeNothing) && newTestObject.is_of_type (anotherCat) && newTestObject.is_of_type (anotherCaracal)); test.validate ( "test is_of_exact_type operator on a child type object", !newTestObject.is_of_exact_type (shouldBeNothing) && !newTestObject.is_of_exact_type (anotherCat) && newTestObject.is_of_exact_type (anotherCaracal)); // test set_type ObjectType anotherTestObject; test.validate ( "test set_type (Name, context)", newTestObject.set_type (CatName, context) && newTestObject.is_of_type (anotherCat) && newTestObject.is_of_exact_type (anotherCat)); anotherTestObject = shouldBeNothing; test.validate ( "test set_type (Handle, context)", newTestObject.set_type (anotherCaracal.get_handle (), context) && newTestObject.is_of_type (anotherCaracal) && newTestObject.is_of_exact_type (anotherCaracal)); test.validate ( "test get_name", (newTestObject.get_name () == CaracalName)); test.validate ( "test get_handle", (newTestObject.get_handle () == anotherCaracal.get_handle ())); // get / become parent ObjectType newKitty (CaracalName, context); test.validate ( "test get_parent", newKitty.get_parent () == anotherCat); test.validate ( "test become_parent", (newKitty == anotherCaracal) && newKitty.become_parent () && (newKitty == anotherCat)); // </validate accessor functions> // ============================================================================ // // <validate lookup functions> String data; anotherCaracal.get_config ().lookup_attribute ("info.texture", data); test.validate ( "test lookup_attribute", !data); String data2, data3; Config returnCaracalData; test.validate ( "test lookup_config", anotherCaracal.get_config ().lookup_all_config_merged ("info", returnCaracalData)); test.validate ( "test lookup_config->lookup_attribute -- success", returnCaracalData.lookup_attribute ("ears", data2) && data2 == "awesome"); test.validate ( "test lookup_config->lookup_attribute -- failure", !returnCaracalData.lookup_attribute ("howTo", data3) && !data3); // test.log.out << "M: <" << data2 << ">" << endl; // test.log.out << "M: <" << data3 << ">" << endl; test.validate ( "test lookup_all_config", anotherCaracal.get_config ().lookup_all_config ("info", returnCaracalData)); ConfigIterator dataIt; Config moreSpecificData; test.validate ( "test lookup_all_config->get_first_config", returnCaracalData.get_first_config (dataIt, moreSpecificData)); ConfigIterator it; String dataName, dataValue; test.validate ( "test lookup_all_config->get_first_attribute", moreSpecificData.get_first_attribute (it, dataName, dataValue) && (dataName == "ears") && (dataValue == "awesome")); test.validate ( "test lookup_all_config->get_next_attribute", moreSpecificData.get_next_attribute (it, dataName, dataValue) && (dataName == "madeOf") && (dataValue == "win")); test.validate ( "test lookup_all_config->get_next_attribute (failure)", !moreSpecificData.get_next_attribute (it, dataName, dataValue)); // test.log.out << "M: <" << dataName1 << ":" << dataValue1 << ">" << endl; // test.log.out << "M: <" << dataName2 << ":" << dataValue2 << ">" << endl; test.validate ( "test lookup_all_config->get_next_config", returnCaracalData.get_next_config (dataIt, moreSpecificData)); test.validate ( "test lookup_all_config->get_first_attribute", moreSpecificData.get_first_attribute (it, dataName, dataValue) && (dataName == "motivation") && (dataValue == "evil")); // test.log.out << "M: <" << dataName << ":" << dataValue << ">" << endl; // </validate lookup functions> // ============================================================================ // // <validate child iterator functions> ObjectTypeIterator oIt; ObjectType otype; test.validate ( "test iterator get_first_child ()", anotherCat.get_first_child (oIt, otype) && otype == anotherCaracal); ObjectType aServal("serval", context); test.validate ( "test iterator get_next_child ()", anotherCat.get_next_child (oIt, otype) && otype == aServal); test.validate ( "test iterator get_next_child ()", !anotherCat.get_next_child (oIt, otype)); // </validate child iterator functions> // ============================================================================ // return test.result (); }