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); }
}
Exemplo n.º 3
0
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);
   }
}
Exemplo n.º 4
0
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); }
      }
   }
}
Exemplo n.º 5
0
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; }
   }
}
Exemplo n.º 6
0
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);
   }
}
Exemplo n.º 9
0
// 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);
         }
      }
   }
}
Exemplo n.º 10
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);
         }
      }
   }
}
Exemplo n.º 12
0
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;
      }
   }
}
Exemplo n.º 13
0
// 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);
}
Exemplo n.º 14
0
// 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;
}