void Cloud::Draw() { ofSetColor(color_.r, color_.g, color_.b,color_.a); if(enable_) { switch (flower_state_) { case GROWING: case DISAPPEARING: case WAITING: drawFaces(); break; case FALLING: drawFaces(); ofDisableLighting(); ofEnableAlphaBlending(); rain_emitter_.draw(0,0); ofEnableLighting(); break; case HOLDING: break; } } }
// Renders the requested list of faces // Normal faces are rendered with vertex arrays and multitexturing. The first TMU handles the // lightmap, while the second TMU handles the surface texture itself. int GLDriver::drawGeometryList(GeometryList* l) { Assert(l != NULL); if(lastTime == 0) lastTime = timeGetTime(); renderTime = timeGetTime(); qmap = l->mapData; ShaderUtils::renderTime = renderTime; ShaderUtils::qmap = qmap; ShaderUtils::textureFactory = textureFactory; qsort(l->faces, l->faceCount, sizeof(int), TransSort); glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glClientActiveTextureARB(GL_TEXTURE0_ARB); glDepthFunc(GL_LEQUAL); float timeDiff = renderTime - lastTime; drawSky(l, timeDiff); drawFaces(l, timeDiff); drawMeshes(l, timeDiff); drawPatches(l); //drawFog(l); lastTime = renderTime; return 0; }
void Mesh::drawMesh() { sumAngle = this->rotatedAngle.x + this->rotatedAngle.y + this->rotatedAngle.z; if (sumAngle > 90) { if (this->rotatedAngle.x > 0) calculateRotateMesh(1); if (this->rotatedAngle.y > 0) calculateRotateMesh(2); if (this->rotatedAngle.z > 0) calculateRotateMesh(3); this->rotatedAngle.x = 0; this->rotatedAngle.y = 0; this->rotatedAngle.z = 0; } if (sumAngle > 0) { glPushMatrix(); glRotated(this->rotatedAngle.x, 1, 0, 0); glRotated(this->rotatedAngle.y, 0, 1, 0); glRotated(this->rotatedAngle.z, 0, 0, 1); if (this->rotatedAngle.x > 0) this->rotatedAngle.x += addAngle; if (this->rotatedAngle.y > 0) this->rotatedAngle.y += addAngle; if (this->rotatedAngle.z > 0) this->rotatedAngle.z += addAngle; this->drawFaces(); glPopMatrix(); } else drawFaces(); }
void Mesh :: drawOpenGL() { tellMaterialsGL(); glPushMatrix(); glMultMatrixf(transf.m); switch (mode) { case MODE_WIRE: drawEdges(); break; case MODE_SOLID: drawFaces(); break; default: drawFaces(); drawEdges(); break; } glPopMatrix(); }
void display() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_PROJECTION); glLoadIdentity(); GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); double aspect = (double)viewport[2] / (double)viewport[3]; gluPerspective(fovy, aspect, clipNear, clipFar); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0, 0, z, x, y, 0, 0, 1, 0); if (success) { drawFaces(); if (drawAABB) { Eigen::Vector3d max = boundingBox.max; Eigen::Vector3d min = boundingBox.min; Eigen::Vector3d extent = boundingBox.extent; Eigen::Vector3d b2(min.x() + extent.x(), min.y(), min.z()); Eigen::Vector3d b3(min.x() + extent.x(), min.y() + extent.y(), min.z()); Eigen::Vector3d b4(min.x(), min.y() + extent.y(), min.z()); Eigen::Vector3d b5(max.x() - extent.x(), max.y() - extent.y(), max.z()); Eigen::Vector3d b6(max.x(), max.y() - extent.y(), max.z()); Eigen::Vector3d b8(max.x() - extent.x(), max.y(), max.z()); drawBox(min, b2, b3, b4, b5, b6, max, b8); } else { std::vector<Eigen::Vector3d> orientedPoints = boundingBox.orientedPoints; Eigen::Vector3d b1 = orientedPoints[0] + orientedPoints[2] + orientedPoints[4]; Eigen::Vector3d b2 = orientedPoints[1] + orientedPoints[2] + orientedPoints[4]; Eigen::Vector3d b3 = orientedPoints[1] + orientedPoints[2] + orientedPoints[5]; Eigen::Vector3d b4 = orientedPoints[0] + orientedPoints[2] + orientedPoints[5]; Eigen::Vector3d b5 = orientedPoints[0] + orientedPoints[3] + orientedPoints[4]; Eigen::Vector3d b6 = orientedPoints[1] + orientedPoints[3] + orientedPoints[4]; Eigen::Vector3d b8 = orientedPoints[0] + orientedPoints[3] + orientedPoints[5]; Eigen::Vector3d b7 = orientedPoints[1] + orientedPoints[3] + orientedPoints[5]; drawBox(b1, b2, b3, b4, b5, b6, b7, b8); } } glutSwapBuffers(); }
void poShape3D::draw() { po::setColor(fillColor, appliedAlpha()); if(callListID != -1) glCallList(callListID); else if ( enableFill ) drawFaces(); else if ( strokeWidth != 0 ) drawWireframe(); else if ( enablePoints ) drawVertices(); }
void Mesh::drawOpenGL() { tellMaterialsGL(); glPushMatrix(); if (usesTexture) { if (!textureLoaded) { cout << " \n TextureFileName = " << texturefile << endl; setTexture(loadTexture(texturefile)); } glBindTexture(GL_TEXTURE_2D, texture); glEnable(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_MODULATE); } glMultMatrixf(transf.m); switch (mode) { case MODE_WIRE: drawEdges(); break; case MODE_SOLID: drawFaces(); break; default: drawFaces(); drawEdges(); break; } glPopMatrix(); }
void Viewer::cb_redraw() { // Draw the faces with SSAO and everything else if (m_useSSAO && m_drawFaces) { CGoGNGLuint SSAOTexture = computeSSAO(); // Get and draw only SSAO results if (m_displayOnlySSAO) Utils::TextureSticker::StickTextureOnWholeScreen(SSAOTexture); // Use SSAO results with regular rendering else { // Render color and depth m_finalRenderFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); { // Simply render faces color and depth drawFaces(); } m_finalRenderFbo->Unbind(); // Merge color and SSAO m_colorAndSSAOMergeFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT); { // Send textures to multiply shader m_multTexturesShader->bind(); m_multTexturesShader->setTexture1Unit(GL_TEXTURE0); m_multTexturesShader->activeTexture1(m_finalRenderFbo->GetColorTexId(0)); m_multTexturesShader->setTexture2Unit(GL_TEXTURE1); m_multTexturesShader->activeTexture2(SSAOTexture); m_multTexturesShader->unbind(); // Multiply textures together Utils::TextureSticker::DrawFullscreenQuadWithShader(m_multTexturesShader); } m_colorAndSSAOMergeFbo->Unbind(); // Get and draw color texture from merged SSAO and color Fbo into final render Fbo (we need to use the depth information to display everything else) m_finalRenderFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT); { // Simply stick result texture on screen Utils::TextureSticker::StickTextureOnWholeScreen(m_colorAndSSAOMergeFbo->GetColorTexId(0)); // Now that we have depth *and* SSAO information, display everything else if(m_drawVertices) drawVertices(); if(m_drawEdges) drawEdges(); if(m_drawTopo) drawTopo(); if(m_drawNormals) drawNormals(); } m_finalRenderFbo->Unbind(); // Stick final render in main framebuffer Utils::TextureSticker::StickTextureOnWholeScreen(m_finalRenderFbo->GetColorTexId(0)); } } // Draw everything without SSAO else { if (m_drawFaces) drawFaces(); if(m_drawVertices) drawVertices(); if(m_drawEdges) drawEdges(); if(m_drawTopo) drawTopo(); if(m_drawNormals) drawNormals(); } // Check for OpenGL errors GLenum glError = glGetError(); if (glError != GL_NO_ERROR) std::cout << "GL error : " << gluErrorString(glError) << std::endl; }
CGoGNGLuint Viewer::computeSSAO() { // Render in positions and normals Fbo m_positionsAndNormalsFbo->Bind(); m_positionsAndNormalsFbo->EnableColorAttachments(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); { // Render faces color, normals and depth int oldRenderStyle = m_renderStyle; m_renderStyle = POSITIONS_AND_NORMALS; drawFaces(); m_renderStyle = oldRenderStyle; } m_positionsAndNormalsFbo->Unbind(); // Render in SSAO Fbo m_SSAOFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT); { // Send textures to SSAO shader m_computeSSAOShader->bind(); m_computeSSAOShader->setPositionTextureUnit(GL_TEXTURE0); m_computeSSAOShader->activePositionTexture(m_positionsAndNormalsFbo->GetColorTexId(0)); m_computeSSAOShader->setNormalTextureUnit(GL_TEXTURE1); m_computeSSAOShader->activeNormalTexture(m_positionsAndNormalsFbo->GetColorTexId(1)); m_computeSSAOShader->setDepthTextureUnit(GL_TEXTURE2); m_computeSSAOShader->activeDepthTexture(m_positionsAndNormalsFbo->GetDepthTexId()); m_computeSSAOShader->unbind(); // Render SSAO texture Utils::TextureSticker::DrawFullscreenQuadWithShader(m_computeSSAOShader); } m_SSAOFbo->Unbind(); // Blur SSAO texture horizontaly m_SSAOFirstBlurPassFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT); { // Send textures and blur size to blur shader m_textureBlurHShader->bind(); m_textureBlurHShader->setTextureUnit(GL_TEXTURE0); m_textureBlurHShader->activeTexture(m_SSAOFbo->GetColorTexId(0)); m_textureBlurHShader->setBlurSize(1.0/1024.0); m_textureBlurHShader->unbind(); // Render blurred SSAO texture Utils::TextureSticker::DrawFullscreenQuadWithShader(m_textureBlurHShader); } m_SSAOFirstBlurPassFbo->Unbind(); // Blur SSAO texture verticaly m_SSAOSecondBlurPassFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT); { // Send textures and blur size to blur shader m_textureBlurVShader->bind(); m_textureBlurVShader->setTextureUnit(GL_TEXTURE0); m_textureBlurVShader->activeTexture(m_SSAOFirstBlurPassFbo->GetColorTexId(0)); m_textureBlurVShader->setBlurSize(1.0/1024.0); m_textureBlurVShader->unbind(); // Render blurred SSAO texture Utils::TextureSticker::DrawFullscreenQuadWithShader(m_textureBlurVShader); } m_SSAOSecondBlurPassFbo->Unbind(); return m_SSAOSecondBlurPassFbo->GetColorTexId(0); }
//---------- void Device::drawWorld() { auto colorSource = this->getColorSource(); auto depthSource = this->getDepthSource(); auto bodySource = this->getBodySource(); if (!depthSource) { ofLogError("ofxKinectForWindows2::Device::drawPrettyMesh") << "No depth source initialised"; return; } //point cloud { //setup some point cloud properties for kicks bool usePointSize = true; #if OF_VERSION_MAJOR > 0 || OF_VERSION_MINOR >= 10 auto mainWindow = std::static_pointer_cast<ofAppGLFWWindow>(ofGetCurrentWindow()); usePointSize = mainWindow ? mainWindow->getSettings().glVersionMajor <= 2 : false; #endif usePointSize = false; if (usePointSize) { glPushAttrib(GL_POINT_BIT); glPointSize(5.0f); glEnable(GL_POINT_SMOOTH); } ofPushStyle(); bool useColor = colorSource.get(); if (useColor) { useColor &= colorSource->getTexture().isAllocated(); } if (useColor) { //bind kinect color camera texture and draw mesh from depth (which has texture coordinates) colorSource->getTexture().bind(); } auto opts = Source::Depth::PointCloudOptions(true, Source::Depth::PointCloudOptions::TextureCoordinates::ColorCamera); auto mesh = depthSource->getMesh(opts); //draw point cloud mesh.drawVertices(); //draw triangles ofSetColor(255, 150); mesh.drawWireframe(); //draw fills faded ofSetColor(255, 50); mesh.drawFaces(); if (useColor) { //unbind colour camera colorSource->getTexture().unbind(); } ofPopStyle(); //clear the point cloud drawing attributes if (usePointSize) { glPopAttrib(); } } //bodies and floor if (bodySource) { bodySource->drawWorld(); ofPushMatrix(); ofRotateDeg(90, 0, 0, 1); ofMultMatrix(bodySource->getFloorTransform()); ofDrawGridPlane(5.0f); ofPopMatrix(); } //draw the view cones of depth and colour cameras ofPushStyle(); ofNoFill(); ofSetLineWidth(2.0f); ofSetColor(100, 200, 100); depthSource->drawFrustum(); if (colorSource) { ofSetColor(200, 100, 100); colorSource->drawFrustum(); } ofPopStyle(); }
char operateImage(Userdata *userdata) { if (!userdata) { return 0; } IplImage *image1 = userdata->input[0]; IplImage *image2 = userdata->input[1]; IplImage *imageOut = userdata->output[0]; IplImage *imageOut2 = userdata->output[1]; static int color_mode = 4; static int smooth_mode = 0; static int otsu_mode = 0; static int close_mode = 0; static int canny_mode = 0; static int contour_mode = 0; static int hsv_mode = 0; static int save_img = 0; static int history_mode = 0; int key = userdata->key; switch (key) { case 'g': color_mode++; color_mode %= 5; break; case 's': smooth_mode = !smooth_mode; break; case 'o': otsu_mode = !otsu_mode; break; case 'e': close_mode = !close_mode; break; case 'c': canny_mode = !canny_mode; break; case 'b': contour_mode = !contour_mode; break; case 'h': hsv_mode = !hsv_mode; break; case 'H': history_mode = !history_mode; break; case 'S': save_img = 1; break; default: //cout << key << "\n"; break; } int value = userdata->value; int kernelSize = userdata->kernelSize; kernelSize += 1 - (kernelSize % 2); int lowThreshold = userdata->lowThreshold; int highThreshold = userdata->highThreshold; CvScalar minScalar = cvScalar(userdata->minScalar0, userdata->minScalar1, userdata->minScalar2); CvScalar maxScalar = cvScalar(userdata->maxScalar0, userdata->maxScalar1, userdata->maxScalar2); static IplImage *tmp1d = cvCreateImage(cvGetSize(image1), IPL_DEPTH_8U, 1); static IplImage *tmp3d = cvCreateImage(cvGetSize(image1), IPL_DEPTH_8U, 3); cvCopy(image1, tmp3d, NULL); filterByHSV(tmp3d, minScalar, maxScalar, tmp3d); static int tick = 0; static CvRect face = cvRect(0,0,1,1); if ((tick %= 10) == 0) { //userdata->timestep = 100; double scale = 4; CvRect *faces = NULL; double t = 0; int facesCount = findFaces(tmp3d, &faces, scale, &t); face = (facesCount != 0) ? faces[0] : face; free(faces); //printf("%d face(s) detected in %g ms :: 1st face at {%d,%d,%d,%d}", facesCount, t, face.x, face.y, face.width, face.height); drawFaces(tmp3d, 1, &face); } tick++; //face extraction IplImage *subimage = createSubArray(tmp3d, face); cvNamedWindow(CONTROL_WINDOW "face", 0); cvResizeWindow(CONTROL_WINDOW "face", subimage->width, subimage->height); cvShowImage(CONTROL_WINDOW "face", subimage); //face histogram IplImage *subimage2 = cvCloneImage(subimage); cvCvtColor(subimage2, subimage2, CV_BGR2HSV); size_t binsCount = 0; size_t *bins = NULL; //printf("%d (%p)", binsCount, &bins); size_t ret = calcularHistograma(subimage2, &binsCount, &bins); //printf(" ret=%d %d (%p)", ret, binsCount, bins); CvScalar maxValues; if (bins) { for (size_t i = 0; i < binsCount; i++) { size_t idx = 0; for (size_t j = 0; j < 256; j++) { if (bins[i * 256 + j] > bins[idx]) { idx = j; } } maxValues.val[i] = idx; } free(bins); } #if 0 if (subimage->width > 10 && subimage->height > 10) graficarHistograma(subimage, binsCount, bins); cvNamedWindow(CONTROL_WINDOW "42", 0); cvResizeWindow(CONTROL_WINDOW "42", subimage->width, subimage->height); cvShowImage(CONTROL_WINDOW "42", subimage); #endif #if 0 int minH = (int)maxValues.val[0] - 20; int maxH = (int)maxValues.val[0] + 20; int minS = (int)maxValues.val[1] - 20; int maxS = (int)maxValues.val[1] + 20; int minV = (int)maxValues.val[2] - 20; int maxV = (int)maxValues.val[2] + 20; minH = minH < 0 ? 180 - minH : minH; maxH = maxH > 180 ? maxH - 180 : maxH; printf("%d,%d,%d %d,%d,%d", minH, minS, minV, maxH, maxS, maxV); filterByHSV(subimage2, cvScalar(minH, minS, minV, 0), cvScalar(maxH, maxS, maxV, 0), subimage2); filterByHSV(subimage2, minScalar, maxScalar, subimage2); cvCvtColor(subimage2, subimage2, CV_HSV2BGR); cvNamedWindow(CONTROL_WINDOW "41", 0); cvResizeWindow(CONTROL_WINDOW "41", subimage2->width, subimage2->height); cvShowImage(CONTROL_WINDOW "41", subimage2); #endif cvReleaseImage(&subimage); cvReleaseImage(&subimage2); cvCopy(image1, image2, NULL); cvCopy(imageOut, imageOut2, NULL); cvCopy(tmp3d, imageOut, NULL); //cvReleaseImage(&tmp1d); //cvReleaseImage(&tmp3d); //afterProcess(userdata); printf("\r"); return 0; }
void Cube::render(FrameBuffer* fb,DepthBuffer* db,VertexShader vs,FragmentShader fs,int cullFlag) { drawFaces(fb,db,vs,fs,cullFlag,verts,faceNum); }
//-------------------------------------------------------------- void testApp::draw(){ ofClear(0); opticalFlow.setSource(cameraFbo.getTextureReference()); opticalFlow.update(deltaTime); velocityMask.setDensity(cameraFbo.getTextureReference()); velocityMask.setVelocity(opticalFlow.getOpticalFlow()); velocityMask.update(); fluid.addVelocity(opticalFlow.getOpticalFlowDecay()); fluid.addDensity(velocityMask.getColorMask()); fluid.addTemperature(velocityMask.getLuminanceMask()); for (int i=0; i<numDrawForces; i++) { flexDrawForces[i].update(); if (flexDrawForces[i].didChange()) { // if a force is constant multiply by deltaTime float strength = flexDrawForces[i].getStrength(); if (!flexDrawForces[i].getIsTemporary()) strength *=deltaTime; switch (flexDrawForces[i].getType()) { case flowTools::FT_DENSITY: fluid.addDensity(flexDrawForces[i].getTextureReference(), strength); break; case flowTools::FT_VELOCITY: fluid.addVelocity(flexDrawForces[i].getTextureReference(), strength); particleFlow.addFlowVelocity(flexDrawForces[i].getTextureReference(), strength); break; case flowTools::FT_TEMPERATURE: fluid.addTemperature(flexDrawForces[i].getTextureReference(), strength); break; case flowTools::FT_PRESSURE: fluid.addPressure(flexDrawForces[i].getTextureReference(), strength); break; case flowTools::FT_OBSTACLE: fluid.addTempObstacle(flexDrawForces[i].getTextureReference()); default: break; } } } fluid.update(); if (particleFlow.isActive()) { particleFlow.setSpeed(fluid.getSpeed()); particleFlow.setCellSize(fluid.getCellSize()); particleFlow.addFlowVelocity(opticalFlow.getOpticalFlow()); particleFlow.addFluidVelocity(fluid.getVelocity()); particleFlow.setObstacle(fluid.getObstacle()); } particleFlow.update(); int windowWidth = ofGetWindowWidth(); int windowHeight = ofGetWindowHeight(); ofClear(0,0); switch(visualisationMode.get()) { case 0: // Source cameraFbo.draw(0,0, windowWidth, windowHeight); break; case 1: // Fluid Composite ofPushStyle(); ofEnableBlendMode(OF_BLENDMODE_DISABLED); cameraFbo.begin(); if (doFlipCamera) kinect.draw(cameraFbo.getWidth(), 0, -ofGetWindowWidth(), ofGetWindowHeight()); else kinect.draw(0, 0, ofGetWindowWidth(), ofGetWindowHeight()); cameraFbo.end(); cameraFbo.draw(0,0, windowWidth, windowHeight); ofEnableBlendMode(blendMode); fluid.draw(0, 0,windowWidth, windowHeight); if (particleFlow.isActive()) particleFlow.draw(0, 0, windowWidth, windowHeight); if (showLogo) { theImage.draw(0, 0,windowWidth, windowHeight); } ofPopStyle(); break; case 2: // Fluid Color //---------------------- ofPushStyle(); ofEnableBlendMode(OF_BLENDMODE_DISABLED); cameraFbo.begin(); if (doFlipCamera) kinect.draw(cameraFbo.getWidth(), 0, -ofGetWindowWidth(), ofGetWindowHeight()); else kinect.draw(0, 0, ofGetWindowWidth(), ofGetWindowHeight()); cameraFbo.end(); //---------------------- ofEnableBlendMode(blendMode); fluid.draw(0, 0, windowWidth, windowHeight); if (particleFlow.isActive()) particleFlow.draw(0, 0, windowWidth, windowHeight); ofPopStyle(); break; case 3: // velocityMask //---------------------- ofPushStyle(); ofEnableBlendMode(OF_BLENDMODE_DISABLED); cameraFbo.begin(); if (doFlipCamera) kinect.draw(cameraFbo.getWidth(), 0, -ofGetWindowWidth(), ofGetWindowHeight()); else kinect.draw(0, 0, ofGetWindowWidth(), ofGetWindowHeight()); cameraFbo.end(); ofBackground(255); ofEnableBlendMode(blendMode); velocityMask.draw(0, 0, windowWidth, windowHeight); fluid.draw(0, 0, windowWidth, windowHeight); if (particleFlow.isActive()) particleFlow.draw(0, 0, windowWidth, windowHeight); if (showLogo) { ofEnableBlendMode(OF_BLENDMODE_ADD); theImage.draw(0,0,windowWidth, windowHeight); } ofPopStyle(); break; case 4: // CLOUD ofPushStyle(); ofEnableBlendMode(blendMode); easyCam.begin(); drawPointCloud(); easyCam.end(); cameraFbo.begin(); particleFlow.draw(0, 0, windowWidth, windowHeight); cameraFbo.end(); ofPopStyle(); break; case 5: // LINES fluid.draw(0, 0, windowWidth, windowHeight); ofPushStyle(); ofEnableBlendMode(blendMode); easyCam.begin(); drawLines(); easyCam.end(); ofPopStyle(); break; case 6: // FACES fluid.draw(0, 0, windowWidth, windowHeight); ofPushStyle(); ofEnableBlendMode(blendMode); easyCam.begin(); drawFaces(); easyCam.end(); ofPopStyle(); break; case 7: // ofPushStyle(); ofEnableBlendMode(OF_BLENDMODE_DISABLED); cameraFbo.begin(); if (doFlipCamera) kinect.draw(cameraFbo.getWidth(), 0, -ofGetWindowWidth(), ofGetWindowHeight()); else kinect.draw(0, 0, ofGetWindowWidth(), ofGetWindowHeight()); cameraFbo.end(); ofBackground(220,200,100,60); ofColor(188,10,10); ofEnableBlendMode(blendMode); fluid.draw(0, 0, windowWidth, windowHeight); if (particleFlow.isActive()) particleFlow.draw(0, 0, windowWidth, windowHeight); if (showLogo) { ofEnableBlendMode(OF_BLENDMODE_SUBTRACT); ofSetColor(255,255,255,200); theImage.draw(0,0,windowWidth, windowHeight); } ofPopStyle(); break; } if (toggleGuiDraw) { guiFPS = ofGetFrameRate(); if (visualisationMode.get() >= numVisualisationModes) visualisationMode.set(numVisualisationModes-1); visualisationName.set(visualisationModeTitles[visualisationMode.get()]); gui.draw(); } drawtheMidi(); }