RefreshLiveviewEvent:: RefreshLiveviewEvent(double refresh_interval, int min_delay, Visualization &vis) :vis_(&vis), refresh_interval_(refresh_interval) { #ifdef HAVE_BOOST boost::xtime_get(&last_refresh_, boost::TIME_UTC); last_refresh_.sec -= 1; boost::mutex::scoped_lock lock(*getUpdateMutex()); #endif min_delay_time_ = min_delay; // Convert to Nanoseconds as needed by boost::thread: min_delay_time_ *= 1000000; // Writes current network state to texture. write_frame(); // Informs the external window that texture data has changed. updateTexture(getTexture()); }
void Menu::step(float dt) { if(!active) return; int deltaScroll = 0; bool update = false; sf::Vector2f mouse = sf::Vector2f(sf::Mouse::getPosition(Application::getWindow())); sf::Vector2f relMouse = mouse - spr.getPosition(); sf::Vector2f mouseInView = rndrTxtre.mapPixelToCoords(static_cast<sf::Vector2i>(relMouse)); if(scroll && sf::Mouse::isButtonPressed(sf::Mouse::Left) && contains(scrollBar.getPosition().x,spr.getPosition().y,scrollBar.getSize().x,view.getSize().y,mouse.x,mouse.y)) { int new_scrolled = (menuList.size()-itemsVisible+1)*relMouse.y/(view.getSize().y); if(new_scrolled != scrolled) { deltaScroll = new_scrolled-scrolled; update = true; } } if(update) updateTexture(deltaScroll); }
void Vinyl::setImage () { quad.clear(); ofDisableArbTex(); quad.getVertices().resize(4); quad.getTexCoords().resize(4); quad.setMode(OF_PRIMITIVE_TRIANGLE_FAN); vinylHeight = (ofGetHeight()-HEADER_HEIGHT-FOOTER_HEIGHT); s = PIXELS_READING/vinylImage.getHeight(); w = vinylImage.getWidth()*s; h = vinylImage.getHeight()*s; vinylImage.resize(w, h); if(vinylImage.bAllocated()){ updateTexture(); } }
Card(Value v, Suit s, bool FaceUp) { faceup = FaceUp; value = v; suit = s; const std::string str(std::string("Cards/") .append(intStringValues[static_cast<int>(value)]) .append("_of_") .append(stringSuits[static_cast<int>(suit)]) .append(".png")); std::cout << str << ", value =" << static_cast<int>(value)<< ", suit = " << static_cast<int>(suit) << std::endl; if (!face.loadFromFile(str)) { // TODO error std::cout << "Couldn't load card img" << std::endl; } else { updateTexture(); std::cout << "Left: " << sprite.getLocalBounds().left << ", width: " << sprite.getLocalBounds().width << ", top: " << sprite.getLocalBounds().top << ", height: " << sprite.getLocalBounds().height << std::endl; } }
/**Allocate resources for the lookup table and the volume on the GPU. * Prerequisite: SetImage and SetcolorTable has been called. * * Call this from inside a PrepareForRendering() methods in vtk. */ virtual void allocate() { if (mAllocated) // do this only once. { return; } if (!mTexture) { std::cout << "error: bad volume buffer initialization" << std::endl; return; } glActiveTexture(GL_TEXTURE7); glEnable(GL_TEXTURE_3D); glGenTextures(1, &textureId); glDisable(GL_TEXTURE_3D); updateTexture(); mAllocated = true; }
void receiver() { int size; while ((size = recv(sock, buff, sizeof(buff), MSG_DONTWAIT)) > 0) { //printf("recved %d\n", size); if (buff[0] != type) { synced = 0; } type = buff[0]; switch (type) { case 1: // raw raw_seq = buff[1] << 8 | buff[2]; raw_line = buff[3]; setLine(raw_line, buff+6, size-6); if (raw_line == h-1) { updateTexture(); } break; case 2: // cmpr case 3: // cmpr3 cmpr_seq = buff[1] << 8 | buff[2]; if (cmpr_seq != cmpr_next) { synced = 0; printf("packet lost %d -> %d\n", (int)cmpr_next, (int)cmpr_seq); } cmpr_next = cmpr_seq+1; //printf("received compression unit %d\n", cmpr_seq); if (type == 2) decompress(buff+3, size-3); else decompress3(buff+3, size-3); break; default: break; } // XXX do on end of frame } }
void MediaPlayerPrivateGStreamerBase::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity) { if (!m_player->visible()) return; if (m_usingFallbackVideoSink) { if (RefPtr<BitmapTexture> texture = updateTexture(textureMapper)) textureMapper->drawTexture(*texture.get(), targetRect, matrix, opacity); return; } #if USE(GSTREAMER_GL) if (!GST_IS_SAMPLE(m_sample.get())) return; GstCaps* caps = gst_sample_get_caps(m_sample.get()); if (!caps) return; GstVideoInfo videoInfo; gst_video_info_init(&videoInfo); if (!gst_video_info_from_caps(&videoInfo, caps)) return; GstBuffer* buffer = gst_sample_get_buffer(m_sample.get()); GstVideoFrame videoFrame; if (!gst_video_frame_map(&videoFrame, &videoInfo, buffer, static_cast<GstMapFlags>(GST_MAP_READ | GST_MAP_GL))) return; unsigned textureID = *reinterpret_cast<unsigned*>(videoFrame.data[0]); BitmapTexture::Flags flags = BitmapTexture::NoFlag; if (GST_VIDEO_INFO_HAS_ALPHA(&videoInfo)) flags |= BitmapTexture::SupportsAlpha; IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo)); TextureMapperGL* textureMapperGL = reinterpret_cast<TextureMapperGL*>(textureMapper); textureMapperGL->drawTexture(textureID, flags, size, targetRect, matrix, opacity); gst_video_frame_unmap(&videoFrame); #endif }
void Image::updateDrawables() { if(m_upd_recreate) { destroyDrawables(); createDrawables(); } if(m_upd_geometry) { updateGeometry(); } if(m_upd_xf) { updateTransform(); } if(m_upd_texture) { updateTexture(); } if(m_upd_tile_ratio) { updateTileRatio(); } if(m_upd_smooth) { updateSmooth(); } if(m_upd_opacity) { updateOpacity(); } m_upd_recreate = false; m_upd_geometry = false; m_upd_xf = false; m_upd_texture = false; m_upd_tile_ratio = false; m_upd_smooth = false; m_upd_opacity = false; }
void display() { HandleOpcode(); if(DrawFlag) { // Clear framebuffer glClear(GL_COLOR_BUFFER_BIT); #ifdef DRAWWITHTEXTURE updateTexture(); #else updateQuads(); #endif // Swap buffers! glutSwapBuffers(); // Processed frame DrawFlag = 0; } }
/** * Function to render and display content. */ GLUSboolean update(GLUSfloat time) { static GLfloat passedTime = 0.0f; static GLUSfloat angle = 0.0f; // http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clear.html glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml glUseProgram(g_programBackground.program); // http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml glUniformMatrix4fv(g_modelViewLocationBackground, 1, GL_FALSE, g_modelView); // ToDo: glBindVertexArray(g_vaoBackground); // ToDo: glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html glEnable( GL_CULL_FACE); // http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml glDrawElements(GL_TRIANGLES, g_numberIndicesBackground, GL_UNSIGNED_INT, 0); // Update the texture updateTexture(passedTime); // Render the water scene renderWater(passedTime, angle); passedTime += time; angle += 2.0f * PIf / 120.0f * time; return GLUS_TRUE; }
//-------------------------------------------------------------------------------- void ofxCvImage::draw( float x, float y, float w, float h ) { if( bUseTexture ) { updateTexture(); tex.draw(x,y, w,h); } else { #ifdef TARGET_OPENGLES ofLog(OF_LOG_ERROR, "texture-less drawing not supported in OpenGL ES"); #else // this is slower than the typical draw method based on textures // but useful when dealing with threads GL textures often don't work ofLog(OF_LOG_NOTICE, "in draw, using slow texture-less drawing"); ofLog(OF_LOG_NOTICE, "texture-less drawing - be aware, unlike texture drawing, \ this always draws window aligned, rotation not supported"); if( x == 0) { x += 0.01; ofLog(OF_LOG_NOTICE, "BUG: can't draw at x==0 in texture-less mode."); } if(bAnchorIsPct){ x -= anchor.x * w; y -= anchor.y * h; }else{ x -= anchor.x; y -= anchor.y; } glRasterPos2f( x, y+h ); IplImage* tempImg; tempImg = cvCreateImage( cvSize((int)w, (int)h), ipldepth, iplchannels ); cvResize( cvImage, tempImg, CV_INTER_NN ); cvFlip( tempImg, tempImg, 0 ); glDrawPixels( tempImg->width, tempImg->height , glchannels, gldepth, tempImg->imageData ); cvReleaseImage( &tempImg ); #endif } }
//-------------------------------------------------------------------------------- void ofxCvImage::draw( float x, float y, float w, float h ) { if( bUseTexture ) { updateTexture(); tex.draw(x,y, w,h); } else { #ifdef TARGET_OPENGLES ofLogError("ofxCvImage") << "draw(): textureless drawing mode not supported in OpenGL ES"; #else // this is slower than the typical draw method based on textures // but useful when dealing with threads GL textures often don't work ofLogNotice("ofxCvImage") << "draw(): using textureless drawing mode"; ofLogNotice("ofxCvImage") << "draw(): drawing is slower, aligned to the window, & does not support rotation"; if( x == 0) { ofLogNotice("ofxCvImage") << "draw(): x position cannot be 0 in textureless drawing mode, setting to 0.01"; x += 0.01; } if(bAnchorIsPct){ x -= anchor.x * w; y -= anchor.y * h; }else{ x -= anchor.x; y -= anchor.y; } glRasterPos2f( x, y+h ); IplImage* tempImg; tempImg = cvCreateImage( cvSize((int)w, (int)h), ipldepth, iplchannels ); cvResize( cvImage, tempImg, CV_INTER_NN ); cvFlip( tempImg, tempImg, 0 ); glDrawPixels( tempImg->width, tempImg->height , glchannels, gldepth, tempImg->imageData ); cvReleaseImage( &tempImg ); #endif } }
void FluidDrawerBase::drawColor(float x, float y, float renderWidth, float renderHeight, bool withAlpha) { if(enabled == false) return; if(useAdditiveBlending) { glBlendFunc(GL_ONE, GL_ONE); glEnable(GL_BLEND); } else { glDisable(GL_BLEND); } int fw = _fluidSolver->getWidth(); int fh = _fluidSolver->getHeight(); ofVec2f vel; ofColor color; int index = 0; for(int j=1; j < fh-1; j++) { for(int i=1; i < fw-1; i++) { _fluidSolver->getInfoAtCell(i, j, &vel, &color); int r = (unsigned char)min(color.r * 255 * brightness, 255.0f); int g = (unsigned char)min(color.g * 255 * brightness, 255.0f); int b = (unsigned char)min(color.b * 255 * brightness, 255.0f); if(doInvert) { r = 255 - r; g = 255 - g; b = 255 - b; } _pixels[index++] = r; _pixels[index++] = g; _pixels[index++] = b; if(_alphaEnabled) _pixels[index++] = withAlpha ? max(b, max(r, g)) : 255; } } updateTexture(); drawTexture(x, y, renderWidth, renderHeight); }
void reposition(const QRect& frameGeometry, QSize& fullSize) { QRect nodeRect = FrameSvgHelpers::sectionRect(m_border, frameGeometry, fullSize); //ensure we're not passing a weird rectangle to updateTexturedRectGeometry if(!nodeRect.isValid() || nodeRect.isEmpty()) nodeRect = QRect(); //the position of the relevant texture within this texture ID. //for atlas' this will only be a small part of the texture QRectF textureRect; if (m_fitMode == Tile) { textureRect = QRectF(0,0,1,1); //we can never be in an atlas for tiled images. //if tiling horizontally if (m_border == FrameSvg::TopBorder || m_border == FrameSvg::BottomBorder || m_border == FrameSvg::NoBorder) { textureRect.setWidth(nodeRect.width() / m_elementNativeSize.width()); } //if tiling vertically if (m_border == FrameSvg::LeftBorder || m_border == FrameSvg::RightBorder || m_border == FrameSvg::NoBorder) { textureRect.setHeight(nodeRect.height() / m_elementNativeSize.height()); } } else if (m_fitMode == Stretch) { QString prefix = m_frameSvg->frameSvg()->actualPrefix(); QString elementId = prefix + FrameSvgHelpers::borderToElementId(m_border); //re-render the SVG at new size updateTexture(nodeRect.size(), elementId); textureRect = texture()->normalizedTextureSubRect(); } else if (texture()) { // for fast stretch. textureRect = texture()->normalizedTextureSubRect(); } QSGGeometry::updateTexturedRectGeometry(geometry(), nodeRect, textureRect); markDirty(QSGNode::DirtyGeometry); }
// ---------------------------------------------------------------------- void RefreshLiveviewEvent::timeout(shawn::EventScheduler &es, shawn::EventScheduler::EventHandle eh, double t, shawn::EventScheduler::EventTagHandle &) throw() { #ifdef HAVE_BOOST // Compute timestamp of next refresh. last_refresh_.nsec += min_delay_time_; // Sleeps until next refresh (if needed, maybe already reached). boost::thread::sleep(last_refresh_); // Start refresh and mark current time as time of last refresh. boost::xtime_get(&last_refresh_, boost::TIME_UTC); // Lock the texture update mutex! boost::mutex::scoped_lock lock(*getUpdateMutex()); #endif // Writes current network state to texture. write_frame(); // Informs the external window that texture data has changed. updateTexture(getTexture()); // Re-schedules the event for next execution. es.move_event(eh, t + refresh_interval_); }
//-------------------------------------------------------------- void DrawerBase::drawColor(float x, float y, float renderWidth, float renderHeight, bool withAlpha) const { if(enabled == false) return; ofPushStyle(); if(useAdditiveBlending) ofEnableBlendMode(OF_BLENDMODE_ADD); else ofDisableAlphaBlending(); int fw = _fluidSolver->getWidth(); int fh = _fluidSolver->getHeight(); Vec2f vel; Color color; int index = 0; for(int j=1; j < fh-1; j++) { for(int i=1; i < fw-1; i++) { _fluidSolver->getInfoAtCell(i, j, &vel, &color); int r = (unsigned char)min(color.r * 255 * brightness, 255.0f); int g = (unsigned char)min(color.g * 255 * brightness, 255.0f); int b = (unsigned char)min(color.b * 255 * brightness, 255.0f); if(doInvert) { r = 255 - r; g = 255 - g; b = 255 - b; } _pixels[index++] = r; _pixels[index++] = g; _pixels[index++] = b; if(_alphaEnabled) _pixels[index++] = withAlpha ? max(b, max(r, g)) : 255; } } updateTexture(); drawTexture(x, y, renderWidth, renderHeight); ofPopStyle(); }
void ColourPanel::updateFromColour(const MyGUI::Colour& _colour) { mCurrentColour = _colour; if (!mAlphaSupport) mCurrentColour.alpha = 1; std::vector<float> vec; vec.push_back(mCurrentColour.red); vec.push_back(mCurrentColour.green); vec.push_back(mCurrentColour.blue); std::sort(vec.begin(), vec.end()); MyGUI::IntPoint point((int)((1 - vec[0] / vec[2]) * mColourRect->getWidth()), (int)((1 - vec[2]) * mColourRect->getHeight())); mImageColourPicker->setPosition(point.left - (mImageColourPicker->getWidth() / 2), point.top - (mImageColourPicker->getHeight() / 2)); int iMax = (mCurrentColour.red == vec[2]) ? 0 : (mCurrentColour.green == vec[2]) ? 1 : 2; int iMin = (mCurrentColour.red == vec[0]) ? 0 : (mCurrentColour.green == vec[0]) ? 1 : 2; int iAvg = 3 - iMax - iMin; if (iMin == iMax) // if gray colour - set base red { iMax = 0; iMin = 1; iAvg = 2; byIndex(mBaseColour, iMin) = 0.; byIndex(mBaseColour, iAvg) = 0.; byIndex(mBaseColour, iMax) = 1.; } else { byIndex(mBaseColour, iMin) = 0.; byIndex(mBaseColour, iAvg) = (vec[1] - vec[0]) / (vec[2] - vec[0]); byIndex(mBaseColour, iMax) = 1.; } int i; for (i = 0; i < 6; ++i) { if ((fabs(byIndex(mColourRange[i], iMin) - byIndex(mBaseColour, iMin)) < 0.001) && (fabs(byIndex(mColourRange[i], iMax) - byIndex(mBaseColour, iMax)) < 0.001) && (fabs(byIndex(mColourRange[i+1], iMin) - byIndex(mBaseColour, iMin)) < 0.001) && (fabs(byIndex(mColourRange[i+1], iMax) - byIndex(mBaseColour, iMax)) < 0.001)) break; } float sector_size = (float)mScrollRange->getScrollRange() / 6.0f; size_t current = i; float offset = byIndex(mBaseColour, iAvg); if (byIndex(mColourRange[i+1], iAvg) < byIndex(mColourRange[i], iAvg)) offset = 1 - byIndex(mBaseColour, iAvg); size_t pos = size_t((current + offset) * sector_size); mScrollRange->setScrollPosition(pos); // бонус для обрезки цвета под шкалу mBaseColour.red = mColourRange[i].red + offset * (mColourRange[i+1].red - mColourRange[i].red); mBaseColour.green = mColourRange[i].green + offset * (mColourRange[i+1].green - mColourRange[i].green); mBaseColour.blue = mColourRange[i].blue + offset * (mColourRange[i+1].blue - mColourRange[i].blue); updateTexture(mBaseColour); mAlphaSlider->setScrollPosition((size_t)((double)(mAlphaSlider->getScrollRange() - 1) * (double)mCurrentColour.alpha)); mColourView->setColour(mCurrentColour); mColourView->setAlpha(mCurrentColour.alpha); mAlphaSliderBack->setColour(mCurrentColour); eventPreviewColour(mCurrentColour); }
void setFaceUp(bool faceUp) { faceup = faceUp; updateTexture(); }
void Flip() { faceup = !faceup; updateTexture(); }
void StateTextureControl::updateSkinProperties() { updateTexture(); updateCoord(); }
//---------------------------------------------------------- ofTexture& ofFbo::getTexture(int attachmentPoint) { updateTexture(attachmentPoint); return textures[attachmentPoint]; }
tgt::Texture* TransFunc::getTexture() { if (textureInvalid_) updateTexture(); return tex_; }
void Menu::passEvent(const sf::Event &event) { if(!active) return; bool update = false; int deltaScroll = 0; if(event.type == sf::Event::KeyPressed) { switch(event.key.code) { case sf::Keyboard::Up: if(--marker < 0) { marker = menuList.size()-1; deltaScroll = menuList.size()-itemsVisible; } else if(marker < scrolled) deltaScroll = -1; update = true; break; case sf::Keyboard::Down: if(size_t(++marker) > menuList.size()-1) { deltaScroll = -menuList.size()+itemsVisible; marker = 0; } else if(marker-scrolled+1>itemsVisible) deltaScroll = 1; update = true; break; case sf::Keyboard::Return: clicked = marker; break; default: break; } } else if(event.type == sf::Event::MouseMoved) { sf::Vector2f mouse(event.mouseMove.x,event.mouseMove.y); sf::Vector2f mouseInView = rndrTxtre.mapPixelToCoords(sf::Vector2i(mouse) - sf::Vector2i(spr.getPosition())); if(spr.getGlobalBounds().contains(mouse) && mouseInView.y/(linePadding+characterSize) != marker && mouseInView.y/(linePadding+characterSize)-scrolled <= menuList.size()) { marker = mouseInView.y/(linePadding+characterSize); update = true; } } else if(event.type == sf::Event::MouseButtonPressed) { sf::Vector2f mouse(event.mouseButton.x,event.mouseButton.y); sf::Vector2f mouseInView = rndrTxtre.mapPixelToCoords(sf::Vector2i(mouse) - sf::Vector2i(spr.getPosition())); if(spr.getGlobalBounds().contains(mouse) && mouseInView.y/(linePadding+characterSize) != marker && mouseInView.y/(linePadding+characterSize)-scrolled <= menuList.size()) { clicked = marker = mouseInView.y/(linePadding+characterSize); update = true; } } else if(event.type == sf::Event::MouseWheelMoved) { if(-event.mouseWheel.delta+scrolled+itemsVisible <= int(menuList.size()) && -event.mouseWheel.delta+scrolled >= 0) { sf::Vector2f mouse(event.mouseWheel.x,event.mouseWheel.y); if(spr.getGlobalBounds().contains(mouse)) { deltaScroll = -event.mouseWheel.delta; update = true; mouse.y += deltaScroll*(linePadding+characterSize);//adjust for the new scroll mouse -= spr.getPosition(); mouse = rndrTxtre.mapPixelToCoords(static_cast<sf::Vector2i>(mouse)); if(mouse.y/(linePadding+characterSize) != marker/* && mouse.y/(linePadding+characterSize)-scrolled <= itemsVisible*/) marker = mouse.y/(linePadding+characterSize); } } } if(update) updateTexture(deltaScroll); }
// Updates the rendered scene void GLDvrWidget::updateContent() { if(mp_volume) { updateTexture(); // Update the texture buffer updateGL(); // Update the display (cautomatically call paintGL()) } }
int Tile::increaseValue() noexcept { m_Value *= 2; updateTexture(); return m_Value; }
GLubyte* TransFunc::getPixelData() { if (textureInvalid_) updateTexture(); tgtAssert(tex_, "No texture"); return tex_->getPixelData(); }
MatWindow::MatWindow(QWidget *parent) : QWidget(parent) { setWindowTitle(tr("View/Change Material")); setWindowFlags(Qt::Dialog); setMinimumSize(QSize(400, 500)); setMaximumSize(QSize(400, 500)); treeMat = new QTreeWidget(this); treeMat->setHeaderLabels(QStringList("Sub Entities")); treeMat->setMinimumSize(150, 150); connect(treeMat, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(processMat(QTreeWidgetItem*))); textureLbl = new QLabel("Texture Preview"); textureLbl->setPixmap(tr("settings.png")); textureLbl->setMinimumSize(150, 150); matText = new QTextEdit; matText->setMinimumSize(300, 200); connect(matText, SIGNAL(textChanged()), this, SLOT(updateTexture())); //Textures viewTexture = new QGroupBox(tr("View Texture")); treeTextureLayout = new QHBoxLayout; treeTextureLayout->addWidget(treeMat); treeTextureLayout->addWidget(textureLbl); viewTexture->setLayout(treeTextureLayout); ////////// //Material viewMat = new QGroupBox(tr("View Material")); matLayout = new QVBoxLayout; matLayout->addWidget(matText); viewMat->setLayout(matLayout); //////////// //Btn groupBtn = new QGroupBox; groupBtn->setFlat(true); okBtn = new QPushButton(tr("&Ok")); okBtn->setMaximumSize(QSize(75, 25)); connect(okBtn, SIGNAL(clicked()), this, SLOT(saveMat())); cancelBtn = new QPushButton(tr("&Cancel")); cancelBtn->setMaximumSize(QSize(75, 25)); connect(cancelBtn, SIGNAL(clicked()), this, SLOT(close())); btnLayout = new QGridLayout; btnLayout->addWidget(okBtn, 0, 1); btnLayout->addWidget(cancelBtn, 0, 2); btnLayout->setAlignment(okBtn, Qt::AlignRight & Qt::AlignBottom); btnLayout->setAlignment(cancelBtn, Qt::AlignRight & Qt::AlignBottom); groupBtn->setLayout(btnLayout); /////////// gridLayout = new QVBoxLayout; gridLayout->addWidget(viewTexture); gridLayout->addWidget(viewMat); gridLayout->addWidget(groupBtn); setLayout(gridLayout); scriptPath += QDir::currentPath()+"/media/materials/scripts/"; texturePath += QDir::currentPath()+"/media/materials/textures/"; posMat = -1; nextMat = -1; strAllMat = ""; }
//-------------------------------------------------------------- void ofxThreadedVideo::update(){ if(lock()){ // check if we're loading a video if(loadVideoID != VIDEO_NONE){ videos[loadVideoID].update(); float w = videos[loadVideoID].getWidth(); float h = videos[loadVideoID].getHeight(); // allocate a texture if the one we have is a different size if(bUseTexture && (textures[loadVideoID].getWidth() != w || textures[loadVideoID].getHeight() != h)){ ofLogVerbose() << "Allocating texture" << loadVideoID << w << h; textures[loadVideoID].allocate(w, h, ofGetGLTypeFromPixelFormat(internalPixelFormat)); } // check for a new frame before loading video if(bFrameNew[loadVideoID]){ // switch the current movie ID to the one we just loaded int lastVideoID = currentVideoID; currentVideoID = loadVideoID; loadVideoID = VIDEO_NONE; // close the last movie - we do this here because // ofQuicktimeVideo chokes if you try to close in a thread if(lastVideoID != VIDEO_NONE){ ofLogVerbose() << "Closing last video" << lastVideoID; paths[lastVideoID] = names[lastVideoID] = ""; videos[lastVideoID].stop(); // reset properties to defaults newPosition[lastVideoID] = -1.0f; newFrame[lastVideoID] = -1; newSpeed[lastVideoID] = 1.0f; newLoopType[lastVideoID] = -1; frame[lastVideoID] = 0; bFrameNew[lastVideoID] = false; bPaused[lastVideoID] = false; volume[lastVideoID] = 255; } // send event notification ofxThreadedVideoEvent videoEvent = ofxThreadedVideoEvent(paths[currentVideoID], VIDEO_EVENT_LOAD_OK, this); ofNotifyEvent(threadedVideoEvent, videoEvent, this); } } // check for a new frame for current video updateTexture(currentVideoID); // if there's a movie in the queue if(pathsToLoad.size() > 0 && loadPath == "" && loadVideoID == VIDEO_NONE){ // ...let's start trying to load it! loadPath = pathsToLoad.front(); pathsToLoad.pop(); }; // calculate frameRate -> taken from ofAppRunner prevMillis = ofGetElapsedTimeMillis(); timeNow = ofGetElapsedTimef(); double diff = timeNow-timeThen; if( diff > 0.00001 ){ fps = 1.0 / diff; frameRate *= 0.9f; frameRate += 0.1f*fps; } lastFrameTime = diff; timeThen = timeNow; unlock(); } }
void Canvas::textureInvalidate(ITexture* _texture) { updateTexture(); }
void iil4mitkImage::drawTextures (iil4mitkWidget* widget) { const unsigned int s = _size; // size of the tiles unsigned int n, m; // number of the tiles n = (unsigned int) ceilf ((float) _rw / (float) (s - 2)); m = (unsigned int) ceilf ((float) _rh / (float) (s - 2)); /* Allocate memory for the textures */ Textures* textures; { iil4mitkWidget* w; unsigned int available, total; //w = (widget->IsSharing () ? widget->SharedWidget () : widget); w = (false ? NULL : widget); std::map<void*,Textures*>::iterator tex_it = _textures.find (w); if(tex_it!=_textures.end()) textures = tex_it->second; else textures = NULL; if (!textures) { textures = new Textures (); typedef std::pair <void*, std::vector<_iil4mitkTexture*>* > TexturePair; _textures.insert (TexturePair(w, textures)); } available = textures->size (); total = n * m; //textures->resize (total); int iii; for (unsigned int i = available; i < total; i++) { textures->push_back(new _iil4mitkTexture (w)); iii=textures->size (); } widget->MakeCurrent (); } /* Render the textures */ glScalef ((float) (s-2), (float) (s-2), 1.0); for (unsigned int i = 0; i < n; i++) { unsigned int pos [2]; // left-top corner of the region unsigned int len [2]; // extent of the region unsigned int tex [2]; // size of the texture float res [2]; // resolution of the texture pos [0] = _rx+i*(s-2); len [0] = (pos[0]+(s-2)>_rw ? _rw-pos[0] : s-2); tex [0] = power2(s); res [0] = 1.0f/tex[0]; for (unsigned int j = 0; j < m; j++) { _iil4mitkTexture* texture; texture = (*textures)[i*m+j]; pos [1] = _ry+j*(s-2); len [1] = (pos[1]+(s-2)>_rh ? _rh-pos[1] : s-2); tex [1] = power2(s); res [1] = 1.0f/tex[1]; //if (widget->isVisible (pos [0], pos [1], len [0], len [1])) { if (true) { // widget->makeCurrent (); texture->bind (); // widget->makeCurrent (); texture->setSize (tex[0], tex[1]); texture->setModel (_model); texture->setInterpolation (_interpolation); if (!texture->isValid ()) { updateTexture (texture, pos[0], pos[1], len[0], len[1]); } glBegin (GL_QUADS); glTexCoord2f (res[0], res[1]); glVertex3f (0.0, 0.0, 0.0); glTexCoord2f (1.0-res[0], res[1]); glVertex3f (1.0, 0.0, 0.0); glTexCoord2f (1.0-res[0], 1.0-res[1]); glVertex3f (1.0, 1.0, 0.0); glTexCoord2f (res[0], 1.0-res[1]); glVertex3f (0.0, 1.0, 0.0); glEnd (); } glTranslatef (0.0, 1.0, 0.0); } glTranslatef (1.0, -((float) m), 0.0); } }