void dmz::CyclesPluginWallOSG::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { const Boolean IsDead (Value.contains (_deadState)); const Boolean WasDead (PreviousValue ? PreviousValue->contains (_deadState) : False); const Boolean IsOn (Value.contains (_engineOnState)); const Boolean WasOn (PreviousValue ? PreviousValue->contains (_engineOnState) : False); if ((IsDead && !WasDead) || (!IsOn && WasOn)) { ObjectStruct *os (_objectTable.remove (ObjectHandle)); if (os && !_deadTable.store (ObjectHandle, os)) { _remove_wall (*os); delete os; os = 0; } } else if (IsOn && !WasOn) { ObjectModule *objMod (get_object_module ()); if (objMod) { _create_object_wall (ObjectHandle, objMod->lookup_object_type (ObjectHandle)); } } }
void dmz::QtPluginCanvasObjectBasic::_update_group_state ( StateGroupStruct &group, const Mask &Value, const Mask &PreviousValue) { StateStruct *ssToHide (0); StateStruct *ssToShow (0); StateStruct *ss (group.stateList); Boolean done (False); while (ss && !done) { if (!ssToShow) { if (!Value) { ssToShow = group.defaultState; } else if (ss->State) { if (Value.contains (ss->State)) { ssToShow = ss; } } } if (!ssToHide) { if (!PreviousValue) { ssToHide = group.defaultState; } else if (ss->State) { if (PreviousValue.contains (ss->State)) { ssToHide = ss; } } } if (ssToShow && ssToHide) { done = True; } ss = ss->next; } if (ssToHide) { ssToHide->set_visible (False); } else if (group.defaultState) { group.defaultState->set_visible (False); } if (ssToShow) { ssToShow->set_visible (True); } else if (group.defaultState) { group.defaultState->set_visible (True); } }
void dmz::RenderPluginObjectOSG::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { ObjectStruct *os (_objectTable.lookup (ObjectHandle)); if (os && os->model.valid ()) { unsigned int place (0); StateStruct *ss (os->Def.stateMap); while (ss) { if (Value.contains (ss->State)) { place = ss->Place; ss = 0; } else { ss = ss->next; } } os->model->setSingleChildOn (place); } }
void dmz::QtPluginCanvasLink::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { LinkStruct *ls = _attrObjTable.lookup (ObjectHandle); if (ls) { if (AttributeHandle == _defaultAttrHandle) { ColorStruct *current (_stateList); ColorStruct *cs (0); while (current && !cs) { if (Value.contains (current->State)) { cs = current; } else { current = current->next; } } QColor color (Qt::black); color.setAlphaF (0.75f); if (cs) { color = cs->Color; } QBrush b (color); ls->item->setColorAll (QPen (b, 4)); } else if (AttributeHandle == _flowAttrHandle) { if (Value & _flowStateMask) { const Boolean Forward = Value & _forwardState; const Boolean Reverse = Value & _reverseState; if (Forward && !Reverse) { ls->item->set_arrow_state (True); ls->item->set_rotation_offset (0.0f); } else if (!Forward && Reverse) { ls->item->set_arrow_state (True); ls->item->set_rotation_offset (180.0f); } else { ls->item->set_arrow_state (False); } } else { ls->item->set_arrow_state (False); } } } }
void dmz::WeaponPluginFixedLauncher::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { if (_hil && (ObjectHandle == _hil) && (AttributeHandle == _defaultHandle)) { if (Value.contains (_deadState)) { _hilActive = False; } else { _hilActive = True; } } }
void dmz::EntityPluginDeadTimer::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { if (_deadState && (AttributeHandle == _defaultHandle) && (ObjectHandle == _hil)) { const Boolean IsDead (Value.contains (_deadState)); const Boolean WasDead ( PreviousValue ? PreviousValue->contains (_deadState) : False); if (IsDead && !WasDead) { start_time_slice (); } } }
// Object Observer Interface void dmz::EntityPluginGroundSimple::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { if (_deadState && (AttributeHandle == _defaultHandle) && (ObjectHandle == _hil)) { const Boolean IsDead (Value.contains (_deadState)); const Boolean WasDead ( PreviousValue ? PreviousValue->contains (_deadState) : False); if (IsDead && !WasDead) { _isDead = True; } else if (!IsDead && WasDead) { _isDead = False; } } }
void dmz::QtPluginCanvasObjectBasic::_update_default_group_state ( StateGroupStruct &group, const Mask &Value) { Boolean showDefault (True); StateStruct *ssDefault (0); StateStruct *ss (group.stateList); while (ss) { if (!ssDefault && !(ss->State)) { ssDefault = ss; } if (ss->State) { if (Value.contains (ss->State)) { ss->set_visible (True); showDefault = False; } else { ss->set_visible (False); } } else if (!Value) { ss->set_visible (True); showDefault = False; } ss = ss->next; } if (showDefault && ssDefault) { ssDefault->set_visible (True); } }
// Object Observer Interface void dmz::EntityPluginOverlayDead::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { if (_overlay && (ObjectHandle == _hil)) { const Boolean IsDead (Value.contains (_deadState)); const Boolean WasDead ( PreviousValue ? PreviousValue->contains (_deadState) : False); if (IsDead && !WasDead) { if (_overlaySwitch) { _overlay->enable_switch_state_single (_overlaySwitch, 1); } if (_overlayScale) { _overlay->store_transform_scale ( _overlayScale, Float64 (get_portal_x ()), Float64 (get_portal_y ())); } } else if (!IsDead && WasDead) { if (_overlaySwitch) { _overlay->enable_switch_state_single (_overlaySwitch, 0); } } } }
void dmz::WeaponPluginFixedLauncher::update_object_flag ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Boolean Value, const Boolean *PreviousValue) { if (Value) { _hil = ObjectHandle; Mask state; ObjectModule *objMod (get_object_module ()); if (_hil && objMod && objMod->lookup_state (_hil, _defaultHandle, state)) { if (state.contains (_deadState)) { _hilActive = False; } else { _hilActive = True; } } } else if (ObjectHandle == _hil) { _hil = 0; } }
// Object Observer Interface void dmz::EntityPluginRestoreHealth::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { ObjectModule *objMod (get_object_module ()); if (objMod) { if (objMod->lookup_locality (ObjectHandle) == ObjectLocal) { const Boolean IsDead (Value.contains (_dead)); const Boolean WasDead (PreviousValue ? PreviousValue->contains (_dead) : False); if (!IsDead && WasDead) { objMod->store_scalar (ObjectHandle, _healthAttrHandle, _health); } } } }
void dmz::AudioPluginObject::update_object_state ( const UUID &Identity, const Handle ObjectHandle, const Handle AttributeHandle, const Mask &Value, const Mask *PreviousValue) { ObjectStruct *os (_objectTable.lookup (ObjectHandle)); if (os) { SoundStruct *current = os->list; while (current) { SoundInit init; SoundAttributes attr; if (!current->Data.relative) { attr.set_position (os->pos); attr.set_velocity (os->vel); } else { init.set (SoundRelative, True); } const Boolean IsSet (Value.contains (current->Data.State)); const Boolean WasSet ( PreviousValue ? PreviousValue->contains (current->Data.State) : False); ObjectModule *objMod (get_object_module ()); if (objMod && current->Data.scalarAttributeHandle) { objMod->lookup_scalar ( ObjectHandle, current->Data.scalarAttributeHandle, current->scale); attr.set_pitch_scale (current->scale); } else { attr.set_pitch_scale (1.0); } if (IsSet && !WasSet) { if (PreviousValue && _audioMod && current->Data.activateHandle) { init.set (SoundLooped, False); _audioMod->play_sound (current->Data.activateHandle, init, attr); } if (_audioMod && current->Data.loopHandle) { init.set (SoundLooped, True); current->handle = _audioMod->play_sound (current->Data.loopHandle, init, attr); } } if (WasSet && !IsSet) { if (_audioMod && current->Data.deactivateHandle) { init.set (SoundLooped, False); _audioMod->play_sound (current->Data.deactivateHandle, init, attr); } if (_audioMod && current->Data.loopHandle) { _audioMod->stop_sound (current->handle); current->handle = 0; } } current = current->next; } } }
// JsExtV8Input Interface dmz::V8Value dmz::JsExtV8Input::_register_callback (const v8::Arguments &Args, const Mask &Type) { v8::HandleScope scope; V8Value result = v8::Undefined (); const int Length = Args.Length (); V8Object src = v8_to_object (Args[0]); Handle channel (_defaultChannel); V8Function func; if (Length == 2) { func = v8_to_function (Args[1]); } else if (Length > 2) { channel = _to_handle (Args[1]); func = v8_to_function (Args[2]); } const Handle Obs = _core ? _core->get_instance_handle (src) : 0; ObsStruct *os = _obsTable.lookup (Obs); if (Obs && !os) { os = new ObsStruct; if (os && !_obsTable.store (Obs, os)) { delete os; os = 0; } } CallbackTable *ct (0); if (channel) { if (Type.contains (InputEventChannelStateMask)) { ct = _stateTable.lookup (channel); } else if (Type.contains (InputEventAxisMask)) { ct = _axisTable.lookup (channel); } else if (Type.contains (InputEventButtonMask)) { ct = _buttonTable.lookup (channel); } else if (Type.contains (InputEventSwitchMask)) { ct = _leverTable.lookup (channel); } else if (Type.contains (InputEventKeyMask)) { ct = _keyTable.lookup (channel); } else if (Type.contains (InputEventMouseMask)) { ct = _mouseTable.lookup (channel); } else if (Type.contains (InputEventDataMask)) { ct = _dataTable.lookup (channel); } if (!ct) { ct = new CallbackTable (channel, Type); if (ct) { if (Type.contains (InputEventChannelStateMask)) { if (!_stateTable.store (channel, ct)) { delete ct; ct = 0; } } else if (Type.contains (InputEventAxisMask)) { if (!_axisTable.store (channel, ct)) { delete ct; ct = 0; } } else if (Type.contains (InputEventButtonMask)) { if (!_buttonTable.store (channel, ct)) { delete ct; ct = 0; } } else if (Type.contains (InputEventSwitchMask)) { if (!_leverTable.store (channel, ct)) { delete ct; ct = 0; } } else if (Type.contains (InputEventKeyMask)) { if (!_keyTable.store (channel, ct)) { delete ct; ct = 0; } } else if (Type.contains (InputEventMouseMask)) { if (!_mouseTable.store (channel, ct)) { delete ct; ct = 0; } } else if (Type.contains (InputEventDataMask)) { if (!_dataTable.store (channel, ct)) { delete ct; ct = 0; } } } } if (ct && os && (src.IsEmpty () == false) && (func.IsEmpty () == false)) { CallbackStruct *cb = new CallbackStruct (*ct); if (cb) { const Boolean Activate = (ct->table.get_count () == 0); if (ct->table.store (Obs, cb)) { cb->self = V8ObjectPersist::New (src); cb->func = V8FunctionPersist::New (func); result = func; cb->next = os->list; os->list = cb; if (Activate) { activate_input_channel (channel, Type | InputEventChannelStateMask); } else if ((Type & InputEventChannelStateMask) && _active.contains (channel)) { const int Argc (3); V8Value argv[Argc]; argv[0] = v8::Integer::New (channel); argv[1] = v8::Boolean::New (true); CallbackTable tmp (channel, Type); tmp.table.store (Obs, cb); HandleContainer called; _do_callback (Argc, argv, tmp, called); tmp.table.remove (Obs); } } else { delete cb; cb = 0; } } } } return scope.Close (result); }
// NetExtPacketCodecObject Interface dmz::Boolean dmz::NetExtPacketCodecObjectBasic::decode (Unmarshal &data, Boolean &isLoopback) { Boolean result (False); isLoopback = False; if (_attrMod && _objMod) { UUID uuid; data.get_next_uuid (uuid); if (_SysID == uuid) { isLoopback = True; } else { data.get_next_uuid (uuid); Vector pos; Matrix ori; Vector vel; ArrayUInt32 typeArray; ArrayUInt32 stateArray; data.get_next_vector (pos); data.get_next_matrix (ori); data.get_next_vector (vel); typeArray.set (0, data.get_next_uint32 ()); typeArray.set (1, data.get_next_uint32 ()); typeArray.set (2, data.get_next_uint32 ()); stateArray.set (0, data.get_next_uint32 ()); ObjectType type; _attrMod->to_internal_object_type (typeArray, type); Handle handle (_objMod->lookup_handle_from_uuid (uuid)); Boolean activateObject (False); if (type && !handle) { handle = _objMod->create_object (type, ObjectRemote); if (handle) { _objMod->store_uuid (handle, uuid); activateObject = True; } } if (handle) { Mask state; _objMod->lookup_state (handle, _defaultHandle, state); _attrMod->to_internal_object_mask (type, stateArray, state); if (_deactivateState && state.contains (_deactivateState)) { _objMod->destroy_object (handle); } else { _objMod->store_position (handle, _defaultHandle, pos); _objMod->store_position (handle, _lnvHandle, pos); _objMod->store_orientation (handle, _defaultHandle, ori); _objMod->store_velocity (handle, _defaultHandle, vel); _objMod->store_state (handle, _defaultHandle, state); _objMod->store_time_stamp (handle, _lnvHandle, _time.get_frame_time ()); const Handle ScalarCount (data.get_next_uint32 ()); if (ScalarCount) { for (UInt32 ix = 0; ix < ScalarCount; ix++) { const Handle NetHandle = data.get_next_uint32 (); const Float64 Value = data.get_next_float64 (); ScalarStruct *ss = _scalarTable.lookup (NetHandle); if (ss && ss->AttrHandle) { _objMod->store_scalar (handle, ss->AttrHandle, Value); } } } if (activateObject) { _objMod->activate_object (handle); } } result = True; } } } return result; }