int DAUDIO_Flush(void* id, int isSource) { SolPcmInfo* info = (SolPcmInfo*) id; int err = -1; int pos; TRACE0("DAUDIO_Flush\n"); if (info) { if (isSource) { err = ioctl(info->fd, I_FLUSH, FLUSHW); } else { err = ioctl(info->fd, I_FLUSH, FLUSHR); } if (err >= 0) { /* resets the transferedBytes parameter to * the current samples count of the device */ pos = getDevicePosition(info, isSource); if (pos >= 0) { info->transferedBytes = pos; } } } if (err < 0) { ERROR0("ERROR in DAUDIO_Flush\n"); } return (err < 0)?FALSE:TRUE; }
void SixDofWithScaleNavigationTool::frame(void) { /* Act depending on this tool's current state: */ switch(navigationMode) { case IDLE: /* Do nothing */ break; case MOVING: { /* Compose the new navigation transformation: */ NavTrackerState navigation=getDeviceTransformation(0); navigation*=preScale; /* Update Vrui's navigation transformation: */ setNavigationTransformation(navigation); break; } case SCALING: { /* Compose the new navigation transformation: */ NavTrackerState navigation=preScale; Vector scaleDirection=getDeviceTransformation(1).transform(factory->deviceScaleDirection); Scalar currentScale=Math::exp((getDevicePosition(0)*scaleDirection-initialScale)/factory->scaleFactor); navigation*=NavTrackerState::scale(currentScale); navigation*=postScale; /* Update Vrui's navigation transformation: */ setNavigationTransformation(navigation); break; } } }
void ClutchTool::buttonCallback(int,int deviceButtonIndex,InputDevice::ButtonCallbackData* cbData) { if(deviceButtonIndex==0) // Clutch button { bool mustInit=false; if(factory->clutchButtonToggleFlag) { if(!cbData->newButtonState) { clutchButtonState=!clutchButtonState; mustInit=!clutchButtonState; } } else { clutchButtonState=cbData->newButtonState; mustInit=!clutchButtonState; } if(mustInit) { /* Calculate the new offset transformation: */ Vector offsetT=transformedDevice->getPosition()-getDevicePosition(0); Rotation offsetR=transformedDevice->getTransformation().getRotation()*Geometry::invert(getDeviceTransformation(0).getRotation()); offset=TrackerState(offsetT,offsetR); } } else // Pass-through button { if(setButtonState(deviceButtonIndex-1,cbData->newButtonState)) transformedDevice->setButtonState(deviceButtonIndex-1,buttonStates[deviceButtonIndex-1]); } }
void SixDofWithScaleNavigationTool::buttonCallback(int,int,InputDevice::ButtonCallbackData* cbData) { if(cbData->newButtonState) // Button has just been pressed { if(navigationMode==IDLE&&activate()) { /* Decide whether to go to moving or scaling mode: */ if(Geometry::sqrDist(getDevicePosition(0),getDevicePosition(1))<=factory->scaleDeviceDistance2) // Want to scale { /* Determine the scaling center and initial scale: */ scalingCenter=getDevicePosition(1); Vector scaleDirection=getDeviceTransformation(1).transform(factory->deviceScaleDirection); initialScale=getDevicePosition(0)*scaleDirection; /* Initialize the navigation transformations: */ preScale=NavTrackerState::translateFromOriginTo(scalingCenter); postScale=NavTrackerState::translateToOriginFrom(scalingCenter); postScale*=getNavigationTransformation(); /* Go from MOVING to SCALING mode: */ navigationMode=SCALING; } else // Want to move { /* Initialize the navigation transformations: */ preScale=Geometry::invert(getDeviceTransformation(0)); preScale*=getNavigationTransformation(); /* Go from IDLE to MOVING mode: */ navigationMode=MOVING; } } } else // Button has just been released { /* Deactivate this tool: */ deactivate(); /* Go from MOVING or SCALING to IDLE mode: */ navigationMode=IDLE; } }
void ClipPlaneTool::frame(void) { if(active) { /* Get the new normal vector and plane center point: */ Vector normal=getDeviceTransformation(0).transform(factory->normal); Point center=getDevicePosition(0); /* Set the clipping plane's plane equation: */ clipPlane->getPlane()=Plane(normal,center); } }
void DAUDIO_SetBytePosition(void* id, int isSource, INT64 javaBytePos) { SolPcmInfo* info = (SolPcmInfo*) id; int ret; int pos; if (info) { pos = getDevicePosition(info, isSource); if (pos >= 0) { info->positionOffset = javaBytePos - pos; } } }
void ClutchTool::frame(void) { if(!clutchButtonState) { /* Update the transformation of the transformed device: */ TrackerState clutch=getDeviceTransformation(0); clutch.leftMultiply(TrackerState::rotateAround(getDevicePosition(0),offset.getRotation())); clutch.leftMultiply(TrackerState::translate(offset.getTranslation())); clutch.renormalize(); transformedDevice->setTransformation(clutch); } }
INT64 DAUDIO_GetBytePosition(void* id, int isSource, INT64 javaBytePos) { SolPcmInfo* info = (SolPcmInfo*) id; int ret; int pos; INT64 result = javaBytePos; if (info) { pos = getDevicePosition(info, isSource); if (pos >= 0) { result = info->positionOffset + pos; } } //printf("getbyteposition: javaBytePos=%d , return=%d\n", (int) javaBytePos, (int) result); return result; }
int DAUDIO_GetAvailable(void* id, int isSource) { SolPcmInfo* info = (SolPcmInfo*) id; int ret = 0; int pos; if (info) { /* unfortunately, the STREAMS architecture * seems to not have a method for querying * the available bytes to read/write! * estimate it... */ pos = getDevicePosition(info, isSource); if (pos >= 0) { if (isSource) { /* we usually have written more bytes * to the queue than the device position should be */ ret = (info->bufferSizeInBytes) - (info->transferedBytes - pos); } else { /* for record, the device stream should * be usually ahead of our read actions */ ret = pos - info->transferedBytes; } if (ret > info->bufferSizeInBytes) { ERROR2("DAUDIO_GetAvailable: available=%d, too big at bufferSize=%d!\n", (int) ret, (int) info->bufferSizeInBytes); ERROR2(" devicePos=%d, transferedBytes=%d\n", (int) pos, (int) info->transferedBytes); ret = info->bufferSizeInBytes; } else if (ret < 0) { ERROR1("DAUDIO_GetAvailable: available=%d, in theory not possible!\n", (int) ret); ERROR2(" devicePos=%d, transferedBytes=%d\n", (int) pos, (int) info->transferedBytes); ret = 0; } } } TRACE1("DAUDIO_GetAvailable returns %d bytes\n", ret); return ret; }
void ValuatorScalingNavigationTool::valuatorCallback(int,int,InputDevice::ValuatorCallbackData* cbData) { currentValue=Scalar(cbData->newValuatorValue); if(Math::abs(currentValue)>factory->valuatorThreshold) { /* Try activating this tool: */ if(!isActive()&&activate()) { /* Initialize the navigation transformations: */ scalingCenter=getDevicePosition(0); preScale=NavTrackerState::translateFromOriginTo(scalingCenter); postScale=NavTrackerState::translateToOriginFrom(scalingCenter); postScale*=getNavigationTransformation(); currentScale=Scalar(1); } } else { /* Deactivate this tool: */ deactivate(); } }