コード例 #1
0
PlotWidget::PlotWidget(QWidget * parent) : KPlotWidget(parent)
, mKpoBCWP(NULL)
, mKpoBCWS(NULL)
, mKpoACWP(NULL)
{
    kDebug() << "------------> ChartWidget :: Constructor"<<endl;

    // UI Parameters
    setBackgroundColor(Qt::white);
    setForegroundColor(Qt::black);
    setGridColor(Qt::black);
    setAntialiasing(false);

//     // creating a plot object whose points are connected by red lines 
//     mKpoBCWP = new KPlotObject( Qt::black, KPlotObject::Lines );
//     mKpoBCWS = new KPlotObject( Qt::green, KPlotObject::Lines );
//     mKpoACWP = new KPlotObject( Qt::red, KPlotObject::Lines );
// 
//     // ... and adding the object to the plot widget
//     addPlotObject(mKpoBCWP);
//     addPlotObject(mKpoBCWS);
//     addPlotObject(mKpoACWP);

    kDebug() << "ChartWidget :: Constructor Ended"<<endl;
}
コード例 #2
0
ファイル: mygraphicsview.cpp プロジェクト: epruesse/Bandage
MyGraphicsView::MyGraphicsView(QObject * /*parent*/) :
    QGraphicsView(), m_rotation(0.0)
{
    setDragMode(QGraphicsView::RubberBandDrag);
    setAntialiasing(g_settings->antialiasing);
    setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
}
コード例 #3
0
ChartsTimeGraph::ChartsTimeGraph( QQuickItem* parent ) :
    QQuickItem( parent )
{
    setFlag( ItemHasContents, true );
    setSmooth( true );
    setAntialiasing( true );
}
コード例 #4
0
ファイル: demoqpitem.cpp プロジェクト: gabriele/qnanopainter
DemoQPItem::DemoQPItem(QQuickItem *parent)
    : QQuickPaintedItem(parent)
    , m_animationTime(0.0)
    , m_enabledTests(0)
    , m_testCount(1)
    , m_qpAntialiasing(true)
    , m_qpRenderTargetFBO(false)
{
    // Setup colors
    m_colorWhite = QColor(255,255,255,255);
    m_colorGray = QColor(180,180,180,255);
    m_colorBlack = QColor(0,0,0,255);
    m_color1 = QColor(180,190,40,20);
    m_color2 = QColor(255,255,255,150);
    m_color3 = QColor(255,255,255,80);

    m_circleImage = QImage(":/qml/images/circle.png");

    // Load custom font
    int id = QFontDatabase::addApplicationFont(":/qml/fonts/Roboto-Regular.ttf");
    QStringList s = QFontDatabase::applicationFontFamilies(id);
    m_testFont = QFont(s.at(0));

    // Set antialiasing and render target
    setAntialiasing(m_qpAntialiasing);
    setRenderTarget(m_qpRenderTargetFBO ? QQuickPaintedItem::FramebufferObject : QQuickPaintedItem::Image);
    // Enable this to try FastFBOResizing
    //setPerformanceHint(QQuickPaintedItem::FastFBOResizing, true);
}
コード例 #5
0
void QQuickContext2DTexture::canvasChanged(const QSize& canvasSize, const QSize& tileSize, const QRect& canvasWindow, const QRect& dirtyRect, bool smooth, bool antialiasing)
{
    QSize ts = tileSize;
    if (ts.width() > canvasSize.width())
        ts.setWidth(canvasSize.width());

    if (ts.height() > canvasSize.height())
        ts.setHeight(canvasSize.height());

    setCanvasSize(canvasSize);
    setTileSize(ts);
    setCanvasWindow(canvasWindow);

    if (canvasSize == canvasWindow.size()) {
        m_tiledCanvas = false;
    } else {
        m_tiledCanvas = true;
    }

    if (dirtyRect.isValid())
        setDirtyRect(dirtyRect);

    setSmooth(smooth);
    setAntialiasing(antialiasing);
}
コード例 #6
0
QmlMitkSliderLevelWindowItem::QmlMitkSliderLevelWindowItem( QQuickPaintedItem * parent )
: QQuickPaintedItem(parent)
{
    m_Manager = mitk::LevelWindowManager::New();
    m_Manager->SetDataStorage(QmlMitkSliderLevelWindowItem::storage);

    itk::ReceptorMemberCommand<QmlMitkSliderLevelWindowItem>::Pointer command = itk::ReceptorMemberCommand<QmlMitkSliderLevelWindowItem>::New();
    command->SetCallbackFunction(this, &QmlMitkSliderLevelWindowItem::OnPropertyModified);
    m_ObserverTag = m_Manager->AddObserver(itk::ModifiedEvent(), command);
    m_IsObserverTagSet = true;

    setAcceptedMouseButtons(Qt::AllButtons);
    setAcceptHoverEvents(true);
    setAntialiasing(true);

    m_Resize = false;
    m_Bottom = false;
    m_CtrlPressed = false;
    m_MouseDown = false;
    m_ScaleVisible = true;

    this->setEnabled(false);

    update();
}
コード例 #7
0
ファイル: graphconnection.cpp プロジェクト: mjmvisser/pug
GraphConnection::GraphConnection(QQuickItem *parent) :
    QQuickItem(parent),
    m_source(),
    m_sink()
{
    setFlag(ItemHasContents, true);
    setAntialiasing(true);
}
コード例 #8
0
MachinePage::MachinePage(QObject *parent) :
    PagePlugin(parent)
{
    m_componentUrl.setUrl("qrc:/machineparameters/main.qml");
    m_model = Datahandling::createParameterModel();
    connect(this, SIGNAL(engineChanged()), this, SLOT(setModel()), Qt::DirectConnection);
    connect(this, SIGNAL(componentCreated()), this, SLOT(setAntialiasing()), Qt::DirectConnection);
}
コード例 #9
0
PolygonItem::PolygonItem(QQuickItem *parent) :
	QQuickPaintedItem(parent),
	_color(QColor(255, 255, 255))
{
	setAntialiasing(true);
	connect(this, SIGNAL(widthChanged()), SLOT(onAppearanceChanged()));
	connect(this, SIGNAL(heightChanged()), SLOT(onAppearanceChanged()));
	connect(this, SIGNAL(colorChanged()), SLOT(onAppearanceChanged()));
}
コード例 #10
0
AVTPlotWidget::AVTPlotWidget( QWidget *parent )
        : KPlotWidget( parent )
{
    setAntialiasing(true);

    //Default SunRise/SunSet values
    SunRise = 0.25;
    SunSet = 0.75;

    MousePoint = QPoint( -1, -1 );
}
コード例 #11
0
ファイル: qmlprofile.cpp プロジェクト: xuvw/subsurface
QMLProfile::QMLProfile(QQuickItem *parent) :
	QQuickPaintedItem(parent),
	m_devicePixelRatio(1.0),
	m_margin(0)
{
	setAntialiasing(true);
	m_profileWidget = new ProfileWidget2(0);
	m_profileWidget->setProfileState();
	m_profileWidget->setPrintMode(true);
	m_profileWidget->setFontPrintScale(0.8);
	//m_profileWidget->setGeometry(this->geometry());
}
コード例 #12
0
QMLProfile::QMLProfile(QQuickItem *parent) :
	QQuickPaintedItem(parent),
	m_devicePixelRatio(1.0),
	m_margin(0)
{
	setAntialiasing(true);
	m_profileWidget = new ProfileWidget2(0);
	m_profileWidget->setProfileState();
	m_profileWidget->setPrintMode(true);
	m_profileWidget->setFontPrintScale(0.8);
	connect(QMLManager::instance(), &QMLManager::sendScreenChanged, this, &QMLProfile::screenChanged);
	setDevicePixelRatio(QMLManager::instance()->lastDevicePixelRatio());
}
コード例 #13
0
FeatureListModelHighlight::FeatureListModelHighlight( QQuickItem* parent )
  : QQuickItem( parent )
  , mModel( nullptr )
  , mSelection( nullptr )
  , mDirty( false )
  , mMapSettings( nullptr )
{
  setFlags( QQuickItem::ItemHasContents );
  setAntialiasing( true );

  connect( this, &FeatureListModelHighlight::modelChanged, this, &FeatureListModelHighlight::onDataChanged );
  connect( this, &FeatureListModelHighlight::selectionChanged, this, &FeatureListModelHighlight::onDataChanged );
}
コード例 #14
0
ParameterPlotter::ParameterPlotter(QWidget *parent) :
        KPlotWidget(parent)
{
    setAntialiasing(true);
    setLeftPadding(20);
    setRightPadding(10);
    setTopPadding(10);
    setBottomPadding(20);
    m_movepoint = NULL;
    m_colors << Qt::white << Qt::red << Qt::green << Qt::blue << Qt::magenta << Qt::gray << Qt::cyan;
    m_moveX = false;
    m_moveY = true;
    m_moveTimeline = true;
    m_newPoints = false;
    m_activeIndexPlot = -1;
    m_max_y = 0;
    m_min_y = 0;
}
コード例 #15
0
void JSonIO::reset(){
    parserState = 0;

    setOutputFile("empty");
    setTopFace("empty");
    setBottomFace("empty");
    setLeftFace("empty");
    setRightFace("empty");
    setFrontFace("empty");
    setBackFace("empty");
    setFrameStart(0);
    setFrameStop(0);
    setOutputWidth(0);
    setAntialiasing(0);
    setAaPattern("grid");
    frames.clear();

}
コード例 #16
0
ファイル: arcstyle.cpp プロジェクト: the-snowwhite/QtQuickVcp
ArcStyle::ArcStyle(QQuickItem *parent) :
    QQuickPaintedItem(parent),
    m_value(0),
    m_minValue(0),
    m_maxValue(100),
    m_stepSize(0.1),
    m_readOnly(false),
    m_color(QColor(135,206,235)),
    m_factor(57.6),
    m_scale(16 / m_factor),
    m_startAngle(-1680),
    m_spanAngle(480),
    m_offset((1440) + ( m_spanAngle / 2 )),
    m_anim(NULL)
{
    setAntialiasing(true);
#if defined Q_OS_LINUX || defined Q_OS_MAC
    setRenderTarget(QQuickPaintedItem::FramebufferObject);
#endif
}
コード例 #17
0
void JSonIO::loadJSon(QString filePath){
    parserState = 0;
    QJson::Parser parser;
    QFile jsonFile(filePath);
    if (!jsonFile.open(QIODevice::ReadOnly | QIODevice::Text)){
        parserState = 1;
        return;
    }

    QTextStream in(&jsonFile);
    QString json = in.readAll();
    jsonFile.close();

    bool ok;
    QVariantMap result = parser.parse(json.toAscii(), &ok).toMap();
    if (!ok) {
        parserState = 2;
    }

    setOutputFile(result["outputFile"].toString());

    setTopFace(result["topFace"].toString());
    setBottomFace(result["bottomFace"].toString());
    setLeftFace(result["leftFace"].toString());
    setRightFace(result["rightFace"].toString());
    setFrontFace(result["frontFace"].toString());
    setBackFace(result["backFace"].toString());

    setFrameStart(result["frameStart"].toInt());
    setFrameStop(result["frameStop"].toInt());
    setOutputWidth(result["outputWidth"].toInt());
    setAntialiasing(result["antialiasing"].toInt());
    setAaPattern(result["aaPattern"].toString());

    frames = result["frames"].toList();
}
コード例 #18
0
Graphics::PixelBuffer SurfaceSdlGraphicsManager::setupScreen(int screenW, int screenH, bool fullscreen, bool accel3d) {
	uint32 sdlflags;
	int bpp;

	closeOverlay();

#ifdef USE_OPENGL
	_opengl = accel3d;
	_antialiasing = 0;
#endif
	_fullscreen = fullscreen;

#ifdef USE_OPENGL
	if (_opengl) {
		if (ConfMan.hasKey("antialiasing"))
			_antialiasing = ConfMan.getInt("antialiasing");

		SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
		SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
		setAntialiasing(true);

		sdlflags = SDL_OPENGL;
		bpp = 24;
	} else
#endif
	{
		bpp = 16;
		sdlflags = SDL_HWSURFACE;
	}

	if (_fullscreen)
		sdlflags |= SDL_FULLSCREEN;

	_screen = SDL_SetVideoMode(screenW, screenH, bpp, sdlflags);
#ifdef USE_OPENGL
	// If 32-bit with antialiasing failed, try 32-bit without antialiasing
	if (!_screen && _opengl && _antialiasing) {
		warning("Couldn't create 32-bit visual with AA, trying 32-bit without AA");
		setAntialiasing(false);
		_screen = SDL_SetVideoMode(screenW, screenH, bpp, sdlflags);
	}

	// If 32-bit failed, try 16-bit
	if (!_screen && _opengl) {
		warning("Couldn't create 32-bit visual, trying 16-bit");
		SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
		SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
		SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 1);
		setAntialiasing(true);
		_screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
	}

	// If 16-bit with antialiasing failed, try 16-bit without antialiasing
	if (!_screen && _opengl && _antialiasing) {
		warning("Couldn't create 16-bit visual with AA, trying 16-bit without AA");
		setAntialiasing(false);
		_screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
	}
#endif

	if (!_screen)
		error("Could not initialize video: %s", SDL_GetError());

#ifdef USE_OPENGL
	if (_opengl) {
		int glflag;

		// apply atribute again for sure based on SDL docs
		SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

		SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &glflag);
		warning("INFO: GL RED bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &glflag);
		warning("INFO: GL GREEN bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &glflag);
		warning("INFO: GL BLUE bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &glflag);
		warning("INFO: GL APLHA bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &glflag);
		warning("INFO: GL Z buffer depth bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &glflag);
		warning("INFO: GL Double Buffer: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &glflag);
		warning("INFO: GL Stencil buffer bits: %d", glflag);
	}
#endif

	_overlayWidth = screenW;
	_overlayHeight = screenH;

#ifdef USE_OPENGL
	if (_opengl) {
		uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
		rmask = 0x00001f00;
		gmask = 0x000007e0;
		bmask = 0x000000f8;
		amask = 0x00000000;
#else
		rmask = 0x0000f800;
		gmask = 0x000007e0;
		bmask = 0x0000001f;
		amask = 0x00000000;
#endif
		_overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth, _overlayHeight, 16,
						rmask, gmask, bmask, amask);
	} else
#endif
	{
		_overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth, _overlayHeight, 16,
					_screen->format->Rmask, _screen->format->Gmask, _screen->format->Bmask, _screen->format->Amask);
	}

	if (!_overlayscreen)
		error("allocating _overlayscreen failed");

	/*_overlayFormat.bytesPerPixel = _overlayscreen->format->BytesPerPixel;

// 	For some reason the values below aren't right, at least on my system
	_overlayFormat.rLoss = _overlayscreen->format->Rloss;
	_overlayFormat.gLoss = _overlayscreen->format->Gloss;
	_overlayFormat.bLoss = _overlayscreen->format->Bloss;
	_overlayFormat.aLoss = _overlayscreen->format->Aloss;

	_overlayFormat.rShift = _overlayscreen->format->Rshift;
	_overlayFormat.gShift = _overlayscreen->format->Gshift;
	_overlayFormat.bShift = _overlayscreen->format->Bshift;
	_overlayFormat.aShift = _overlayscreen->format->Ashift;*/

	_overlayFormat = Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);

	_screenChangeCount++;

	SDL_PixelFormat *f = _screen->format;
	_screenFormat = Graphics::PixelFormat(f->BytesPerPixel, 8 - f->Rloss, 8 - f->Gloss, 8 - f->Bloss, 0,
										f->Rshift, f->Gshift, f->Bshift, f->Ashift);

	return Graphics::PixelBuffer(_screenFormat, (byte *)_screen->pixels);
}
コード例 #19
0
ファイル: qanGraphView.cpp プロジェクト: cneben/QuickQanava
GraphView::GraphView( QQuickItem* parent ) :
    qan::Navigable{ parent }
{
    setAntialiasing( true );
    setSmooth( true );
}
コード例 #20
0
ファイル: connection_item.cpp プロジェクト: bw-github/wgtf
InteractiveConnectionItem::InteractiveConnectionItem(QQuickItem* parent /*= 0*/)
    : QQuickItem(parent)
{
    setFlag(QQuickItem::ItemHasContents);
    setAntialiasing(true);
}
コード例 #21
0
Graphics::PixelBuffer SurfaceSdlGraphicsManager::setupScreen(uint screenW, uint screenH, bool fullscreen, bool accel3d) {
    uint32 sdlflags;
    int bpp;

    closeOverlay();

#ifdef USE_OPENGL
    _opengl = accel3d;
    _antialiasing = 0;
#endif
    _fullscreen = fullscreen;

    ConfMan.registerDefault("fullscreen_res", "desktop");
    const Common::String &fsres = ConfMan.get("fullscreen_res");
    if (fsres != "desktop") {
        uint newW, newH;
        int converted = sscanf(fsres.c_str(), "%ux%u", &newW, &newH);
        if (converted == 2) {
            _desktopW = newW;
            _desktopH = newH;
        } else {
            warning("Could not parse 'fullscreen_res' option: expected WWWxHHH, got %s", fsres.c_str());
        }
    }

    ConfMan.registerDefault("aspect_ratio", true);
    _lockAspectRatio = ConfMan.getBool("aspect_ratio");
    uint fbW = screenW;
    uint fbH = screenH;
    _gameRect = Math::Rect2d(Math::Vector2d(0, 0), Math::Vector2d(1, 1));

#ifdef USE_OPENGL
    bool framebufferSupported = false;

    // Use the desktop resolution for fullscreen when possible
    if (_fullscreen) {
        if (g_engine->hasFeature(Engine::kSupportsArbitraryResolutions)) {
            // If the game supports arbitrary resolutions, use the desktop mode as the game mode
            screenW = _desktopW;
            screenH = _desktopH;
        } else if (_opengl) {
            // If available, draw to a framebuffer and scale it to the desktop resolution
#ifndef AMIGAOS
            // Spawn a 32x32 window off-screen
            SDL_putenv(const_cast<char *>("SDL_VIDEO_WINDOW_POS=9000,9000"));
            SDL_SetVideoMode(32, 32, 0, SDL_OPENGL);
            SDL_putenv(const_cast<char *>("SDL_VIDEO_WINDOW_POS=centered"));
            Graphics::initExtensions();
            framebufferSupported = Graphics::isExtensionSupported("GL_EXT_framebuffer_object");
            if (_fullscreen && framebufferSupported) {
                screenW = _desktopW;
                screenH = _desktopH;

                if (_lockAspectRatio) {
                    float scale = MIN(_desktopH / float(fbH), _desktopW / float(fbW));
                    float scaledW = scale * (fbW / float(_desktopW));
                    float scaledH = scale * (fbH / float(_desktopH));
                    _gameRect = Math::Rect2d(
                                    Math::Vector2d(0.5 - (0.5 * scaledW), 0.5 - (0.5 * scaledH)),
                                    Math::Vector2d(0.5 + (0.5 * scaledW), 0.5 + (0.5 * scaledH))
                                );
                }
            }
#endif
        }
    }

    if (_opengl) {
        if (ConfMan.hasKey("antialiasing"))
            _antialiasing = ConfMan.getInt("antialiasing");

        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
        SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
        setAntialiasing(true);

        sdlflags = SDL_OPENGL;
        bpp = 24;
    } else
#endif
    {
        bpp = 16;
        sdlflags = SDL_SWSURFACE;
    }

    if (_fullscreen && !accel3d && _lockAspectRatio) {
        screenW = _desktopW;
        screenH = _desktopH;
        _gameRect = Math::Rect2d(
                        Math::Vector2d((_desktopW - fbW) / 2, (_desktopH - fbH) / 2),
                        Math::Vector2d((_desktopW + fbW) / 2, (_desktopH + fbH) / 2)
                    );
    }

    if (_fullscreen)
        sdlflags |= SDL_FULLSCREEN;

    _screen = SDL_SetVideoMode(screenW, screenH, bpp, sdlflags);
#ifdef USE_OPENGL
    // If 32-bit with antialiasing failed, try 32-bit without antialiasing
    if (!_screen && _opengl && _antialiasing) {
        warning("Couldn't create 32-bit visual with AA, trying 32-bit without AA");
        setAntialiasing(false);
        _screen = SDL_SetVideoMode(screenW, screenH, bpp, sdlflags);
    }

    // If 32-bit failed, try 16-bit
    if (!_screen && _opengl) {
        warning("Couldn't create 32-bit visual, trying 16-bit");
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 1);
        setAntialiasing(true);
        _screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
    }

    // If 16-bit with antialiasing failed, try 16-bit without antialiasing
    if (!_screen && _opengl && _antialiasing) {
        warning("Couldn't create 16-bit visual with AA, trying 16-bit without AA");
        setAntialiasing(false);
        _screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
    }

    // If 16-bit with alpha failed, try 16-bit without alpha
    if (!_screen && _opengl) {
        warning("Couldn't create 16-bit visual with alpha, trying without alpha");
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
        setAntialiasing(true);
        _screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
    }

    // If 16-bit without alpha and with antialiasing didn't work, try without antialiasing
    if (!_screen && _opengl && _antialiasing) {
        warning("Couldn't create 16-bit visual with AA, trying 16-bit without AA");
        setAntialiasing(false);
        _screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
    }
#endif

    if (!_screen) {
        warning("Error: %s", SDL_GetError());
        g_system->quit();
    }

#ifdef USE_OPENGL
    if (_opengl) {
        int glflag;
        const GLubyte *str;

        // apply atribute again for sure based on SDL docs
        SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

        str = glGetString(GL_VENDOR);
        debug("INFO: OpenGL Vendor: %s", str);
        str = glGetString(GL_RENDERER);
        debug("INFO: OpenGL Renderer: %s", str);
        str = glGetString(GL_VERSION);
        debug("INFO: OpenGL Version: %s", str);
        SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &glflag);
        debug("INFO: OpenGL Red bits: %d", glflag);
        SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &glflag);
        debug("INFO: OpenGL Green bits: %d", glflag);
        SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &glflag);
        debug("INFO: OpenGL Blue bits: %d", glflag);
        SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &glflag);
        debug("INFO: OpenGL Alpha bits: %d", glflag);
        SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &glflag);
        debug("INFO: OpenGL Z buffer depth bits: %d", glflag);
        SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &glflag);
        debug("INFO: OpenGL Double Buffer: %d", glflag);
        SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &glflag);
        debug("INFO: OpenGL Stencil buffer bits: %d", glflag);

#ifdef USE_GLEW
        debug("INFO: GLEW Version: %s", glewGetString(GLEW_VERSION));
        GLenum err = glewInit();
        if (err != GLEW_OK) {
            warning("Error: %s", glewGetErrorString(err));
            g_system->quit();
        }
#endif

#ifdef USE_OPENGL_SHADERS
        debug("INFO: GLSL version: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));

        const GLfloat vertices[] = {
            0.0, 0.0,
            1.0, 0.0,
            0.0, 1.0,
            1.0, 1.0,
        };

        // Setup the box shader used to render the overlay
        const char* attributes[] = { "position", "texcoord", NULL };
        _boxShader = Graphics::Shader::fromStrings("box", Graphics::BuiltinShaders::boxVertex, Graphics::BuiltinShaders::boxFragment, attributes);
        _boxVerticesVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(vertices), vertices);
        _boxShader->enableVertexAttribute("position", _boxVerticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
        _boxShader->enableVertexAttribute("texcoord", _boxVerticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
#endif

        Graphics::initExtensions();

    }
#endif

    _overlayWidth = screenW;
    _overlayHeight = screenH;

#ifdef USE_OPENGL
    if (_opengl) {
        uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
        rmask = 0x00001f00;
        gmask = 0x000007e0;
        bmask = 0x000000f8;
        amask = 0x00000000;
#else
        rmask = 0x0000f800;
        gmask = 0x000007e0;
        bmask = 0x0000001f;
        amask = 0x00000000;
#endif
        _overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth, _overlayHeight, 16,
                                              rmask, gmask, bmask, amask);
        _overlayScreenGLFormat = GL_UNSIGNED_SHORT_5_6_5;
    } else
#endif
    {
        _overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth, _overlayHeight, 16,
                                              _screen->format->Rmask, _screen->format->Gmask, _screen->format->Bmask, _screen->format->Amask);
    }

    if (!_overlayscreen) {
        warning("Error: %s", SDL_GetError());
        g_system->quit();
    }

    /*_overlayFormat.bytesPerPixel = _overlayscreen->format->BytesPerPixel;

    // 	For some reason the values below aren't right, at least on my system
    _overlayFormat.rLoss = _overlayscreen->format->Rloss;
    _overlayFormat.gLoss = _overlayscreen->format->Gloss;
    _overlayFormat.bLoss = _overlayscreen->format->Bloss;
    _overlayFormat.aLoss = _overlayscreen->format->Aloss;

    _overlayFormat.rShift = _overlayscreen->format->Rshift;
    _overlayFormat.gShift = _overlayscreen->format->Gshift;
    _overlayFormat.bShift = _overlayscreen->format->Bshift;
    _overlayFormat.aShift = _overlayscreen->format->Ashift;*/

    _overlayFormat = Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);

    _screenChangeCount++;

    SDL_PixelFormat *f = _screen->format;
    _screenFormat = Graphics::PixelFormat(f->BytesPerPixel, 8 - f->Rloss, 8 - f->Gloss, 8 - f->Bloss, 0,
                                          f->Rshift, f->Gshift, f->Bshift, f->Ashift);

#if defined(USE_OPENGL) && !defined(AMIGAOS)
    if (_opengl && _fullscreen
            && !g_engine->hasFeature(Engine::kSupportsArbitraryResolutions)
            && framebufferSupported) {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
        _frameBuffer = new Graphics::FrameBuffer(fbW, fbH);
        _frameBuffer->attach();
    }
#endif
    if (_fullscreen && !accel3d) {
        _subScreen = SDL_CreateRGBSurface(SDL_SWSURFACE, fbW, fbH, bpp, _screen->format->Rmask, _screen->format->Gmask, _screen->format->Bmask, _screen->format->Amask);
        return Graphics::PixelBuffer(_screenFormat, (byte *)_subScreen->pixels);
    }
    return Graphics::PixelBuffer(_screenFormat, (byte *)_screen->pixels);
}
コード例 #22
0
Graphics::PixelBuffer SurfaceSdlGraphicsManager::setupScreen(uint screenW, uint screenH, bool fullscreen, bool accel3d) {
	uint32 sdlflags;
	int bpp;

	closeOverlay();

#ifdef USE_OPENGL
	_opengl = accel3d;
	_antialiasing = 0;
#endif
	_fullscreen = fullscreen;

#ifdef USE_OPENGL
	if (_opengl) {
		if (ConfMan.hasKey("antialiasing"))
			_antialiasing = ConfMan.getInt("antialiasing");

		SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
		SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
		setAntialiasing(true);

		sdlflags = SDL_OPENGL;
		bpp = 24;
	} else
#endif
	{
		bpp = 16;
		sdlflags = SDL_SWSURFACE;
	}

	if (_fullscreen)
		sdlflags |= SDL_FULLSCREEN;

	_screen = SDL_SetVideoMode(screenW, screenH, bpp, sdlflags);
#ifdef USE_OPENGL
	// If 32-bit with antialiasing failed, try 32-bit without antialiasing
	if (!_screen && _opengl && _antialiasing) {
		warning("Couldn't create 32-bit visual with AA, trying 32-bit without AA");
		setAntialiasing(false);
		_screen = SDL_SetVideoMode(screenW, screenH, bpp, sdlflags);
	}

	// If 32-bit failed, try 16-bit
	if (!_screen && _opengl) {
		warning("Couldn't create 32-bit visual, trying 16-bit");
		SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
		SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
		SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 1);
		setAntialiasing(true);
		_screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
	}

	// If 16-bit with antialiasing failed, try 16-bit without antialiasing
	if (!_screen && _opengl && _antialiasing) {
		warning("Couldn't create 16-bit visual with AA, trying 16-bit without AA");
		setAntialiasing(false);
		_screen = SDL_SetVideoMode(screenW, screenH, 0, sdlflags);
	}
#endif

	if (!_screen) {
		warning("Error: %s", SDL_GetError());
		g_system->quit();
	}

#ifdef USE_OPENGL
	if (_opengl) {
		int glflag;
		const GLubyte *str;

		// apply atribute again for sure based on SDL docs
		SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);

		str = glGetString(GL_VENDOR);
		debug("INFO: OpenGL Vendor: %s", str);
		str = glGetString(GL_RENDERER);
		debug("INFO: OpenGL Renderer: %s", str);
		str = glGetString(GL_VERSION);
		debug("INFO: OpenGL Version: %s", str);
		SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &glflag);
		debug("INFO: OpenGL Red bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &glflag);
		debug("INFO: OpenGL Green bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &glflag);
		debug("INFO: OpenGL Blue bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &glflag);
		debug("INFO: OpenGL Alpha bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &glflag);
		debug("INFO: OpenGL Z buffer depth bits: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &glflag);
		debug("INFO: OpenGL Double Buffer: %d", glflag);
		SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &glflag);
		debug("INFO: OpenGL Stencil buffer bits: %d", glflag);

#ifdef USE_OPENGL_SHADERS
		debug("INFO: GLSL version: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));

		debug("INFO: GLEW Version: %s", glewGetString(GLEW_VERSION));

		// GLEW needs to be initialized to use shaders
		GLenum err = glewInit();
		if (err != GLEW_OK) {
			warning("Error: %s", glewGetErrorString(err));
			g_system->quit();
		}

		const GLfloat vertices[] = {
			0.0, 0.0,
			1.0, 0.0,
			0.0, 1.0,
			1.0, 1.0,
		};

		// Setup the box shader used to render the overlay
		const char* attributes[] = { "position", "texcoord", NULL };
		_boxShader = Graphics::Shader::fromStrings("box", Graphics::BuiltinShaders::boxVertex, Graphics::BuiltinShaders::boxFragment, attributes);
		_boxVerticesVBO = Graphics::Shader::createBuffer(GL_ARRAY_BUFFER, sizeof(vertices), vertices);
		_boxShader->enableVertexAttribute("position", _boxVerticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
		_boxShader->enableVertexAttribute("texcoord", _boxVerticesVBO, 2, GL_FLOAT, GL_TRUE, 2 * sizeof(float), 0);
#endif

	}
#endif

	_overlayWidth = screenW;
	_overlayHeight = screenH;

#ifdef USE_OPENGL
	if (_opengl) {
		uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
		rmask = 0x00001f00;
		gmask = 0x000007e0;
		bmask = 0x000000f8;
		amask = 0x00000000;
#else
		rmask = 0x0000f800;
		gmask = 0x000007e0;
		bmask = 0x0000001f;
		amask = 0x00000000;
#endif
		_overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth, _overlayHeight, 16,
						rmask, gmask, bmask, amask);
		_overlayScreenGLFormat = GL_UNSIGNED_SHORT_5_6_5;
	} else
#endif
	{
		_overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _overlayWidth, _overlayHeight, 16,
					_screen->format->Rmask, _screen->format->Gmask, _screen->format->Bmask, _screen->format->Amask);
	}

	if (!_overlayscreen) {
		warning("Error: %s", SDL_GetError());
		g_system->quit();
	}

	/*_overlayFormat.bytesPerPixel = _overlayscreen->format->BytesPerPixel;

// 	For some reason the values below aren't right, at least on my system
	_overlayFormat.rLoss = _overlayscreen->format->Rloss;
	_overlayFormat.gLoss = _overlayscreen->format->Gloss;
	_overlayFormat.bLoss = _overlayscreen->format->Bloss;
	_overlayFormat.aLoss = _overlayscreen->format->Aloss;

	_overlayFormat.rShift = _overlayscreen->format->Rshift;
	_overlayFormat.gShift = _overlayscreen->format->Gshift;
	_overlayFormat.bShift = _overlayscreen->format->Bshift;
	_overlayFormat.aShift = _overlayscreen->format->Ashift;*/

	_overlayFormat = Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);

	_screenChangeCount++;

	SDL_PixelFormat *f = _screen->format;
	_screenFormat = Graphics::PixelFormat(f->BytesPerPixel, 8 - f->Rloss, 8 - f->Gloss, 8 - f->Bloss, 0,
										f->Rshift, f->Gshift, f->Bshift, f->Ashift);

	return Graphics::PixelBuffer(_screenFormat, (byte *)_screen->pixels);
}