void TaskKey::update()
{
unsigned int pressed = 0;
if(ofGetKeyPressed()) {
for(int index = 0; table[index] != 0; index += 2) {
if(ofGetKeyPressed(table[index+1])) {
pressed |= table[index];
}
}
}
release_ = hold_&~pressed;
trigger_ = pressed&~hold_;
hold_ = pressed;
repeat_ = 0;
for(int i = 0; i < KEY_MAX; ++i) {
if(hold_ & (1<<i)) {
if(repeat_frame_count_[i]-- == 0) {
repeat_ |= (1<<i);
repeat_frame_count_[i] = repeat_second_;
}
}
else if(release_ & (1<<i)) {
repeat_frame_count_[i] = repeat_first_;
}
}
}
void ofApp::update() {
if(ofGetKeyPressed('1')) {
ofSeedRandom(0);
for(int i = 0; i < mesh.getNumVertices(); i++) {
ofVec3f point = mesh.getVertex(i);
point*=1.001;
point+=ofVec3f(ofRandomf(), ofRandomf(), ofRandomf());
mesh.setVertex(i, point);
}
}
if(ofGetKeyPressed('2')) {
for(int i = 0; i< referenceMesh.getNumVertices(); i++) {
ofVec3f refpoint = referenceMesh.getVertex(i);
ofVec3f point = mesh.getVertex(i);
float increment=1-.3;
float lerpX = ofLerp(refpoint.x, point.x, increment);
float lerpY = ofLerp(refpoint.y, point.y, increment);
float lerpZ = ofLerp(refpoint.z, point.z, increment);
ofVec3f move(lerpX, lerpY, lerpZ);
ofColor cur = referenceMesh.getColor(i).lerp(mesh.getColor(i), increment);
mesh.setColor(i, cur);
mesh.setVertex(i, move);
}
}
}
// returns true if intercepted (stops event bubbling), false otherwise
bool basicShape::interceptMouseClick(ofMouseEventArgs &e){
if( isInEditMode() ){
// toggle GUI ?
if( guiToggle.inside(e.x, e.y) ){
drawShapeGui = !drawShapeGui;
shapeGui.setPosition( guiToggle.getTopRight()+ofVec2f(5,20));
return true;
}
// over shapeGui ?
else if(drawShapeGui && shapeGui.getShape().inside(e.x,e.y)){
// if click on name, then ask for new name... #hacky
ofxBaseGui* nameLabel = basicShapeGui.getControl(GUIinfo_ShapeName);
if(nameLabel && nameLabel->getShape().inside(e.x, e.y) ){
shapeName = ofSystemTextBoxDialog("Enter the shape name...", shapeName);
ofLogNotice("basicShape::interceptMouseClick") << "New shape name: " << shapeName;
}
return true;
}
// on position handler ?
else if( position.interceptMouseClick(e) ){
// erase whole shape ?
if( ofGetKeyPressed('r') || ofGetKeyPressed('R') ){
pleaseDeleteMe = true;
}
return true;
}
}
return false;
}
bool Director::mousePressed(ofPoint _mouse){
if (inside(_mouse)){
// Is over one dot?
//
bool overDot = false;
for(int i=1;i<points.size()-1;i++){
ofPoint pos = toScreen(points[i]);
if(pos.distance(_mouse)<20){
overDot = true;
break;
}
}
if (!overDot){
lastCLick = _mouse;
}
if(!ofGetKeyPressed() && !overDot){
float lenghtToClosest = 1000;
int closest = -1;
for (int i=0;i<points.size()-1;i++){
int next=i+1;
ofVec2f AtoM = _mouse - toScreen(points[i]);
ofVec2f AtoB = toScreen(points[next]) - toScreen(points[i]);
float a = atan2f(AtoM.x, AtoM.y);
float b = atan2f(AtoB.x, AtoB.y);
if (abs(a - b) <= 0.05 && // 1. Is over the line
AtoM.length() < lenghtToClosest && // 2. Is the closest one
AtoM.length() < AtoB.length() ){ // 3. Is between those two points
lenghtToClosest = AtoM.length();
closest = next;
}
}
if(closest!=-1){
points.insert(points.begin()+closest, fromScreen(_mouse));
}
} else if (ofGetKeyPressed('a') && !overDot){
points.insert(points.end()-1, fromScreen(_mouse));
} else if( ( ofGetKeyPressed('d') || ofGetKeyPressed(OF_KEY_BACKSPACE) || ofGetKeyPressed(OF_KEY_DEL) )&& overDot){
for(int i=1;i<points.size()-1;i++){
ofPoint pos = toScreen(points[i]);
if(pos.distance(_mouse)<10){
points.erase(points.begin()+i);
break;
}
}
}
}
}
//--------------------------------------------------------------
void ofApp::draw(){
ofEnableLighting();
ofBackgroundGradient(ofColor(65,62,50),ofColor(25,22,10) );
// disable normals if a key is pressed
if(ofGetKeyPressed() || ofGetMousePressed()){
mesh.disableNormals();
}else{
mesh.enableNormals();
}
cam.begin();
mesh.enableColors();
mesh.drawWireframe();
mesh.disableColors();
ofSetColor(137,137,140);
ofFill();
#ifndef TARGET_OPENGLES
glEnable(GL_POLYGON_OFFSET_LINE);
glPolygonOffset(-1,-1);
#endif
mesh.drawFaces();
ofSetColor(255,255,255);
light.draw();
// draw our normals, and show that they are perpendicular to the vector from the center to the vertex
vector<ofVec3f> n = mesh.getNormals();
vector<ofVec3f> v = mesh.getVertices();
float normalLength = 50.;
if(!ofGetKeyPressed()){
ofDisableLighting();
ofSetColor(255,255,255,70);
for(unsigned int i=0; i < n.size() ;i++){
ofDrawLine(v[i].x,v[i].y,v[i].z,
v[i].x+n[i].x*normalLength,v[i].y+n[i].y*normalLength,v[i].z+n[i].z*normalLength);
ofDrawLine(.98*v[i].x,.98*v[i].y,.98*v[i].z,
.98*v[i].x+n[i].x*normalLength*.2,.98*v[i].y+n[i].y*normalLength*.2,.98*v[i].z+n[i].z*normalLength*.2);
ofDrawLine(.98*v[i].x+n[i].x*normalLength*.2,.98*v[i].y+n[i].y*normalLength*.2,.98*v[i].z+n[i].z*normalLength*.2,
v[i].x+n[i].x*normalLength*.2,v[i].y+n[i].y*normalLength*.2,v[i].z+n[i].z*normalLength*.2);
}
}
cam.end();
ofSetColor(255,255,255);
ofDrawBitmapString("press any key or mouse button to disable mesh normals", 20,20);
ofDrawBitmapString("light", cam.worldToScreen(light.getGlobalPosition()) + ofPoint(10,0));
}
//------------------------------------------------------------
void ofxFensterManager::mouse_cb(GLFWwindow* windowP_, int button, int state, int mods) {
ofLogVerbose("ofxFenster") << "mouse button: " << button;
#ifdef TARGET_OSX
//we do this as unlike glut, glfw doesn't report right click for ctrl click or middle click for alt click
if( ofGetKeyPressed(OF_KEY_CONTROL) && button == GLFW_MOUSE_BUTTON_LEFT) {
button = GLFW_MOUSE_BUTTON_RIGHT;
}
if( ofGetKeyPressed(OF_KEY_ALT) && button == GLFW_MOUSE_BUTTON_LEFT) {
button = GLFW_MOUSE_BUTTON_MIDDLE;
}
#endif
switch(button) {
case GLFW_MOUSE_BUTTON_LEFT:
button = OF_MOUSE_BUTTON_LEFT;
break;
case GLFW_MOUSE_BUTTON_RIGHT:
button = OF_MOUSE_BUTTON_RIGHT;
break;
case GLFW_MOUSE_BUTTON_MIDDLE:
button = OF_MOUSE_BUTTON_MIDDLE;
break;
}
ofxFensterPtr fenster = get()->getFensterByGlfwHandle(windowP_);
if (state == GLFW_PRESS) {
if(fenster == get()->mainWindow)
ofNotifyMousePressed(ofGetMouseX(), ofGetMouseY(), button);
fenster->buttonPressed=true;
ofMouseEventArgs args;
args.x = fenster->curMouseX;
args.y = fenster->curMouseY;
args.type = ofMouseEventArgs::Pressed;
ofNotifyEvent(fenster->onMousePressed, args);
} else if (state == GLFW_RELEASE) {
if(fenster == get()->mainWindow)
ofNotifyMouseReleased(ofGetMouseX(), ofGetMouseY(), button);
fenster->buttonPressed=false;
ofMouseEventArgs args;
args.x = fenster->curMouseX;
args.y = fenster->curMouseY;
args.type = ofMouseEventArgs::Released;
ofNotifyEvent(fenster->onMouseReleased, args);
}
fenster->buttonInUse = button;
}
void ofMeshP::update(string hill, int max) {
//////////////////////////////////////////////// //JUSTIN
path = hill;
l = max;
now = currentFrame;
//if space bar is pressed, increment playback number
if(ofGetKeyPressed('p')) {
skip++;
}
if(ofGetKeyPressed('o') && skip >= 1) {
skip--;
}
if(currentFrame < l) {
currentFrame++;
cout<<"PLAYING"<<endl;
} else {
currentFrame = 1;
}
ostringstream fileNameToSave;
fileNameToSave << currentFrame << ".png";
frameResult = fileNameToSave.str();
img.loadImage(path+ frameResult);
mesh.clear();
for(int y = 0; y < img.getHeight(); y++) {
for(int x = 0; x < img.getWidth(); x++) {
ofColor cur = img.getColor(x, y);
if(cur.a > 0) {
// the alpha value encodes depth, let's remap it to a good depth range
float z = ofMap(cur.a, 0, 255, -480, 480);
cur.a = 255;
mesh.addColor(cur);
ofVec3f pos(x - img.getWidth() / 2, y - img.getHeight() / 2, z);
mesh.addVertex(pos);
}
}
}
}
//--------------------------------------------------------------
void testApp::draw(){
// ofBackgroundGradient(ofColor::gray, ofColor::black);
// ofBackground(0);
ofSetColor(255);
depthOfField.begin();
cam.begin(depthOfField.getDimensions());
ofEnableLighting();
coldLight.enable();
warmLight.enable();
glEnable(GL_DEPTH_TEST);
ofPushMatrix();
ofRotateY((ofGetElapsedTimef()*0.1)*180);
ofRotateX(sin(ofGetElapsedTimef()*0.1)*90);
// ofRotateZ((ofGetElapsedTimef()*0.1)*180);
ofTranslate(0,offSet.x*0.7);
ofRotate(-90, 0, 0, 1);
ofSetColor(255,250,240);
if(ofGetKeyPressed( 'm' )){
mesh.drawWireframe();
} else {
mesh.drawFaces();
}
ofPopMatrix();
glDisable(GL_DEPTH_TEST);
coldLight.disable();
warmLight.disable();
ofDisableLighting();
ofPopMatrix();
cam.end();
depthOfField.end();
ofPushMatrix();
if(ofGetKeyPressed( 'a' )){
depthOfField.drawFocusAssist(0, 0);
} else{
depthOfField.getFbo().draw(0, 0);
}
ofPopMatrix();
sServer.publishScreen();
}
void testApp::mousePressed(int x, int y,int button ){
// cout << "mouse pressed!" << endl;
ofVec2f camvec(x,y);
ofVec2f offset = depthImage1Rect.getTopLeft();
if(ofGetKeyPressed('1') && depthImage1Rect.inside(camvec)){
cam1Calib[0] = camvec - offset;
}
if(ofGetKeyPressed('2') && depthImage1Rect.inside(camvec)){
cam1Calib[1] = camvec - offset;
}
if(ofGetKeyPressed('3') && depthImage1Rect.inside(camvec)){
cam1Calib[2] = camvec - offset;
}
if(ofGetKeyPressed('4') && depthImage1Rect.inside(camvec)){
cam1Calib[3] = camvec - offset;
}
offset = depthImage2Rect.getTopLeft();
if(ofGetKeyPressed('5') && depthImage2Rect.inside(camvec)){
cam2Calib[0] = camvec - offset;
}
if(ofGetKeyPressed('6') && depthImage2Rect.inside(camvec)){
cam2Calib[1] = camvec - offset;
}
if(ofGetKeyPressed('7') && depthImage2Rect.inside(camvec)){
cam2Calib[2] = camvec - offset;
}
if(ofGetKeyPressed('8') && depthImage2Rect.inside(camvec)){
cam2Calib[3] = camvec - offset;
}
}
void Calibrator::keyPressed(int key){
ofVec3f keyVec(0,0,0);
if(key == OF_KEY_LEFT){
keyVec.x = -1;
}
if(key == OF_KEY_RIGHT){
keyVec.x = 1;
}
if(key == OF_KEY_UP){
keyVec.y = -1;
}
if(key == OF_KEY_DOWN){
keyVec.y = 1;
}
if(ofGetKeyPressed(OF_KEY_SHIFT)){
keyVec *= 0.01;
} else {
keyVec *= 0.00025;
}
for(auto point : points){
point->set(keyVec + point->get());
}
}
void ofEasyCam::mousePressed(ofMouseEventArgs & mouse){
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) || ofGetKeyPressed(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;
}
}
void ofApp::update() {
if (zoom_in && (ofGetKeyPressed(OF_KEY_CONTROL) ||
ofGetKeyPressed(OF_KEY_COMMAND))) {
c.zoomIn();
zoom_in = false;
setGrid();
}
if (zoom_out && (ofGetKeyPressed(OF_KEY_CONTROL) ||
ofGetKeyPressed(OF_KEY_COMMAND))) {
c.zoomOut();
zoom_out = false;
setGrid();
}
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key) {
// note: when using CTRL as the modifier key, CTRL + key might be an ascii
// control char so check for both the char 'f' and 6, the ascii value for
// CTRL + f, see also: http://ascii-table.com/control-chars.php
bool modifier = ofGetKeyPressed(ofxEditor::getSuperAsModifier() ? OF_KEY_SUPER : OF_KEY_CONTROL);
if(modifier) {
switch(key) {
case 'f': case 6:
ofToggleFullscreen();
return;
case 'l': case 12:
editor.setLineWrapping(!editor.getLineWrapping());
return;
case 'n': case 14:
editor.setLineNumbers(!editor.getLineNumbers());
return;
case 'k': case 26:
editor.setAutoFocus(!editor.getAutoFocus());
return;
}
}
// see ofxGLEditor.h for key commands
editor.keyPressed(key);
}
void resetDrawSettings()
{
m_inSetup = false;
fill(m_defaultFillColor.getHex());
stroke(m_defaultStrokeColor.getHex());
strokeWeight(m_defaultStrokeWeight);
m_hasFill = m_defaultHasFill;
m_hasStroke = m_defaultHasStroke;
ofEnableBlendMode(OF_BLENDMODE_ALPHA);
smooth(2);
width = ofGetWidth();
height = ofGetHeight();
pmouseX = ofGetPreviousMouseX();
pmouseY = ofGetPreviousMouseY();
keyPressed = ofGetKeyPressed();
mousePressed = ofGetMousePressed();
mouseButton = NONE;
if( ofGetMousePressed(0) )
mouseButton = LEFT;
else if(ofGetMousePressed(1))
mouseButton = RIGHT;
ofSetCircleResolution(100);
ofSetCurveResolution(100);
}
//----------
void Scene::mousePressed(ofMouseEventArgs & args) {
this->updateCursor();
this->cursor.start(args.button);
this->cursor.captured = args.button == 0 && !ofGetKeyPressed();
this->cursor.dragged = false;
this->getElementUnderCursor().cursorDown(cursor);
// if (this->inspector.getShape().inside(this->cursor.screen.x, this->cursor.screen.y)) {
//
// //we're inside the gui
// cursor.captured = true;
//
// //horrible hack to stop mouse clicks in gui affecting node selection
// cursor.dragged = true;
// }
isSettingOrigin = ofGetModifierPressed(OF_KEY_ALT);
cursor.captured |= isSettingOrigin;
if (cursor.captured) {
this->camera->setMouseActions(false);
}
this->lockIndex = true;
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
if (key == 'r') {
cam.beginRecording();
}
if (key == 'R') {
cam.endRecording();
}
if (key == ' ') {
if (!ofGetKeyPressed(OF_KEY_SHIFT)) {
cam.play();
}
else {
cam.pause();
}
}
if (key == 'l') {
ofFileDialogResult result = ofSystemLoadDialog("Choose a folder of recorded data", true, ofToDataPath(""));
if (result.getPath() != "") {
cam.setPlaybackPath(result.getPath());
}
}
if (key == 'L') {
cam.setLive();
}
}
// - - - - - - -
// GUI STUFF
// - - - - - - -
void basicShape::keyPressed(ofKeyEventArgs& e){
if(!bEditMode) return;
// select another handle ?
if( e.key == 91 ){ // 91 = [
selectPrevHandle();
return;
}
else if( e.key == 93){ // 93 = ]
selectNextHandle();
}
else if( e.key == OF_KEY_RETURN ){
selectHandle(NULL);
}
// editActiveHandleWithArrows
else if( bEditMode && handleExists(activeHandle) ){
basicPoint translation(0,0);
int amplifier = 1 + ofGetKeyPressed(OF_KEY_SHIFT)*10;
if( e.key == OF_KEY_DOWN ) translation += basicPoint(0,1);
else if( e.key == OF_KEY_UP ) translation += basicPoint(0,-1);
else if( e.key == OF_KEY_LEFT ) translation += basicPoint(-1,0);
else if( e.key == OF_KEY_RIGHT ) translation += basicPoint(1,0);
if(translation.x!=0 || translation.y!=0)translateActiveHandle( translation*amplifier );
}
//else ofLogNotice("basicShape::keyPressed()","Unrecognised key: "+ofToString(e.key));
}
void QuadWarp::onMouseDragged(ofMouseEventArgs& mouseArgs) {
if(bShow){
if(selectedCornerIndex < 0 || selectedCornerIndex > 3) {
return;
}
ofPoint mousePoint(mouseArgs.x, mouseArgs.y);
if (ofGetKeyPressed(cKey)) {
dstPoints[selectedCornerIndex].set( dstPoints[selectedCornerIndex]- (lastMouse - mousePoint) * value);
if (selectedCornerIndex == 0) {
dstPoints[1].set( dstPoints[1]- (lastMouse - mousePoint) * value *-1);
}
else if (selectedCornerIndex == 1) {
dstPoints[0].set( dstPoints[0]- (lastMouse - mousePoint) * value *-1);
}
else if (selectedCornerIndex == 2) {
dstPoints[3].set( dstPoints[3]- (lastMouse - mousePoint) * value *-1);
}
else if (selectedCornerIndex == 3) {
dstPoints[2].set( dstPoints[2]- (lastMouse - mousePoint) * value *-1);
}
}
else
dstPoints[selectedCornerIndex].set( dstPoints[selectedCornerIndex]- (lastMouse - mousePoint) * value);
lastMouse = mousePoint;
}
}
//--------------------------------------------------------------
void testApp::update(){
bool press = ofGetKeyPressed();
voro::container con(-containerSize,containerSize,
-containerSize,containerSize,
-containerSize,containerSize,
1, 1, 1, press, press, press, 8);
for(int i = 0; i < boids.size();i++){
boids[i]->update( boids );
if ( insideContainer( con, *boids[i])){
addCellSeed( con, boids[i], i);
boids[i]->color.set(50, 200,200);
} else {
boids[i]->color.set(255,0,0);
}
}
cellMeshes.clear();
cellMeshes = getCellsFromContainer(con,0);
cellMeshWireframes.clear();
cellMeshWireframes = getCellsFromContainer(con,0,true);
ofSetWindowTitle(ofToString(ofGetFrameRate()));
}
//-----------------------------------------------------------------------------------------
//
void ofApp::update()
{
// Update time, this let's us hit space and slow down time, even reverse it.
if( ofGetKeyPressed(' ') ) { timeStep = ofLerp( timeStep, ofMap( ofGetMouseX(), 0, ofGetWidth(), -(1.0f/60.0f), (1.0f/60.0f) ), 0.1f );}
else { timeStep = ofLerp( timeStep, 1.0f / 60.0f, 0.1f ); }
time += timeStep;
}
void ofApp::update() {
if(ofGetKeyPressed()) {
float minRadius = mouseX / (float) ofGetWidth();
float maxRadius = (mouseY) / (float) ofGetHeight();
iso.setRadius(minRadius, minRadius + maxRadius);
iso.update();
}
}
//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){
ofPoint mouse = ofPoint(x,y);
if ( graphView.inside(mouse)){
} else if (ofGetKeyPressed()){
map.mouseReleased(x,y,button);
}
}
//--------------------------------------------------------------
void testApp::update(){
// when press spacebar, capture the background
if(ofGetKeyPressed(' ')){
if(ps3eye.isFrameNew()){
background.setFromPixels(ps3eye.getPixelsRef());
backgroundPixels = background.getPixels(); // pixels from bg image
// fill array of bgPixel vectors with the RGB values of each background pixel
for(int i=0; i < camWidth; i++){
for(int j=0; j < camHeight; j++){
bgPixels[j*camWidth + i].set(backgroundPixels[(j*camWidth + i)*3], backgroundPixels[(j*camWidth + i)*3 + 1], backgroundPixels[(j*camWidth + i)*3 + 2]);
}
}
}
}
// when press a, record from camera (each frame adds an image to vector)
if(ofGetKeyPressed('a')){
makeLoop(images);
drums.setVolume(1.0);
}
// when press b, record a different loop from the camera (each frame adds an image to a different vector)
if(ofGetKeyPressed('b')){
makeLoop(images2);
conga.setVolume(1.0);
}
// when press c, record a different loop from the camera (each frame adds an image to a different vector)
if(ofGetKeyPressed('c')){
makeLoop(images3);
bass.setVolume(1.0);
}
// when press d, record a different loop from the camera (each frame adds an image to a different vector)
if(ofGetKeyPressed('d')){
makeLoop(images4);
guitar.setVolume(1.0);
}
ps3eye.update();
}
void update() {
ofSetWindowTitle(ofToString(ofGetFrameRate()));
cam.update();
if(cam.isFrameNew()) {
if(ofGetKeyPressed()) {
results = ccv.classifyFace(cam);
}
}
}
//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){
// TODO: check if we're over the map
ofPoint mouse = ofPoint(x,y);
if ( graphView.inside(mouse)){
} else if (ofGetKeyPressed()){
map.mouseDragged(x,y,button);
}
}
//----------------------------------------
void ofxViewportCam::begin(ofRectangle viewport)
{
ofPushStyle();
if(drawWireFrame)
{
ofNoFill();
}
else
{
ofFill();
}
ofVec3f pos = getPosition();
ofVec2f mousePosScreen = ofVec3f(ofGetMouseX() - viewport.width / 2 - viewport.x, viewport.height / 2 - (ofGetMouseY() - viewport.y), 0);
#ifdef TARGET_LINUX
if(ofGetKeyPressed(OF_KEY_SHIFT))
#else
if(ofGetKeyPressed(OF_KEY_ALT))
#endif
{
ofVec2f trans(mousePosScreenPrev - mousePosScreen);
if(ofGetMousePressed(0))
{
tumble(trans.x, -trans.y);
}
else if(ofGetMousePressed(1))
{
track(trans.x, trans.y);
}
else if(ofGetMousePressed(2))
{
float zoomAmount = trans.y;
zoom(zoomAmount);
}
}
mousePosScreenPrev = mousePosScreen;
ofCamera::begin(viewport);
ofPopStyle();
}
//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button)
{
if(!ofGetKeyPressed(OF_KEY_ALT))
{
this->scene->pickObject(x, y);
//#define DEBUG_PICKING 1
#ifdef DEBUG_PICKING
this->window->getWxGLCanvas()->setAutoRedraw(!this->window->getWxGLCanvas()->getAutoRedraw());
this->window->getWxGLCanvas()->SwapBuffers();
#endif
}
}
void ofApp::draw() {
ofBackground(0);
ofSetColor(255);
ofTranslate(ofGetWidth() / 2, ofGetHeight() / 2);
ofRotateY(ofGetFrameNum());
ofTranslate(-ofGetWidth() / 2, -ofGetHeight() / 2);
if(ofGetKeyPressed()) {
mesh.drawWireframe();
} else {
mesh.draw();
}
}
//--------------------------------------------------------------
void ofApp::draw(){
cam.begin();
ofPushStyle();
ofPushMatrix();
//units are in meters which makes the models super small in OF
ofScale(1000,1000,1000);
if(ofGetKeyPressed('c')){
mesh.disableColors();
}
else{
mesh.enableColors();
}
if(ofGetKeyPressed('w')){
ofEnableDepthTest();
mesh.drawWireframe();
ofDisableDepthTest();
}
else if(ofGetKeyPressed('p')){
ofEnableBlendMode(OF_BLENDMODE_SCREEN); //make it glow
mesh.drawVertices();
}
else {
ofEnableDepthTest();
mesh.draw();
copyMesh.draw();
ofDisableDepthTest();
}
//copyMesh.draw();
ofPopMatrix();
ofPopStyle();
cam.end();
}
void ofApp::update() {
kinect.update();
if(ofGetKeyPressed('3')) {
recordingOn =! recordingOn;
}
else {
if (recordingOn==true && ofGetKeyPressed(' '))
recordingOn =false;
}
if(kinect.isFrameNew()) {
if (recordingOn == true && frameNumber <= 200) {
ofPixels& depthPixels = kinect.getDepthPixelsRef();
ofPixels& colorPixels = kinect.getPixelsRef();
for(int y = 0; y < 480; y++) {
for(int x = 0; x < 640; x++) {
ofColor color = colorPixels.getColor(x, y);
ofColor depth = depthPixels.getColor(x, y);
img.setColor(x, y, ofColor(color, depth.getBrightness()));
}
}
frameNumber = frameNumber + 1;
ostringstream Name;
Name << frameNumber << ".png";
string result = Name.str();
img.saveImage(result);
cout<<"recording"<<endl;
}
}
}
