Esempio n. 1
0
///--------------------------------------------------------------
void Scene2::draw()
{
    BaseScene::drawPre();

    switch(backgroundMode)
    {
        case SceneBgModeVideo:
        {
            if (videoPlayer.isPlaying()) {
                videoPlayer.draw(0, 0, ofGetViewportWidth(), ofGetViewportHeight());
            }
            break;
        }
        case SceneBgModeImages:
        {
            ofSetColor(255, 255, 255, int(bgImageAlpha));
            bgImage1.draw(ofGetViewportWidth()/2, ofGetViewportHeight()/2, ofGetViewportWidth() * bgImageScale, ofGetViewportHeight() * bgImageScale);
            ofSetColor(255, 255, 255, 255-int(bgImageAlpha));
            bgImage2.draw(ofGetViewportWidth()/2, ofGetViewportHeight()/2, ofGetViewportWidth() * bgImageScale, ofGetViewportHeight() * bgImageScale);
            break;
        }
        case SceneBgModeNone:
        default:
            break;
    }

    ofEnableBlendMode(OF_BLENDMODE_ADD);
    {
        for (unsigned int i = 0; i < numObjects; ++i)
            objects[i]->draw();
    }
    ofDisableBlendMode();

    bool showTUIOCursors;
#ifdef OF_DEBUG
    showTUIOCursors = SettingsManager::getInstance().debugShowTUIOCursors;
#else
    showTUIOCursors = SettingsManager::getInstance().releaseShowTUIOCursors;
#endif

    if (showTUIOCursors)
    {
        ofxTuioClient *tuioClient = TUIOHandler::getInstance().tuioClient;
        tuioClient->drawCursors(0.5, 1, 0);
    }

#ifdef OF_DEBUG
    ofSetColor(ofColor::white);
    ofDrawBitmapString("Artist: " + ofToString(artistIndex), 0, ofGetHeight()/2);
#endif

    BaseScene::drawPost();
}
//--------------------------
void ofxGrabCam::mouseDragged(ofMouseEventArgs &args) {

	float dx = (args.x - mouseP.x) / ofGetViewportWidth();
	float dy = (args.y - mouseP.y) / ofGetViewportHeight();
	mouseP.x = args.x;
	mouseP.y = args.y;
	
	if (!mouseActions)
		return;

	if (!this->mouseDown)
		return;
	
	if (mouseP.z == 1.0f)
		mouseP.z = 0.5f;
	
	ofVec3f p = ofCamera::getPosition();
	ofVec3f uy = ofCamera::getUpDir();
	ofVec3f ux = ofCamera::getSideDir();
	float ar = float(ofGetViewportWidth()) / float(ofGetViewportHeight());
	
	if (handDown) {
		//dolly
		ofCamera::move(2 * (mouseW - p) * dy);
	} else {
		if (args.button==0 && !altDown) {
			//orbit
			ofVec3f arcEnd(dx, -dy, -trackballRadius);
			arcEnd = arcEnd;
			arcEnd.normalize();
			ofQuaternion orientation = this->getGlobalOrientation();
			rotation.makeRotate(orientation * ofVec3f(0.0f, 0.0f, -1.0f), orientation * arcEnd);
			
			if (fixUpwards) {
				ofQuaternion rotToUp;
				ofVec3f sideDir = ofCamera::getSideDir() * rotation;
				rotToUp.makeRotate(sideDir, sideDir * ofVec3f(1.0f, 0, 1.0f));
				rotation *= rotToUp;
			}
			
			this->setOrientation(this->getGlobalOrientation() * rotation);
			ofCamera::setPosition((p - mouseW) * rotation + mouseW);
		} else {
			//pan
			float d = (p - mouseW).length();
			//ofCamera::getFov() doesn't exist!!
			ofCamera::move(dx * -ux * d * ar);
			ofCamera::move(dy * uy * d);
		}
	}
}
Esempio n. 3
0
//----------------------------------------------------------
void ofGLRenderer::setupScreenOrtho(float width, float height, bool vFlip, float nearDist, float farDist) {
	if(width == 0) width = ofGetViewportWidth();
	if(height == 0) height = ofGetViewportHeight();

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	ofSetCoordHandedness(OF_RIGHT_HANDED);
#ifndef TARGET_OPENGLES
	if(vFlip) {
		glOrtho(0, width, height, 0, nearDist, farDist);
		ofSetCoordHandedness(OF_LEFT_HANDED);
	}
	else glOrtho(0, width, 0, height, nearDist, farDist);

#else
	if(vFlip) {
		ofMatrix4x4 ortho = ofxMatrix4x4::newOrthoMatrix(0, width, height, 0, nearDist, farDist);
		ofSetCoordHandedness(OF_LEFT_HANDED);
		glMultMatrixf(ortho.getPtr());
	}else{
		ofMatrix4x4 ortho = ofxMatrix4x4::newOrthoMatrix(0, width, 0, height, nearDist, farDist);
		glMultMatrixf(ortho.getPtr());
	}
#endif
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

}
Esempio n. 4
0
void ofImage_<PixelType>::grabScreen(int _x, int _y, int _w, int _h){

	allocate(_w, _h, OF_IMAGE_COLOR);

	int screenHeight =	ofGetViewportHeight(); // if we are in a FBO or other viewport, this fails: ofGetHeight();
	_y = screenHeight - _y;
	_y -= _h; // top, bottom issues

	if (!((width == _w) && (height == _h))){
		resize(_w, _h);
	}

	#ifndef TARGET_OPENGLES
		glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );											// be nice to anyone else who might use pixelStore
	#endif
		glPixelStorei(GL_PACK_ALIGNMENT, 1);
		glReadPixels(_x, _y, _w, _h, ofGetGlInternalFormat(pixels), GL_UNSIGNED_BYTE, pixels.getPixels()); // read the memory....
	#ifndef TARGET_OPENGLES
		glPopClientAttrib();
	#endif

	int sizeOfOneLineOfPixels = pixels.getWidth() * pixels.getBytesPerPixel();
	PixelType * tempLineOfPix = new PixelType[sizeOfOneLineOfPixels];
	PixelType * linea;
	PixelType * lineb;
	for (int i = 0; i < pixels.getHeight()/2; i++){
		linea = pixels.getPixels() + i * sizeOfOneLineOfPixels;
		lineb = pixels.getPixels() + (pixels.getHeight()-i-1) * sizeOfOneLineOfPixels;
		memcpy(tempLineOfPix, linea, sizeOfOneLineOfPixels);
		memcpy(linea, lineb, sizeOfOneLineOfPixels);
		memcpy(lineb, tempLineOfPix, sizeOfOneLineOfPixels);
	}
	delete [] tempLineOfPix;
	update();
}
Esempio n. 5
0
Workspace::Workspace() {
    // create log viewers for each REPL
    replLog = new ReplLog(repl);
    screplLog = new ReplLog(screpl);

    createEditor(repl);
    createEditor(screpl);

#ifdef SPLIT_SCREEN
    // 3rd editor for split screen
    Editor* ed = createEditor();
    subThread.setEditor(ed);
    subThread.startThread(true);
#endif

    repl.start("data/tidalStartup.hss");
    screpl.start("data/scStartup.scd");

    currentEditor = 0;
    showReplBuffer = true;

    // force resize to position editors
    int w = (ofGetWindowMode() == OF_WINDOW) ? ofGetViewportWidth() : ofGetScreenWidth();
    int h = (ofGetWindowMode() == OF_WINDOW) ? ofGetViewportHeight() : ofGetScreenHeight();
    resize(w, h);
}
void DelaunayVisualization::update(){
	triangulator.reset();
	/*
	triangulator.addPoint(0,0, 0);
	triangulator.addPoint(ofGetViewportWidth(), 0, 0);
	triangulator.addPoint(0, ofGetViewportHeight(), 0);
	triangulator.addPoint(ofGetViewportWidth(), ofGetViewportHeight(), 0);
	*/


	vector<int> reaper;

	ofPoint centerOfMass;
	float totalWeight = 0;

	for (cursorMap::iterator i = cursors.begin(); i != cursors.end(); ++i) {
		tuioCursor *tc = &(i->second);
		float weight = (150 - tc->age); // fresh points weigh 3 times more than oldest ones
		totalWeight += weight;

		centerOfMass.x += tc->x * weight;
		centerOfMass.y += tc->y * weight;
	}
	centerOfMass.x /= totalWeight; //cursors.size();
	centerOfMass.y /= totalWeight; //cursors.size();

	for (cursorMap::iterator i = cursors.begin(); i != cursors.end(); ++i) {
		tuioCursor *tc = &(i->second);
		if (++tc->age < 100) {
			if (COLLAPSING) {
				triangulator.addPoint(tc->x * ofGetViewportWidth(), tc->y * ofGetViewportHeight(), 0);
				if (tc->age<=3) {
					tc->dx = 0;
					tc->dy = 0;
				}
				if (tc->age > 3) {
					tc->x += tc->dx;
					tc->y += tc->dy;
					tc->dx += (tc->x > centerOfMass.x) ? -0.00003 : 0.00003;
					tc->dy += (tc->y > centerOfMass.y) ? -0.00003 : 0.00003;

					// friction
					//float v = sqrt(tc->dx*tc->dx + tc->dy*tc->dy);


				}
			}
		}
		else {
			reaper.push_back(i->first);
		}
	}

	for (vector<int>::iterator i = reaper.begin(); i != reaper.end(); ++i) {
		cursors.erase(*i);
	}

	// triangulator.addPoint(tc.x * ofGetViewportWidth(), tc.y * ofGetViewportHeight(), 0);
	triangulator.triangulate();
}
Esempio n. 7
0
//----------------------------------------
void ofCamera::setupPerspective(bool vFlip, float fov, float nearDist, float farDist, const ofVec2f & lensOffset){
	float viewW = ofGetViewportWidth();
	float viewH = ofGetViewportHeight();

	float eyeX = viewW / 2;
	float eyeY = viewH / 2;
	float halfFov = PI * fov / 360;
	float theTan = tanf(halfFov);
	float dist = eyeY / theTan;

	if(nearDist == 0) nearDist = dist / 10.0f;
	if(farDist == 0) farDist = dist * 10.0f;

	setFov(fov);
	setNearClip(nearDist);
	setFarClip(farDist);
	setLensOffset(lensOffset);
	setForceAspectRatio(false);

	setPosition(eyeX,eyeY,dist);
	lookAt(ofVec3f(eyeX,eyeY,0),ofVec3f(0,1,0));


	if(vFlip){
		setScale(1,-1,1);
	}
}
Esempio n. 8
0
//----------------------------------------------------------
void ofSetupScreenPerspective(float width, float height, bool vFlip, float fov, float nearDist, float farDist) {
	if(width == 0) width = ofGetViewportWidth();
	if(height == 0) height = ofGetViewportHeight();

	float eyeX = width / 2;
	float eyeY = height / 2;
	float halfFov = PI * fov / 360;
	float theTan = tanf(halfFov);
	float dist = eyeY / theTan;
	float aspect = (float) width / height;
	
	if(nearDist == 0) nearDist = dist / 10.0f;
	if(farDist == 0) farDist = dist * 10.0f;
	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(fov, aspect, nearDist, farDist);
	
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(eyeX, eyeY, dist, eyeX, eyeY, 0, 0, 1, 0);
	
	ofSetCoordHandedness(OF_RIGHT_HANDED);
	
	if(vFlip) {
		glScalef(1, -1, 1);           // invert Y axis so increasing Y goes down.
		glTranslatef(0, -height, 0);       // shift origin up to upper-left corner.
		ofSetCoordHandedness(OF_LEFT_HANDED);
	}
}
Esempio n. 9
0
//--------------------------------------------------------------
void testApp::setup() {

    x = ofGetViewportWidth() / 2;
    y = ofGetViewportHeight() / 2;
    radius = 100;


}
void tuioVisContainer::draw() {
	if (currentVisualization >= 0) visualizations[currentVisualization].draw();
	
	// draw the fade curtain, if any
	if (stageFadeAlpha < 1.0) {
		ofSetColor(0, 0, 0, 255*(1.0 - stageFadeAlpha));
		ofRect(0, 0, ofGetViewportWidth(), ofGetViewportHeight());
	}
}
Esempio n. 11
0
void ofxLayout::update(float dt){
    if(tuioEnabled){
        tuioClient.getMessage();
    }
    width = ofGetViewportWidth();
    height = ofGetViewportHeight();
    
    am.update(dt);
    assets.update();
    contextTreeRoot.update(dt);
}
Esempio n. 12
0
//--------------------------------------------------------------
void ofApp::draw()
{
    ofClear( 0, 0, 0, 255 );

    ofDisableDepthTest();

    glEnable( GL_CULL_FACE );
    glCullFace( GL_BACK );
    
    // size of 1 pixel in a texture if the texture coordinate range from 0..1
    ofVec2f inverseResolution( 1.0f / (float)ofGetViewportWidth(), 1.0f / (float)ofGetViewportHeight() );

    if ( true )
    {
        m_vignetteShader.begin();

            m_fsQuadVbo.draw();

        m_vignetteShader.end();
    }
    
    if ( false )
    {
        m_blurShader.begin();
        m_blurShader.setUniformTexture( "uTexture", m_texture, 0 );
 
            m_fsQuadVbo.draw();

        m_blurShader.end();
    }
    
    if ( false )
    {
        m_filmGrainShader.begin();
        m_filmGrainShader.setUniformTexture( "uTexture", m_texture, 0 );
        m_filmGrainShader.setUniform2f( "uTexelSize", inverseResolution );
        
            m_fsQuadVbo.draw();

        m_filmGrainShader.end();
    }
    
    if ( false )
    {
        m_sobelShader.begin();
        m_sobelShader.setUniformTexture( "uTexture", m_texture, 0 );
        m_sobelShader.setUniform2f( "uTexelSize", inverseResolution );

            m_fsQuadVbo.draw();

        m_sobelShader.end();
    }
  }
Esempio n. 13
0
	//----------
	void Controller::closeActiveDialog() {
		if (this->activeDialog) {
			this->onDialogClose.notifyListeners(this->activeDialog);
			this->activeDialog.reset();

			//setup the size of the root group
			ofResizeEventArgs resizeArgs = {
				ofGetViewportWidth(),
				ofGetViewportHeight()
			};
			this->windowResized(resizeArgs);
		}
	}
//--------------------------------------------------------------
void ofApp::draw(){
   ofTranslate(ofGetViewportWidth()/2.0f,ofGetViewportHeight()/2.0f);

     ofRotateZ(angleDegrees);

     ofSetColor(0,0,0);
     ofFill();
     ofLine(-50,0,50,0);
     ofCircle(50,0,10);
     ofCircle(-50,0,10);
     ofSetColor(175,175,175);
     ofCircle(50,0,8);
     ofCircle(-50,0,8);
}
Esempio n. 15
0
void ofCairoRenderer::setupScreenOrtho(float width, float height, bool vFlip, float nearDist, float farDist){
	if(!b3D) return;
	if(width == 0) width = ofGetViewportWidth();
	if(height == 0) height = ofGetViewportHeight();

	ofSetCoordHandedness(OF_RIGHT_HANDED);

	if(vFlip) {
		projection.makeOrthoMatrix(0, width, height, 0, nearDist, farDist);
		ofSetCoordHandedness(OF_LEFT_HANDED);
	}else{
		projection.makeOrthoMatrix(0, width, 0, height, nearDist, farDist);
	}
	modelView.makeIdentityMatrix();
};
//--------------------------------------------------------------
void ofApp::draw(){

  float x = amplitude * cos(TWO_PI * ofGetFrameNum() / period);

  ofFill();
  ofSetColor(0,0,0);

  ofTranslate(ofGetWindowWidth()/2, ofGetViewportHeight()/2);
  ofLine(0,0,x,0);
  ofSetColor(0,0,0);
  ofCircle(x,0,22);
  ofSetColor(175,175,175);
  ofCircle(x,0,20);

}
Esempio n. 17
0
void Circle::update()
{
    positionX += velX;
    positionY += velY;

    if (positionX + radius >= ofGetViewportWidth() || positionX - radius <= 0)
    {
        velX = (-1) * velX;
    }

    if (positionY + radius >= ofGetViewportHeight() || positionY - radius <= 0)
    {
        velY = (-1) * velY;
    }

}
// r g b, b fill full first, then g, then r
unsigned int SelectableObjectClass::CheckSelected( float mousex, float mousey )
{
	// Read colour of clicked pixel to determine object
	unsigned char colour[4];
	glReadPixels( mousex, ofGetViewportHeight() - mousey, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &colour );

	// Handle selection logic
	unsigned int id = 0;
	{
		id += colour[0] * 255 * 255;
		id += colour[1] * 255;
		id += colour[2];
	}
	printf( "id: %i\n", id );
	printf( "col: %i %i %i\n", colour[0], colour[1], colour[2] );
	return id;
}
Esempio n. 19
0
//----------------------------------------------------------
void ofTexture::loadScreenData(int x, int y, int w, int h){
	
	int screenHeight = ofGetViewportHeight(); // this call fails if we are in a different viewport or FBO: ofGetHeight();
	y = screenHeight - y;
	y -= h; // top, bottom issues
	texData.bFlipTexture = true;
	
	if ( w > texData.tex_w || h > texData.tex_h) {
		ofLogError("ofTexture") << "loadScreenData(): " << w << "x" << h << " image data too big for "
		<< texData.tex_w << "x " << texData.tex_h << " allocated texture, not uploading";
		return;
	}
	
	//update our size with the new dimensions - this should be the same size or smaller than the allocated texture size
	texData.width 	= w;
	texData.height 	= h;
	//texData.glType  = GL_RGB; // this was probably a bug, because you might be resetting the glType to something other than what the texture was created for
	
	//compute new tex co-ords based on the ratio of data's w, h to texture w,h;
#ifndef TARGET_OPENGLES // DAMIAN
	if (texData.textureTarget == GL_TEXTURE_RECTANGLE_ARB){
		texData.tex_t = (float)(w);
		texData.tex_u = (float)(h);
	} else 
#endif
	{
		texData.tex_t = (float)(w) / (float)texData.tex_w;
		texData.tex_u = (float)(h) / (float)texData.tex_h;
	}
	
	
	enableTextureTarget(0);

	glBindTexture(texData.textureTarget, (GLuint)texData.textureID);
	glCopyTexSubImage2D(texData.textureTarget, 0,0,0,x,y,w,h);

	disableTextureTarget(0);
	
	if (bWantsMipmap) {
		generateMipmap();
	}
}
Esempio n. 20
0
//----------------------------------------------------------
void ofTexture::loadScreenData(int x, int y, int w, int h){
	// TODO: this should go into the renderers so it
	// doesn't depend on global calls
	int screenHeight = ofGetViewportHeight();
	y = screenHeight - y;
	y -= h; // top, bottom issues
	texData.bFlipTexture = true;
	
	if ( w > texData.tex_w || h > texData.tex_h) {
		ofLogError("ofTexture") << "loadScreenData(): " << w << "x" << h << " image data too big for "
		<< texData.tex_w << "x " << texData.tex_h << " allocated texture, not uploading";
		return;
	}
	
	//update our size with the new dimensions - this should be the same size or smaller than the allocated texture size
	texData.width 	= w;
	texData.height 	= h;
	
	//compute new tex co-ords based on the ratio of data's w, h to texture w,h;
#ifndef TARGET_OPENGLES // DAMIAN
	if (texData.textureTarget == GL_TEXTURE_RECTANGLE_ARB){
		texData.tex_t = (float)(w);
		texData.tex_u = (float)(h);
	} else 
#endif
	{
		texData.tex_t = (float)(w) / (float)texData.tex_w;
		texData.tex_u = (float)(h) / (float)texData.tex_h;
	}
	
	
	glBindTexture(texData.textureTarget,texData.textureID);

	glCopyTexSubImage2D(texData.textureTarget, 0,0,0,x,y,w,h);

	glBindTexture(texData.textureTarget,0);
	
	if (bWantsMipmap) {
		generateMipmap();
	}
}
Esempio n. 21
0
	//----------
	void Controller::setActiveDialog(PanelPtr panel) {
		if (panel) {
			auto bounds = ofGetCurrentViewport();

			//first get a cached draw for the background
			this->activeDialogBackground.grabScreen(0, 0, ofGetWindowWidth(), ofGetWindowHeight());

			//setup the active Dialog
			this->activeDialog = panel;
			
			//setup the size of the Dialog
			ofResizeEventArgs resizeArgs = {
				ofGetViewportWidth(),
				ofGetViewportHeight()
			};
			this->windowResized(resizeArgs);
		}
		else {
			this->closeActiveDialog();
		}
	}
Esempio n. 22
0
void ofEasyFingerCam::findCursor()
{
    //read z value from depth buffer at mouse coords
    if(fingers.size()==3)
    {
        ofVec3f mouseP;
        mouseP.x = (fingers[0]->getX()*ofGetWidth()+fingers[1]->getX()*ofGetWidth()+fingers[2]->getX()*ofGetWidth())/3;
        mouseP.y = (fingers[0]->getY()*ofGetHeight()+fingers[1]->getY()*ofGetHeight()+fingers[2]->getY()*ofGetHeight())/3;
        if (mouseP.z == 1.0f)
            mouseP.z = 0.5f;
        glReadPixels(mouseP.x, ofGetHeight()-1-mouseP.y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &mouseP.z);
        //if we get nothing, scatter until we get something
        //we search in a spiral until we hit something
        if (mouseP.z == 1.0f)
        {
            float sx, sy; // search this spot in screen space
            float r, theta; // search is in polar coords
            for (int iteration=0; iteration < ofEasyFingerCam_SEARCH_MAX_ITERATIONS; iteration++)
            {
                r = ofEasyFingerCam_SEARCH_WIDTH * float(iteration) / float(ofEasyFingerCam_SEARCH_MAX_ITERATIONS);
                theta = ofEasyFingerCam_SEARCH_WINDINGS * 2 * PI * float(iteration) / float(ofEasyFingerCam_SEARCH_MAX_ITERATIONS);
                sx = ofGetWidth() * r * cos(theta) + mouseP.x;
                sy = ofGetHeight() * r * sin(theta) + mouseP.y;
                if (!viewportRect.inside(sx, sy))
                    continue;
                glReadPixels(sx, ofGetViewportHeight()-1-sy, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &mouseP.z);
                if (mouseP.z != 1.0f)
                    break;
            }
        }
        if (mouseP.z == 1.0f)
            return;
        GLdouble c[3];
        gluUnProject(mouseP.x, ofGetHeight()-1-mouseP.y, mouseP.z, matM, matP, viewport, c, c+1, c+2);
        cursor.x = c[0];
        cursor.y = c[1];
        cursor.z = c[2];
    }
}
Esempio n. 23
0
//----------------------------------------------------------
void ofSetupScreenOrtho(float width, float height, bool vFlip, float nearDist, float farDist) {
	if(width == 0) width = ofGetViewportWidth();
	if(height == 0) height = ofGetViewportHeight();
	
	#ifndef TARGET_OPENGLES

		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();

		ofSetCoordHandedness(OF_RIGHT_HANDED);

		if(vFlip) {
			glOrtho(0, width, height, 0, nearDist, farDist);
			ofSetCoordHandedness(OF_LEFT_HANDED);
		}
		else glOrtho(0, width, 0, height, nearDist, farDist);
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
	
	#else
		//FIX: is here http://stackoverflow.com/questions/2847574/opengl-es-2-0-equivalent-of-glortho
		ofLog(OF_LOG_ERROR, "ofSetupScreenOrtho - you can't use glOrtho with iphone / ES at the moment");
	#endif 
}
Esempio n. 24
0
ofVec3f ofxGrabCam::getPosition3f(float _x, float _y)
{
    float _z;
    //read z value from depth buffer at mouse coords
	glReadPixels(_x, ofGetHeight()-1-_y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &_z);
	
	//if we get nothing, scatter until we get something
	//we search in a spiral until we hit something
	if (_z == 1.0f) {
		float sx, sy; // search this spot in screen space
		float r, theta; // search is in polar coords
		for (int iteration=0; iteration < OFXGRABCAM_SEARCH_MAX_ITERATIONS; iteration++) {
			r = OFXGRABCAM_SEARCH_WIDTH * float(iteration) / float(OFXGRABCAM_SEARCH_MAX_ITERATIONS);
			theta = OFXGRABCAM_SEARCH_WINDINGS * 2 * PI * float(iteration) / float(OFXGRABCAM_SEARCH_MAX_ITERATIONS);
			sx = ofGetWidth() * r * cos(theta) + _x;
			sy = ofGetHeight() * r * sin(theta) + _y;
			
			if (!viewportRect.inside(sx, sy))
				continue;
			
			glReadPixels(sx, ofGetViewportHeight()-1-sy, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &_z);
			
			if (_z != 1.0f)
				break;
		}
	}
	
	if (_z == 1.0f)
		return ofVec3f();
	
	GLdouble c[3];
	
	gluUnProject(_x, ofGetHeight()-1-_y, _z, matM, matP, viewport, c, c+1, c+2);
	c[ 2 ] += ofRandom(1, 1.8);
    return ofVec3f(c[0], c[1], c[2]);
}
Esempio n. 25
0
//--------------------------
void ofxGrabCam::findCursor() {
	//read z value from depth buffer at mouse coords
	glReadPixels(mouseP.x, ofGetHeight()-1-mouseP.y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &mouseP.z);
	
	//if we get nothing, scatter until we get something
	//we search in a spiral until we hit something
	if (mouseP.z == 1.0f) {
		float sx, sy; // search this spot in screen space
		float r, theta; // search is in polar coords
		for (int iteration=0; iteration < OFXGRABCAM_SEARCH_MAX_ITERATIONS; iteration++) {
			r = OFXGRABCAM_SEARCH_WIDTH * float(iteration) / float(OFXGRABCAM_SEARCH_MAX_ITERATIONS);
			theta = OFXGRABCAM_SEARCH_WINDINGS * 2 * PI * float(iteration) / float(OFXGRABCAM_SEARCH_MAX_ITERATIONS);
			sx = ofGetWidth() * r * cos(theta) + mouseP.x;
			sy = ofGetHeight() * r * sin(theta) + mouseP.y;
			
			if (!viewportRect.inside(sx, sy))
				continue;
			
			glReadPixels(sx, ofGetViewportHeight()-1-sy, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &mouseP.z);
			
			if (mouseP.z != 1.0f)
				break;
		}
	}
	
	if (mouseP.z == 1.0f)
		return;
	
	GLdouble c[3];
	
	gluUnProject(mouseP.x, ofGetHeight()-1-mouseP.y, mouseP.z, matM, matP, viewport, c, c+1, c+2);
	
	mouseW.x = c[0];
	mouseW.y = c[1];
	mouseW.z = c[2];
}
Esempio n. 26
0
ofxLayout::ofxLayout(){
    mouseTransformation = ofMatrix4x4::newIdentityMatrix();
    init(0,0,ofGetViewportWidth(),ofGetViewportHeight());
}
Esempio n. 27
0
//----------------------------------------------------------
void ofGLRenderer::setupScreenOrtho(float width, float height, ofOrientation orientation, bool vFlip, float nearDist, float farDist) {
	if(width == 0) width = ofGetWidth();
	if(height == 0) height = ofGetHeight();
	
	float viewW = ofGetViewportWidth();
	float viewH = ofGetViewportHeight();
	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	ofSetCoordHandedness(OF_RIGHT_HANDED);
	if(vFlip) {
		ofMatrix4x4 ortho = ofMatrix4x4::newOrthoMatrix(0, width, height, 0, nearDist, farDist);
		ofSetCoordHandedness(OF_LEFT_HANDED);
	}
	
	ofMatrix4x4 ortho = ofMatrix4x4::newOrthoMatrix(0, viewW, 0, viewH, nearDist, farDist);
	glMultMatrixf(ortho.getPtr());	

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	//note - theo checked this on iPhone and Desktop for both vFlip = false and true
	if(ofDoesHWOrientation()){
		if(vFlip){
			glScalef(1, -1, 1);
			glTranslatef(0, -height, 0);
		}
	}else{
		if( orientation == OF_ORIENTATION_UNKNOWN ) orientation = ofGetOrientation();
		switch(orientation) {
			case OF_ORIENTATION_180:
				glRotatef(-180, 0, 0, 1);
				if(vFlip){
					glScalef(1, -1, 1);
					glTranslatef(-width, 0, 0);
				}else{
					glTranslatef(-width, -height, 0);
				}

				break;

			case OF_ORIENTATION_90_RIGHT:
				glRotatef(-90, 0, 0, 1);
				if(vFlip){
					glScalef(-1, 1, 1);
				}else{
					glScalef(-1, -1, 1);
					glTranslatef(0, -height, 0);
				}
				break;

			case OF_ORIENTATION_90_LEFT:
				glRotatef(90, 0, 0, 1);
				if(vFlip){
					glScalef(-1, 1, 1);
					glTranslatef(-width, -height, 0);
				}else{
					glScalef(-1, -1, 1);
					glTranslatef(-width, 0, 0);
				}
				break;

			case OF_ORIENTATION_DEFAULT:
			default:
				if(vFlip){
					glScalef(1, -1, 1);
					glTranslatef(0, -height, 0);
				}
				break;
		}
	}

}
Esempio n. 28
0
//----------------------------------------------------------
void ofGLRenderer::setupScreenPerspective(float width, float height, ofOrientation orientation, bool vFlip, float fov, float nearDist, float farDist) {
	if(width == 0) width = ofGetWidth();
	if(height == 0) height = ofGetHeight();

	float viewW = ofGetViewportWidth();
	float viewH = ofGetViewportHeight();

	float eyeX = viewW / 2;
	float eyeY = viewH / 2;
	float halfFov = PI * fov / 360;
	float theTan = tanf(halfFov);
	float dist = eyeY / theTan;
	float aspect = (float) viewW / viewH;

	if(nearDist == 0) nearDist = dist / 10.0f;
	if(farDist == 0) farDist = dist * 10.0f;

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
		
	ofMatrix4x4 persp;
	persp.makePerspectiveMatrix(fov, aspect, nearDist, farDist);
	loadMatrix( persp );
	//gluPerspective(fov, aspect, nearDist, farDist);


	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	
	ofMatrix4x4 lookAt;
	lookAt.makeLookAtViewMatrix( ofVec3f(eyeX, eyeY, dist),  ofVec3f(eyeX, eyeY, 0),  ofVec3f(0, 1, 0) );
	loadMatrix( lookAt );
	//gluLookAt(eyeX, eyeY, dist, eyeX, eyeY, 0, 0, 1, 0);

	//note - theo checked this on iPhone and Desktop for both vFlip = false and true
	if(ofDoesHWOrientation()){
		if(vFlip){
			glScalef(1, -1, 1);
			glTranslatef(0, -height, 0);
		}
	}else{
		if( orientation == OF_ORIENTATION_UNKNOWN ) orientation = ofGetOrientation();
		switch(orientation) {
			case OF_ORIENTATION_180:
				glRotatef(-180, 0, 0, 1);
				if(vFlip){
					glScalef(1, -1, 1);
					glTranslatef(-width, 0, 0);
				}else{
					glTranslatef(-width, -height, 0);
				}

				break;

			case OF_ORIENTATION_90_RIGHT:
				glRotatef(-90, 0, 0, 1);
				if(vFlip){
					glScalef(-1, 1, 1);
				}else{
					glScalef(-1, -1, 1);
					glTranslatef(0, -height, 0);
				}
				break;

			case OF_ORIENTATION_90_LEFT:
				glRotatef(90, 0, 0, 1);
				if(vFlip){
					glScalef(-1, 1, 1);
					glTranslatef(-width, -height, 0);
				}else{
					glScalef(-1, -1, 1);
					glTranslatef(-width, 0, 0);
				}
				break;

			case OF_ORIENTATION_DEFAULT:
			default:
				if(vFlip){
					glScalef(1, -1, 1);
					glTranslatef(0, -height, 0);
				}
				break;
		}
	}

}
void SelectableMovableObjectClass::OnDragged( int x, int y, int button )
{
	SelectableObjectClass::OnDragged( x, y, button );

	// Move along the axis selected
	{
		// Different directions depending on axis selected
		ofVec3f offset;
		{
			// Get different axis depending on selected
			switch ( *AxisSelected )
			{
				case 0: // Blue forward
					offset = getLookAtDir();
					break;
				case 1: // Red right
					offset = getSideDir();
					break;
				case 2: // Green up
					offset = -getUpDir();
					break;
				default:
					break;
			}
		}

		// Calculate direction of axis in screen space
		ofVec2f direction = Camera->worldToScreen( getPosition() - offset, ofGetCurrentViewport() );
		direction /= ofVec2f( ofGetViewportWidth(), ofGetViewportHeight() );

		// Calculate the position of the object in screen space
		ofVec2f position = Camera->worldToScreen( getPosition(), ofGetCurrentViewport() );
		position /= ofVec2f( ofGetViewportWidth(), ofGetViewportHeight() );

		// Get the direction vector from these two aspects
		ofVec2f axisdir = direction - position;
		axisdir.normalize();

		// Check the movement of the cursor in relation to the axis line
		ofVec2f mousedir = LastMouse - ofVec2f( *mouseX, *mouseY );
		mousedir.y *= -1;
		float length = mousedir.length();
		{
			if ( length > 10 )
			{
				length = 10;
			}
		}
		float directionamount = axisdir.dot( mousedir ) * length / 2;

		// Check for snapping enabled
		if ( KeyPressed[OF_KEY_SHIFT] )
		{
			if ( abs( directionamount ) > GRID_SNAP_FORCE )
			{
				// Get the length along this axis
				ofVec3f nodedir = getPosition() * offset;
				float length = nodedir.length();
				if ( ( nodedir.x > 0 ) || ( nodedir.z > 0 ) )
				{
					length *= -1;
				}

				// Divide and floor to get closest minimum grid snap point on this axis
				length = floor( length / GRID_SNAP_DISTANCE );

				// Correct to move in the right direction (i.e. backwards or forwards along the vector)
				if ( signbit( directionamount ) )
				{
					// Take 1 to move to the next grid point
					length--;
				}
				else
				{
					// Plus 1 to move to the next grid point
					length++;
				}

				// Move
				length *= GRID_SNAP_DISTANCE;
				ofVec3f pos = getPosition();
				{
					if ( offset.x != 0 )
					{
						pos.x = length;
					}
					if ( offset.y != 0 )
					{
						pos.y = -length;
					}
					if ( offset.z != 0 )
					{
						pos.z = length;
					}
				}
				setPosition( pos );
			}
		}
		else
		{
			// Move the object
			move( offset * directionamount );
		}

		// Update lastmouse to this frame for mousedir calculation
		LastMouse = ofVec2f( *mouseX, *mouseY );

		// Update slider variables
		SliderX = CLAMP( getPosition().x, -AXISLIMIT_X, AXISLIMIT_X );
		SliderY = CLAMP( getPosition().y, -AXISLIMIT_Y, AXISLIMIT_Y );
		SliderZ = CLAMP( getPosition().z, -AXISLIMIT_Z, AXISLIMIT_Z );
	}
}
void ofCairoRenderer::setup(string _filename, Type _type, bool multiPage_, bool b3D_, ofRectangle _viewport){
	if( _viewport.width == 0 || _viewport.height == 0 ){
		_viewport.set(0, 0, ofGetViewportWidth(), ofGetViewportHeight());
	}

	filename = _filename;
	type = _type;
	streamBuffer.clear();

	if(type == FROM_FILE_EXTENSION){
		string ext = ofFilePath::getFileExt(filename);
		if(ofToLower(ext)=="svg"){
			type = SVG;
		}else if(ofToLower(ext)=="pdf"){
			type = PDF;
		}else{ // default to image
			type = IMAGE;
		}
	}

	if(filename != "") {
		switch(type) {
			case PDF:
			case SVG:
			case IMAGE:
				ofFilePath::createEnclosingDirectory(filename);
			case FROM_FILE_EXTENSION:
				break;
		}
	}

	switch(type){
	case PDF:
		if(filename==""){
			surface = cairo_pdf_surface_create_for_stream(&ofCairoRenderer::stream_function,this,_viewport.width, _viewport.height);
		}else{
			surface = cairo_pdf_surface_create(ofToDataPath(filename).c_str(),_viewport.width, _viewport.height);
		}
		break;
	case SVG:
		if(filename==""){
			surface = cairo_svg_surface_create_for_stream(&ofCairoRenderer::stream_function,this,_viewport.width, _viewport.height);
		}else{
			surface = cairo_svg_surface_create(ofToDataPath(filename).c_str(),_viewport.width, _viewport.height);
		}
		break;
	case IMAGE:
		imageBuffer.allocate(_viewport.width, _viewport.height, OF_PIXELS_BGRA);
		imageBuffer.set(0);
		surface = cairo_image_surface_create_for_data(imageBuffer.getData(),CAIRO_FORMAT_ARGB32,_viewport.width, _viewport.height,_viewport.width*4);
		break;
	case FROM_FILE_EXTENSION:
		ofLogFatalError("ofCairoRenderer") << "setup(): couldn't determine type from extension for filename: \"" << _filename << "\"!";
		break;
	default:
		ofLogError("ofCairoRenderer") << "setup(): encountered unknown type for filename \"" << _filename << "\"";
		break;
	}

	cr = cairo_create(surface);
	cairo_set_antialias(cr,CAIRO_ANTIALIAS_SUBPIXEL);
	viewportRect = _viewport;
	originalViewport = _viewport;
	viewport(viewportRect);
	page = 0;
	b3D = b3D_;
	multiPage = multiPage_;
}