////////////////////////////////////////////////////////
// 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() ) );
}