コード例 #1
0
ファイル: ofEasyCam.cpp プロジェクト: nanu-c/openFrameworks
//----------------------------------------
void ofEasyCam::mousePressed(ofMouseEventArgs & mouse){
	ofRectangle area = getControlArea();
	if(area.inside(mouse.x, mouse.y)){
		lastMouse = mouse;
		prevMouse = mouse;
		prevAxisX = getXAxis();
		prevAxisY = getYAxis();
		prevAxisZ = getZAxis();
		prevPosition = ofCamera::getGlobalPosition();
		prevOrientation = ofCamera::getGlobalOrientation();

		if((bEnableMouseMiddleButton && mouse.button == OF_MOUSE_BUTTON_MIDDLE) || events->getKeyPressed(doTranslationKey)  || mouse.button == OF_MOUSE_BUTTON_RIGHT){
			bDoTranslate = true;
			bDoRotate = false;
		}else if(mouse.button == OF_MOUSE_BUTTON_LEFT){
			bDoTranslate = false;
			bDoRotate = true;
			if(glm::length(glm::vec2(mouse.x - area.x - (area.width/2), mouse.y - area.y - (area.height/2))) < std::min(area.width/2, area.height/2)){
				bInsideArcball = true;
			}else{
				bInsideArcball = false;
			}
		}
		bApplyInertia = false;
	}
}
コード例 #2
0
ファイル: ofEasyCam.cpp プロジェクト: K0j0/openFrameworks
void ofEasyCam::mousePressed(ofMouseEventArgs & mouse){
	ofRectangle viewport = getViewport(this->viewport);
	if(viewport.inside(mouse.x, mouse.y)){
		lastMouse = mouse;
		prevMouse = mouse;
		prevAxisX = getXAxis();
		prevAxisY = getYAxis();
		prevAxisZ = getZAxis();
		prevPosition = ofCamera::getGlobalPosition();
		prevOrientation = ofCamera::getGlobalOrientation();

		if ((bEnableMouseMiddleButton && mouse.button == OF_MOUSE_BUTTON_MIDDLE) || events->getKeyPressed(doTranslationKey)  || mouse.button == OF_MOUSE_BUTTON_RIGHT){
			bDoTranslate = true;
			bDoRotate = false;
		}else if (mouse.button == OF_MOUSE_BUTTON_LEFT) {
			bDoTranslate = false;
			bDoRotate = true;
			if(ofVec2f(mouse.x - viewport.x - (viewport.width/2), mouse.y - viewport.y - (viewport.height/2)).length() < min(viewport.width/2, viewport.height/2)){
				bInsideArcball = true;
			}else {
				bInsideArcball = false;
			}
		}
		bApplyInertia = false;
	}
}
コード例 #3
0
ファイル: ofEasyFingerCam.cpp プロジェクト: paulobala/tCAD
void ofEasyFingerCam::updateRotation()
{
    rotationX += (targetXRot - rotationX) *.1;
    rotationY += (targetYRot - rotationY) *.1;
    rotationZ += (targetZRot - rotationZ) *.1;
    target.setOrientation(ofQuaternion(0,0,0,1)); //reset
    ofQuaternion p = ((getOrientationQuat() * ofQuaternion(-rotationY, getXAxis())) * ofQuaternion(-rotationX, getYAxis())) * ofQuaternion(-rotationZ, getZAxis());
    target.setOrientation(p);
}
コード例 #4
0
//------------------------------------------------
void TravelingCam::update(ofEventArgs& a) {

    unsigned long long t = ofGetElapsedTimeMillis();
    if (bTweening) {
        currentSpeed = tween.update();
    } else if (pathLength < currentDistance + slowdownDist) {

        currentSpeed = ofMap(currentDistance, pathLength - slowdownDist, pathLength, 0, speed);

    } else {
        currentSpeed = speed;
    }



    unsigned long long dt = t - lastUpdateTime;
    currentDistance += currentSpeed * dt;

    ofPoint p = path.getPointAtLength(currentDistance);
    float inc = 10;

    if (pathLength < currentDistance + inc ) {
        inc = pathLength - currentDistance;
    }
    ofPoint p0 = path.getPointAtLength(currentDistance + inc);

    p.y *= heightMult;
    p0.y *= heightMult;
    //lookAt( p + (p - p0).normalize());
    setPosition( p);
    dirVec  = p + (p0 - p).normalize();

    lookAt(dirVec, ofVec3f(0,1,0));

    boom(altura);
    if(bMousePressed || bXenoRunning) {
        ofVec2f c (ofGetWidth()/2, ofGetHeight()/2);



        ofVec2f mouseNorm = mousePos - c;
        xenoPos = xenoPos + (mouseNorm- xenoPos)*xenoFactor;
        if ((mouseNorm - xenoPos).length() < 1) {
            xenoPos = mouseNorm;
            bXenoRunning = false;
        }

//        mouseNorm.x /= c.x;
        //      mouseNorm.y /= c.y;

        rotate(ofMap(xenoPos.x, -c.x, c.x, 90, -90), getYAxis());
        rotate(ofMap(xenoPos.y, -c.y, c.y, 60, -60), getXAxis());
    }
    lastUpdateTime = t;
}
コード例 #5
0
//----------------------------------------
void ofEasyCam::updateTranslation(){
	if (bApplyInertia) {
		moveX *= drag;
		moveY *= drag;
		moveZ *= drag;
		if (ABS(moveX) <= minDifference && ABS(moveY) <= minDifference && ABS(moveZ) <= minDifference) {
			bApplyInertia = false;
			bDoTranslate = false;
		}
	}
	move((getXAxis() * moveX) + (getYAxis() * moveY) + (getZAxis() * moveZ));
}	
コード例 #6
0
ファイル: ofEasyCam.cpp プロジェクト: K0j0/openFrameworks
//----------------------------------------
void ofEasyCam::updateTranslation(){
	if (bApplyInertia) {
		moveX *= drag;
		moveY *= drag;
		moveZ *= drag;
		if (ABS(moveX) <= minDifference && ABS(moveY) <= minDifference && ABS(moveZ) <= minDifference) {
			bApplyInertia = false;
			bDoTranslate = false;
		}
		move((getXAxis() * moveX) + (getYAxis() * moveY) + (getZAxis() * moveZ));
	}else{
		setPosition(prevPosition + ofVec3f(prevAxisX * moveX) + (prevAxisY * moveY) + (prevAxisZ * moveZ));
	}
}	
コード例 #7
0
//----------------------------------------
void ofLight::onOrientationChanged() {
	if(data->glIndex==-1) return;
	if(getIsDirectional()) {
		// if we are a directional light and not positional, update light position (direction)
		auto lookAtDir = glm::normalize(getGlobalOrientation() * glm::vec4(0,0,-1, 1)).xyz();
		data->position = {lookAtDir.x,lookAtDir.y,lookAtDir.z,0.f};
		ofGetGLRenderer()->setLightPosition(data->glIndex,data->position);
	}else if(getIsSpotlight() || getIsAreaLight()) {
		// determines the axis of the cone light
		auto lookAtDir = glm::normalize(getGlobalOrientation() * glm::vec4(0,0,-1, 1)).xyz();
		data->direction = lookAtDir;
		ofGetGLRenderer()->setLightSpotDirection(data->glIndex, glm::vec4(data->direction, 0.0f));
	}
	if(getIsAreaLight()){
		data->up = getUpDir();
		data->right = getXAxis();
	}
}
コード例 #8
0
ファイル: ofEasyCam.cpp プロジェクト: K0j0/openFrameworks
//----------------------------------------
void ofEasyCam::updateRotation(){
	if (bApplyInertia) {
		xRot *=drag; 
		yRot *=drag;
		zRot *=drag;
		
		if (ABS(xRot) <= minDifference && ABS(yRot) <= minDifference && ABS(zRot) <= minDifference) {
			bApplyInertia = false;
			bDoRotate = false;
		}
		curRot = ofQuaternion(xRot, getXAxis(), yRot, getYAxis(), zRot, getZAxis());
		setPosition((getGlobalPosition()-target.getGlobalPosition())*curRot +target.getGlobalPosition());
		rotate(curRot);
	}else{
		curRot = ofQuaternion(xRot, prevAxisX, yRot, prevAxisY, zRot, prevAxisZ);
		setPosition((prevPosition-target.getGlobalPosition())*curRot +target.getGlobalPosition());
		setOrientation(prevOrientation * curRot);
	}
}
コード例 #9
0
ファイル: ofLight.cpp プロジェクト: 6uclz1/openFrameworks
//----------------------------------------
void ofLight::onOrientationChanged() {
	if(data->glIndex==-1) return;
	// if we are a directional light and not positional, update light position (direction)
	if(getIsDirectional()) {
		// (tig) takes into account global orientation should node be parented.
		ofVec3f lookAtDir = ( getGlobalTransformMatrix().getInverse() * ofVec4f(0,0,-1, 1) ).getNormalized();
		data->position = ofVec4f(lookAtDir.x,lookAtDir.y,lookAtDir.z,0);
		ofGetGLRenderer()->setLightPosition(data->glIndex,data->position);
	}else if(getIsSpotlight() || getIsAreaLight()) {
		// determines the axis of the cone light //

		// (tig) takes into account global orientation should node be parented.
		ofVec3f lookAtDir = ( getGlobalTransformMatrix().getInverse() * ofVec4f(0,0,-1, 1) ).getNormalized();
		data->direction = ofVec3f(lookAtDir.x,lookAtDir.y,lookAtDir.z);
		ofGetGLRenderer()->setLightSpotDirection(data->glIndex,data->direction);
	}
	if(getIsAreaLight()){
		data->up = getUpDir();
		data->right = getXAxis();
	}
}
コード例 #10
0
ファイル: ofEasyCam.cpp プロジェクト: nanu-c/openFrameworks
//----------------------------------------
void ofEasyCam::updateTranslation(){
	if(bApplyInertia){
		moveX *= drag;
		moveY *= drag;
		moveZ *= drag;

		if(ABS(moveZ) >= minDifference){
			bIsBeingScrolled = true;
		} else {
			bIsBeingScrolled = false;
		}

		if(ABS(moveX) <= minDifference && ABS(moveY) <= minDifference && ABS(moveZ) <= minDifference){
			bApplyInertia = false;
			bDoTranslate = false;
		}
		move((getXAxis() * moveX) + (getYAxis() * moveY) + (getZAxis() * moveZ));
	}else if(bDoTranslate || bIsBeingScrolled){
		setPosition(prevPosition + glm::vec3(prevAxisX * moveX) + (prevAxisY * moveY) + (prevAxisZ * moveZ));
		bIsBeingScrolled = false;
	}
}	
コード例 #11
0
ファイル: main.c プロジェクト: ArjunThiraviam/CADMouse
int main(void) {
	wdt_enable(WDTO_1S);

	//odDebugInit();
	//DBG1(0x00, 0, 0);  /* debug output: main starts */

	mouseInit();

	usbInit();

	usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */
	uchar i = 0;
	while(--i){  /* fake USB disconnect for > 250 ms */
		wdt_reset();
		_delay_ms(1);
	}
	usbDeviceConnect();

	sei();
	//DBG1(0x01, 0, 0);  /* debug output: main loop starts */
	
	
	for(;;){ /* main event loop */
		//DBG1(0x02, 0, 0);  /* debug output: main loop iterates */
		wdt_reset();
		usbPoll();
		
		reportBuffer[0]=getXAxis();
		reportBuffer[1]=getYAxis();
		reportBuffer[2]=getZAxis();
		
		if(usbInterruptIsReady()){
		// called after every poll of the interrupt endpoint
		//DBG1(0x03, 0, 0);  // debug output: interrupt report prepared
		usbSetInterrupt((void *)&reportBuffer, sizeof(reportBuffer));
		}
	}
}
コード例 #12
0
void ofxGameCamera::updateRotation(){
	
	if(!applyRotation) return;
	
//	cout << "update rotation!" << endl;
	if(dampen){
		rotationX += (targetXRot - rotationX) *.2;
		rotationY += (targetYRot - rotationY) *.2;
		rotationZ += (targetZRot - rotationZ) *.2;
	}
	else{
		rotationX = targetXRot;
		rotationY = targetYRot;
		rotationZ = targetZRot;
	}
	
	setOrientation(ofQuaternion(0,0,0,1)); //reset
	setOrientation(getOrientationQuat() * ofQuaternion(-rotationZ, getZAxis()));
	setOrientation(getOrientationQuat() * ofQuaternion(-rotationX, getYAxis()));
	setOrientation(getOrientationQuat() * ofQuaternion(-rotationY, getXAxis()));
		
	targetNode.setOrientation(getOrientationQuat());
}
コード例 #13
0
//----------------------------------------
void ofEasyCamExt::update(ofEventArgs & args)
{
	if( isDoingMove )
	{
		float tmpFraction = ofMap( ofGetElapsedTimef(),
								   moveStartEndTimeParameters.getMin(), moveStartEndTimeParameters.getMax(),
								  0.0f, 1.0f );
		
		if( tmpFraction >= 1.0f )
		{
			isDoingMove = false;
		}
		
		tmpFraction = ofClamp( tmpFraction, 0.0f, 1.0f );
		tmpFraction = EasingEquations::ease( tmpFraction, easeType );
		
		ofVec3f newPos = positionEaseParameters.getMin().interpolate( positionEaseParameters.getMax(), tmpFraction );
		//ofVec3f newLookAtDir = lookAtEaseParameters.getMin().interpolate( lookAtEaseParameters.getMax(), tmpFraction );
		
		ofQuaternion newOrientation;
		newOrientation.slerp( tmpFraction, orientationEaseStart, orientationEaseEnd );
		
		//resetTransform();
		setPosition(newPos);
		
		//target.resetTransform();
		//target.setPosition(newLookAtDir);
		//lookAt(target, getUpDir() );
		setOrientation( newOrientation );
		
		moveX = 0;
		moveY = 0;
		moveZ = 0;
	}
	else
	{
			
		if(!bDistanceSet && bAutoDistance)
		{
			setDistance(getImagePlaneDistance(viewport), true);
		}
		
		if(bMouseInputEnabled)
		{
			rotationFactor = sensitivityRot * 180 / min(viewport.width, viewport.height);
			if (bMouseInputEnabled)
			{
				updateMouse();
			}
			
			if (bDoRotate)
			{
				updateRotation();
			}
			else if (bDoTranslate)
			{
				updateTranslation(); 
			}
		}
		
		if( dollyForwardKey != 0 )
		{
			if( ofGetKeyPressed(dollyForwardKey) ) { dollyImpulse( -dollyImpulseAmount ); }
		}
		
		if( dollyBackwardKey != 0 )
		{
			if( ofGetKeyPressed(dollyBackwardKey) ) { dollyImpulse( dollyImpulseAmount ); }
		}
		
	//	if (bApplyInertia) {
			moveX *= drag;
			moveY *= drag;
			moveZ *= drag;
			if (ABS(moveX) <= minDifference && ABS(moveY) <= minDifference && ABS(moveZ) <= minDifference) {
				//bApplyInertia = false;
				bDoTranslate = false;
			}
	//	}
		
		move((getXAxis() * moveX) + (getYAxis() * moveY) + (getZAxis() * moveZ));
	}

}
コード例 #14
0
//----------------------------------------
void ofEasyCamExt::updateTranslation()
{
	move((getXAxis() * moveX) + (getYAxis() * moveY) + (getZAxis() * moveZ));
}
コード例 #15
0
ファイル: ofNode.cpp プロジェクト: Catchoom/openFrameworks
//----------------------------------------
glm::vec3 ofNode::getSideDir() const {
	return getXAxis();
}
コード例 #16
0
ファイル: ofNode.cpp プロジェクト: Catchoom/openFrameworks
//----------------------------------------
void ofNode::tiltRad(float radians) {
	rotateRad(radians, getXAxis());
}
コード例 #17
0
ファイル: ofNode.cpp プロジェクト: Catchoom/openFrameworks
//----------------------------------------
void ofNode::tiltDeg(float degrees) {
	rotateDeg(degrees, getXAxis());
}
コード例 #18
0
ファイル: ofNode.cpp プロジェクト: Catchoom/openFrameworks
//----------------------------------------
void ofNode::truck(float amount) {
	move(getXAxis() * amount);
}
コード例 #19
0
ファイル: ofNode.cpp プロジェクト: CaterTsai/openFrameworks
//----------------------------------------
ofVec3f ofNode::getSideDir() const {
    return getXAxis();
}
コード例 #20
0
/** Execute the algorithm.
 */
void ConjoinXRuns::exec() {

  const std::vector<std::string> inputs_given =
      getProperty(INPUT_WORKSPACE_PROPERTY);
  m_logEntry = getPropertyValue(SAMPLE_LOG_X_AXIS_PROPERTY);

  const std::string sampleLogsSum = getProperty(SampleLogsBehaviour::SUM_PROP);
  const std::string sampleLogsTimeSeries =
      getProperty(SampleLogsBehaviour::TIME_SERIES_PROP);
  const std::string sampleLogsList =
      getProperty(SampleLogsBehaviour::LIST_PROP);
  const std::string sampleLogsWarn =
      getProperty(SampleLogsBehaviour::WARN_PROP);
  const std::string sampleLogsWarnTolerances =
      getProperty(SampleLogsBehaviour::WARN_TOL_PROP);
  const std::string sampleLogsFail =
      getProperty(SampleLogsBehaviour::FAIL_PROP);
  const std::string sampleLogsFailTolerances =
      getProperty(SampleLogsBehaviour::FAIL_TOL_PROP);
  const std::string sampleLogsFailBehaviour = getProperty("FailBehaviour");

  m_inputWS.clear();

  for (const auto &input : RunCombinationHelper::unWrapGroups(inputs_given)) {
    MatrixWorkspace_sptr ws =
        AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(input);
    m_inputWS.push_back(ws);
  }

  auto first = m_inputWS.front();
  SampleLogsBehaviour sampleLogsBehaviour = SampleLogsBehaviour(
      *first, g_log, sampleLogsSum, sampleLogsTimeSeries, sampleLogsList,
      sampleLogsWarn, sampleLogsWarnTolerances, sampleLogsFail,
      sampleLogsFailTolerances);

  auto it = m_inputWS.begin();

  // Temporary workspace to carry the merged sample logs
  // This is cloned from the first workspace and does not have
  // the correct size to be the output, since the size is unknown
  // at this point. We can check only later which ones are going
  // to be skipped, to compute the size of the output respectively.
  MatrixWorkspace_uptr temp = first->clone();

  size_t outBlockSize = (*it)->blocksize();
  // First sequentially merge the sample logs
  for (++it; it != m_inputWS.end(); ++it) {
    // attempt to merge the sample logs
    try {
      sampleLogsBehaviour.mergeSampleLogs(**it, *temp);
      sampleLogsBehaviour.setUpdatedSampleLogs(*temp);
      outBlockSize += (*it)->blocksize();
    } catch (std::invalid_argument &e) {
      if (sampleLogsFailBehaviour == SKIP_BEHAVIOUR) {
        g_log.error() << "Could not join workspace: " << (*it)->getName()
                      << ". Reason: \"" << e.what() << "\". Skipping.\n";
        sampleLogsBehaviour.resetSampleLogs(*temp);
        // remove the skipped one from the list
        m_inputWS.erase(it);
        --it;
      } else {
        throw std::invalid_argument(e);
      }
    }
  }

  if (m_inputWS.size() == 1) {
    g_log.warning() << "Nothing left to join [after skipping the workspaces "
                       "that failed to merge the sample logs].";
    // note, we need to continue still, since
    // the x-axis might need to be changed
  }

  if (!m_logEntry.empty()) {
    for (const auto &ws : m_inputWS) {
      m_axisCache[ws->getName()] = getXAxis(ws);
    }
  }

  // now get the size of the output
  size_t numSpec = first->getNumberHistograms();

  m_outWS = WorkspaceFactory::Instance().create(first, numSpec, outBlockSize,
                                                outBlockSize);

  // copy over the merged sample logs from the temp
  m_outWS->mutableRun() = temp->run();

  m_progress = make_unique<Progress>(this, 0.0, 1.0, numSpec);

  // Now loop in parallel over all the spectra and join the data
  PARALLEL_FOR_IF(threadSafe(*m_outWS))
  for (int64_t index = 0; index < static_cast<int64_t>(numSpec); ++index) {
    PARALLEL_START_INTERUPT_REGION
    joinSpectrum(index);
    m_progress->report();
    PARALLEL_END_INTERUPT_REGION
  }
  PARALLEL_CHECK_INTERUPT_REGION

  if (!m_logEntry.empty()) {
    std::string unit = first->run().getLogData(m_logEntry)->units();
    try {
      m_outWS->getAxis(0)->unit() = UnitFactory::Instance().create(unit);
    } catch (Exception::NotFoundError &) {
      m_outWS->getAxis(0)->unit() = UnitFactory::Instance().create("Empty");
    }
  }

  setProperty("OutputWorkspace", m_outWS);
  m_inputWS.clear();
  m_axisCache.clear();
}
コード例 #21
0
ファイル: ofEasyCam.cpp プロジェクト: nanu-c/openFrameworks
//----------------------------------------
void ofEasyCam::updateRotation(){
	if(bApplyInertia){
		xRot *=drag; 
		yRot *=drag;
		zRot *=drag;

		if(ABS(xRot) <= minDifference && ABS(yRot) <= minDifference && ABS(zRot) <= minDifference){
			xRot = 0;
			yRot = 0;
			zRot = 0;
			bApplyInertia = false;
			bDoRotate = false;
		}
		curRot = glm::angleAxis(zRot, getZAxis()) * glm::angleAxis(yRot, up()) * glm::angleAxis(xRot, getXAxis());
		setPosition(curRot * (getGlobalPosition()-target.getGlobalPosition()) + target.getGlobalPosition());
		rotate(curRot);
	}else if(bDoRotate){
		curRot = glm::angleAxis(zRot, prevAxisZ) * glm::angleAxis(yRot, up()) * glm::angleAxis(xRot, prevAxisX);
		setPosition(curRot * (prevPosition-target.getGlobalPosition()) + target.getGlobalPosition());
		setOrientation(curRot * prevOrientation);
	}
}