예제 #1
1
EglContext::EglContext(EglContext* shared) :
m_display (EGL_NO_DISPLAY),
m_context (EGL_NO_CONTEXT),
m_surface (EGL_NO_SURFACE),
m_config  (NULL)
{
    // Get the initialized EGL display
    m_display = getInitializedDisplay();

    // Get the best EGL config matching the default video settings
    m_config = getBestConfig(m_display, VideoMode::getDesktopMode().bitsPerPixel, ContextSettings());
    updateSettings();

    // Note: The EGL specs say that attrib_list can be NULL when passed to eglCreatePbufferSurface,
    // but this is resulting in a segfault. Bug in Android?
    EGLint attrib_list[] = {
        EGL_WIDTH, 1,
        EGL_HEIGHT,1,
        EGL_NONE
    };

    m_surface = eglCheck(eglCreatePbufferSurface(m_display, m_config, attrib_list));

    // Create EGL context
    createContext(shared);
}
예제 #2
0
파일: GlContext.cpp 프로젝트: bacsmar/SFML
GlContext* GlContext::create()
{
    // Make sure that there's an active context (context creation may need extensions, and thus a valid context)
    assert(sharedContext != NULL);

    Lock lock(mutex);

    GlContext* context = NULL;

    // We don't use acquireTransientContext here since we have
    // to ensure we have exclusive access to the shared context
    // in order to make sure it is not active during context creation
    {
        sharedContext->setActive(true);

        // Create the context
        context = new ContextType(sharedContext);

        sharedContext->setActive(false);
    }

    context->initialize(ContextSettings());

    return context;
}
예제 #3
0
GlxContext::GlxContext(GlxContext* shared) :
myWindow    (0),
myContext   (NULL),
myOwnsWindow(true)
{
    // Open a connection with the X server
    myDisplay = XOpenDisplay(NULL);

    // Create a dummy window (disabled and hidden)
    int screen = DefaultScreen(myDisplay);
    myWindow = XCreateWindow(myDisplay,
                             RootWindow(myDisplay, screen),
                             0, 0,
                             1, 1,
                             0,
                             DefaultDepth(myDisplay, screen),
                             InputOutput,
                             DefaultVisual(myDisplay, screen),
                             0, NULL);

    // Create the context
    CreateContext(shared, VideoMode::GetDesktopMode().BitsPerPixel, ContextSettings(0, 0, 0));

    // Activate the context
    SetActive(true);
}
예제 #4
0
파일: GlContext.cpp 프로젝트: bacsmar/SFML
void GlContext::globalInit()
{
    Lock lock(mutex);

    if (sharedContext)
        return;

    // Create the shared context
    sharedContext = new ContextType(NULL);
    sharedContext->initialize(ContextSettings());

    // Load our extensions vector
    extensions.clear();

    // Check whether a >= 3.0 context is available
    int majorVersion = 0;
    glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);

    if (glGetError() == GL_INVALID_ENUM)
    {
        // Try to load the < 3.0 way
        const char* extensionString = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));

        do
        {
            const char* extension = extensionString;

            while(*extensionString && (*extensionString != ' '))
                extensionString++;

            extensions.push_back(std::string(extension, extensionString));
        }
        while (*extensionString++);
    }
    else
    {
        // Try to load the >= 3.0 way
        glGetStringiFuncType glGetStringiFunc = NULL;
        glGetStringiFunc = reinterpret_cast<glGetStringiFuncType>(getFunction("glGetStringi"));

        if (glGetStringiFunc)
        {
            int numExtensions = 0;
            glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);

            if (numExtensions)
            {
                for (unsigned int i = 0; i < static_cast<unsigned int>(numExtensions); ++i)
                {
                    const char* extensionString = reinterpret_cast<const char*>(glGetStringiFunc(GL_EXTENSIONS, i));

                    extensions.push_back(extensionString);
                }
            }
        }
    }

    // Deactivate the shared context so that others can activate it when necessary
    sharedContext->setActive(false);
}
예제 #5
0
파일: App.cpp 프로젝트: Nitrooos/Kastle
void App::initSFML() {
    // stwórz okno
    window.create(VideoMode(windowWidth, windowHeight), "OpenGL", Style::Fullscreen, ContextSettings(32));
    window.setFramerateLimit(60);
    window.setKeyRepeatEnabled(false);
    window.setMouseCursorVisible(false);

    Mouse::setPosition(getWindowCenter(), window);
}
예제 #6
0
void createWindow(Window* app)
{
    app->contextSettings =  ContextSettings(24,8,0,3,3);
    app->contextVideoMode = VideoMode(WIDTH,HEIGHT,32);
    app->contextWindow = new sf::Window(app->contextVideoMode,"Midori - NG4 Logo identify tool", Style::Close,app->contextSettings);
    app->contextWindow->SetActive();
    app->contextWindow->ShowMouseCursor(true);
    app->contextWindow->SetCursorPosition(WIDTH/2,HEIGHT/2);
}
예제 #7
0
bool RenderImageImplDefault::Create(unsigned int width, unsigned int height, unsigned int, bool depthBuffer)
{
    // Store the dimensions
    myWidth = width;
    myHeight = height;

    // Create the in-memory OpenGL context
    myContext = new Context(ContextSettings(depthBuffer ? 32 : 0, 0, 4), width, height);

    return true;
}
예제 #8
0
bool RenderTextureImplDefault::create(unsigned int width, unsigned int height, unsigned int, bool depthBuffer)
{
    // Store the dimensions
    m_width = width;
    m_height = height;

    // Create the in-memory OpenGL context
    m_context = new Context(ContextSettings(depthBuffer ? 32 : 0), width, height);

    return true;
}
예제 #9
0
GLContextWin32::GLContextWin32(GLContextWin32 *shared) :
	mWindow(null),
	mDeviceContext(null),
	mContext(null),
	mOwnsWindow(true)
{
	mWindow = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, 1, 1, null, null, GetModuleHandle(null), null);
	ShowWindow(mWindow, SW_HIDE);
	mDeviceContext = GetDC(mWindow);

	if (mDeviceContext) {
		createContext(shared, VideoMode::getDesktopMode().bpp, ContextSettings());
	}
}
예제 #10
0
파일: WindowBase.cpp 프로젝트: PKEuS/SFML
void WindowBase::create(VideoMode mode, const String& title, Uint32 style)
{
    // Destroy the previous window implementation
    close();

    // Fullscreen style requires some tests
    if (style & Style::Fullscreen)
    {
        // Make sure there's not already a fullscreen window (only one is allowed)
        if (getFullscreenWindow())
        {
            err() << "Creating two fullscreen windows is not allowed, switching to windowed mode" << std::endl;
            style &= ~Style::Fullscreen;
        }
        else
        {
            // Make sure that the chosen video mode is compatible
            if (!mode.isValid())
            {
                err() << "The requested video mode is not available, switching to a valid mode" << std::endl;
                mode = VideoMode::getFullscreenModes()[0];
            }

            // Update the fullscreen window
            setFullscreenWindow(this);
        }
    }

    // Check validity of style according to the underlying platform
    #if defined(SFML_SYSTEM_IOS) || defined(SFML_SYSTEM_ANDROID)
        if (style & Style::Fullscreen)
            style &= ~Style::Titlebar;
        else
            style |= Style::Titlebar;
    #else
        if ((style & Style::Close) || (style & Style::Resize))
            style |= Style::Titlebar;
    #endif

    // Recreate the window implementation
    m_impl = priv::WindowImpl::create(mode, title, style, ContextSettings(0, 0, 0, 0, 0, 0xFFFFFFFF, false));

    // Perform common initializations
    initialize();
}
예제 #11
0
WglContext::WglContext(WglContext* shared) :
m_window       (NULL),
m_deviceContext(NULL),
m_context      (NULL),
m_ownsWindow   (true)
{
    // Creating a dummy window is mandatory: we could create a memory DC but then
    // its pixel format wouldn't match the regular contexts' format, and thus
    // wglShareLists would always fail. Too bad...

    // Create a dummy window (disabled and hidden)
    m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL);
    ShowWindow(m_window, SW_HIDE);
    m_deviceContext = GetDC(m_window);

    // Create the context
    if (m_deviceContext)
        createContext(shared, VideoMode::getDesktopMode().bitsPerPixel, ContextSettings());
}
예제 #12
0
파일: GameManager.cpp 프로젝트: JesseTG/RAY
GameManager::GameManager() :
    _lua(new LuaContext),
    _world(new World),
    _script_manager(new ScriptManager(_lua, SCRIPT_PATH)),
    _image_manager(new ImageManager),
    _shape_manager(new ShapeManager(SHAPE_PATH)),
    _sound_manager(new SoundManager(SOUND_PATH)),
    _music_manager(new MusicManager(MUSIC_PATH)),
    _level_manager(new LevelManager(LEVEL_PATH)),
    _physics_world(new b2World(b2Vec2_zero)),
    _sfgui(new sfg::SFGUI),
    _desktop(new sfg::Desktop)
{
    this->_render_window = make_shared<RenderWindow>(
                               VideoMode(SCREEN_SIZE.x, SCREEN_SIZE.y),
                               "RAY",
                               sf::Style::Default,
                               ContextSettings(0, 0, 4)
                           );
    this->_render_window->setFramerateLimit(FPS);
#ifdef DEBUG
    this->_debug_draw.setWindow(*this->_render_window);
    this->resetPhysicsWorld();
#endif // DEBUG
    this->_state_machine.reset(
        new GSM(
            *this->_world,
            "start",
    {
        {"start",  make_shared<TitleScreenState>(*this)},
        {"game", make_shared<InGameState>(*this)},
    },
    {
        {make_pair("swap", "start"), "game"},
        {make_pair("swap", "game"), "start"},
        {make_pair("advance", "game"), "game"},
        {make_pair("return", "game"), "start"},
    }));

    enemiesKilled = 0;
}
예제 #13
0
GlContext::GlContext()
:
m_window(NULL),
m_deviceContext(NULL),
m_context(NULL),
m_ownsWindow(true)
{
	m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, 1, 1, NULL, NULL, GetModuleHandle(NULL), NULL);
	ShowWindow(m_window, SW_HIDE);
	m_deviceContext = GetDC(m_window);

	if (m_deviceContext)
	{
		createContext(VideoMode::getDesktopMode().bitsPerPixel, ContextSettings());
	}

	makeCurrent();

	//now that we have a dummy context we can initialize glew
	initGlew();
}
예제 #14
0
GlxContext::GlxContext(GlxContext* shared) :
m_display   (NULL),
m_window    (0),
m_context   (NULL),
m_pbuffer   (0),
m_ownsWindow(false)
{
    // Save the creation settings
    m_settings = ContextSettings();

    // Make sure that extensions are initialized if this is not the shared context
    // The shared context is the context used to initialize the extensions
    if (shared && shared->m_display)
        ensureExtensionsInit(shared->m_display, DefaultScreen(shared->m_display));

    // Create the rendering surface (window or pbuffer if supported)
    createSurface(shared, 1, 1, VideoMode::getDesktopMode().bitsPerPixel);

    // Create the context
    createContext(shared);
}
예제 #15
0
GlxContext::GlxContext(GlxContext* shared) :
m_window    (0),
m_context   (NULL),
m_ownsWindow(true)
{
    // Open a connection with the X server
    m_display = OpenDisplay();

    // Create a dummy window (disabled and hidden)
    int screen = DefaultScreen(m_display);
    m_window = XCreateWindow(m_display,
                             RootWindow(m_display, screen),
                             0, 0,
                             1, 1,
                             0,
                             DefaultDepth(m_display, screen),
                             InputOutput,
                             DefaultVisual(m_display, screen),
                             0, NULL);

    // Create the context
    createContext(shared, VideoMode::getDesktopMode().bitsPerPixel, ContextSettings());
}
예제 #16
0
파일: GlxContext.cpp 프로젝트: CPB9/SFML
GlxContext::GlxContext(GlxContext* shared) :
m_window    (0),
m_context   (NULL),
m_ownsWindow(true)
{
    // Open a connection with the X server
    m_display = OpenDisplay();
    m_connection = XGetXCBConnection(m_display);
    xcb_screen_t* screen = XCBScreenOfDisplay(m_connection, DefaultScreen(m_display));

    // Choose the visual according to the context settings
    XVisualInfo visualInfo = selectBestVisual(m_display, VideoMode::getDesktopMode().bitsPerPixel, ContextSettings());

    // Define the window attributes
    xcb_colormap_t colormap = xcb_generate_id(m_connection);
    xcb_create_colormap(m_connection, XCB_COLORMAP_ALLOC_NONE, colormap, screen->root, visualInfo.visualid);
    const uint32_t value_list[] = {colormap};

    // Create a dummy window (disabled and hidden)
    m_window = xcb_generate_id(m_connection);
    xcb_create_window(
        m_connection,
        static_cast<uint8_t>(visualInfo.depth),
        m_window,
        screen->root,
        0, 0,
        1, 1,
        0,
        XCB_WINDOW_CLASS_INPUT_OUTPUT,
        visualInfo.visualid,
        XCB_CW_COLORMAP,
        value_list
    );

    // Create the context
    createContext(shared, VideoMode::getDesktopMode().bitsPerPixel, ContextSettings());
}
예제 #17
0
 const ContextSettings SDL2WindowBackend::getSettings() const
 {
     //settings not finalized;
     return ContextSettings();
 }
예제 #18
0
	/**
	 * Method is used to create application window.
	 */
	void Core::createWindow()
	{
		const int width = Configuration::getInstance()->getWidth();
		const int height = Configuration::getInstance()->getHeight();
		const bool isFull = Configuration::getInstance()->isFullscreenEnabled();
		if(isFull)
			window = new RenderWindow(VideoMode(width,height,32),"DammSmallEngine", Style::Fullscreen, ContextSettings());
		else
			window = new RenderWindow(VideoMode(width,height,32),"DammSmallEngine", Style::Close, ContextSettings());
	}