void wxCustomButton::SendEvent()
{
if (((m_button_style & wxCUSTBUT_TOGGLE) && (m_eventType == wxEVT_LEFT_UP)) ||
((m_button_style & wxCUSTBUT_BUT_DCLICK_TOG) && (m_eventType == wxEVT_LEFT_DCLICK)) ||
((m_button_style & wxCUSTBUT_TOG_DCLICK_BUT) && (m_eventType == wxEVT_LEFT_UP)))
{
wxCommandEvent eventOut(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, GetId());
eventOut.SetInt(m_down%2 ? 1 : 0);
eventOut.SetExtraLong(m_eventType);
eventOut.SetEventObject(this);
GetEventHandler()->ProcessEvent(eventOut);
}
else
{
wxCommandEvent eventOut(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
eventOut.SetInt(0);
eventOut.SetExtraLong(m_eventType);
eventOut.SetEventObject(this);
GetEventHandler()->ProcessEvent(eventOut);
}
}
void VrmlNodeMovieTexture::eventIn(double timeStamp,
const char *eventName,
const VrmlField *fieldValue)
{
const char *origEventName = eventName;
if ( strncmp(eventName, "set_", 4) == 0 )
eventName += 4;
// Ignore set_speed when active
if ( strcmp(eventName,"speed") == 0 )
{
if (! d_isActive.get())
{
setField(eventName, *fieldValue);
eventOut(timeStamp, "speed_changed", *fieldValue);
setModified();
}
}
// Let the generic code handle the rest.
else
VrmlNode::eventIn( timeStamp, origEventName, fieldValue );
}
void VrmlNodeMultiTouchSensor::remoteUpdate(bool visible, float *pos, float angle)
{
double timeNow = System::the->time();
bool wasVisible = d_visible.get();
if (visible)
{
if (!wasVisible)
{
d_visible.set(true);
eventOut(timeNow, "isVisible", d_visible);
d_scale.set(1, 1, 1);
eventOut(timeNow, "scale_changed", d_scale);
}
d_translation.set(pos[0], pos[1], pos[2]);
eventOut(timeNow, "translation_changed", d_translation);
osg::Vec3 normal(0, 0, 1);
normal = osg::Matrix::transform3x3(surfaceTrans, normal);
d_rotation.set(normal[0], normal[1], normal[2], angle);
eventOut(timeNow, "rotation_changed", d_rotation);
}
else
{
if (wasVisible)
{
d_visible.set(false);
eventOut(timeNow, "isVisible", d_visible);
if (!d_freeze.get())
{
d_translation = d_invisiblePosition;
eventOut(timeNow, "translation_changed", d_translation);
d_scale.set(0.000001, 0.0000001, 0.0000001);
eventOut(timeNow, "scale_changed", d_scale);
}
}
}
setModified();
}
void VrmlNodeOrientationInt::eventIn(double timeStamp,
const char *eventName,
const VrmlField *fieldValue)
{
if (strcmp(eventName, "set_fraction") == 0)
{
if (! fieldValue->toSFFloat() )
{
theSystem->error
("Invalid type for %s eventIn %s (expected SFFloat).\n",
nodeType()->getName(), eventName);
return;
}
float f = fieldValue->toSFFloat()->get();
//printf("OI.set_fraction %g ", f);
int n = d_key.size() - 1;
if (f < d_key[0])
{
float *v0 = d_keyValue[0];
//printf(" 0 [%g %g %g %g]\n", v0[0], v0[1], v0[2], v0[3] );
d_value.set( v0[0], v0[1], v0[2], v0[3] );
}
else if (f > d_key[n])
{
float *vn = d_keyValue[n];
//printf(" n [%g %g %g %g]\n", vn[0], vn[1], vn[2], vn[3] );
d_value.set( vn[0], vn[1], vn[2], vn[3] );
}
else
{
for (int i=0; i<n; ++i)
if (d_key[i] <= f && f <= d_key[i+1])
{
float *v1 = d_keyValue[i];
float *v2 = d_keyValue[i+1];
// Interpolation factor
f = (f - d_key[i]) / (d_key[i+1] - d_key[i]);
float x, y, z, r1, r2;
r1 = v1[3];
// Make sure the vectors are not pointing opposite ways
if (v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] < 0.0)
{
x = v1[0] + f * (-v2[0] - v1[0]);
y = v1[1] + f * (-v2[1] - v1[1]);
z = v1[2] + f * (-v2[2] - v1[2]);
r2 = -v2[3];
}
else
{
x = v1[0] + f * (v2[0] - v1[0]);
y = v1[1] + f * (v2[1] - v1[1]);
z = v1[2] + f * (v2[2] - v1[2]);
r2 = v2[3];
}
// Interpolate angles via the shortest direction
if (fabs(double(r2 - r1)) > M_PI)
{
if (r2 > r1) r1 += 2.0 * M_PI;
else r2 += 2.0 * M_PI;
}
float r = r1 + f * (r2 - r1);
if (r >= 2.0 * M_PI) r -= 2.0 * M_PI;
else if (r < 0.0) r += 2.0 * M_PI;
//printf(" %g between (%d,%d) [%g %g %g %g]\n", f, i, i+1,
//x, y, z, r);
d_value.set( x, y, z, r);
break;
}
}
// Send the new value
eventOut(timeStamp, "value_changed", d_value);
}
// Check exposedFields
else
{
VrmlNode::eventIn(timeStamp, eventName, fieldValue);
// This node is not renderable, so don't re-render on changes to it.
clearModified();
}
}
void VrmlNodePlaneSensor::activate( double timeStamp,
bool isActive,
double *p )
{
// Become active
if ( isActive && ! d_isActive.get() )
{
d_isActive.set(isActive);
float V[3] = { (float)p[0], (float)p[1], (float)p[2] };
double M[4][4];
inverseTransform( M );
VM( V, M, V );
d_activationPoint.set( V[0], V[1], V[2] );
#if 0
theSystem->warn(" planesensor: activate at (%g %g %g)\n",
p[0],p[1],p[2]);
theSystem->warn(" planesensor: local coord (%g %g %g)\n",
V[0],V[1],V[2]);
#endif
eventOut( timeStamp, "isActive", d_isActive );
}
// Become inactive
else if ( ! isActive && d_isActive.get() )
{
#if 0
theSystem->warn(" planesensor: deactivate\n");
#endif
d_isActive.set(isActive);
eventOut( timeStamp, "isActive", d_isActive );
// auto offset
if ( d_autoOffset.get() )
{
d_offset = d_translation;
eventOut( timeStamp, "offset_changed", d_offset );
}
}
// Tracking
else if ( isActive )
{
float V[3] = { (float)p[0], (float)p[1], (float)p[2] };
double M[4][4];
inverseTransform( M );
VM( V, M, V );
#if 0
theSystem->warn(" planesensor: track at (%g %g %g)\n",
p[0],p[1],p[2]);
theSystem->warn(" planesensor: local cd (%g %g %g)\n",
V[0],V[1],V[2]);
#endif
d_trackPoint.set( V[0], V[1], V[2] );
eventOut( timeStamp, "trackPoint_changed", d_trackPoint );
float t[3];
t[0] = V[0] - d_activationPoint.x() + d_offset.x();
t[1] = V[1] - d_activationPoint.y() + d_offset.y();
t[2] = 0.0;
if ( d_minPosition.x() == d_maxPosition.x() )
t[0] = d_minPosition.x();
else if ( d_minPosition.x() < d_maxPosition.x() )
{
if (t[0] < d_minPosition.x())
t[0] = d_minPosition.x();
else if (t[0] > d_maxPosition.x())
t[0] = d_maxPosition.x();
}
if ( d_minPosition.y() == d_maxPosition.y() )
t[1] = d_minPosition.y();
else if ( d_minPosition.y() < d_maxPosition.y() )
{
if (t[1] < d_minPosition.y())
t[1] = d_minPosition.y();
else if (t[1] > d_maxPosition.y())
t[1] = d_maxPosition.y();
}
d_translation.set( t[0], t[1], t[2] );
eventOut( timeStamp, "translation_changed", d_translation );
}
}
void VrmlNodeVisibilitySensor::render(Viewer *viewer)
{
if (d_enabled.get())
{
VrmlSFTime timeNow( theSystem->time() );
float xyz[2][3];
// hack: enclose box in a sphere...
xyz[0][0] = d_center.x();
xyz[0][1] = d_center.y();
xyz[0][2] = d_center.z();
xyz[1][0] = d_center.x() + d_size.x();
xyz[1][1] = d_center.y() + d_size.y();
xyz[1][2] = d_center.z() + d_size.z();
viewer->transformPoints( 2, &xyz[0][0] );
float dx = xyz[1][0]-xyz[0][0];
float dy = xyz[1][1]-xyz[0][1];
float dz = xyz[1][2]-xyz[0][2];
float r = dx*dx + dy*dy + dz*dz;
if (! FPZERO(r) ) r = sqrt( r );
// Was the sphere visible last time through? How does this work
// for USE'd nodes? I need a way for each USE to store whether
// it was active.
bool wasIn = d_isActive.get();
// Is the sphere visible? ...
bool inside = xyz[0][2] < 0.0; // && z > - scene->visLimit()
if (inside)
{
VrmlNodeNavigationInfo *ni = d_scene->bindableNavigationInfoTop();
if (ni &&
! FPZERO(ni->visibilityLimit()) &&
xyz[0][2] < - ni->visibilityLimit())
inside = false;
}
// This bit assumes 90degree fieldOfView to get rid of trig calls...
if (inside)
inside = ( fabs(double(xyz[0][0])) < -0.5 * xyz[0][2] + r &&
fabs(double(xyz[0][1])) < -0.5 * xyz[0][2] + r );
// Just became visible
if (inside && ! wasIn)
{
theSystem->debug("VS enter %g, %g, %g\n",
xyz[0][0], xyz[0][1], xyz[0][2]);
d_isActive.set(true);
eventOut(timeNow.get(), "isActive", d_isActive);
d_enterTime = timeNow;
eventOut(timeNow.get(), "enterTime", d_enterTime);
}
// Check if viewer has left the box
else if (wasIn && ! inside)
{
theSystem->debug("VS exit %g, %g, %g\n",
xyz[0][0], xyz[0][1], xyz[0][2]);
d_isActive.set(false);
eventOut(timeNow.get(), "isActive", d_isActive );
d_exitTime = timeNow;
eventOut(timeNow.get(), "exitTime", d_exitTime);
}
}
else
clearModified();
}
void VrmlNodeCoordinateInt::eventIn(double timeStamp,
const char *eventName,
const VrmlField *fieldValue)
{
if (strcmp(eventName, "set_fraction") == 0)
{
if (! fieldValue->toSFFloat() )
{
theSystem->error
("Invalid type for %s eventIn %s (expected SFFloat).\n",
nodeType()->getName(), eventName);
return;
}
float f = fieldValue->toSFFloat()->get();
int nCoords = d_keyValue.size() / d_key.size();
int n = d_key.size() - 1;
if (f < d_key[0])
{
d_value.set( nCoords, d_keyValue[0] );
}
else if (f > d_key[n])
{
d_value.set( nCoords, d_keyValue[n*nCoords] );
}
else
{
// Reserve enough space for the new value
d_value.set( nCoords, 0 );
for (int i=0; i<n; ++i)
if (d_key[i] <= f && f <= d_key[i+1])
{
float *v1 = d_keyValue[i*nCoords];
float *v2 = d_keyValue[(i+1)*nCoords];
float *x = d_value.get();
f = (f - d_key[i]) / (d_key[i+1] - d_key[i]);
for (int j=0; j<nCoords; ++j)
{
*x++ = v1[0] + f * (v2[0] - v1[0]);
*x++ = v1[1] + f * (v2[1] - v1[1]);
*x++ = v1[2] + f * (v2[2] - v1[2]);
v1 += 3;
v2 += 3;
}
break;
}
}
// Send the new value
eventOut(timeStamp, "value_changed", d_value);
}
// Check exposedFields
else
{
VrmlNode::eventIn(timeStamp, eventName, fieldValue);
// This node is not renderable, so don't re-render on changes to it.
clearModified();
}
}
void VrmlNodeMovieTexture::update( VrmlSFTime &timeNow )
{
if ( isModified() )
{
if (d_image)
{
const char *imageUrl = d_image->url();
int imageLen = (int)strlen(imageUrl);
int i, nUrls = d_url.size();
for (i=0; i<nUrls; ++i)
{
int len = (int)strlen(d_url[i]);
if ((strcmp(imageUrl, d_url[i]) == 0) ||
(imageLen > len &&
strcmp(imageUrl+imageLen-len, d_url[i]) == 0))
break;
}
// if (d_image->url() not in d_url list) ...
if (i == nUrls)
{
delete d_image;
d_image = 0;
}
}
}
// Load the movie if needed (should check startTime...)
if (! d_image && d_url.size() > 0)
{
Doc relDoc( d_relativeUrl.get() );
Doc *rel = d_relativeUrl.get() ? &relDoc : d_scene->urlDoc();
d_image = new Image;
if ( ! d_image->tryURLs( d_url.size(), d_url.get(), rel ) )
cerr << "Error: couldn't read MovieTexture from URL " << d_url << endl;
int nFrames = d_image->nFrames();
d_duration = (nFrames >= 0) ? nFrames : -1;
eventOut( timeNow.get(), "duration_changed", d_duration );
d_frame = (d_speed.get() >= 0) ? 0 : nFrames-1;
//theSystem->debug("MovieTexture.%s loaded %d frames\n", name(), nFrames);
}
// No pictures to show
if (! d_image || d_image->nFrames() == 0) return;
// Become active at the first tick at or after startTime if either
// the valid stopTime hasn't passed or we are looping.
if (! d_isActive.get() &&
d_startTime.get() <= timeNow.get() &&
d_startTime.get() >= d_lastFrameTime &&
( (d_stopTime.get() < d_startTime.get() || // valid stopTime
d_stopTime.get() > timeNow.get()) || // hasn't passed
d_loop.get() ))
{
//theSystem->debug("MovieTexture.%s::isActive TRUE\n", name());
d_isActive.set(true);
eventOut( timeNow.get(), "isActive", d_isActive );
d_lastFrameTime = timeNow.get();
d_frame = (d_speed.get() >= 0) ? 0 : d_image->nFrames() - 1;
setModified();
}
// Check whether stopTime has passed
else if ( d_isActive.get() &&
(( d_stopTime.get() > d_startTime.get() &&
d_stopTime.get() <= timeNow.get() ) ||
d_frame < 0))
{
//theSystem->debug("MovieTexture.%s::isActive FALSE\n", name());
d_isActive.set(false);
eventOut( timeNow.get(), "isActive", d_isActive );
setModified();
}
// Check whether the frame should be advanced
else if ( d_isActive.get() &&
d_lastFrameTime + fabs(double(d_speed.get())) <= timeNow.get() )
{
if (d_speed.get() < 0.0)
--d_frame;
else
++d_frame;
//theSystem->debug("MovieTexture.%s::frame %d\n", name(), d_frame);
d_lastFrameTime = timeNow.get();
setModified();
}
// Tell the scene when the next update is needed.
if (d_isActive.get())
{
double d = d_lastFrameTime + fabs(double(d_speed.get())) - timeNow.get();
d_scene->setDelta( 0.9 * d );
}
}
void VrmlNodeMultiTouchSensor::render(Viewer *viewer)
{
(void)viewer;
if (markerID < 0 && coVRTouchTable::instance()->ttInterface != NULL && d_markerName.get())
{
markerID = coVRTouchTable::instance()->ttInterface->getMarker(d_markerName.get());
}
if (markerID >= 0)
{
double timeNow = System::the->time();
bool wasVisible = d_visible.get();
coVRTouchTableInterface *tti = coVRTouchTable::instance()->ttInterface;
if (tti->isVisible(markerID))
{
if (!wasVisible)
{
d_visible.set(true);
eventOut(timeNow, "isVisible", d_visible);
d_scale.set(1, 1, 1);
eventOut(timeNow, "scale_changed", d_scale);
}
osg::Matrix MarkerPos; // marker position in camera coordinate system
osg::Vec2 pos2 = tti->getPosition(markerID);
float angle = tti->getOrientation(markerID);
osg::Vec3 pos;
pos.set(pos2[0] * d_size.x(), pos2[1] * d_size.y(), 0);
pos = surfaceTrans.preMult(pos);
osg::Vec3 normal(0, 0, 1);
normal = osg::Matrix::transform3x3(surfaceTrans, normal);
if (fabs(pos[0] - oldPos[0]) > d_positionThreshold.get() || fabs(pos[1] - oldPos[1]) > d_positionThreshold.get()
|| fabs(angle - oldAngle) > d_orientationThreshold.get()
|| ((timeNow - oldTime) < 1.0))
{
d_translation.set(pos[0], pos[1], pos[2]);
d_translation.subtract(&d_markerPosition);
eventOut(timeNow, "translation_changed", d_translation);
d_rotation.set(normal[0], normal[1], normal[2], angle);
d_rotation.multiply(&d_markerRotation);
eventOut(timeNow, "rotation_changed", d_rotation);
if (fabs(pos[0] - oldPos[0]) > d_positionThreshold.get() || fabs(pos[1] - oldPos[1]) > d_positionThreshold.get()
|| fabs(angle - oldAngle) > d_orientationThreshold.get())
{
oldTime = timeNow;
}
oldPos[0] = pos[0];
oldPos[1] = pos[1];
oldAngle = angle;
float t[3];
t[0] = pos[0];
t[1] = pos[1];
t[2] = pos[2];
sendMultiTouchEvent(d_markerName.get(), true, t, angle);
}
else
{
//oldPos[0] = t[0]; oldPos[1] = t[1]; oldPos[2] = t[2];
//oldAngles[0] = coord.hpr[0]; oldAngles[1] = coord.hpr[1]; oldAngles[2] = coord.hpr[2];
}
}
else
{
if (wasVisible)
{
d_visible.set(false);
eventOut(timeNow, "isVisible", d_visible);
if (!d_freeze.get())
{
d_translation = d_invisiblePosition;
eventOut(timeNow, "translation_changed", d_translation);
d_scale.set(0.000001, 0.0000001, 0.0000001);
eventOut(timeNow, "scale_changed", d_scale);
}
oldPos[0] = 3212;
oldPos[1] = 100000;
oldAngle = 1000;
oldTime = 0.0;
float pos[2];
pos[0] = pos[1] = /*pos[2]=*/0;
float angle = 0.0;
sendMultiTouchEvent(d_markerName.get(), false, pos, angle);
}
}
}
setModified();
}