void TextStyle::onBeginDrawFrame(const View& _view, Scene& _scene, int _textureUnit) { bool contextLost = Style::glContextLost(); m_fontContext->bindAtlas(0); m_shaderProgram->setUniformf("u_uv_scale_factor", 1.0f / m_fontContext->getAtlasResolution()); if (contextLost) { m_shaderProgram->setUniformi("u_tex", 0); } if (m_dirtyViewport || contextLost) { m_shaderProgram->setUniformMatrix4f("u_ortho", glm::value_ptr(_view.getOrthoViewportMatrix())); m_dirtyViewport = false; } Style::onBeginDrawFrame(_view, _scene, 1); }
GIL_FORCEINLINE F transform_pixels_locator( const View& src, const rect_t<std::ptrdiff_t>& srcRod, const ViewDst& dst, const rect_t<std::ptrdiff_t>& dstRod, const rect_t<std::ptrdiff_t>& renderWin, F& fun ) { const std::ptrdiff_t renderWidth = renderWin.x2 - renderWin.x1; typename View::xy_locator sloc = src.xy_at( renderWin.x1-srcRod.x1, renderWin.y1-srcRod.y1 ); for( std::ptrdiff_t y = renderWin.y1; y < renderWin.y2; ++y ) { typename ViewDst::x_iterator dstIt = dst.x_at( renderWin.x1-dstRod.x1, y-dstRod.y1 ); for( std::ptrdiff_t x = renderWin.x1; x < renderWin.x2; ++x, ++sloc.x(), ++dstIt ) { *dstIt = fun( sloc ); } sloc.x() -= renderWidth; ++sloc.y(); } return fun; }
void Play::drawCharactersFromView(const View& view) { if(!_isPlaying) return ; // Draw from view only if it was installed for(const auto& v : _views) { if(v->id() == view.id()) { StageTime time(_drawClock.totalSeconds(), _drawClock.elapsedSeconds(), _drawClock.ticksPerSecond()); DrawCaller drawCaller(v, time); (*_currentAct)->welcome( drawCaller ); break; } } }
double State::insert_feature(int feature_idx, vector<double> feature_data, View& which_view) { string col_datatype = global_col_datatypes[feature_idx]; CM_Hypers& hypers = hypers_m[feature_idx]; double crp_logp_delta, data_logp_delta; double score_delta = calc_feature_view_predictive_logp(feature_data, col_datatype, which_view, crp_logp_delta, data_logp_delta, hypers); vector<int> data_global_row_indices = create_sequence(feature_data.size()); which_view.insert_col(feature_data, data_global_row_indices, feature_idx, hypers); view_lookup[feature_idx] = &which_view; column_crp_score += crp_logp_delta; data_score += data_logp_delta; return score_delta; }
bool LarsonSekaninaInstance::ExecuteOn( View& view ) { AutoViewLock lock( view ); ImageVariant image = view.Image(); if ( image.IsComplexSample() ) return false; StandardStatus status; image.SetStatusCallback( &status ); Console().EnableAbort(); ImageVariant sharpImg; sharpImg.CreateFloatImage( (image.BitsPerSample() > 32) ? image.BitsPerSample() : 32 ); sharpImg.AllocateImage( image->Width(), image->Height(), 1, ColorSpace::Gray ); if ( useLuminance && image->IsColor() ) { ImageVariant L; image.GetLightness( L ); Convolve( L, sharpImg, interpolation, radiusDiff, angleDiff, center, 0 ); ApplyFilter( L, sharpImg, amount, threshold, deringing, rangeLow, rangeHigh, false, 0, highPass ); image.SetLightness( L ); } else { for ( int c = 0, n = image->NumberOfNominalChannels(); c < n; ++c ) { image->SelectChannel( c ); if ( n > 1 ) Console().WriteLn( "<end><cbr>Processing channel #" + String( c ) ); Convolve( image, sharpImg, interpolation, radiusDiff, angleDiff, center, c ); ApplyFilter( image, sharpImg, amount, threshold, deringing, rangeLow, rangeHigh, disableExtension, c, highPass ); } } return true; }
void drawScene() { glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_COLOR_MATERIAL); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_TEXTURE_2D); glViewport(0,0, width, height); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); v.setView(width, height); if (c.isThirdPerson()) c.updateLook(m); else c.updateLook(m.getX()+hx, m.getY()+hy, m.getZ()); if (phase == 0) introGame(); if (phase == 1) playGame(); if (phase == 2) concGame(); glutSwapBuffers(); }
void PivotPlugin::pivot() { View *view = dynamic_cast<View *>(parent()); if (!view) { return; } if ((view->selection()->lastRange().width() < 2) || (view->selection()->lastRange().height() < 2)) { KMessageBox::error(view->canvasWidget(), i18n("You must select multiple cells.")); return; } QPointer<Pivot> dialog = new Pivot(view->canvasWidget(), view->selection()); dialog->exec(); delete dialog; }
void viewmap(RenderWindow* window,Vector2i pos,float time) { if (pos.x<=0||Keyboard::isKeyPressed(Keyboard::A)) { if(Keyboard::isKeyPressed(Keyboard::RShift)||Keyboard::isKeyPressed(Keyboard::LShift)) view.move(-0.6*time, 0); else view.move(-0.3*time, 0); } if (pos.x>=(int)window->getSize().x-1||Keyboard::isKeyPressed(Keyboard::D)) { if(Keyboard::isKeyPressed(Keyboard::RShift)||Keyboard::isKeyPressed(Keyboard::LShift)) view.move(0.3*time, 0); else view.move(0.3*time, 0); } if (pos.y<=0||Keyboard::isKeyPressed(Keyboard::W)) { if(Keyboard::isKeyPressed(Keyboard::RShift)||Keyboard::isKeyPressed(Keyboard::LShift)) view.move(0,-0.6*time); else view.move(0, -0.3*time); } if (pos.y>=(int)window->getSize().y-1||Keyboard::isKeyPressed(Keyboard::S)) { if(Keyboard::isKeyPressed(Keyboard::RShift)||Keyboard::isKeyPressed(Keyboard::LShift)) view.move(0,0.6*time); else view.move(0, 0.3*time); } }
View lb::operator|(View const& _a, View const& _b) { if (!!_a->children().size() == !!_b->children().size()) { View ret = FrameBody::create(); _a->setParent(ret); _b->setParent(ret); return ret; } else if (_a->children().size()) { _b->setParent(_a); return _a; } else { _a->setParent(_b); return _b; } }
GIL_FORCEINLINE F transform_pixels_locator_progress( const View& src, const OfxRectI& srcRod, const ViewDst& dst, const OfxRectI& dstRod, const OfxRectI& renderWin, const F& fun, IProgress& p ) { const std::ptrdiff_t renderWidth = renderWin.x2 - renderWin.x1; typename View::xy_locator sloc = src.xy_at( renderWin.x1-srcRod.x1, renderWin.y1-srcRod.y1 ); for( std::ptrdiff_t y = renderWin.y1; y < renderWin.y2; ++y ) { typename ViewDst::x_iterator dstIt = dst.x_at( renderWin.x1-dstRod.x1, y-dstRod.y1 ); for( std::ptrdiff_t x = renderWin.x1; x < renderWin.x2; ++x, ++sloc.x(), ++dstIt ) { *dstIt = fun( sloc ); } sloc.x() -= renderWidth; ++sloc.y(); if( p.progressForward( renderWidth ) ) return fun; } return fun; }
/*! Estimates shift of current image relative to background image. \param [in] current - current image. \param [in] region - a region at the background where the algorithm start to search current image. Estimated shift is taken relative of the region. \param [in] maxShift - a 2D-point which characterizes maximal possible shift of the region (along X and Y axes). \param [in] hiddenAreaPenalty - a parameter used to restrict searching of the shift at the border of background image. \param [in] regionAreaMin - a parameter used to set minimal area of region use for shift estimation. By default is equal to 25. \return a result of shift estimation. */ bool Estimate(const View & current, const Rect & region, const Point & maxShift, double hiddenAreaPenalty = 0, ptrdiff_t regionAreaMin = REGION_CORRELATION_AREA_MIN) { assert(current.Size() == region.Size() && region.Area() > 0); assert(_current.Size() && _current[0].width >= current.width && _current[0].height >= current.height); if (region.Area() < regionAreaMin) return false; InitLevels(region, maxShift, regionAreaMin); SetCurrent(current, region); Point shift; for (ptrdiff_t i = _levels.size() - 1; i >= 0; i--) { shift.x *= 2; shift.y *= 2; if (!SearchLocalMin(_levels[i], shift, hiddenAreaPenalty)) return false; shift = _levels[i].shift; } return true; }
void init(View& view, std::vector<Sprite*>& sprites, bool val[2][WIDTH][HEIGHT]) { int i,j; for (i = 0; i < HEIGHT; i++) { for (j=0; j < WIDTH;j++) { Vector2d<float> pos(j*S_WIDTH,i*S_WIDTH); Vector2d<float> size(S_WIDTH,S_WIDTH); Rect<float> texCoord(0,0,S_WIDTH,S_WIDTH); Sprite *s = view.addSprite(pos,size,"bitmap",texCoord); Color tColor(System::rnd(10)/10.0f,System::rnd(10)/10.0f,System::rnd(10)/10.0f,1.0f); Vector2d<float> c(2,2); s->setRotationCenter(c); s->setRotationAngle(45.0f); s->setTintColor(tColor); sprites.push_back(s); s->hide(); val[0][j][i] = false; if (System::rnd(7) == 0) { val[0][j][i] = true; } } } }
typename sge::image::traits::dim< Tag >::type size_any( View const &_view ) { return fcppt::variant::apply_unary( []( auto const &_src ) { return sge::image::impl::from_mizuiro_dim( _src.size() ); }, _view.get() ); }
void PoslvControl::renderAxes(View& view, const QColor& color, double length) { Line<double, 3> l_1, l_2, l_3; l_1[1][0] = length; view.render(l_1, color, _T_w_i); l_2[1][1] = length; view.render(l_2, color, _T_w_i); l_3[1][2] = length; view.render(l_3, color, _T_w_i); Eigen::Vector3d xLabelPosition = _T_w_i * l_1[1]; Eigen::Vector3d yLabelPosition = _T_w_i * l_2[1]; Eigen::Vector3d zLabelPosition = _T_w_i * l_3[1]; view.render("X", xLabelPosition, color, 0.2*length); view.render("Y", yLabelPosition, color, 0.2*length); view.render("Z", zLabelPosition, color, 0.2*length); Eigen::Vector3d labelPosition = _T_w_i * Eigen::Vector3d(0, 0, length + 0.1); view.render("poslv", labelPosition, color, 0.2 * length); }
void display(sf::RenderWindow *window) { if (frames==0) sfclock.restart(); // Draw using SFML window->pushGLStates(); window->resetGLStates(); //insert SFML drawing code here (any part you are using that does not involve opengl code) window->popGLStates(); //set up the background color of the window. This does NOT clear the window. Right now it is (0,0,0) which is black glClearColor(0,0,0,0); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //this command actually clears the window. glEnable(GL_DEPTH_TEST); v.draw(); //simply delegate to our view class that has all the data and does all the rendering if (frames>500) { sf::Time t = sfclock.getElapsedTime(); frame_rate = frames/t.asSeconds(); frames = 0; } else { frames++; } stringstream str; str << "Frame rate " << frame_rate; // Draw some text on top of our OpenGL object drawText(window,str.str(),window->getSize().x,20); // Finally, display the rendered frame on screen window->display(); // cout << "Rendering" << endl; }
void BinarizeInterface::UpdateReadout( const View& v, const DPoint&, double R, double G, double B, double /*A*/ ) { if ( GUI != 0 && IsVisible() ) { if ( instance.isGlobal ) { RGBColorSystem rgbws; v.Window().GetRGBWS( rgbws ); instance.level[0] = instance.level[1] = instance.level[2] = rgbws.Lightness( R, G, B ); } else { instance.level[0] = R; instance.level[1] = G; instance.level[2] = B; } UpdateControls(); if ( !RealTimePreview::IsUpdating() ) RealTimePreview::Update(); } }
void SummaryDrawWidget::paintEvent( QPaintEvent * ) { Channel *ch; //if((right - left) <= 0) return; View *view = gdata->view; /* if (view->totalTime() == 0) { buffer = new QPixmap(size()); buffer->fill(myBackgroundColor); bitBlt(this, 0, 0, buffer); */ if(gdata->totalTime() < 0) return; double timeRatio = double(width()) / gdata->totalTime(); double pitchRatio = double(height()) / (gdata->topPitch() / scaler); beginDrawing(); //draw all the channels for(int j = 0; j < (int)gdata->channels.size(); j++) { ch = gdata->channels.at(j); if(!ch->isVisible()) continue; //drawChannel(ch, p, view->leftTime(), (view->totalTime() / (double) width()), 0.0f, (double) view->topNote() / (double) height(), DRAW_VIEW_SUMMARY); drawChannel(*this, ch, p, gdata->leftTime(), view->currentTime(), (gdata->totalTime() / (double) width()), 0.0f, (double) gdata->topPitch() / (double) height(), DRAW_VIEW_SUMMARY); } //draw the view rectangle p.setPen(QPen(colorGroup().highlight(), 1)); p.drawRect(int((gdata->leftTime()+view->viewLeft())*timeRatio), height()-1-int((view->viewTop())*pitchRatio), int(view->viewWidth()*timeRatio), int(view->viewHeight()*pitchRatio)); //draw the current time line p.setPen(QPen(colorGroup().foreground(), 1)); //p.moveTo(int((gdata->leftTime()+view->currentTime())*timeRatio), 0); //p.lineTo(int((gdata->leftTime()+view->currentTime())*timeRatio), height()-1); p.drawLine(int((gdata->leftTime()+view->currentTime())*timeRatio), 0, int((gdata->leftTime()+view->currentTime())*timeRatio), height()-1); endDrawing(); }
int main(int argc, char *argv[]) { /* parse command line args */ for (int i = 1; i+1 < argc; i+=2) { if (strcmp(argv[i], "-m") == 0) mazefile = argv[i+1]; else if (strcmp(argv[i], "-a") == 0) algfile = argv[i+1]; } /* initialize program */ if (algfile && !load_algorithm(algfile, &algorithm)) { fprintf(stderr, "error loading algorithm\n"); return 1; } if (!parse_maze(mazefile, &maze)) { fprintf(stderr, "error reading maze file\n"); return 1; } view = create_view(); controller = create_controller( &view, &maze, &mouse, &algorithm); /* run program */ while(!controller.quit) { do_command( &controller, getchar() ); } /* cleanup */ view.destroy(); return 0; }
inline void for_each( View const &_view, Function const &_function, MakeIterator const _make_iterator, mizuiro::image::algorithm::uninitialized const _uninitialized ) { switch( _uninitialized ) { case mizuiro::image::algorithm::uninitialized::yes: mizuiro::image::algorithm::unary_iteration( mizuiro::image::algorithm::detail::wrap_prepare< typename View::access, typename View::format >( _view.format_store(), _function ), _view, _make_iterator ); return; case mizuiro::image::algorithm::uninitialized::no: mizuiro::image::algorithm::unary_iteration( _function, _view, _make_iterator ); return; } }
// Main entry point for the program int main(int argc, char* argv[]) { // window initialization View * v = new View(&argc, argv); //glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); // Open a window v->createWindow("CS458 - Assignment 5", 640, 480); // Initialize OpenGL and objects Initialize(); // Setup callback functions v->onIdle(OnIdle); v->onMouse(OnMouseButton); v->onDraw(RenderScene); v->onResize(OnResize); // Start Glut window v->start(); return 0; }
void remove_all_data(View &v, map<int, vector<double> > data_map) { vector<int> rows_in_view; for(mapICp_it it=v.cluster_lookup.begin(); it!=v.cluster_lookup.end(); it++) { rows_in_view.push_back(it->first); } for(vectorI_it it=rows_in_view.begin(); it!=rows_in_view.end(); it++) { int idx_to_remove = *it; vector<double> row = data_map[idx_to_remove]; vector<int> global_indices = create_sequence(row.size()); vector<double> aligned_row = v.align_data(row, global_indices); v.remove_row(aligned_row, idx_to_remove); } cout << "removed all data" << endl; v.print(); // for(setCp_it it=v.clusters.begin(); it!=v.clusters.end(); it++) { v.remove_if_empty(**it); } assert(v.get_num_vectors()==0); assert(v.get_num_clusters()==0); cout << "removed empty clusters" << endl; v.print(); }
void EventSystem::updateCurrentViewStack(Event* event) { Vec2 pos(event->mouseEvent.x, event->mouseEvent.y); bool containsPoint = rootView->containsPoint(pos); View* view = rootView; currentViewStack.clear(); while(view && view->visible() && view->userInteractionEnabled() && containsPoint) { currentViewStack.push_back(view); containsPoint = false; for(auto i=view->subviews.rbegin(); i!=view->subviews.rend(); ++i) { View* v = (*i).get(); if(v->visible() && v->userInteractionEnabled() && v->containsPoint(pos)) { view = v; containsPoint = true; break; } } } }
void test_image_views(const View& img_view, const string& prefix) { check_image(img_view,prefix+"original.jpg"); check_image(subimage_view(img_view, iround(img_view.dimensions()/4), iround(img_view.dimensions()/2)),prefix+"cropped.jpg"); check_image(color_converted_view<gray8_pixel_t>(img_view),prefix+"gray8.jpg"); check_image(color_converted_view<gray8_pixel_t>(img_view,my_color_converter()),prefix+"my_gray8.jpg"); check_image(transposed_view(img_view),prefix+"transpose.jpg"); check_image(rotated180_view(img_view),prefix+"rot180.jpg"); check_image(rotated90cw_view(img_view),prefix+"90cw.jpg"); check_image(rotated90ccw_view(img_view),prefix+"90ccw.jpg"); check_image(flipped_up_down_view(img_view),prefix+"flipped_ud.jpg"); check_image(flipped_left_right_view(img_view),prefix+"flipped_lr.jpg"); check_image(subsampled_view(img_view,typename View::point_t(2,1)),prefix+"subsampled.jpg"); check_image(nth_channel_view(img_view,0),prefix+"0th_channel.jpg"); // some iterator math ptrdiff_t dst=(img_view.end()-(img_view.begin()+4500))+4500; ignore_unused_variable_warning(dst); ptrdiff_t dst2=img_view.end()-img_view.begin(); ignore_unused_variable_warning(dst2); ptrdiff_t sz=img_view.size(); ignore_unused_variable_warning(sz); io_error_if(sz!=dst2); }
static void GEMM (const Teuchos::ETransp transA, const Teuchos::ETransp transB, const double& alpha, const View<const double**, LayoutLeft, DeviceType>& A, const View<const double**, LayoutLeft, DeviceType>& B, const double& beta, const View<double**, LayoutLeft, DeviceType>& C) { const int n = static_cast<int> (C.dimension_1 ()); // For some BLAS implementations (e.g., MKL), GEMM when B has // one column may be signficantly less efficient than GEMV. if (n == 1 && transB == Teuchos::NO_TRANS) { char trans = 'N'; if (transA == Teuchos::TRANS) { trans = 'T'; } else if (transA == Teuchos::CONJ_TRANS) { trans = 'C'; } auto B_0 = Kokkos::subview (B, Kokkos::ALL (), 0); auto C_0 = Kokkos::subview (C, Kokkos::ALL (), 0); KokkosBlas::gemv (&trans, alpha, A, B_0, beta, C_0); } else { const int m = static_cast<int> (C.dimension_0 ()); const int k = static_cast<int> (transA == Teuchos::NO_TRANS ? A.dimension_1 () : A.dimension_0 ()); const int lda = static_cast<int> (Impl::getStride2DView (A)); const int ldb = static_cast<int> (Impl::getStride2DView (B)); const int ldc = static_cast<int> (Impl::getStride2DView (C)); Teuchos::BLAS<int,double> blas; blas.GEMM (transA, transB, m, n, k, alpha, A.ptr_on_device(), lda, B.ptr_on_device(), ldb, beta, C.ptr_on_device(), ldc); } }
void ViewManager::handleMouseEvents(M4EventType event) { Common::Point mousePos = _vm->_mouse->currentPos(); ListIterator i; View *view; bool blockedFlag; bool foundFlag; // If a window sets the _captureEvents flag to true, it will receive all events until // it sets it to false, even if it's not the top window if (_captureEvents) { if (_captureScreen->screenFlags().get & SCREVENT_MOUSE) (_captureScreen->onEvent)(event, 0, mousePos.x, mousePos.y, _captureEvents); } else { blockedFlag = false; foundFlag = false; view = NULL; // Loop from the front to back view for (i = _views.reverse_begin(); (i != _views.end()) && !foundFlag && !blockedFlag; --i) { view = *i; if (!view->isVisible()) continue; if (view->screenFlags().blocks & SCREVENT_MOUSE) blockedFlag = true; if ((view->screenFlags().get & SCREVENT_MOUSE) && view->isInside(mousePos.x, mousePos.y)) foundFlag = true; } if (foundFlag) view->onEvent(event, 0, mousePos.x, mousePos.y, _captureEvents); else _captureEvents = false; if (_captureEvents) _captureScreen = view; } }
Presenter::Presenter( Model& m, View& v, QObject *parent): iscore::SettingsDelegatePresenter{m, v, parent} { { // view -> model con(v, &View::simplificationRatioChanged, this, [&] (auto simplificationRatio) { if(simplificationRatio != m.getSimplificationRatio()) { m_disp.submitCommand<SetModelSimplificationRatio>(this->model(this), simplificationRatio); } }); // model -> view con(m, &Model::SimplificationRatioChanged, &v, &View::setSimplificationRatio); // initial value v.setSimplificationRatio(m.getSimplificationRatio()); } { // view -> model con(v, &View::simplifyChanged, this, [&] (auto simplify) { if(simplify != m.getSimplify()) { m_disp.submitCommand<SetModelSimplify>(this->model(this), simplify); } }); // model -> view con(m, &Model::SimplifyChanged, &v, &View::setSimplify); // initial value v.setSimplify(m.getSimplify()); } { // view -> model con(v, &View::modeChanged, this, [&] (auto val) { if(val != m.getCurveMode()) { m_disp.submitCommand<SetModelCurveMode>(this->model(this), val); } }); // model -> view con(m, &Model::CurveModeChanged, &v, &View::setMode); // initial value v.setMode(m.getCurveMode()); } { // view -> model con(v, &View::playWhileRecordingChanged, this, [&] (auto val) { if(val != m.getPlayWhileRecording()) { m_disp.submitCommand<SetModelPlayWhileRecording>(this->model(this), val); } }); // model -> view con(m, &Model::PlayWhileRecordingChanged, &v, &View::setPlayWhileRecording); // initial value v.setMode(m.getCurveMode()); } }
void MasterClass::playGameOver() { View view = window->getView(); Vector2u window_size = window->getSize(); Color darkColor(0,0,0,0); Color redColor(6,0,0,6); RectangleShape darkenedScreen(Vector2f(window_size.x, window_size.y)); darkenedScreen.setPosition(view.getCenter().x - (float)window_size.x/2, 0); darkenedScreen.setFillColor(darkColor); RectangleShape redScreen(Vector2f(window_size.x, window_size.y)); redScreen.setPosition(view.getCenter().x - (float)window_size.x/2, 0); redScreen.setFillColor(redColor); Clock clock; Time time; int t = 0, cpt = 0, dt = 0; Texture gameOverTex; gameOverTex.loadFromFile("res/tex/decor/game_over.png"); Sprite gameOverSprite(gameOverTex); Vector2u texture_size = gameOverTex.getSize(); gameOverSprite.scale((float)window_size.x/texture_size.x, (float)window_size.y/texture_size.y); gameOverSprite.setPosition(view.getCenter().x - (float)window_size.x/2, 0); game->updateVolume(); game->resume(); while (window->isOpen() && state == GAMEOVER) { Event event; while(window->pollEvent(event)) { if(event.type == Event::KeyPressed && event.key.code == Keyboard::Escape) { previousState = state; state = MAINMENU; } } time = clock.restart(); dt = time.asMilliseconds(); t += dt; cpt += dt; game->update(time); game->checkCollisions(); if(t < 2550 && cpt >= 50) { cpt = 0; if(redColor.r < 250) { redColor.r += 6; redColor.a += 6; } else { redColor.r = 255; redColor.a = 255; } if(darkColor.a < 250) darkColor.a += 6; else darkColor.a = 255; } if(t > 2550) redColor.a = 0; if(t > 2550 && cpt >= 50) { cpt = 0; if(darkColor.a > 5) darkColor.a -= 6; else darkColor.a = 0; } darkenedScreen.setFillColor(darkColor); redScreen.setFillColor(redColor); window->clear(); game->display(window); if(t > 2550) window->draw(gameOverSprite); window->draw(redScreen); window->draw(darkenedScreen); window->display(); } }
void MasterClass::playSettings() { Vector2u window_size = window->getSize(); Image img = window->capture(); Texture texture; //texture.loadFromImage(img); texture.loadFromFile("res/tex/decor/settings_menu.png"); Vector2u texture_size = texture.getSize(); Sprite sprite(texture); // 0 -> pas transparent et 255 -> transparent //sprite.setColor(sf::Color(255, 255, 255, 128)); sprite.scale((float)window_size.x/texture_size.x, (float)window_size.y/texture_size.y); View view = window->getView(); sprite.setPosition(view.getCenter().x - (float)window_size.x/2, 0); Font font; font.loadFromFile("res/font/arcade.ttf"); vector<String> vectItems; vectItems.push_back("Reprendre"); const int resume = 0; vectItems.push_back("<- Volume musique +>"); const int musicsVolume = 1; vectItems.push_back("<- Volume bruitages +>"); const int soundEffectsVolume = 2; vectItems.push_back("Menu principal"); const int mainMenu = 3; Menu menu(vectItems, window, font, Menu::CENTER, (unsigned int)window_size.y*0.0444); SoundBuffer buffer; Sound s; buffer.loadFromFile("res/snd/enemy/rebel/death1.wav"); s.setBuffer(buffer); Music music; music.openFromFile("res/snd/level/The_Military_System.wav"); music.setVolume(config.musicsVolume); music.setLoop(true); music.play(); while (window->isOpen() && state == SETTINGS) { sf::Event event; while(window->pollEvent(event)) { if (event.type == Event::KeyPressed) { switch(event.key.code) { case Keyboard::Escape : state = previousState; break; case Keyboard::Up : menu.moveUp(); break; case Keyboard::Down : menu.moveDown(); break; case Keyboard::Return : switch(menu.getSelectedItemIndex()) { case resume : state = previousState; break; case mainMenu : previousState = state; state = MAINMENU; break; default : break; } break; case Keyboard::Left : switch(menu.getSelectedItemIndex()) { case musicsVolume : config.musicsVolume -= 10; if(config.musicsVolume < 0) config.musicsVolume = 0; music.setVolume(config.musicsVolume); break; case soundEffectsVolume : config.soundEffectsVolume -= 10; if(config.soundEffectsVolume < 0) config.soundEffectsVolume = 0; s.setVolume(config.soundEffectsVolume); s.play(); break; default : break; } break; case Keyboard::Right : switch(menu.getSelectedItemIndex()) { case musicsVolume : config.musicsVolume += 10; if(config.musicsVolume > 100) config.musicsVolume = 100; music.setVolume(config.musicsVolume); break; case soundEffectsVolume : config.soundEffectsVolume += 10; if(config.soundEffectsVolume > 100) config.soundEffectsVolume = 100; s.setVolume(config.soundEffectsVolume); s.play(); break; default : break; } break; default : break; } } } window->clear(); window->draw(sprite); menu.draw(window); window->display(); } }
void CompositeViewer::eventTraversal() { if (_done) return; if (_views.empty()) return; double cutOffTime = _frameStamp->getReferenceTime(); double beginEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); // need to copy events from the GraphicsWindow's into local EventQueue for each view; typedef std::map<osgViewer::View*, osgGA::EventQueue::Events> ViewEventsMap; ViewEventsMap viewEventsMap; Contexts contexts; getContexts(contexts); // set done if there are no windows checkWindowStatus(contexts); if (_done) return; osgGA::EventQueue::Events all_events; for(Contexts::iterator citr = contexts.begin(); citr != contexts.end(); ++citr) { osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr); if (gw) { gw->checkEvents(); osgGA::EventQueue::Events gw_events; gw->getEventQueue()->takeEvents(gw_events, cutOffTime); for(osgGA::EventQueue::Events::iterator itr = gw_events.begin(); itr != gw_events.end(); ++itr) { (*itr)->setGraphicsContext(gw); } all_events.insert(all_events.end(), gw_events.begin(), gw_events.end()); } } // sort all the events in time order so we can make sure we pass them all on in the correct order. all_events.sort(SortEvents()); // pass on pointer data onto non mouse events to keep the position data usable by all recipients of all events. for(osgGA::EventQueue::Events::iterator itr = all_events.begin(); itr != all_events.end(); ++itr) { osgGA::GUIEventAdapter* event = itr->get(); switch(event->getEventType()) { case(osgGA::GUIEventAdapter::PUSH): case(osgGA::GUIEventAdapter::RELEASE): case(osgGA::GUIEventAdapter::DOUBLECLICK): case(osgGA::GUIEventAdapter::MOVE): case(osgGA::GUIEventAdapter::DRAG): { if ((event->getEventType()!=osgGA::GUIEventAdapter::DRAG && event->getEventType()!=osgGA::GUIEventAdapter::RELEASE) || !_previousEvent || _previousEvent->getGraphicsContext()!=event->getGraphicsContext() || _previousEvent->getNumPointerData()<2) { generatePointerData(*event); } else { reprojectPointerData(*_previousEvent, *event); } #if 0 // assign topmost PointeData settings as the events X,Y and InputRange osgGA::PointerData* pd = event->getPointerData(event->getNumPointerData()-1); event->setX(pd->x); event->setY(pd->y); event->setInputRange(pd->xMin, pd->yMin, pd->xMax, pd->yMax); event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); #else if (event->getMouseYOrientation()!=osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS) { event->setY((event->getYmax()-event->getY())+event->getYmin()); event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS); } #endif _previousEvent = event; break; } default: if (_previousEvent.valid()) event->copyPointerDataFrom(*_previousEvent); break; } osgGA::PointerData* pd = event->getNumPointerData()>0 ? event->getPointerData(event->getNumPointerData()-1) : 0; osg::Camera* camera = pd ? dynamic_cast<osg::Camera*>(pd->object.get()) : 0; osgViewer::View* view = camera ? dynamic_cast<osgViewer::View*>(camera->getView()) : 0; if (!view) { if (_viewWithFocus.valid()) { // OSG_NOTICE<<"Falling back to using _viewWithFocus"<<std::endl; view = _viewWithFocus.get(); } else if (!_views.empty()) { // OSG_NOTICE<<"Falling back to using first view as one with focus"<<std::endl; view = _views[0].get(); } } // reassign view with focus if (_viewWithFocus != view) _viewWithFocus = view; if (view) { viewEventsMap[view].push_back( event ); osgGA::GUIEventAdapter* eventState = view->getEventQueue()->getCurrentEventState(); eventState->copyPointerDataFrom(*event); } _previousEvent = event; } // handle any close windows for(osgGA::EventQueue::Events::iterator itr = all_events.begin(); itr != all_events.end(); ++itr) { osgGA::GUIEventAdapter* event = itr->get(); switch(event->getEventType()) { case(osgGA::GUIEventAdapter::CLOSE_WINDOW): { bool wasThreading = areThreadsRunning(); if (wasThreading) stopThreading(); if (event->getGraphicsContext()) { event->getGraphicsContext()->close(); } if (wasThreading) startThreading(); break; } default: break; } } for(RefViews::iterator vitr = _views.begin(); vitr != _views.end(); ++vitr) { View* view = vitr->get(); // get events from user Devices attached to Viewer. for(osgViewer::View::Devices::iterator eitr = view->getDevices().begin(); eitr != view->getDevices().end(); ++eitr) { osgGA::Device* es = eitr->get(); if (es->getCapabilities() & osgGA::Device::RECEIVE_EVENTS) es->checkEvents(); // open question, will we need to reproject mouse coordinates into current view's coordinate frame as is down for GraphicsWindow provided events? // for now assume now and just get the events directly without any reprojection. es->getEventQueue()->takeEvents(viewEventsMap[view], cutOffTime); } // generate frame event view->getEventQueue()->frame( getFrameStamp()->getReferenceTime() ); view->getEventQueue()->takeEvents(viewEventsMap[view], cutOffTime); } if ((_keyEventSetsDone!=0) || _quitEventSetsDone) { for(ViewEventsMap::iterator veitr = viewEventsMap.begin(); veitr != viewEventsMap.end(); ++veitr) { for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); itr != veitr->second.end(); ++itr) { osgGA::GUIEventAdapter* event = itr->get(); switch(event->getEventType()) { case(osgGA::GUIEventAdapter::KEYUP): if (_keyEventSetsDone && event->getKey()==_keyEventSetsDone) _done = true; break; case(osgGA::GUIEventAdapter::QUIT_APPLICATION): if (_quitEventSetsDone) _done = true; break; default: break; } } } } if (_done) return; if (_eventVisitor.valid()) { _eventVisitor->setFrameStamp(getFrameStamp()); _eventVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber()); for(ViewEventsMap::iterator veitr = viewEventsMap.begin(); veitr != viewEventsMap.end(); ++veitr) { View* view = veitr->first; if (view && view->getSceneData()) { _eventVisitor->setActionAdapter(view); for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); itr != veitr->second.end(); ++itr) { osgGA::GUIEventAdapter* event = itr->get(); _eventVisitor->reset(); _eventVisitor->addEvent( event ); view->getSceneData()->accept(*_eventVisitor); // Do EventTraversal for slaves with their own subgraph for(unsigned int i=0; i<view->getNumSlaves(); ++i) { osg::View::Slave& slave = view->getSlave(i); osg::Camera* camera = slave._camera.get(); if(camera && !slave._useMastersSceneData) { camera->accept(*_eventVisitor); } } // call any camera event callbacks, but only traverse that callback, don't traverse its subgraph // leave that to the scene update traversal. osg::NodeVisitor::TraversalMode tm = _eventVisitor->getTraversalMode(); _eventVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE); if (view->getCamera() && view->getCamera()->getEventCallback()) view->getCamera()->accept(*_eventVisitor); for(unsigned int i=0; i<view->getNumSlaves(); ++i) { osg::View::Slave& slave = view->getSlave(i); osg::Camera* camera = view->getSlave(i)._camera.get(); if (camera && slave._useMastersSceneData && camera->getEventCallback()) { camera->accept(*_eventVisitor); } } _eventVisitor->setTraversalMode(tm); } } } } for(ViewEventsMap::iterator veitr = viewEventsMap.begin(); veitr != viewEventsMap.end(); ++veitr) { View* view = veitr->first; for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); itr != veitr->second.end(); ++itr) { osgGA::GUIEventAdapter* event = itr->get(); for(View::EventHandlers::iterator hitr = view->getEventHandlers().begin(); hitr != view->getEventHandlers().end(); ++hitr) { (*hitr)->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view, 0, _eventVisitor.get()); } } } for(ViewEventsMap::iterator veitr = viewEventsMap.begin(); veitr != viewEventsMap.end(); ++veitr) { View* view = veitr->first; for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); itr != veitr->second.end(); ++itr) { osgGA::GUIEventAdapter* event = itr->get(); if (view->getCameraManipulator()) { view->getCameraManipulator()->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view); } } } if (getViewerStats() && getViewerStats()->collectStats("event")) { double endEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); // update current frames stats getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal begin time", beginEventTraversal); getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal end time", endEventTraversal); getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal time taken", endEventTraversal-beginEventTraversal); } }
void CompositeViewer::updateTraversal() { if (_done) return; double beginUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); _updateVisitor->reset(); _updateVisitor->setFrameStamp(getFrameStamp()); _updateVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber()); Scenes scenes; getScenes(scenes); for(Scenes::iterator sitr = scenes.begin(); sitr != scenes.end(); ++sitr) { Scene* scene = *sitr; scene->updateSceneGraph(*_updateVisitor); } // if we have a shared state manager prune any unused entries if (osgDB::Registry::instance()->getSharedStateManager()) osgDB::Registry::instance()->getSharedStateManager()->prune(); // update the Registry object cache. osgDB::Registry::instance()->updateTimeStampOfObjectsInCacheWithExternalReferences(*getFrameStamp()); osgDB::Registry::instance()->removeExpiredObjectsInCache(*getFrameStamp()); if (_incrementalCompileOperation.valid()) { // merge subgraphs that have been compiled by the incremental compiler operation. _incrementalCompileOperation->mergeCompiledSubgraphs(getFrameStamp()); } if (_updateOperations.valid()) { _updateOperations->runOperations(this); } for(RefViews::iterator vitr = _views.begin(); vitr != _views.end(); ++vitr) { View* view = vitr->get(); { // Do UpdateTraversal for slaves with their own subgraph for(unsigned int i=0; i<view->getNumSlaves(); ++i) { osg::View::Slave& slave = view->getSlave(i); osg::Camera* camera = slave._camera.get(); if(camera && !slave._useMastersSceneData) { camera->accept(*_updateVisitor); } } // call any camera update callbacks, but only traverse that callback, don't traverse its subgraph // leave that to the scene update traversal. osg::NodeVisitor::TraversalMode tm = _updateVisitor->getTraversalMode(); _updateVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE); if (view->getCamera() && view->getCamera()->getUpdateCallback()) view->getCamera()->accept(*_updateVisitor); for(unsigned int i=0; i<view->getNumSlaves(); ++i) { osg::View::Slave& slave = view->getSlave(i); osg::Camera* camera = slave._camera.get(); if (camera && slave._useMastersSceneData && camera->getUpdateCallback()) { camera->accept(*_updateVisitor); } } _updateVisitor->setTraversalMode(tm); } if (view->getCameraManipulator()) { view->setFusionDistance( view->getCameraManipulator()->getFusionDistanceMode(), view->getCameraManipulator()->getFusionDistanceValue() ); view->getCameraManipulator()->updateCamera(*(view->getCamera())); } view->updateSlaves(); } if (getViewerStats() && getViewerStats()->collectStats("update")) { double endUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()); // update current frames stats getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal begin time", beginUpdateTraversal); getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal end time", endUpdateTraversal); getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal time taken", endUpdateTraversal-beginUpdateTraversal); } }