void dmz::ObjectModuleGridBasic::_init (Config &local) { _xCoordMax = config_to_int32 ("grid.cell.x", local, _xCoordMax); _yCoordMax = config_to_int32 ("grid.cell.y", local, _yCoordMax); _minGrid = config_to_vector ("grid.min", local, _minGrid); _maxGrid = config_to_vector ("grid.max", local, _maxGrid); _log.info << "grid: " << _xCoordMax << "x" << _yCoordMax << endl; _log.info << "extents:" << endl << "\t" << _minGrid << endl << "\t" << _maxGrid << endl; Vector vec (_maxGrid - _minGrid); _xCellSize = vec.get (_primaryAxis) / (Float64)(_xCoordMax); _yCellSize = vec.get (_secondaryAxis) / (Float64)(_yCoordMax); _log.info << "cell count: " << _xCoordMax * _yCoordMax << endl; if (is_zero64 (_xCellSize)) { _xCellSize = 1.0; } if (is_zero64 (_yCellSize)) { _yCellSize = 1.0; } _grid = new GridStruct[_xCoordMax * _yCoordMax]; activate_default_object_attribute ( ObjectCreateMask | ObjectDestroyMask | ObjectPositionMask); }
/*! \brief Decomposes the Matrix into three Euler angles. \param[out] hy Heading in radians. \param[out] px Pitch in radians. \param[out] rz Roll in radians. */ void dmz::Matrix::to_euler_angles (Float64 &hy, Float64 &px, Float64 &rz) const { Vector hvec (Forward), pvec (Forward), rvec (Up); transform_vector(hvec); Matrix cmat (*this), hmat, pmat, rmat; hvec.set_y (0.0); if (hvec.is_zero ()) { hy = 0.0; } else { hvec.normalize_in_place (); hy = Forward.get_signed_angle (hvec); hmat.from_axis_and_angle (Up, hy); hmat.transpose_in_place (); cmat = hmat * cmat; } cmat.transform_vector (pvec); if (is_zero64 (pvec.get_y ())) { px = 0.0; } else { px = Forward.get_signed_angle (pvec); pmat.from_axis_and_angle (Right, px); pmat.transpose_in_place (); cmat = pmat * cmat; } cmat.transform_vector (rvec); if (is_zero64 (rvec.get_x ())) { rz = 0.0; } else { rz = Up.get_signed_angle (rvec); } }
/*===========================================================================* * switch_to_user * *===========================================================================*/ PUBLIC void switch_to_user(void) { /* This function is called an instant before proc_ptr is * to be scheduled again. */ /* * if the current process is still runnable check the misc flags and let * it run unless it becomes not runnable in the meantime */ if (proc_is_runnable(proc_ptr)) goto check_misc_flags; /* * if a process becomes not runnable while handling the misc flags, we * need to pick a new one here and start from scratch. Also if the * current process wasn' runnable, we pick a new one here */ not_runnable_pick_new: if (proc_is_preempted(proc_ptr)) { proc_ptr->p_rts_flags &= ~RTS_PREEMPTED; if (proc_is_runnable(proc_ptr)) { if (!is_zero64(proc_ptr->p_cpu_time_left)) enqueue_head(proc_ptr); else enqueue(proc_ptr); } } /* * if we have no process to run, set IDLE as the current process for * time accounting and put the cpu in and idle state. After the next * timer interrupt the execution resumes here and we can pick another * process. If there is still nothing runnable we "schedule" IDLE again */ while (!(proc_ptr = pick_proc())) { proc_ptr = proc_addr(IDLE); if (priv(proc_ptr)->s_flags & BILLABLE) bill_ptr = proc_ptr; idle(); } switch_address_space(proc_ptr); check_misc_flags: assert(proc_ptr); assert(proc_is_runnable(proc_ptr)); while (proc_ptr->p_misc_flags & (MF_KCALL_RESUME | MF_DELIVERMSG | MF_SC_DEFER | MF_SC_TRACE | MF_SC_ACTIVE)) { assert(proc_is_runnable(proc_ptr)); if (proc_ptr->p_misc_flags & MF_KCALL_RESUME) { kernel_call_resume(proc_ptr); } else if (proc_ptr->p_misc_flags & MF_DELIVERMSG) { TRACE(VF_SCHEDULING, printf("delivering to %s / %d\n", proc_ptr->p_name, proc_ptr->p_endpoint);); delivermsg(proc_ptr); }
//! Stops Plugins. dmz::Boolean dmz::Application::stop () { _state.rt.update_time_slice (); _state.container.stop_plugins (); const Float64 StopTime (get_time ()); const Float64 TimeDelta (StopTime - _state.startTime); if (!is_zero64 (_state.frameCount) && !is_zero64 (TimeDelta) && !_state.quiet) { _state.log.out << "Average Frame Rate: " << _state.frameCount / TimeDelta << "Hz" << endl; } return True; }
void dmz::EntityPluginFreeFly::receive_axis_event ( const Handle Channel, const InputEventAxis &Value) { const Float64 AxisValue = Value.get_axis_value (); Float64 rvalue = 0.0; if (!is_zero64 (AxisValue, 0.1)) { rvalue = AxisValue * fabs (AxisValue); } switch (Value.get_axis_id ()) { case 2: { _move.speedAxis = rvalue * _move.moveSpeed; break; } case 1: { _move.turnAxis = rvalue * _move.turnRate; break; } case 6: { _move.strafeAxis = rvalue * _move.moveSpeed; break; } case 7: { _move.pitchAxis = rvalue * _move.turnRate; break; } case 8: { _move.ymoveAxis = rvalue * _move.moveSpeed; break; } } }
/*! \brief Creates a Matrix from a single Vector. \details The Matrix will look in the direction of the given vector. The Matrix will only update heading a pitch and will not contain a roll component. \param[in] Direction Vector pointing in the direction to look. */ void dmz::Matrix::from_vector (const Vector &Direction) { Vector hvec (Direction), pvec (Direction); Matrix hmat, pmat; hvec.set_y (0.0); if (!hvec.is_zero ()) { hvec.normalize_in_place (); hmat.from_axis_and_angle (Up, Forward.get_signed_angle (hvec)); } hmat.transpose ().transform_vector (pvec); if (!is_zero64 (pvec.get_y ())) { pmat.from_axis_and_angle (Right, Forward.get_signed_angle (pvec)); } *this = hmat * pmat; }
PUBLIC short cpu_load(void) { u64_t current_tsc, *current_idle; u64_t tsc_delta, idle_delta, busy; struct proc *idle; short load; #ifdef CONFIG_SMP unsigned cpu = cpuid; #endif u64_t *last_tsc, *last_idle; last_tsc = get_cpu_var_ptr(cpu, cpu_last_tsc); last_idle = get_cpu_var_ptr(cpu, cpu_last_idle); idle = get_cpu_var_ptr(cpu, idle_proc);; read_tsc_64(¤t_tsc); current_idle = &idle->p_cycles; /* ptr to idle proc */ /* calculate load since last cpu_load invocation */ if (!is_zero64(*last_tsc)) { tsc_delta = sub64(current_tsc, *last_tsc); idle_delta = sub64(*current_idle, *last_idle); busy = sub64(tsc_delta, idle_delta); busy = mul64(busy, make64(100, 0)); load = ex64lo(div64(busy, tsc_delta)); if (load > 100) load = 100; } else load = 0; *last_tsc = current_tsc; *last_idle = *current_idle; return load; }
void dmz::MBRAPluginArchiveSupport::post_process_archive ( const Handle ArchiveHandle, const Int32 Version) { ObjectModule *objMod = get_object_module (); if (objMod && _storeObjects) { if (_objects.get_count () > 0) { Float64 minx = 1.0e32, miny = 1.0e32, maxx = -1.0e32, maxy = -1.0e32; HandleContainerIterator it; Handle object (0); while (_objects.get_next (it, object)) { Vector pos; if (objMod->lookup_position (object, _defaultAttrHandle, pos)) { const Float64 XX = pos.get_x (); const Float64 YY = pos.get_z (); if (XX < minx) { minx = XX; } if (XX > maxx) { maxx = XX; } if (YY < miny) { miny = YY; } if (YY > maxy) { maxy = YY; } } } const Float64 OffsetX = minx + ((maxx - minx) * 0.5); const Float64 OffsetY = miny + ((maxy - miny) * 0.5); const Float64 Scale = is_zero64 (maxx - minx) ? 1.0 : 0.6 / (maxx - minx); it.reset (); while (_objects.get_next (it, object)) { Vector pos; if (objMod->lookup_position (object, _defaultAttrHandle, pos)) { pos.set_x ((pos.get_x () - OffsetX) * Scale); pos.set_z ((pos.get_z () - OffsetY) * Scale); objMod->store_position (object, _defaultAttrHandle, pos); } } if (_map) { _map->center_on (0.0, 0.0); _map->set_zoom (10); Data out; out.store_boolean (_toggleHandle, 0, False); _toggleMapMessage.send (_toggleTargetHandle, &out); } _undo.reset (); } } if (objMod) { HandleContainerIterator it; Handle object (0); while (_ecObjects.get_next (it, object)) { Float64 value (0.0); if (!objMod->lookup_scalar (object, _threatAttrHandle, value)) { objMod->store_scalar (object, _threatAttrHandle, 1.0); } if (!objMod->lookup_scalar (object, _vulAttrHandle, value)) { objMod->store_scalar (object, _vulAttrHandle, 1.0); } } } _storeObjects = False; }
void dmz::EntityPluginGroundSimple::_move_entity ( const Float64 TimeDelta, const Boolean Airborn, Vector &pos, Matrix &ori, Vector &vel, Float64 &heading) { const Vector Up (0.0, 1.0, 0.0); const Vector Forward (0.0, 0.0, -1.0); Vector vup (Up), vforward (Forward); ori.transform_vector (vup); ori.transform_vector (vforward); Matrix mat (vup, Up); mat.transform_vector (vforward); heading = Forward.get_signed_angle ( vforward); if (Airborn) { vel.set_y (vel.get_y () - (EarthGravity64 * TimeDelta)); pos += vel * TimeDelta; } else if (_isDead) { pos += vel * TimeDelta; } else { const Float64 ForwardFactor ((vforward.get_angle (vel) > HalfPi64) ? -1.0 : 1.0); mat.transpose_in_place (); heading -= _move.turn * _move.turnRate * TimeDelta; Matrix hm (Up, heading); ori = mat * hm; vforward = Forward; ori.transform_vector (vforward); Float64 speed (vel.magnitude () - (_move.brake * _move.brakeRate * TimeDelta)); if (!is_zero64 (_move.brake) && (speed < 0.0)) { speed = 0.0; } if (!is_zero64 (_move.throttle)) { const Float64 TargetSpeed ( (_move.maxSpeed + _move.turboModifier) * _move.throttle); if ((speed * ForwardFactor) < TargetSpeed) { speed += (_move.throttle * _move.maxAccel * TimeDelta); if (speed > TargetSpeed) { speed = TargetSpeed; } } else if ((speed * ForwardFactor) > TargetSpeed) { speed -= (_move.maxDecel * TimeDelta); if (speed < 0) { speed = 0; } } } if (is_zero64 (_move.throttle) && is_zero64 (_move.brake)) { if (is_zero64 (vforward.get_y (), 0.05)) { speed -= _move.maxDecel * TimeDelta; if (speed < 0.0) { speed = 0.0; } } else { speed -= EarthGravity64 * vforward.get_y () * TimeDelta * ForwardFactor; } speed = speed * ForwardFactor; } vel = vforward * speed; pos += vel * TimeDelta; } }
// TimeSlice Interface void dmz::EntityPluginFreeFly::update_time_slice (const Float64 TimeDelta) { ObjectModule *objMod (get_object_module ()); if (objMod && _handle && _defaultHandle) { Vector pos, vel; Matrix ori; objMod->lookup_position (_handle, _defaultHandle, pos); objMod->lookup_velocity (_handle, _defaultHandle, vel); objMod->lookup_orientation (_handle, _defaultHandle, ori); const Vector Right (1.0, 0.0, 0.0); const Vector Up (0.0, 1.0, 0.0); const Vector Forward (0.0, 0.0, -1.0); Vector dir (Forward); ori.transform_vector (dir); Vector headingVec (dir); headingVec.set_y (0.0); headingVec.normalize_in_place (); Float64 heading (Forward.get_angle (headingVec)); const Float64 HCross (Forward.cross (headingVec).normalize_in_place ().get_y ()); if (HCross < 0.0) { heading += _move.turnAxis * TimeDelta; heading = TwoPi64 - heading; } else { heading -= _move.turnAxis * TimeDelta; } if (heading > Pi64) { heading -= TwoPi64; } else if (heading < -Pi64) { heading += TwoPi64; } Float64 pitch (dir.get_angle (headingVec)); if (dir.get_y () < 0.0) { pitch += _move.pitchAxis * TimeDelta; pitch = TwoPi64 - pitch; } else { pitch -= _move.pitchAxis * TimeDelta; } if ((pitch > HalfPi64) && (pitch <= (Pi64))) { pitch = HalfPi64 - 0.001; } else if ((pitch < (Pi64 + HalfPi64)) && (pitch > Pi64)) { pitch = HalfPi64 + Pi64 + 0.001; } Matrix pm (Right, pitch); Matrix hm (Up, heading); ori = hm * pm; dir = Forward; Vector slide (Right); Vector ymove (Up); ori.transform_vector (dir); ori.transform_vector (slide); ori.transform_vector (ymove); const Vector OldPos (pos); pos -= (dir * (_move.speedAxis * TimeDelta)); pos += (slide * (_move.strafeAxis * TimeDelta)); pos += (ymove * (_move.ymoveAxis * TimeDelta)); if (!is_zero64 (TimeDelta)) { vel = (pos - OldPos) * (1 / TimeDelta); } objMod->store_position (_handle, _defaultHandle, pos); objMod->store_velocity (_handle, _defaultHandle, vel); objMod->store_orientation (_handle, _defaultHandle, ori); } }
// Time Slice Interface void dmz::CyclesPluginWallOSG::update_time_slice (const Float64 DeltaTime) { static const Vector Scale (1.0, 1.0, 1.0); HashTableHandleIterator it; ObjectStruct *os (_objectTable.get_first (it)); while (os) { if (!os->dir.is_zero () && !os->dirPrev.is_zero ()) { if (os->triCount <= 0) { os->verts->push_back (osg::Vec3 (os->pos.get_x (), 0.0, os->pos.get_z ())); os->verts->push_back ( osg::Vec3 (os->pos.get_x (), os->WallInfo.Height, os->pos.get_z ())); os->verts->push_back (osg::Vec3 (os->pos.get_x (), 0.0, os->pos.get_z ())); os->verts->push_back ( osg::Vec3 (os->pos.get_x (), os->WallInfo.Height, os->pos.get_z ())); os->triCount = 2; os->draw->setCount (os->triCount + 2); osg::Vec3 normal (os->dir.get_z (), 0.0, os->dir.get_x ()); os->normals->push_back (normal); os->normals->push_back (normal); os->lastCorner = os->pos; } else { const Float64 Dot (os->dir.dot (os->dirPrev)); if (!is_zero64 (Dot - 1.0)) { const Vector Previous (os->dirPrev * os->dirPrev); const Vector Current (os->dir * os->dir); osg::Vec3 pos ( (os->pos.get_x () * Previous.get_x ()) + (os->posPrev.get_x () * Current.get_x ()), 0.0f, (os->pos.get_z () * Previous.get_z ()) + (os->posPrev.get_z () * Current.get_z ())); (*(os->verts))[os->triCount] = pos; os->verts->push_back (pos); pos.y () = os->WallInfo.Height; (*(os->verts))[os->triCount + 1] = pos; os->verts->push_back (pos); os->triCount += 2; os->draw->setCount (os->triCount + 2); osg::Vec3 normal (os->dir.get_z (), 0.0, os->dir.get_x ()); os->normals->push_back (normal); os->normals->push_back (normal); os->lastCorner.set_xyz (pos.x (), 0.0, pos.z ()); } } if ((os->pos - os->lastCorner).magnitude () > os->WallInfo.Offset) { Vector pos (os->pos - (os->dir * os->WallInfo.Offset)); (*(os->verts))[os->triCount] = osg::Vec3 (pos.get_x (), 0.0f, pos.get_z ()); (*(os->verts))[os->triCount + 1] = osg::Vec3 (pos.get_x (), os->WallInfo.Height, pos.get_z ()); os->wall->dirtyDisplayList (); os->wall->dirtyBound (); } os->posPrev = os->pos; os->dirPrev = os->dir; } os = _objectTable.get_next (it); } os = _deadTable.get_first (it); while (os) { if (os->wallYOffset < (-os->WallInfo.Height)) { ObjectStruct *tmp = _deadTable.remove (it.get_hash_key ()); if (tmp) { _remove_wall (*tmp); delete tmp; tmp = 0; } } else { os->wallYOffset -= 2.0 * DeltaTime; os->xform->setMatrix ( to_osg_matrix (Matrix (), Vector (0.0, os->wallYOffset, 0.0), Scale)); } os = _deadTable.get_next (it); } }