// TimeSlice Interface
void
dmz::NetPluginRemoteDR::update_time_slice (const Float64 TimeDelta) {
if (_objMod && _lnvHandle && _defaultHandle) {
const Float64 CurrentTime (_time.get_frame_time ());
HashTableHandleIterator it;
for (
NetPluginRemoteDR *current = _objTable.get_first (it);
current;
current = _objTable.get_next (it)) {
const Handle ObjectHandle (it.get_hash_key ());
Vector lnvPos;
Vector vel;
Float64 timestamp (0.0);
if (_objMod->lookup_position (ObjectHandle, _lnvHandle, lnvPos) &&
_objMod->lookup_velocity (ObjectHandle, _defaultHandle, vel) &&
_objMod->lookup_time_stamp (ObjectHandle, _lnvHandle, timestamp)) {
const Vector Pos (lnvPos + (vel * (CurrentTime - timestamp)));
_objMod->store_position (ObjectHandle, _defaultHandle, Pos);
}
}
}
}
void
dmz::RenderPluginObjectLoaderOSG::discover_plugin (
const PluginDiscoverEnum Mode,
const Plugin *PluginPtr) {
if (Mode == PluginDiscoverAdd) {
if (!_core) { _core = RenderModuleCoreOSG::cast (PluginPtr); }
}
else if (Mode == PluginDiscoverRemove) {
if (_core && (_core == RenderModuleCoreOSG::cast (PluginPtr))) {
HashTableHandleIterator it;
ObjectStruct *os (0);
while (_objectTable.get_next (it, os)) {
osg::Group *group (_core->lookup_dynamic_object (it.get_hash_key ()));
if (os->model.valid () && group) { group->removeChild (os->model.get ()); }
}
_core = 0;
}
}
}
// TimeSlice Interface
void
dmz::RenderPluginEventOSG::update_time_slice (const Float64 TimeDelta) {
HashTableHandleIterator it;
EventStruct *event (0);
osg::Group *group = _core ? _core->get_dynamic_objects () : 0;
while (_eventTable.get_next (it, event)) {
event->scalar += event->Type.Rate * TimeDelta;
//_log.warn << "Processing: " << it.get_hash_key () << " " << event->scalar << " " << event->Type.Scale << endl;
if (event->scalar > event->Type.Scale) {
if (group) { group->removeChild (event->root.get ()); }
event = _eventTable.remove (it.get_hash_key ());
if (event) { delete event; event = 0; }
}
else {
const Float64 Value = event->scalar;
osg::Matrix mat;
mat.makeScale (osg::Vec3 (Value, Value, Value));
event->scale->setMatrix (mat);
}
}
}
void
dmz::JsExtV8Archive::create_archive (
const Handle ArchiveHandle,
const Int32 Version,
Config &local,
Config &global) {
CallbackTable *ct = _createTable.lookup (ArchiveHandle);
if (ct && (_v8Context.IsEmpty () == false) && _runtime) {
v8::Context::Scope cscope (_v8Context);
v8::HandleScope scope;
const int Argc = 5;
V8Value argv[Argc];
argv[1] = v8::Integer::New (Version);
argv[2] = v8::Integer::NewFromUnsigned (ArchiveHandle);
argv[3] = _runtime->create_v8_config (&global);
HashTableHandleIterator it;
CallbackStruct *cb (0);
while (ct->table.get_next (it, cb)) {
if ((cb->self.IsEmpty () == false) && (cb->func.IsEmpty () == false)) {
// Copy self and func onto stack because CallbackStruct may not be valid
// after the callback is made.
V8Object localSelf = v8::Local<v8::Object>::New (cb->self);
V8Function localFunc = v8::Local<v8::Function>::New (cb->func);
const Handle Instance = cb->is.Instance;
v8::TryCatch tc;
Config data (cb->is.Name);
argv[0] = _runtime->create_v8_config (&data);
argv[Argc - 1] = localSelf;
// CallbackStruct cs may not be valid after this call and should not be
// referenced after this point.
localFunc->Call (localSelf, Argc, argv);
global.add_config (data);
if (tc.HasCaught ()) {
if (_core) { _core->handle_v8_exception (it.get_hash_key (), tc); }
cb = ct->table.lookup (Instance);
if (cb) { delete cb; cb = 0; }
}
}
}
}
}
/*!
\brief Relational "equal to" operator.
\details Compares the attribute handles and element values.
\param[in] Value Data object to compare values.
\return Returns dmz::True if the two data object contain the same values for
their attributes.
*/
dmz::Boolean
dmz::Data::operator== (const Data &Value) const {
Boolean result (False);
if (_state.dataTable.get_count () == Value._state.dataTable.get_count ()) {
result = True;
HashTableHandleIterator it;
dataStruct *ds (_state.dataTable.get_first (it));
while (result && ds) {
dataStruct *compareDs (Value._state.dataTable.lookup (it.get_hash_key ()));
if (compareDs) {
if (compareDs->Attr.Type == ds->Attr.Type) {
if (ds->Attr.Type == BaseTypeString) {
const Int32 ElementCount (ds->get_element_count ());
Int32 elCount (0);
Boolean keepChecking (True);
while (keepChecking) {
if (elCount >= ElementCount) { keepChecking = False; }
else {
String str1, str2;
_state.to_string (*ds, elCount, str1);
Value._state.to_string (*compareDs, elCount, str2);
if (str1 != str2) { keepChecking = False; result = False; }
else { elCount++; }
}
}
}
else if (*ds != *compareDs) {
result = False;
}
ds = _state.dataTable.get_next (it);
}
else { result = False; }
}
else { result = False; }
}
}
return result;
}
// RuntimeModule Interface
virtual void get_plugin_list (HandleContainer &container) {
HashTableHandleIterator it;
PluginStruct *ps (0);
while (pluginTable.get_next (it, ps)) {
container.add (it.get_hash_key ());
}
}
void dump_all (const PluginDiscoverEnum Mode) {
if (observerContext) {
HashTableHandleIterator it;
PluginObserver *obs (0);
while (observerContext->obsActiveTable.get_next (it, obs)) {
dump (it.get_hash_key (), Mode);
}
}
}
void
dmz::RenderPluginObjectOSG::_remove_models () {
if (_core) {
HashTableHandleIterator it;
ObjectStruct *os (0);
while (_objectTable.get_next (it, os)) {
osg::Group *group (_core->lookup_dynamic_object (it.get_hash_key ()));
if (os->model.valid () && group) { group->removeChild (os->model.get ()); }
}
}
}
//! Assignment operator.
dmz::HandleContainer &
dmz::HandleContainer::operator= (const HandleContainer &Container) {
_state.table.clear ();
HashTableHandleIterator it;
void *ptr = Container._state.table.get_next (it);
while (ptr) {
_state.table.store (it.get_hash_key (), (void *)this);
ptr = Container._state.table.get_next (it);
}
return *this;
}
void delete_plugins () {
discovered = False;
started = False;
interfaceTable.clear ();
HashTableHandleIterator it;
PluginStruct *ps (0);
while (pluginTable.get_prev (it, ps)) { ps->delete_plugin (); }
it.reset ();
ps = 0;
while (pluginTable.get_prev (it, ps)) { ps->unload_plugin (); }
pluginTable.empty ();
externTable.clear ();
if (levelsHead) { delete levelsHead; levelsHead = 0; }
levelsTail = 0;
maxLevel = 1;
}
void
dmz::JsExtV8Input::_do_callback (
const int Argc,
V8Value argv[],
CallbackTable &ct,
HandleContainer &called) {
HashTableHandleIterator it;
CallbackStruct *cb (0);
while (ct.table.get_next (it, cb)) {
if (!called.contains (it.get_hash_key ()) &&
(cb->self.IsEmpty () == false) && (cb->func.IsEmpty () == false)) {
// Copy self and func onto stack because CallbackStruct may not be valid
// after the callback is made.
V8Object localSelf = v8::Local<v8::Object>::New (cb->self);
V8Function localFunc = v8::Local<v8::Function>::New (cb->func);
called.add (it.get_hash_key ());
v8::TryCatch tc;
argv[Argc - 1] = localSelf;
// CallbackStruct cs may not be valid after this call and should not be
// referenced after this point.
localFunc->Call (localSelf, Argc, argv);
if (tc.HasCaught ()) {
if (_core) { _core->handle_v8_exception (it.get_hash_key (), tc); }
_release_callback (localSelf, localFunc);
cb = 0;
}
}
}
}
// TimeSlice Interface
void
dmz::WeaponPluginGravityBullet::update_time_slice (const Float64 TimeDelta) {
ObjectModule *objMod (get_object_module ());
if (objMod && _isectMod) {
const Vector GravityVel (0.0, (-_gravity) * TimeDelta, 0.0);
HashTableHandleIterator it;
IsectParameters params;
params.set_test_result_type (IsectClosestPoint);
Float64 *speedPtr (_objectTable.get_first (it));
while (speedPtr) {
Handle obj (it.get_hash_key ());
Vector pos;
Matrix ori;
Vector vel;
objMod->lookup_position (obj, _defaultHandle, pos);
objMod->lookup_orientation (obj, _defaultHandle, ori);
objMod->lookup_velocity (obj, _defaultHandle, vel);
vel += GravityVel;
objMod->store_velocity (obj, _defaultHandle, vel);
const Vector NewPos (pos + (vel * TimeDelta));
IsectTestContainer test;
IsectResultContainer isectResults;
test.set_test (1, IsectSegmentTest, pos, NewPos);
_isectMod->disable_isect (obj);
if (_isectMod->do_isect (params, test, isectResults)) {
if (_eventMod) {
IsectResult value;
isectResults.get_first (value);
Handle target (0);
value.get_object_handle (target);
_eventMod->create_detonation_event (obj, target);
}
objMod->destroy_object (obj);
}
else {
objMod->store_position (obj, _defaultHandle, NewPos);
objMod->store_velocity (obj, _defaultHandle, vel);
}
_isectMod->enable_isect (obj);
speedPtr = _objectTable.get_next (it);
}
}
}
/*!
\brief Initialized the runtime types, state, and time.
\ingroup Runtime
\details Defined in dmzRuntimeInit.h. \n
An XML example for defining the various runtime types and time settings:
\code
<dmz>
<runtime>
<time>
<factor value="1.0"/>
<frequency value="60"/>
</time>
<!-- State definition -->
<state name="State Name"/>
<!-- dmz::ObjectType definition -->
<object-type name="Object Name" parent="Parent Name">
<!-- Object data -->
</object-type>
<!-- dmz::EventType definition -->
<event-type name="Event Name" parent="Parent Name">
<!-- Event data -->
</event-type>
<!-- dmz::Message definition -->
<message name="Message Name" parent="Parent Name"/>
<!-- dmz::Resources definition -->
<resource-map>
<!-- Search Path Group -->
<search name="Search Path Name">
<path value="Search Path 1"/>
<path value="Search Path 2"/>
...
<path value="Search Path N"/>
</search>
<!-- Resource List -->
<resource name="Resource Name 1" file="Resource File" path="Search Name"/>
<resource name="Resource Name 2" file="Resource File" path="Search Name"/>
...
<resource name="Resource Name N" file="Resource File" path="Search Name"/>
</resource-map>
</runtime>
</dmz>
\endcode
\param[in] Init Config containing runtime initialization data.
\param[in] context Pointer to runtime context.
\param[in] log Pointer to Log to use for log messages.
\sa dmz::ObjectType \n dmz::EventType \n dmz::Message \n dmz::Time
*/
void
dmz::runtime_init (const Config &Init, RuntimeContext *context, Log *log) {
Config econfig;
Config oconfig;
Config sconfig;
Config mconfig;
Config tconfig;
Config rconfig;
Init.lookup_all_config ("event-type", econfig);
Init.lookup_all_config ("object-type", oconfig);
Init.lookup_all_config ("state", sconfig);
Init.lookup_all_config ("message", mconfig);
Init.lookup_all_config_merged ("time", tconfig);
Init.lookup_all_config_merged ("resource-map", rconfig);
if (context) {
if (econfig || oconfig || sconfig) {
RuntimeContextDefinitions *defs = context->get_definitions_context ();
if (defs) {
defs->ref ();
if (econfig) { local_init_event_type (econfig, *defs, context, log); }
else if (log) { log->debug << "Event type config not found" << endl; }
if (oconfig) { local_init_object_type (oconfig, *defs, context, log); }
else if (log) { log->debug << "Object type config not found" << endl; }
if (sconfig) { local_init_state (sconfig, *defs, log); }
else if (log) { log->debug << "State config not found" << endl; }
if (defs->handleObsTable.get_count () > 0) {
HashTableHandleIterator it;
String *ptr (0);
while (defs->namedHandleNameTable.get_next (it, ptr)) {
defs->define_named_handle (it.get_hash_key (), *ptr);
}
}
if (defs->maskObsTable.get_count () > 0) {
HashTableStringIterator it;
Mask *ptr (0);
while (defs->maskTable.get_next (it, ptr)) {
defs->define_state (*ptr, it.get_hash_key ());
}
}
if (defs->objectObsTable.get_count () > 0) {
HashTableHandleIterator it;
ObjectType *ptr (0);
while (defs->objectHandleTable.get_next (it, ptr)) {
defs->define_object_type (*ptr);
}
}
if (defs->eventObsTable.get_count () > 0) {
HashTableHandleIterator it;
EventType *ptr (0);
while (defs->eventHandleTable.get_next (it, ptr)) {
defs->define_event_type (*ptr);
}
}
defs->unref (); defs = 0;
}
}
if (mconfig) { local_init_message (mconfig, context, log); }
else if (log) { log->debug << "Message type config not found" << endl; }
if (tconfig) { local_init_time (tconfig, context, log); }
else if (log) { log->debug << "Runtime time data not found" << endl; }
if (rconfig) { local_init_resources (rconfig, context, log); }
else if (log) { log->debug << "Runtime resource data not found" << endl; }
}
}
void
dmz::EventModuleBasic::dump_event (const Handle EventHandle, EventDump &dump) {
EventStruct *event (_lookup_event (EventHandle));
if (event) {
dump.start_dump_event (event->handle, event->type, event->locality);
HashTableHandleIterator it;
{
Handle *ptr = event->objectTable.get_first (it);
while (ptr) {
dump.store_event_object_handle (event->handle, it.get_hash_key (), *ptr);
ptr = event->objectTable.get_next (it);
}
}
{
ObjectType *ptr = event->typeTable.get_first (it);
while (ptr) {
dump.store_event_object_type (event->handle, it.get_hash_key (), *ptr);
ptr = event->typeTable.get_next (it);
}
}
{
Mask *ptr = event->stateTable.get_first (it);
while (ptr) {
dump.store_event_state (event->handle, it.get_hash_key (), *ptr);
ptr = event->stateTable.get_next (it);
}
}
{
Float64 *ptr = event->timeStampTable.get_first (it);
while (ptr) {
dump.store_event_time_stamp (event->handle, it.get_hash_key (), *ptr);
ptr = event->timeStampTable.get_next (it);
}
}
{
Vector *ptr = event->positionTable.get_first (it);
while (ptr) {
dump.store_event_position (event->handle, it.get_hash_key (), *ptr);
ptr = event->positionTable.get_next (it);
}
}
{
Matrix *ptr = event->orientationTable.get_first (it);
while (ptr) {
dump.store_event_orientation (event->handle, it.get_hash_key (), *ptr);
ptr = event->orientationTable.get_next (it);
}
}
{
Vector *ptr = event->velocityTable.get_first (it);
while (ptr) {
dump.store_event_velocity (event->handle, it.get_hash_key (), *ptr);
ptr = event->velocityTable.get_next (it);
}
}
{
Vector *ptr = event->accelerationTable.get_first (it);
while (ptr) {
dump.store_event_acceleration (event->handle, it.get_hash_key (), *ptr);
ptr = event->accelerationTable.get_next (it);
}
}
{
Vector *ptr = event->scaleTable.get_first (it);
while (ptr) {
dump.store_event_scale (event->handle, it.get_hash_key (), *ptr);
ptr = event->scaleTable.get_next (it);
}
}
{
Vector *ptr = event->vectorTable.get_first (it);
while (ptr) {
dump.store_event_vector (event->handle, it.get_hash_key (), *ptr);
ptr = event->vectorTable.get_next (it);
}
}
{
Float64 *ptr = event->scalarTable.get_first (it);
while (ptr) {
dump.store_event_scalar (event->handle, it.get_hash_key (), *ptr);
ptr = event->scalarTable.get_next (it);
}
}
{
String *ptr = event->textTable.get_first (it);
while (ptr) {
dump.store_event_text (event->handle, it.get_hash_key (), *ptr);
ptr = event->textTable.get_next (it);
}
}
{
Data *ptr = event->dataTable.get_first (it);
while (ptr) {
dump.store_event_data (event->handle, it.get_hash_key (), *ptr);
ptr = event->dataTable.get_next (it);
}
}
dump.end_dump_event (event->handle);
}
}
// 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);
}
}
