//////////////////////////////////////////////////////// // render // ///////////////////////////////////////////////////////// void pix_texture :: render(GemState *state) { m_didTexture=false; pushTexCoords(state); if(!m_textureOnOff)return; bool upsidedown=false; bool normalized=true; bool canMipmap=m_canMipmap; int texType = m_textureType; int x_2=1, y_2=1; bool useExternalTexture=false; int do_rectangle = (m_rectangle)?m_canRectangle:0; int newfilm = 0; pixBlock*img=NULL; state->get(GemState::_PIX, img); if(img) newfilm = img->newfilm; if (!img || !img->image.data){ if(m_extTextureObj>0) { useExternalTexture= true; m_rebuildList = false; m_textureObj = m_extTextureObj; if(m_extType)m_textureType=m_extType; texType=m_textureType; upsidedown=m_extUpsidedown; m_xRatio=m_extWidth; m_yRatio=m_extHeight; m_upsidedown=upsidedown; } else /* neither do we have an image nor an external texture */ return; } tex2state(state, m_coords, 4); if(!useExternalTexture){ upsidedown = img->image.upsidedown; if (img->newimage) m_rebuildList = true; m_imagebuf.xsize =img->image.xsize; m_imagebuf.ysize =img->image.ysize; m_imagebuf.csize =img->image.csize; m_imagebuf.format=img->image.format; m_imagebuf.type =img->image.type; m_imagebuf.data =img->image.data; x_2 = powerOfTwo(m_imagebuf.xsize); y_2 = powerOfTwo(m_imagebuf.ysize); normalized = ((m_imagebuf.xsize==x_2) && (m_imagebuf.ysize==y_2)); debug("normalized=%d\t%d - %d\t%d - %d", normalized, m_imagebuf.xsize, x_2, m_imagebuf.ysize, y_2); switch(do_rectangle) { case 2: m_textureType = GL_TEXTURE_RECTANGLE_ARB; debug("using mode 1:GL_TEXTURE_RECTANGLE_ARB"); normalized = 0; canMipmap = false; break; case 1: m_textureType = GL_TEXTURE_RECTANGLE_EXT; debug("using mode 1:GL_TEXTURE_RECTANGLE_EXT"); normalized = 0; canMipmap = false; break; default: m_textureType = GL_TEXTURE_2D; debug("using mode 0:GL_TEXTURE_2D"); normalized = 0; break; } debug("normalized=%d", normalized); } if (m_textureType!=texType){ debug("texType != m_textureType"); stopRendering();startRendering(); } if(GLEW_VERSION_1_3) { glActiveTexture(GL_TEXTURE0_ARB + m_texunit); } glEnable(m_textureType); glBindTexture(m_textureType, m_textureObj); if ((!useExternalTexture)&&newfilm ){ // tigital: shouldn't we also allow TEXTURE_2D here? if(NULL!=glTextureRangeAPPLE) { if ( GLEW_APPLE_texture_range ){ if(glTextureRangeAPPLE == NULL) { glTextureRangeAPPLE( m_textureType, m_imagebuf.xsize * m_imagebuf.ysize * m_imagebuf.csize, m_imagebuf.data ); debug("using glTextureRangeAPPLE()"); }else{ glTextureRangeAPPLE( m_textureType, 0, NULL ); } } } /* hmm, GL_TEXTURE_STORAGE_HINT_APPLE throws a GL-error on linux (and probably on w32 too) * how to do a run-time check for it? * * according to http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/chapter_10_section_2.html * this seems to be a part of the texture_range extension, so we check for that! */ if(GLEW_APPLE_texture_range) glTexParameteri( m_textureType, GL_TEXTURE_STORAGE_HINT_APPLE, GL_STORAGE_SHARED_APPLE ); // GL_STORAGE_SHARED_APPLE - AGP texture path // GL_STORAGE_CACHED_APPLE - VRAM texture path // GL_STORAGE_PRIVATE_APPLE - normal texture path if(m_clientStorage) glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE); } /* here comes the work: a new image has to be transfered from main memory to GPU and attached to a texture object */ if (m_rebuildList) { // if YUV is not supported on this platform, we have to convert it to RGB //(skip Alpha since it isnt used) const bool do_yuv = m_yuv && GLEW_APPLE_ycbcr_422; if (!do_yuv && m_imagebuf.format == GL_YUV422_GEM){ m_imagebuf.format=GL_RGB; m_imagebuf.csize=3; m_imagebuf.reallocate(); if(img)m_imagebuf.fromYUV422(img->image.data); } if (normalized) { m_buffer.xsize = m_imagebuf.xsize; m_buffer.ysize = m_imagebuf.ysize; m_buffer.csize = m_imagebuf.csize; m_buffer.format = m_imagebuf.format; m_buffer.type = m_imagebuf.type; m_buffer.reallocate(); m_xRatio=1.0; m_yRatio=1.0; m_upsidedown=upsidedown; tex2state(state, m_coords, 4); if (m_buffer.csize != m_dataSize[0] || m_buffer.xsize != m_dataSize[1] || m_buffer.ysize != m_dataSize[2]){ m_dataSize[0] = m_buffer.csize; m_dataSize[1] = m_buffer.xsize; m_dataSize[2] = m_buffer.ysize; } //if the texture is a power of two in size then there is no need to subtexture glTexImage2D(m_textureType, 0, m_imagebuf.csize, m_imagebuf.xsize, m_imagebuf.ysize, 0, m_imagebuf.format, m_imagebuf.type, m_imagebuf.data); m_hasMipmap = false; } else { // !normalized m_xRatio = (float)m_imagebuf.xsize; m_yRatio = (float)m_imagebuf.ysize; if ( !do_rectangle ) { m_xRatio /= (float)x_2; m_yRatio /= (float)y_2; m_buffer.xsize = x_2; m_buffer.ysize = y_2; } else { m_buffer.xsize = m_imagebuf.xsize; m_buffer.ysize = m_imagebuf.ysize; } m_buffer.csize = m_imagebuf.csize; m_buffer.format = m_imagebuf.format; m_buffer.type = m_imagebuf.type; m_buffer.reallocate(); m_upsidedown=upsidedown; tex2state(state, m_coords, 4); if (m_buffer.csize != m_dataSize[0] || m_buffer.xsize != m_dataSize[1] || m_buffer.ysize != m_dataSize[2]){ newfilm = 1; } //end of loop if size has changed // okay, load in the actual pixel data //when doing rectangle textures the buffer changes after every film is loaded this call makes sure the //texturing is updated as well to prevent crashes if(newfilm) { m_dataSize[0] = m_buffer.csize; m_dataSize[1] = m_buffer.xsize; m_dataSize[2] = m_buffer.ysize; if (m_buffer.format == GL_YUV422_GEM && !m_rectangle)m_buffer.setBlack(); if(m_numPbo>0) { if(GLEW_ARB_pixel_buffer_object) { if(m_pbo) { delete[]m_pbo; m_pbo=NULL; } m_pbo=new GLuint[m_numPbo]; glGenBuffersARB(m_numPbo, m_pbo); int i=0; for(i=0; i<m_numPbo; i++) { glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_pbo[i]); glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_buffer.xsize*m_buffer.ysize*m_buffer.csize, 0, GL_STREAM_DRAW_ARB); } glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0); } else { verbose(1, "PBOs not supported! disabling"); m_numPbo=0; } } //this is for dealing with power of 2 textures which need a buffer that's 2^n if ( !do_rectangle ) { glTexImage2D( m_textureType, 0, //m_buffer.csize, GL_RGBA, m_buffer.xsize, m_buffer.ysize, 0, m_buffer.format, m_buffer.type, m_buffer.data); m_hasMipmap = false; debug("TexImage2D non rectangle"); } else {//this deals with rectangle textures that are h*w glTexImage2D(m_textureType, 0, // m_buffer.csize, GL_RGBA, m_imagebuf.xsize, m_imagebuf.ysize, 0, m_imagebuf.format, m_imagebuf.type, m_imagebuf.data); m_hasMipmap = false; debug("TexImage2D rectangle"); } // just to make sure... img->newfilm = 0; } if(m_pbo && m_numPbo) { m_curPbo=(m_curPbo+1)%m_numPbo; int index=m_curPbo; int nextIndex=(m_curPbo+1)%m_numPbo; glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_pbo[index]); glTexSubImage2D(m_textureType, 0, 0, 0, m_imagebuf.xsize, m_imagebuf.ysize, m_imagebuf.format, m_imagebuf.type, NULL); /* <-- that's the key */ m_hasMipmap = false; glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_pbo[nextIndex]); glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_imagebuf.xsize * m_imagebuf.ysize * m_imagebuf.csize, 0, GL_STREAM_DRAW_ARB); GLubyte* ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB); if(ptr) { // update data off the mapped buffer memcpy(ptr, m_imagebuf.data, m_imagebuf.xsize * m_imagebuf.ysize * m_imagebuf.csize); glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB); // release pointer to mapping buffer } /* unbind the current buffer */ glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0); } else { glTexSubImage2D(m_textureType, 0, 0, 0, // position m_imagebuf.xsize, m_imagebuf.ysize, m_imagebuf.format, m_imagebuf.type, m_imagebuf.data); m_hasMipmap = false; } } } // rebuildlist if (m_wantMipmap && canMipmap && !m_hasMipmap) { glGenerateMipmap(m_textureType); m_hasMipmap = true; } setTexFilters(m_textureMinQuality != GL_LINEAR_MIPMAP_LINEAR || (m_wantMipmap && canMipmap)); setTexCoords(m_coords, m_xRatio, m_yRatio, m_upsidedown); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, m_env); /* cleanup */ m_rebuildList = false; m_didTexture=true; state->set(GemState::_GL_TEX_UNITS, m_numTexUnits); // if we are using rectangle textures, this is a way to inform the downstream objects // (this is important for things like [pix_coordinate] // we don't use switch/case as _ARB and _EXT might be the same... if(m_textureType==GL_TEXTURE_RECTANGLE_ARB || m_textureType==GL_TEXTURE_RECTANGLE_EXT) { state->set(GemState::_GL_TEX_TYPE, 2); } else { state->set(GemState::_GL_TEX_TYPE, 1); } m_baseCoord.s=m_xRatio; m_baseCoord.t=m_yRatio; state->set(GemState::_GL_TEX_BASECOORD, m_baseCoord); state->set(GemState::_GL_TEX_ORIENTATION, upsidedown); sendExtTexture(m_textureObj, m_xRatio, m_yRatio, m_textureType, upsidedown); }
MainWindow::MainWindow(QThread *atermThread): m_fileDialog("", this) { m_ui.setupUi(this); m_ltsManager = new LtsManager(this, &m_settings, atermThread); m_markManager = new MarkManager(this, m_ltsManager); m_infoDock = new InfoDock(this, m_ltsManager, m_markManager); m_markDock = new MarkDock(this, m_markManager); m_simDock = new SimDock(this, m_ltsManager); m_settingsDock = new SettingsDock(this, &m_settings); m_settingsDialog = new SettingsDialog(this, &m_settings); m_ltsCanvas = new LtsCanvas(this, &m_settings, m_ltsManager, m_markManager); setCentralWidget(m_ltsCanvas); m_progressDialog = new QProgressDialog("", QString(), 0, 6, this); m_progressDialog->setMinimumDuration(0); m_ui.informationDock->setWidget(m_infoDock); m_ui.simulationDock->setWidget(m_simDock); m_ui.markDock->setWidget(m_markDock); m_ui.settingsDock->setWidget(m_settingsDock); m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.informationDock->toggleViewAction()); m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.simulationDock->toggleViewAction()); m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.markDock->toggleViewAction()); m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.settingsDock->toggleViewAction()); m_ui.viewMenu->insertSeparator(m_ui.preferences); mcrl2::log::logger::register_output_policy(m_logRelay); connect(&m_logRelay, SIGNAL(logMessage(QString, QString, QDateTime, QString)), this, SLOT(logMessage(QString, QString, QDateTime, QString))); connect(m_ui.open, SIGNAL(triggered()), this, SLOT(open())); connect(m_ui.openTrace, SIGNAL(triggered()), this, SLOT(openTrace())); connect(m_ui.exportBitmap, SIGNAL(triggered()), this, SLOT(exportBitmap())); connect(m_ui.exportText, SIGNAL(triggered()), this, SLOT(exportText())); connect(m_ui.exportVector, SIGNAL(triggered()), this, SLOT(exportVector())); connect(m_ui.exit, SIGNAL(triggered()), QApplication::instance(), SLOT(quit())); connect(m_ui.resetViewpoint, SIGNAL(triggered()), m_ltsCanvas, SLOT(resetView())); connect(m_ui.zoomIntoAbove, SIGNAL(triggered()), m_ltsManager, SLOT(zoomInAbove())); connect(m_ui.zoomIntoBelow, SIGNAL(triggered()), m_ltsManager, SLOT(zoomInBelow())); connect(m_ui.zoomOut, SIGNAL(triggered()), m_ltsManager, SLOT(zoomOut())); connect(m_ui.displayStates, SIGNAL(triggered(bool)), &m_settings.displayStates, SLOT(setValue(bool))); connect(&m_settings.displayStates, SIGNAL(changed(bool)), m_ui.displayStates, SLOT(setChecked(bool))); connect(m_ui.displayTransitions, SIGNAL(triggered(bool)), &m_settings.displayTransitions, SLOT(setValue(bool))); connect(&m_settings.displayTransitions, SIGNAL(changed(bool)), m_ui.displayTransitions, SLOT(setChecked(bool))); connect(m_ui.displayBackpointers, SIGNAL(triggered(bool)), &m_settings.displayBackpointers, SLOT(setValue(bool))); connect(&m_settings.displayBackpointers, SIGNAL(changed(bool)), m_ui.displayBackpointers, SLOT(setChecked(bool))); connect(m_ui.displayWireframe, SIGNAL(triggered(bool)), &m_settings.displayWireframe, SLOT(setValue(bool))); connect(&m_settings.displayWireframe, SIGNAL(changed(bool)), m_ui.displayWireframe, SLOT(setChecked(bool))); connect(m_ui.preferences, SIGNAL(triggered()), m_settingsDialog, SLOT(show())); connect(m_ltsManager, SIGNAL(loadingLts()), this, SLOT(loadingLts())); connect(m_ltsManager, SIGNAL(rankingStates()), this, SLOT(rankingStates())); connect(m_ltsManager, SIGNAL(clusteringStates()), this, SLOT(clusteringStates())); connect(m_ltsManager, SIGNAL(computingClusterInfo()), this, SLOT(computingClusterInfo())); connect(m_ltsManager, SIGNAL(positioningClusters()), this, SLOT(positioningClusters())); connect(m_ltsManager, SIGNAL(positioningStates()), this, SLOT(positioningStates())); connect(m_ltsManager, SIGNAL(ltsStructured()), this, SLOT(hideProgressDialog())); connect(m_ltsManager, SIGNAL(errorLoadingLts()), this, SLOT(hideProgressDialog())); connect(m_ltsManager, SIGNAL(startStructuring()), this, SLOT(startStructuring())); connect(m_ltsManager, SIGNAL(stopStructuring()), this, SLOT(stopStructuring())); connect(m_ltsManager, SIGNAL(selectionChanged()), this, SLOT(selectionChanged())); connect(m_ltsManager, SIGNAL(ltsZoomed(LTS *)), this, SLOT(zoomChanged())); m_ui.zoomIntoAbove->setEnabled(false); m_ui.zoomIntoBelow->setEnabled(false); m_ui.zoomOut->setEnabled(false); connect(m_ltsCanvas, SIGNAL(renderingStarted()), this, SLOT(startRendering())); connect(m_ltsCanvas, SIGNAL(renderingFinished()), this, SLOT(clearStatusBar())); QSettings settings("mCRL2", "LTSView"); restoreGeometry(settings.value("geometry").toByteArray()); restoreState(settings.value("windowState").toByteArray()); }
void BasisManager::createBasisManager(void) // создаем начальную точки каркаса приложения { Ogre::String pluginsPath; // only use plugins.cfg if not static #ifndef OGRE_STATIC_LIB pluginsPath = mResourcePath + "plugins.cfg"; #endif mRoot = new Ogre::Root("", mResourcePath + "ogre.cfg", mResourcePath + "Ogre.log"); mRoot->installPlugin( new Ogre::D3D9Plugin( ) ); setupResources(); if (!mRoot->restoreConfig()) { // попробуем завестись на дефолтных if (!mRoot->showConfigDialog()) return; // ничего не получилось, покажем диалог } mWindow = mRoot->initialise(true, "MyGUI Layout Editor"); mWidth = mWindow->getWidth(); mHeight = mWindow->getHeight(); #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 mWindow->getCustomAttribute("WINDOW", &mHwnd); // устанавливаем поддержку дропа файлов long style = ::GetWindowLong((HWND)mHwnd, GWL_EXSTYLE); ::SetWindowLong((HWND)mHwnd, GWL_EXSTYLE, style | WS_EX_ACCEPTFILES); #endif setMainWindowIcon(IDI_ICON); mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "BasisSceneManager"); mCamera = mSceneMgr->createCamera("BasisCamera"); mCamera->setNearClipDistance(5); mCamera->setPosition(Ogre::Vector3(200, 200, 200)); mCamera->lookAt(Ogre::Vector3(0.0, 0.0, 0.0)); // Create one viewport, entire window /*Ogre::Viewport * vp = */mWindow->addViewport(mCamera); // Alter the camera aspect ratio to match the viewport mCamera->setAspectRatio(Ogre::Real(mWidth) / Ogre::Real(mHeight)); // Set default mipmap level (NB some APIs ignore this) Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5); Ogre::Light* mLight = mSceneMgr->createLight("BasisLight"); mLight->setDiffuseColour(Ogre::ColourValue::White); mLight->setSpecularColour(Ogre::ColourValue::White); mLight->setAttenuation(8000,1,0.0005,0); // Load resources Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); // узнам в каком режиме экрана мы запущенны mFullscreen = mRoot->getRenderSystem()->getConfigOptions().find("Full Screen")->second.currentValue == "Yes"; // создаем систему ввода mInput = new input::InputManager(); mInput->createInput(mWindow, mFullscreen, this, this); mGUI = new MyGUI::Gui(); mGUI->initialise(mWindow, "editor.xml"); // подписываемся на события фреймов mRoot->addFrameListener(this); // пдписываемся на события окна Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this); #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 // если оконное, то скрываем if (!mFullscreen) MyGUI::Gui::getInstance().hidePointer(); // забиваем карту маппинга на стандартные курсоры mInput->addMapPointer("arrow", (size_t)::LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW))); mInput->addMapPointer("beam", (size_t)::LoadCursor(NULL, MAKEINTRESOURCE(IDC_IBEAM))); mInput->addMapPointer("size_left", (size_t)::LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZENWSE))); mInput->addMapPointer("size_right", (size_t)::LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZENESW))); mInput->addMapPointer("size_horz", (size_t)::LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZEWE))); mInput->addMapPointer("size_vert", (size_t)::LoadCursor(NULL, MAKEINTRESOURCE(IDC_SIZENS))); mInput->addMapPointer("hand", (size_t)::LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND))); #endif changeState(&mEditor); startRendering(); }
QgsGlobeTileUpdateManager::QgsGlobeTileUpdateManager( QObject *parent ) : QObject( parent ), mCurrentTile( 0 ), mRenderer( 0 ) { connect( this, SIGNAL( startRendering() ), this, SLOT( start() ) ); connect( this, SIGNAL( cancelRendering() ), this, SLOT( cancel() ) ); }